Files
Netcatty/electron/terminalWorker/runtime.cjs
T
陈大猫 3a0528bbd4 fix(terminal): bound asynchronous Windows PATH refresh (#3608)
* fix(terminal): bound asynchronous Windows PATH refresh

Replace blocking per-terminal registry queries with parallel async reads,
a one-second deadline, and a shared five-second snapshot. Preserve machine
before user PATH ordering and place guessed CLI directories last. Retain
per-hive successful values when registry reads fail, and honor explicit
PATH overrides without querying the registry.

* fix(terminal): cancel pending local starts through boot epochs

Register the existing pending boot controller before awaiting PATH refresh.
Honor tab close and reconnect cancellation before spawning, and clear only
the matching controller so stale completion cannot erase a newer boot.

Regression tests reproduce both the closed-tab PTY spawn and stale-close
ownership failures against the prior revision.

* fix(terminal): abort pending starts before worker close queue

Propagate an owned close to the existing pending boot controller before
waiting for its serialized start. Keep transport cleanup ordered and keep
stale boot-epoch closes from cancelling replacements.

Exercise both fire-and-forget and awaited close messages through the real
worker dispatcher and local-session bridge with a controlled PATH wait.

* fix(terminal): cancel superseded worker starts before queuing

Signal the existing boot-abort controller when a replacement arrives,
reject stale boot epochs, and recheck queued epochs before startup.
Only the latest reconnect may spawn after a pending PATH refresh.

Cover repeated reconnect requests and delayed old starts/closes through
the real worker dispatcher and local-session bridge.
2026-10-08 16:25:15 +08:00

871 lines
29 KiB
JavaScript

"use strict";
const {
logTerminalInterruptDebug,
normalizeTrace,
} = require("../bridges/terminalInterruptDiagnostics.cjs");
const {
clearTerminalSessionPerformanceState,
} = require("../bridges/emitTerminalSessionData.cjs");
const DEFAULT_SESSION_LIFECYCLE_TOMBSTONE_TTL_MS = 60_000;
const DEFAULT_MAX_SESSION_LIFECYCLE_TOMBSTONES = 2_048;
const SESSION_START_CHANNELS = new Set([
"netcatty:start",
"netcatty:local:start",
"netcatty:telnet:start",
"netcatty:mosh:start",
"netcatty:et:start",
"netcatty:serial:start",
"netcatty:local:reconnect",
"netcatty:external:start",
]);
function createIpcMainHarness() {
const handlers = new Map();
const listeners = new Map();
return {
handlers,
listeners,
handle(channel, handler) {
handlers.set(channel, handler);
},
on(channel, listener) {
listeners.set(channel, listener);
},
};
}
function normalizeMessageEvent(eventOrMessage) {
if (eventOrMessage && typeof eventOrMessage === "object" && "data" in eventOrMessage) {
return {
message: eventOrMessage.data,
ports: eventOrMessage.ports || [],
};
}
return {
message: eventOrMessage,
ports: eventOrMessage?.ports || [],
};
}
function createOutputPortRegistry() {
const outputPorts = new Map();
function closeSession(sessionId) {
const port = outputPorts.get(sessionId);
if (!port) return;
outputPorts.delete(sessionId);
try {
port.close?.();
} catch {
// Ignore close races while tearing down a worker-owned output port.
}
}
function post(sessionId, data, meta) {
const port = outputPorts.get(sessionId);
if (!port) return false;
try {
port.postMessage(meta ? { sessionId, data, meta } : { sessionId, data });
return true;
} catch {
closeSession(sessionId);
return false;
}
}
function postControl(sessionId, message) {
const port = outputPorts.get(sessionId);
if (!port) return false;
try {
port.postMessage({ ...message, sessionId });
return true;
} catch {
closeSession(sessionId);
return false;
}
}
function open(sessionId, port) {
if (!sessionId || !port) return;
closeSession(sessionId);
outputPorts.set(sessionId, port);
try {
port.start?.();
} catch {
// Some Electron MessagePort implementations do not require start().
}
}
return {
open,
post,
postControl,
closeSession,
};
}
function addPortMessageListener(port, callback) {
if (typeof port?.on === "function") {
port.on("message", callback);
return;
}
if (port) {
port.onmessage = callback;
}
}
function createUrgentInputPortRegistry(dispatch) {
const ports = new Map();
function close(webContentsId) {
const port = ports.get(webContentsId);
if (!port) return;
ports.delete(webContentsId);
try {
port.close?.();
} catch {
// Ignore stale urgent input port close races.
}
}
function open(webContentsId, port) {
if (!webContentsId || !port) return;
close(webContentsId);
ports.set(webContentsId, port);
addPortMessageListener(port, (eventOrMessage) => {
const { message } = normalizeMessageEvent(eventOrMessage);
dispatch(webContentsId, message);
});
try {
port.start?.();
} catch {
// Some Electron MessagePort implementations do not require start().
}
}
function closeAll() {
for (const webContentsId of Array.from(ports.keys())) {
close(webContentsId);
}
}
return {
open,
close,
closeAll,
};
}
function createSender(
parentPort,
webContentsId,
outputPorts,
terminalDataPipeline,
pendingOutputBySession = new Map(),
sessionOutputGenerations = new Map(),
sessionRequestIds = new Map(),
fixedOriginRequestId = null,
onCurrentSessionExit = null,
) {
const ownedSessionGenerations = new Map();
const getOwnedSessionGeneration = (sessionId) => {
if (!ownedSessionGenerations.has(sessionId)) {
ownedSessionGenerations.set(sessionId, sessionOutputGenerations.get(sessionId) ?? 0);
}
return ownedSessionGenerations.get(sessionId);
};
const trackPendingOutput = (sessionId, pending) => {
pendingOutputBySession.set(sessionId, pending);
const clearPending = () => {
if (pendingOutputBySession.get(sessionId) === pending) {
pendingOutputBySession.delete(sessionId);
}
};
void pending.then(clearPending, clearPending);
};
const getOriginRequestId = (sessionId) => (
fixedOriginRequestId || sessionRequestIds.get(sessionId) || null
);
const postRendererEvent = (channel, payload) => {
const explicitGeneration = payload?._terminalSessionGeneration;
const sessionGeneration = Number.isSafeInteger(explicitGeneration)
? explicitGeneration
: payload?.sessionId
? getOwnedSessionGeneration(payload.sessionId)
: undefined;
const rendererPayload = explicitGeneration === undefined
? payload
: Object.freeze(Object.fromEntries(
Object.entries(payload).filter(([key]) => key !== "_terminalSessionGeneration"),
));
const originRequestId = getOriginRequestId(payload?.sessionId);
if (channel === "netcatty:exit" && payload?.sessionId) {
if ((sessionOutputGenerations.get(payload.sessionId) ?? 0) === sessionGeneration) {
sessionOutputGenerations.set(payload.sessionId, sessionGeneration + 1);
pendingOutputBySession.delete(payload.sessionId);
outputPorts?.closeSession?.(payload.sessionId);
terminalDataPipeline?.detach?.(payload.sessionId, undefined, "session-closed");
onCurrentSessionExit?.(payload.sessionId, sessionGeneration);
}
}
parentPort.postMessage({
kind: "renderer-event",
webContentsId,
channel,
payload: rendererPayload,
...(sessionGeneration === undefined ? {} : { sessionGeneration }),
...(originRequestId ? { originRequestId } : {}),
});
};
const deliverTerminalData = (payload) => {
const sessionId = payload?.sessionId;
const explicitGeneration = payload?._terminalSessionGeneration;
const outputGeneration = Number.isSafeInteger(explicitGeneration)
? explicitGeneration
: getOwnedSessionGeneration(sessionId);
const originRequestId = getOriginRequestId(sessionId);
if ((sessionOutputGenerations.get(sessionId) ?? 0) !== outputGeneration) return;
const tapMessage = {
kind: "output-tap",
sessionId: payload?.sessionId,
data: payload?.data,
sessionGeneration: outputGeneration,
...(originRequestId ? { originRequestId } : {}),
};
if (payload?.meta) tapMessage.meta = payload.meta;
if (payload?.tapped !== true) parentPort.postMessage(tapMessage);
const pipelineProcessed = payload?.pipelineProcessed === true;
const pipelineMode = terminalDataPipeline?.getOutputMode?.(payload?.sessionId) ?? 0;
let sensitiveInputState;
if (!pipelineProcessed && pipelineMode !== 0) {
sensitiveInputState = terminalDataPipeline.observeOutput?.(
payload?.sessionId,
payload?.data,
) === true;
}
const deliver = (data, transformed = false) => {
if ((sessionOutputGenerations.get(sessionId) ?? 0) !== outputGeneration) return;
const inheritedIngressBytes = payload?.meta?.pluginPipelineIngressBytes;
const replayedRawIngressBytes = !transformed
&& !pipelineProcessed
&& Number.isFinite(inheritedIngressBytes)
? Math.max(0, Number(inheritedIngressBytes)) + String(payload?.data ?? "").length
: null;
const pipelineMeta = {
...(payload?.meta ?? {}),
...(replayedRawIngressBytes == null
? {}
: { pluginPipelineIngressBytes: replayedRawIngressBytes }),
...(transformed
? {
pluginPipelineIngressBytes:
Number(payload?.meta?.pluginPipelineIngressBytes ?? 0)
+ String(payload?.data ?? "").length,
pluginPipelineProcessed: true,
}
: {}),
...(sensitiveInputState === undefined
? {}
: { pluginPipelineSensitiveInput: sensitiveInputState }),
};
const meta = Object.keys(pipelineMeta).length > 0 ? pipelineMeta : undefined;
if (outputPorts?.post?.(payload?.sessionId, data, meta)) return;
const outputMessage = {
kind: "output",
sessionId: payload?.sessionId,
data,
tapped: true,
sessionGeneration: outputGeneration,
...(originRequestId ? { originRequestId } : {}),
};
if (meta) outputMessage.meta = meta;
parentPort.postMessage(outputMessage);
};
const previous = pendingOutputBySession.get(sessionId);
if (pipelineProcessed || !terminalDataPipeline?.interceptOutput || (pipelineMode & 2) === 0) {
if (!previous) {
deliver(payload?.data, false);
return Promise.resolve();
}
const pending = previous.then(
() => deliver(payload?.data, false),
() => deliver(payload?.data, false),
);
trackPendingOutput(sessionId, pending);
return pending;
}
const interceptAndDeliver = () => {
try {
return Promise.resolve(terminalDataPipeline.interceptOutput(sessionId, payload?.data)).then(
(data) => deliver(data, true),
() => deliver(payload?.data, false),
);
} catch {
deliver(payload?.data, false);
return undefined;
}
};
// Invoke the pipeline immediately so its bounded byte window and monotonic
// deadline cover time spent waiting behind earlier transforms. The
// pipeline owns per-session transform ordering; this outer registry only
// retains the latest barrier for direct fail-open output and session exit.
const pending = Promise.resolve(interceptAndDeliver());
trackPendingOutput(sessionId, pending);
return pending;
};
return {
id: webContentsId,
claimSessionGeneration(sessionId) {
return getOwnedSessionGeneration(sessionId);
},
isDestroyed() {
return false;
},
send(channel, payload) {
if (channel === "netcatty:data") {
return deliverTerminalData(payload);
}
if (channel === "netcatty:exit" && payload?.sessionId) {
const pending = pendingOutputBySession.get(payload.sessionId);
if (pending) {
void pending.then(
() => postRendererEvent(channel, payload),
() => postRendererEvent(channel, payload),
);
return;
}
}
postRendererEvent(channel, payload);
},
};
}
function createTerminalWorkerRuntime(options = {}) {
const {
parentPort,
registerBridges,
terminalDataPipeline,
} = options;
// Optional hook for suppressed-but-diagnostic failures so they still reach
// the main process's persistent crash log via the "worker-error" channel.
const reportSuppressedError = typeof options.reportSuppressedError === "function"
? options.reportSuppressedError
: null;
const ipcMain = createIpcMainHarness();
let started = false;
const outputPorts = createOutputPortRegistry();
const pendingOutputBySession = new Map();
const sessionOutputGenerations = new Map();
const sessionRequestIds = new Map();
const sessionOperationTails = new Map();
const sessionOperationKinds = new Map();
const sessionCloseEpochs = new Map();
const sessionLifecycleTombstoneTimes = new Map();
const sessionStartMarkers = new Set();
const pendingSessionStartBootEpochs = new Map();
let urgentInputPorts = null;
const now = typeof options.now === "function" ? options.now : Date.now;
const sessionLifecycleTombstoneTtlMs = Number.isFinite(options.sessionLifecycleTombstoneTtlMs)
? Math.max(0, Number(options.sessionLifecycleTombstoneTtlMs))
: DEFAULT_SESSION_LIFECYCLE_TOMBSTONE_TTL_MS;
const maxSessionLifecycleTombstones = Number.isFinite(options.maxSessionLifecycleTombstones)
? Math.max(1, Math.floor(Number(options.maxSessionLifecycleTombstones)))
: DEFAULT_MAX_SESSION_LIFECYCLE_TOMBSTONES;
const setDefaultTransportIdleTtlMs = typeof options.setDefaultTransportIdleTtlMs === "function"
? options.setDefaultTransportIdleTtlMs
: (value) => require("../bridges/sshConnectionPool.cjs").setDefaultTransportIdleTtlMs(value);
function canPruneSessionLifecycleTombstone(sessionId) {
return !sessionOperationTails.has(sessionId)
&& !sessionStartMarkers.has(sessionId)
&& !pendingOutputBySession.has(sessionId);
}
function deleteSessionLifecycleTombstone(sessionId) {
sessionLifecycleTombstoneTimes.delete(sessionId);
sessionOutputGenerations.delete(sessionId);
sessionCloseEpochs.delete(sessionId);
pendingSessionStartBootEpochs.delete(sessionId);
}
function normalizeBootEpoch(bootEpoch) {
if (!Number.isFinite(bootEpoch)) return undefined;
return Number(bootEpoch);
}
function rememberPendingStartBootEpoch(sessionId, bootEpoch) {
const normalized = normalizeBootEpoch(bootEpoch);
if (!sessionId || normalized === undefined) return;
pendingSessionStartBootEpochs.set(sessionId, normalized);
}
function isStaleSessionBootEpoch(sessionId, bootEpoch) {
const requestedEpoch = normalizeBootEpoch(bootEpoch);
if (requestedEpoch === undefined || !sessionId) return false;
const ownerEpoch = pendingSessionStartBootEpochs.get(sessionId);
return ownerEpoch !== undefined && ownerEpoch > requestedEpoch;
}
function pruneSessionLifecycleTombstones() {
const currentTime = now();
for (const [sessionId, closedAt] of sessionLifecycleTombstoneTimes) {
if (currentTime - closedAt < sessionLifecycleTombstoneTtlMs) continue;
if (!canPruneSessionLifecycleTombstone(sessionId)) continue;
deleteSessionLifecycleTombstone(sessionId);
}
if (sessionLifecycleTombstoneTimes.size <= maxSessionLifecycleTombstones) return;
for (const sessionId of [...sessionLifecycleTombstoneTimes.keys()]) {
if (sessionLifecycleTombstoneTimes.size <= maxSessionLifecycleTombstones) break;
if (!canPruneSessionLifecycleTombstone(sessionId)) continue;
deleteSessionLifecycleTombstone(sessionId);
}
}
function touchSessionLifecycleTombstone(sessionId) {
if (!sessionId) return;
sessionLifecycleTombstoneTimes.delete(sessionId);
sessionLifecycleTombstoneTimes.set(sessionId, now());
}
function finalizeNaturalSessionExit(sessionId) {
if (!sessionId) return;
sessionStartMarkers.delete(sessionId);
sessionRequestIds.delete(sessionId);
clearTerminalSessionPerformanceState(sessionId);
touchSessionLifecycleTombstone(sessionId);
pruneSessionLifecycleTombstones();
}
const createWorkerOutputSender = () => createSender(
parentPort,
0,
outputPorts,
terminalDataPipeline,
pendingOutputBySession,
sessionOutputGenerations,
sessionRequestIds,
null,
finalizeNaturalSessionExit,
);
function replayWorkerOutput(sessionId, chunks) {
const sender = createWorkerOutputSender();
for (const chunk of chunks || []) {
const data = chunk && typeof chunk === "object" && "data" in chunk ? chunk.data : chunk;
const meta = chunk && typeof chunk === "object" ? chunk.meta : undefined;
const pipelineProcessed = meta?.pluginPipelineProcessed === true;
sender.send("netcatty:data", {
sessionId,
data,
meta,
tapped: true,
pipelineProcessed,
});
}
}
function invalidateSessionOutput(sessionId) {
if (!sessionId) return;
sessionOutputGenerations.set(
sessionId,
(sessionOutputGenerations.get(sessionId) ?? 0) + 1,
);
pendingOutputBySession.delete(sessionId);
outputPorts.closeSession(sessionId);
terminalDataPipeline?.detach?.(sessionId, undefined, "session-closed");
sessionRequestIds.delete(sessionId);
clearTerminalSessionPerformanceState(sessionId);
touchSessionLifecycleTombstone(sessionId);
pruneSessionLifecycleTombstones();
}
async function handleRequest(message) {
const handler = ipcMain.handlers.get(message.channel);
if (!handler) {
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
error: `No terminal worker handler registered for ${message.channel}`,
});
return;
}
try {
const isSessionStart = SESSION_START_CHANNELS.has(message.channel);
const requestedSessionId = isSessionStart ? message.payload?.sessionId : null;
const naturalExitGenerations = new Map();
const requestedSessionGeneration = requestedSessionId
? (sessionOutputGenerations.get(requestedSessionId) ?? 0)
: null;
if (requestedSessionId) {
sessionRequestIds.set(requestedSessionId, message.requestId);
sessionLifecycleTombstoneTimes.delete(requestedSessionId);
}
const result = await handler({
sender: createSender(
parentPort,
message.webContentsId,
outputPorts,
terminalDataPipeline,
pendingOutputBySession,
sessionOutputGenerations,
sessionRequestIds,
isSessionStart ? message.requestId : null,
(sessionId, generation) => {
naturalExitGenerations.set(sessionId, generation);
finalizeNaturalSessionExit(sessionId);
},
),
}, message.payload);
const sessionId = result?.sessionId;
if (isSessionStart && sessionId) {
const currentGeneration = sessionOutputGenerations.get(sessionId) ?? 0;
const exitedGeneration = naturalExitGenerations.get(sessionId);
const exitedDuringRequest = exitedGeneration !== undefined
&& currentGeneration > exitedGeneration;
const requestedGenerationStillCurrent = requestedSessionGeneration === null
|| currentGeneration === requestedSessionGeneration;
if (!exitedDuringRequest && requestedGenerationStillCurrent) {
sessionRequestIds.set(sessionId, message.requestId);
sessionStartMarkers.add(sessionId);
sessionLifecycleTombstoneTimes.delete(sessionId);
} else {
sessionRequestIds.delete(sessionId);
sessionStartMarkers.delete(sessionId);
}
}
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
result,
...(typeof sessionId === "string"
? { sessionGeneration: sessionOutputGenerations.get(sessionId) ?? 0 }
: {}),
});
} catch (err) {
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
error: err?.message || String(err),
});
}
}
async function closeSupersededSessionStart(message) {
const sessionId = message.payload?.sessionId;
if (!sessionId) return;
parentPort.postMessage({
kind: "session-superseding",
sessionId,
sessionGeneration: sessionOutputGenerations.get(sessionId) ?? 0,
replacementRequestId: message.requestId,
});
invalidateSessionOutput(sessionId);
const closeHandler = ipcMain.handlers.get("netcatty:close:await");
if (closeHandler) {
await closeHandler({
sender: createSender(
parentPort,
message.webContentsId,
outputPorts,
terminalDataPipeline,
pendingOutputBySession,
sessionOutputGenerations,
sessionRequestIds,
null,
finalizeNaturalSessionExit,
),
}, { sessionId });
}
}
function postRequestError(message, error) {
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
error: error?.message || String(error),
});
}
function trackSessionOperation(sessionId, operation, kind) {
sessionOperationTails.set(sessionId, operation);
sessionOperationKinds.set(sessionId, kind);
void operation.finally(() => {
if (sessionOperationTails.get(sessionId) === operation) {
sessionOperationTails.delete(sessionId);
sessionOperationKinds.delete(sessionId);
pruneSessionLifecycleTombstones();
}
});
}
function dispatchRequest(message) {
pruneSessionLifecycleTombstones();
const sessionId = SESSION_START_CHANNELS.has(message.channel)
? message.payload?.sessionId
: null;
if (message.channel === "netcatty:close:await" && message.payload?.sessionId) {
dispatchSessionClose(message, true);
return;
}
if (!sessionId) {
void handleRequest(message);
return;
}
if (isStaleSessionBootEpoch(sessionId, message.payload?.bootEpoch)) {
postRequestError(message, new Error("Terminal session start was superseded by a newer boot"));
return;
}
// The replacement cannot register its own controller until the queued
// start settles, so cancel that start before waiting for its PATH refresh.
const { abortPendingBoot } = require("../bridges/sessionBootEpoch.cjs");
abortPendingBoot(sessionId, message.payload?.bootEpoch);
rememberPendingStartBootEpoch(sessionId, message.payload?.bootEpoch);
const closeEpoch = sessionCloseEpochs.get(sessionId) ?? 0;
const previous = sessionOperationTails.get(sessionId);
const previousKind = sessionOperationKinds.get(sessionId);
const shouldClosePreviousStart = previousKind === "start" || sessionStartMarkers.has(sessionId);
const current = (previous || Promise.resolve()).catch(() => {}).then(async () => {
if ((sessionCloseEpochs.get(sessionId) ?? 0) !== closeEpoch
|| isStaleSessionBootEpoch(sessionId, message.payload?.bootEpoch)) {
postRequestError(message, new Error("Terminal session start was cancelled by close or superseded by a newer boot"));
return;
}
try {
if (shouldClosePreviousStart) await closeSupersededSessionStart(message);
if ((sessionCloseEpochs.get(sessionId) ?? 0) !== closeEpoch
|| isStaleSessionBootEpoch(sessionId, message.payload?.bootEpoch)) {
postRequestError(message, new Error("Terminal session start was cancelled by close or superseded by a newer boot"));
return;
}
sessionStartMarkers.add(sessionId);
await handleRequest(message);
} catch (error) {
postRequestError(message, error);
}
});
trackSessionOperation(sessionId, current, "start");
}
function dispatchSessionClose(message, expectsResponse) {
const sessionId = message.payload?.sessionId;
if (!sessionId) {
if (expectsResponse) void handleRequest(message);
else handleSend(message);
return;
}
if (isStaleSessionBootEpoch(sessionId, message.payload?.bootEpoch)) {
if (expectsResponse) {
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
result: { skipped: true, reason: "boot-epoch-mismatch" },
});
}
return;
}
// Signal cancellation before waiting for the start operation. Otherwise a
// pending PATH refresh can spawn a PTY before its queued close runs.
const { abortPendingBoot } = require("../bridges/sessionBootEpoch.cjs");
abortPendingBoot(sessionId, message.payload?.bootEpoch);
sessionCloseEpochs.set(sessionId, (sessionCloseEpochs.get(sessionId) ?? 0) + 1);
pendingSessionStartBootEpochs.delete(sessionId);
touchSessionLifecycleTombstone(sessionId);
const previous = sessionOperationTails.get(sessionId);
const current = (previous || Promise.resolve()).catch(() => {}).then(async () => {
try {
if (expectsResponse) {
invalidateSessionOutput(sessionId);
await handleRequest(message);
} else {
handleSend(message);
}
sessionStartMarkers.delete(sessionId);
} catch (error) {
if (expectsResponse) postRequestError(message, error);
}
});
trackSessionOperation(sessionId, current, "close");
pruneSessionLifecycleTombstones();
}
function handleSend(message) {
const listener = ipcMain.listeners.get(message.channel);
if (!listener) return;
if (message.channel === "netcatty:interrupt") {
if (message.payload?.cancelPendingWritesOnly !== true) {
terminalDataPipeline?.clearSensitiveInput?.(message.payload?.sessionId);
}
const trace = normalizeTrace(message.payload);
logTerminalInterruptDebug("worker-received-send", {
channel: message.channel,
webContentsId: message.webContentsId,
}, trace);
}
if (message.channel === "netcatty:close" && message.payload?.sessionId) {
invalidateSessionOutput(message.payload.sessionId);
}
try {
listener({
sender: createSender(
parentPort,
message.webContentsId,
outputPorts,
terminalDataPipeline,
pendingOutputBySession,
sessionOutputGenerations,
sessionRequestIds,
null,
finalizeNaturalSessionExit,
),
}, message.payload);
} catch (err) {
// Send listeners (write/resize/flow/close) are fire-and-forget; a throw
// here is synchronous and would otherwise escape as an uncaught
// exception on the worker's message loop.
console.error(`[TerminalWorker] send listener failed for ${message.channel}:`, err);
if (reportSuppressedError) {
try {
reportSuppressedError("send-listener", err, `send listener failed for ${message.channel}`);
} catch {
// Reporting must never be able to escalate into a worker crash.
}
}
}
}
function handleUrgentInput(webContentsId, message) {
if (message?.kind !== "interrupt" || !message.sessionId) return;
handleSend({
channel: "netcatty:interrupt",
payload: {
sessionId: message.sessionId,
trace: message.trace,
urgentInputPort: true,
},
webContentsId,
});
}
function handleMessage(eventOrMessage) {
const { message, ports } = normalizeMessageEvent(eventOrMessage);
if (message?.kind === "set-ssh-transport-idle-ttl") {
setDefaultTransportIdleTtlMs(message.value);
return;
}
if (message?.kind === "urgent-input-port") {
urgentInputPorts?.open(message.webContentsId, ports?.[0]);
return;
}
if (message?.kind === "close-urgent-input-port") {
urgentInputPorts?.close(message.webContentsId);
return;
}
if (message?.kind === "output-port") {
const sessionGeneration = sessionOutputGenerations.get(message.sessionId) ?? 0;
if (Number.isSafeInteger(message.sessionGeneration)
&& message.sessionGeneration !== sessionGeneration) {
try { ports?.[0]?.close?.(); } catch {}
return;
}
outputPorts.open(message.sessionId, ports?.[0]);
replayWorkerOutput(message.sessionId, message.bufferedOutput);
const pending = pendingOutputBySession.get(message.sessionId);
const notifyReady = () => parentPort.postMessage({
kind: "output-port-ready",
sessionId: message.sessionId,
...(Number.isSafeInteger(message.sessionGeneration) ? { sessionGeneration } : {}),
...(message.outputPortRequestId
? { outputPortRequestId: message.outputPortRequestId }
: {}),
});
if (pending) {
void pending.then(
notifyReady,
notifyReady,
);
} else {
notifyReady();
}
return;
}
if (message?.kind === "terminal-interceptor-port") {
terminalDataPipeline?.attach?.(message, ports?.[0]);
return;
}
if (message?.kind === "terminal-interceptor-detach") {
terminalDataPipeline?.detach?.(message.sessionId, message.direction, "detached");
return;
}
if (message?.kind === "output-flush") {
replayWorkerOutput(message.sessionId, message.chunks);
return;
}
if (message?.kind === "close-output-port") {
invalidateSessionOutput(message.sessionId);
return;
}
if (message?.kind === "output-drain") {
outputPorts.postControl(message.sessionId, {
kind: "drain",
requestId: message.requestId,
});
return;
}
if (message?.kind === "request") {
dispatchRequest(message);
return;
}
if (message?.kind === "send") {
if (message.channel === "netcatty:close" && message.payload?.sessionId) {
dispatchSessionClose(message, false);
return;
}
handleSend(message);
}
}
function start() {
if (started) return;
started = true;
urgentInputPorts = createUrgentInputPortRegistry(handleUrgentInput);
registerBridges?.(ipcMain);
parentPort.on("message", handleMessage);
}
return {
start,
ipcMain,
createSender(webContentsId) {
return createSender(
parentPort,
webContentsId,
outputPorts,
terminalDataPipeline,
pendingOutputBySession,
sessionOutputGenerations,
sessionRequestIds,
null,
finalizeNaturalSessionExit,
);
},
closeUrgentInputPortsForTest() {
urgentInputPorts?.closeAll();
},
_getSessionLifecycleStateCountsForTests() {
pruneSessionLifecycleTombstones();
return {
outputGenerations: sessionOutputGenerations.size,
closeEpochs: sessionCloseEpochs.size,
};
},
};
}
module.exports = {
createTerminalWorkerRuntime,
createOutputPortRegistry,
};