Files
Netcatty/electron/terminalWorker/runtime.cjs
T
陈大猫andCursor 6b9b71ac8a feat(scripts): terminal script automation, recording, and side panel (#1763)
* feat(scripts): add terminal script automation, recording, and side panel

Introduce nct script runtime in the main process with terminal-side recording,
execution overlay, Monaco editor, connect-script queues, and scripts side panel
integration. Fix recording to wire scriptRecorderRef into xterm, use waitForPrompt
for root/user shells, and save recorded scripts through the global editor dialog.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): address Bugbot review findings for recording and side panel

Refresh script run state in side panel memo, guard toolbar recording against
multi-session conflicts, reset connect scripts on reconnect, resolve focused
session via getActiveTerminalSessionId, and avoid wiping host edit form when
snippets list updates.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): prevent pending script re-run and improve workspace run feedback

Track one-shot pendingScript execution separately from onConnect queue so
reconnects do not replay Run-now scripts. Fall back to focused session when
running on all tabs outside a workspace, and toast when every tab is still
connecting.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): consume connect-script window once and filter serial hosts

Mark the onConnect script evaluation as consumed even when the queue is
empty so later snippet/host edits do not rerun automation mid-session.
Restore serial-host filtering in SelectHostPanel confirm handler.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): grace period before giving up on connect-script queue

Only mark onConnect automation as consumed after scripts run or a short
post-connect grace window expires, so late-loading snippets still trigger
while mid-session Vault edits do not.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): gate connect-script consumption on vault hydration

Replace the grace timer with vault-init and unresolved host script binding
checks so late-loading snippets still run onConnect automation while
mid-session edits stay suppressed. Clear pending script run state on
disconnect so reconnect retries workspace pending scripts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): honor run targets and retry failed connect automation

Route QuickScriptEditorDialog Run through onRunSnippet for multi-host
workspaces. Defer connect/pending script completion markers until each
script succeeds and retry the queue after failures.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): stabilize pending runs and global connect queue sync

Keep pending script run state across reconnects, run onConnect scripts
before one-shot workspace pending scripts, and strip per-host queue entries
when an onConnect script targets all hosts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): defer host queue snippet sync and guard connect runs

Persist snippet target links only when the host panel is saved, block
duplicate connect-script scheduling while a batch is running, and require
runnable hosts before showing Run in the snippets editor footer.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): retry connect failures and surface output-trigger errors

Use a retry tick in connect-script effect deps, toast automation failures
from output triggers, and require runnable hosts before QuickScript Run.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): track id-less pending runs and re-arm output triggers

Remember anonymous pendingScript objects after first run and allow
onOutput triggers to fire again when new terminal output arrives.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): unblock paused connect runs and pass session meta

Resolve waitForScriptRun on pause, run workspace scripts per session
with hostname context, defer output-trigger arming until runs start, and
add noRunnableHosts i18n for QuickScript Run.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): serialize output triggers and defer empty connect finalize

Fire at most one onOutput trigger per scan while a run is active, and
only finalize an empty connect queue after vault snippets are loaded.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): guard output launch race and script run waits

Block overlapping onOutput launches, timeout stuck waitForScriptRun
promises, and disable vault Run when no connectable targets exist.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): match output triggers on new chunks only

Scan onOutput patterns against recent terminal output instead of buffer
length dedupe, and restore overflow-visible on SelectHostPanel new-host flow.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): await sequential workspace runs and output launch

Wait for each tab script to finish in sequential workspace mode, and hold
output-trigger launch guard until the session run becomes active.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): wait through pause and hold output trigger until done

Keep connect and sequential workspace queues blocked until scripts
complete or fail, and retain output-trigger guard until the launched run
finishes.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): harden output trigger wait helpers

Add explicit timeouts to output-trigger wait helpers and stop rescanning
the buffer after script completion to avoid sticky-match rerun loops.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): allow empty connect queue and match output in new chunks

Treat an empty connectScriptIds array as an explicit cleared queue instead
of re-migrating from snippet targets, and only fire onOutput triggers when
the latest terminal output contains the pattern.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): require fresh output overlap for onOutput triggers

Only fire output-matched scripts when the regex match extends into the
latest terminal chunk, preventing reruns from stale buffer text.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): promote manual scripts added to host connect queue

Diff connect queue changes from raw connectScriptIds so saving a host
updates manual scripts to onConnect when they are newly queued.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): dedupe output triggers by match position

Track the buffer end offset of each output trigger match and ignore
stale re-scans, with a longer wait for run registration before retry.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): record output trigger matches only after run starts

