mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +00:00
* feat: add script dialog form controls * feat: add script dialog text and number fields * feat: add conditional script dialog fields * fix: address script dialog review feedback * fix: harden script dialog form validation * fix: harden script dialog review issues --------- Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com>
676 lines
19 KiB
JavaScript
676 lines
19 KiB
JavaScript
const assert = require("node:assert/strict");
|
|
const test = require("node:test");
|
|
|
|
const scriptBridge = require("./scriptBridge.cjs");
|
|
|
|
function delay(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
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/);
|
|
});
|
|
|
|
test("script run sends form dialog requests and resolves object responses", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
let dialogRequest;
|
|
const sessionId = "session-form-dialog";
|
|
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
webContents: {
|
|
fromId: () => null,
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
if (channel === "netcatty:script:screen-snapshot-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:screen-snapshot-response")({}, {
|
|
requestId: payload.requestId,
|
|
snapshot: {
|
|
rows: 24,
|
|
cols: 80,
|
|
currentRow: 0,
|
|
lines: ["user@host:~$ "],
|
|
},
|
|
});
|
|
});
|
|
}
|
|
if (channel === "netcatty:script:dialog-request") {
|
|
dialogRequest = payload;
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:dialog-response")({}, {
|
|
requestId: payload.requestId,
|
|
value: { env: "prod", restart: true, mode: "safe" },
|
|
});
|
|
});
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "form-dialog",
|
|
scriptLabel: "Form dialog",
|
|
sessionId,
|
|
content: `
|
|
const values = await nct.dialog.form({
|
|
title: 'Deploy',
|
|
message: 'Choose options',
|
|
fields: [
|
|
{ type: 'select', name: 'env', label: 'Environment', options: ['dev', 'prod'], defaultValue: 'dev' },
|
|
{ type: 'checkbox', name: 'restart', label: 'Restart', defaultValue: false },
|
|
{ type: 'radio', name: 'mode', label: 'Mode', options: ['safe', 'fast'], defaultValue: 'fast' },
|
|
],
|
|
});
|
|
nct.log(values.env + ':' + values.restart + ':' + values.mode);
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
assert.equal(dialogRequest.type, "form");
|
|
assert.equal(dialogRequest.message, "Choose options");
|
|
assert.equal(dialogRequest.form.title, "Deploy");
|
|
assert.deepEqual(
|
|
JSON.parse(JSON.stringify(dialogRequest.form.fields.map((field) => [field.type, field.name, field.defaultValue]))),
|
|
[
|
|
["select", "env", "dev"],
|
|
["checkbox", "restart", false],
|
|
["radio", "mode", "fast"],
|
|
],
|
|
);
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "form-dialog");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /prod:true:safe/);
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
});
|
|
|
|
test("script run treats cancelled form dialogs as script failures", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
const sessionId = "session-form-cancel";
|
|
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
webContents: {
|
|
fromId: () => null,
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
if (channel === "netcatty:script:screen-snapshot-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:screen-snapshot-response")({}, {
|
|
requestId: payload.requestId,
|
|
snapshot: {
|
|
rows: 24,
|
|
cols: 80,
|
|
currentRow: 0,
|
|
lines: ["user@host:~$ "],
|
|
},
|
|
});
|
|
});
|
|
}
|
|
if (channel === "netcatty:script:dialog-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:dialog-response")({}, {
|
|
requestId: payload.requestId,
|
|
cancelled: true,
|
|
});
|
|
});
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "form-cancel",
|
|
scriptLabel: "Form cancel",
|
|
sessionId,
|
|
content: `
|
|
await nct.dialog.form({
|
|
message: 'Choose options',
|
|
fields: [{ type: 'checkbox', name: 'restart', label: 'Restart' }],
|
|
});
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "form-cancel");
|
|
assert.equal(finalRun.status, "failed");
|
|
assert.equal(finalRun.error, "Dialog cancelled");
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
});
|
|
|
|
test("script waitFor ignores keywords from the startup screen snapshot until new output arrives", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
const sessionId = "session-stale-startup-output";
|
|
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
webContents: {
|
|
fromId: () => null,
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
if (channel === "netcatty:script:screen-snapshot-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:screen-snapshot-response")({}, {
|
|
requestId: payload.requestId,
|
|
snapshot: {
|
|
rows: 24,
|
|
cols: 80,
|
|
currentRow: 1,
|
|
lines: [
|
|
"old deployment READY marker",
|
|
"user@host:~$ ",
|
|
],
|
|
},
|
|
});
|
|
});
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
const runPromise = handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "stale-output",
|
|
scriptLabel: "Stale output",
|
|
sessionId,
|
|
content: `
|
|
const value = await nct.screen.waitFor('READY', 1000);
|
|
nct.log('matched ' + value);
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
await delay(50);
|
|
const earlyRun = sentRunUpdates.at(-1)?.find((run) => run.scriptId === "stale-output");
|
|
assert.notEqual(earlyRun?.status, "completed");
|
|
assert.doesNotMatch(
|
|
(earlyRun?.logs || []).map((entry) => entry.message).join("\n"),
|
|
/matched READY/,
|
|
);
|
|
|
|
scriptBridge.appendSessionOutput(sessionId, "fresh READY\n");
|
|
await runPromise;
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "stale-output");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /matched READY/);
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
});
|
|
|
|
test("script waitFor sees output that arrives while startup snapshot sync is pending", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
const sessionId = "session-output-during-startup-sync";
|
|
let snapshotRequestId;
|
|
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
webContents: {
|
|
fromId: () => null,
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
if (channel === "netcatty:script:screen-snapshot-request") {
|
|
snapshotRequestId = payload.requestId;
|
|
}
|
|
if (channel === "netcatty:script:dialog-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:dialog-response")({}, {
|
|
requestId: payload.requestId,
|
|
value: "abort",
|
|
});
|
|
});
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
const runPromise = handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "output-during-sync",
|
|
scriptLabel: "Output during sync",
|
|
sessionId,
|
|
content: `
|
|
const value = await nct.screen.waitFor('READY', 1000);
|
|
nct.log('matched ' + value);
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
await delay(20);
|
|
assert.ok(snapshotRequestId);
|
|
scriptBridge.appendSessionOutput(sessionId, "fresh READY\n");
|
|
handlers.get("netcatty:script:screen-snapshot-response")({}, {
|
|
requestId: snapshotRequestId,
|
|
snapshot: {
|
|
rows: 24,
|
|
cols: 80,
|
|
currentRow: 0,
|
|
lines: ["user@host:~$ "],
|
|
},
|
|
});
|
|
|
|
await runPromise;
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "output-during-sync");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /matched READY/);
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
});
|
|
|
|
test("script waitForPrompt can still use the current startup prompt", async () => {
|
|
const handlers = new Map();
|
|
const sentRunUpdates = [];
|
|
const sessionId = "session-startup-prompt";
|
|
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
scriptBridge.init({
|
|
sessions: new Map(),
|
|
electronModule: {
|
|
app: {
|
|
getVersion: () => "test",
|
|
getPath: () => process.cwd(),
|
|
},
|
|
webContents: {
|
|
fromId: () => null,
|
|
},
|
|
},
|
|
terminalBridge: {
|
|
writeToSession() {},
|
|
},
|
|
terminalWorkerManager: null,
|
|
getMainWindow: () => ({
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:script:runs-updated") {
|
|
sentRunUpdates.push(payload.runs);
|
|
}
|
|
if (channel === "netcatty:script:screen-snapshot-request") {
|
|
setImmediate(() => {
|
|
handlers.get("netcatty:script:screen-snapshot-response")({}, {
|
|
requestId: payload.requestId,
|
|
snapshot: {
|
|
rows: 24,
|
|
cols: 80,
|
|
currentRow: 0,
|
|
lines: ["root@host:~# "],
|
|
},
|
|
});
|
|
});
|
|
}
|
|
},
|
|
},
|
|
}),
|
|
});
|
|
scriptBridge.registerHandlers({
|
|
handle(channel, handler) {
|
|
handlers.set(channel, handler);
|
|
},
|
|
});
|
|
|
|
await handlers.get("netcatty:script:run")({}, {
|
|
scriptId: "startup-prompt",
|
|
scriptLabel: "Startup prompt",
|
|
sessionId,
|
|
content: `
|
|
const index = await nct.screen.waitForPrompt(1000);
|
|
nct.log('prompt index ' + index);
|
|
`,
|
|
permissionMode: "auto",
|
|
});
|
|
|
|
const finalRun = sentRunUpdates.at(-1).find((run) => run.scriptId === "startup-prompt");
|
|
assert.equal(finalRun.status, "completed");
|
|
assert.match(finalRun.logs.map((entry) => entry.message).join("\n"), /prompt index/);
|
|
scriptBridge.removeSessionBuffer(sessionId);
|
|
});
|