mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-21 15:41:17 +00:00
* 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>
264 lines
6.8 KiB
JavaScript
264 lines
6.8 KiB
JavaScript
const assert = require("node:assert/strict");
|
|
const test = require("node:test");
|
|
|
|
const scriptBridge = require("./scriptBridge.cjs");
|
|
|
|
test("script run writes through terminal worker manager when enabled", async () => {
|
|
const handlers = new Map();
|
|
const workerSends = [];
|
|
const terminalWrites = [];
|
|
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession(_event, payload) {
|
|
terminalWrites.push(payload);
|
|
},
|
|
},
|
|
terminalWorkerManager: {
|
|
addOutputTap() {
|
|
return () => {};
|
|
},
|
|
send(channel, payload, options) {
|
|
workerSends.push({ channel, payload, options });
|
|
},
|
|
},
|
|
getMainWindow: () => null,
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "script-1",
|
|
scriptLabel: "Smoke",
|
|
sessionId: "session-1",
|
|
content: "await nct.screen.sendLine('echo hi');",
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
assert.deepEqual(terminalWrites, []);
|
|
assert.equal(workerSends.length, 1);
|
|
assert.equal(workerSends[0].channel, "netcatty:write");
|
|
assert.deepEqual(workerSends[0].payload, {
|
|
sessionId: "session-1",
|
|
data: "echo hi\r",
|
|
automated: true,
|
|
});
|
|
});
|
|
|
|
test("script run completion stores actual executed step count", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "script-loop",
|
|
scriptLabel: "Loop",
|
|
sessionId: "session-1",
|
|
content: "for (let i = 0; i < 3; i += 1) { nct.log(`step ${i}`); }",
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "script-loop");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.equal(finalRun.stepIndex, 3);
|
|
assert.equal(finalRun.progressMode, "activity");
|
|
assert.equal(finalRun.totalSteps, undefined);
|
|
});
|
|
|
|
test("same session script runs are serialized through the session mutex", async () => {
|
|
const handlers = new Map();
|
|
const writeOrder = [];
|
|
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession(_event, payload) {
|
|
const marker = String(payload.data || "").match(/slow-run|fast-run/);
|
|
if (marker) writeOrder.push(marker[0]);
|
|
},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => null,
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
const runHandler = handlers.get("netcatty:script:run");
|
|
await Promise.all([
|
|
runHandler({}, {
|
|
scriptId: "slow",
|
|
scriptLabel: "Slow",
|
|
sessionId: "session-mutex",
|
|
content: `
|
|
await nct.sleep(40);
|
|
await nct.screen.sendLine('slow-run');
|
|
`,
|
|
permissionMode: "auto",
|
|
}),
|
|
runHandler({}, {
|
|
scriptId: "fast",
|
|
scriptLabel: "Fast",
|
|
sessionId: "session-mutex",
|
|
content: "await nct.screen.sendLine('fast-run');",
|
|
permissionMode: "auto",
|
|
}),
|
|
]);
|
|
|
|
assert.deepEqual(writeOrder, ["slow-run", "fast-run"]);
|
|
});
|
|
|
|
test("script run treats worker-managed sessions as connected", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: {
|
|
hasOpenSession(sessionId) {
|
|
return sessionId === "session-worker";
|
|
},
|
|
addOutputTap() {
|
|
return () => {};
|
|
},
|
|
send() {},
|
|
},
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "connected-check",
|
|
scriptLabel: "Connected check",
|
|
sessionId: "session-worker",
|
|
sessionMeta: { connected: true, hostname: "worker-host", username: "root" },
|
|
content: `
|
|
if (!nct.session.connected) {
|
|
throw new Error("Session not connected");
|
|
}
|
|
nct.log("connected ok");
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "connected-check");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /connected ok/);
|
|
});
|
|
|
|
test("script run uses renderer sessionMeta when main-process session map is empty", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "renderer-meta",
|
|
scriptLabel: "Renderer meta",
|
|
sessionId: "session-renderer",
|
|
sessionMeta: { connected: true, hostname: "10.0.0.1", username: "root" },
|
|
content: `
|
|
if (!nct.session.connected) {
|
|
throw new Error("Session not connected");
|
|
}
|
|
nct.log(\`\${nct.session.hostname}@\${nct.session.username}\`);
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "renderer-meta");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /10\.0\.0\.1@root/);
|
|
});
|