Propagate automation launch failures to output triggers and commit match
dedupe only once the session run is registered as active.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): address Codex review on wait cursor and sensitive codegen

Track scan offset so waitFor/waitForAny only match output after the previous wait, and emit sendLine after sensitive prompt in recorded scripts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(scripts): harden onOutput triggers against PTY echo and local input

Filter server output before pattern matching so onOutput fires only after
Enter on real stdout, not on keystroke/paste echo, OSC/SGR sequences, or
alternate-screen apps. Add dev diagnostics and scope triggers to the active
session when no explicit host targets are configured.

Co-authored-by: Cursor <cursoragent@cursor.com>

* chore(scripts): remove onOutput trigger debug logging

Drop temporary diagnostics module and console traces now that PTY echo
filtering is verified; keep the production trigger pipeline unchanged.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-06-28 23:48:12 +08:00

300 lines
7.3 KiB
JavaScript

"use strict";
const {
logTerminalInterruptDebug,
normalizeTrace,
} = require("../bridges/terminalInterruptDiagnostics.cjs");
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(parentPort) {
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) {
const port = outputPorts.get(sessionId);
if (!port) return false;
try {
port.postMessage({ sessionId, data });
return true;
} catch {
closeSession(sessionId);
return false;
}
}
function open(sessionId, port, bufferedOutput = []) {
if (!sessionId || !port) return;
closeSession(sessionId);
outputPorts.set(sessionId, port);
try {
port.start?.();
} catch {
// Some Electron MessagePort implementations do not require start().
}
for (const chunk of bufferedOutput || []) {
post(sessionId, chunk);
}
parentPort.postMessage({ kind: "output-port-ready", sessionId });
}
function flush(sessionId, chunks = []) {
for (const chunk of chunks || []) {
if (!post(sessionId, chunk)) {
parentPort.postMessage({ kind: "output", sessionId, data: chunk });
}
}
}
return {
open,
post,
flush,
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,
closeAll,
};
}
function createSender(parentPort, webContentsId, outputPorts) {
return {
id: webContentsId,
isDestroyed() {
return false;
},
send(channel, payload) {
if (channel === "netcatty:data") {
parentPort.postMessage({
kind: "output-tap",
sessionId: payload?.sessionId,
data: payload?.data,
});
if (outputPorts?.post?.(payload?.sessionId, payload?.data)) {
return;
}
parentPort.postMessage({
kind: "output",
sessionId: payload?.sessionId,
data: payload?.data,
});
return;
}
if (channel === "netcatty:exit" && payload?.sessionId) {
outputPorts?.closeSession?.(payload.sessionId);
}
parentPort.postMessage({
kind: "renderer-event",
webContentsId,
channel,
payload,
});
},
};
}
function createTerminalWorkerRuntime(options = {}) {
const {
parentPort,
registerBridges,
} = options;
const ipcMain = createIpcMainHarness();
let started = false;
const outputPorts = createOutputPortRegistry(parentPort);
let urgentInputPorts = null;
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 result = await handler({
sender: createSender(parentPort, message.webContentsId, outputPorts),
}, message.payload);
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
result,
});
} catch (err) {
parentPort.postMessage({
kind: "response",
requestId: message.requestId,
error: err?.message || String(err),
});
}
}
function handleSend(message) {
const listener = ipcMain.listeners.get(message.channel);
if (!listener) return;
if (message.channel === "netcatty:interrupt") {
const trace = normalizeTrace(message.payload);
logTerminalInterruptDebug("worker-received-send", {
channel: message.channel,
webContentsId: message.webContentsId,
}, trace);
}
if (message.channel === "netcatty:close" && message.payload?.sessionId) {
outputPorts.closeSession(message.payload.sessionId);
}
listener({
sender: createSender(parentPort, message.webContentsId, outputPorts),
}, message.payload);
}
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 === "urgent-input-port") {
urgentInputPorts?.open(message.webContentsId, ports?.[0]);
return;
}
if (message?.kind === "output-port") {
outputPorts.open(message.sessionId, ports?.[0], message.bufferedOutput);
return;
}
if (message?.kind === "output-flush") {
outputPorts.flush(message.sessionId, message.chunks);
return;
}
if (message?.kind === "close-output-port") {
outputPorts.closeSession(message.sessionId);
return;
}
if (message?.kind === "request") {
void handleRequest(message);
return;
}
if (message?.kind === "send") {
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);
},
closeUrgentInputPortsForTest() {
urgentInputPorts?.closeAll();
},
};
}
module.exports = {
createTerminalWorkerRuntime,
createOutputPortRegistry,
};