Files
Netcatty/electron/terminalWorker/runtime.test.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

277 lines
6.7 KiB
JavaScript

const assert = require("node:assert/strict");
const test = require("node:test");
const { createTerminalWorkerRuntime } = require("./runtime.cjs");
class FakePort {
constructor() {
this.messages = [];
this.closed = false;
this.started = false;
this.listeners = new Map();
}
postMessage(message) {
this.messages.push(message);
}
start() {
this.started = true;
}
close() {
this.closed = true;
}
on(channel, callback) {
this.listeners.set(channel, callback);
}
emitMessage(message) {
const callback = this.listeners.get("message");
if (callback) {
callback({ data: message });
return;
}
this.onmessage?.({ data: message });
}
}
function createParentPort() {
const messages = [];
const listeners = new Map();
return {
messages,
on(channel, cb) {
listeners.set(channel, cb);
},
postMessage(message) {
messages.push(message);
},
emitMessage(message) {
listeners.get("message")?.(message);
},
};
}
test("runtime invokes registered request handlers and posts responses", async () => {
const parentPort = createParentPort();
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.handle("netcatty:test", async (_event, payload) => ({ ok: true, payload }));
},
});
runtime.start();
parentPort.emitMessage({
kind: "request",
requestId: "req-1",
channel: "netcatty:test",
payload: { value: 1 },
webContentsId: 7,
});
await new Promise((resolve) => setImmediate(resolve));
assert.deepEqual(parentPort.messages, [
{
kind: "response",
requestId: "req-1",
result: { ok: true, payload: { value: 1 } },
},
]);
});
test("runtime invokes fire-and-forget listeners", () => {
const parentPort = createParentPort();
const calls = [];
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.on("netcatty:write", (_event, payload) => calls.push(payload));
},
});
runtime.start();
parentPort.emitMessage({
kind: "send",
channel: "netcatty:write",
payload: { sessionId: "s1", data: "x" },
webContentsId: 7,
});
assert.deepEqual(calls, [{ sessionId: "s1", data: "x" }]);
});
test("runtime routes urgent input port interrupts to the interrupt listener", () => {
const parentPort = createParentPort();
const urgentPort = new FakePort();
const calls = [];
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.on("netcatty:interrupt", (event, payload) => {
calls.push({ senderId: event.sender.id, payload });
});
},
});
runtime.start();
parentPort.emitMessage({
data: {
kind: "urgent-input-port",
webContentsId: 7,
},
ports: [urgentPort],
});
urgentPort.emitMessage({
kind: "interrupt",
sessionId: "s1",
trace: { traceId: "trace-1" },
});
assert.equal(urgentPort.started, true);
assert.deepEqual(calls, [
{
senderId: 7,
payload: {
sessionId: "s1",
trace: { traceId: "trace-1" },
urgentInputPort: true,
},
},
]);
});
test("runtime routes terminal data over output messages", async () => {
const parentPort = createParentPort();
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.handle("netcatty:test", (event) => {
event.sender.send("netcatty:data", { sessionId: "s1", data: "hello" });
return { done: true };
});
},
});
runtime.start();
parentPort.emitMessage({
kind: "request",
requestId: "req-1",
channel: "netcatty:test",
payload: {},
webContentsId: 7,
});
await new Promise((resolve) => setImmediate(resolve));
assert.deepEqual(parentPort.messages[0], {
kind: "output-tap",
sessionId: "s1",
data: "hello",
});
assert.deepEqual(parentPort.messages[1], {
kind: "output",
sessionId: "s1",
data: "hello",
});
});
test("runtime routes terminal data over a transferred output port", async () => {
const parentPort = createParentPort();
const outputPort = new FakePort();
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.handle("netcatty:test", (event) => {
event.sender.send("netcatty:data", { sessionId: "s1", data: "hello" });
return { done: true };
});
},
});
runtime.start();
parentPort.emitMessage({
data: {
kind: "output-port",
sessionId: "s1",
bufferedOutput: ["early"],
},
ports: [outputPort],
});
parentPort.emitMessage({
kind: "request",
requestId: "req-1",
channel: "netcatty:test",
payload: {},
webContentsId: 7,
});
await new Promise((resolve) => setImmediate(resolve));
assert.equal(outputPort.started, true);
assert.deepEqual(outputPort.messages, [
{ sessionId: "s1", data: "early" },
{ sessionId: "s1", data: "hello" },
]);
assert.equal(parentPort.messages[0].kind, "output-port-ready");
assert.deepEqual(parentPort.messages[1], {
kind: "output-tap",
sessionId: "s1",
data: "hello",
});
assert.equal(parentPort.messages.some((message) => message.kind === "output"), false);
});
test("runtime.createSender uses the transferred output port", () => {
const parentPort = createParentPort();
const outputPort = new FakePort();
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges() {},
});
runtime.start();
parentPort.emitMessage({
data: { kind: "output-port", sessionId: "s1" },
ports: [outputPort],
});
runtime.createSender(7).send("netcatty:data", { sessionId: "s1", data: "hello" });
assert.deepEqual(outputPort.messages, [{ sessionId: "s1", data: "hello" }]);
assert.deepEqual(parentPort.messages.at(-1), {
kind: "output-tap",
sessionId: "s1",
data: "hello",
});
});
test("runtime forwards non-output renderer events to the parent", async () => {
const parentPort = createParentPort();
const runtime = createTerminalWorkerRuntime({
parentPort,
registerBridges(ipcMain) {
ipcMain.handle("netcatty:test", (event) => {
event.sender.send("netcatty:exit", { sessionId: "s1", reason: "closed" });
return { done: true };
});
},
});
runtime.start();
parentPort.emitMessage({
kind: "request",
requestId: "req-1",
channel: "netcatty:test",
payload: {},
webContentsId: 7,
});
await new Promise((resolve) => setImmediate(resolve));
assert.deepEqual(parentPort.messages[0], {
kind: "renderer-event",
webContentsId: 7,
channel: "netcatty:exit",
payload: { sessionId: "s1", reason: "closed" },
});
});