mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
823 lines
26 KiB
JavaScript
823 lines
26 KiB
JavaScript
"use strict";
|
|
|
|
const assert = require("node:assert/strict");
|
|
const test = require("node:test");
|
|
|
|
function loadFreshBridge() {
|
|
const bridgePath = require.resolve("./mcpServerBridge.cjs");
|
|
delete require.cache[bridgePath];
|
|
return require("./mcpServerBridge.cjs");
|
|
}
|
|
|
|
test("MCP/Catty capability context uses scoped metadata when terminal sessions live in worker", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:portforward:list") {
|
|
return Promise.resolve([{ tunnelId: "worker-pf-1", status: "active" }]);
|
|
}
|
|
throw new Error(`unexpected worker request: ${channel}`);
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.updateSessionMetadata([
|
|
{
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
label: "Prod",
|
|
username: "root",
|
|
protocol: "ssh",
|
|
shellType: "bash",
|
|
connected: true,
|
|
},
|
|
], "chat-1");
|
|
|
|
const result = await bridge.dispatchBuiltinRpc("netcatty/getContext", {
|
|
chatSessionId: "chat-1",
|
|
});
|
|
|
|
assert.equal(result.hostCount, 1);
|
|
assert.equal(result.tools.terminal.execute, "terminal_execute");
|
|
assert.equal(result.tools.terminal.start, "terminal_start");
|
|
assert.match(result.description, /terminal_execute/);
|
|
assert.deepEqual(result.activePortForwardTunnels, [
|
|
{ tunnelId: "worker-pf-1", status: "active" },
|
|
]);
|
|
assert.deepEqual(requests, [{
|
|
channel: "netcatty:portforward:list",
|
|
payload: {},
|
|
options: {},
|
|
}]);
|
|
assert.deepEqual(result.hosts[0], {
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
label: "Prod",
|
|
os: "",
|
|
username: "root",
|
|
protocol: "ssh",
|
|
shellType: "bash",
|
|
deviceType: "",
|
|
connected: true,
|
|
hostId: "",
|
|
hostChain: [],
|
|
activePortForwards: [],
|
|
});
|
|
});
|
|
|
|
test("MCP/Catty terminal_execute proxies to worker when terminal sessions live in worker", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
return Promise.resolve({ ok: true, stdout: "ok\n", stderr: "", exitCode: 0 });
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.setCommandTimeout(23);
|
|
bridge.updateSessionMetadata([
|
|
{
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
protocol: "ssh",
|
|
connected: true,
|
|
},
|
|
], "chat-1");
|
|
|
|
const result = await bridge.dispatchBuiltinRpc("netcatty/exec", {
|
|
sessionId: "ssh-1",
|
|
command: "pwd",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
|
|
assert.deepEqual(result, { ok: true, stdout: "ok\n", stderr: "", exitCode: 0 });
|
|
assert.deepEqual(requests, [
|
|
{
|
|
channel: "netcatty:ai:exec",
|
|
payload: {
|
|
sessionId: "ssh-1",
|
|
command: "pwd",
|
|
chatSessionId: "chat-1",
|
|
commandTimeoutMs: 23000,
|
|
sessionMeta: {
|
|
hostname: "host.example",
|
|
label: "",
|
|
os: "",
|
|
username: "",
|
|
protocol: "ssh",
|
|
shellType: "",
|
|
deviceType: "",
|
|
connected: true,
|
|
hostId: "",
|
|
savedHostId: "",
|
|
hostChain: [],
|
|
activePortForwards: [],
|
|
},
|
|
enforceWallTimeout: true,
|
|
commandBlocklist: [],
|
|
},
|
|
options: {},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test("approved worker command is rejected when its session scope disappeared while waiting", async () => {
|
|
let approvalId = null;
|
|
let workerRequestCount = 0;
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request() {
|
|
workerRequestCount += 1;
|
|
return Promise.resolve({ ok: true, stdout: "unexpected" });
|
|
},
|
|
},
|
|
});
|
|
bridge.setMainWindowGetter(() => ({
|
|
isDestroyed: () => false,
|
|
webContents: {
|
|
id: 1,
|
|
send(channel, payload) {
|
|
if (channel === "netcatty:ai:mcp:approval-request") approvalId = payload.approvalId;
|
|
},
|
|
},
|
|
}));
|
|
bridge.setPermissionMode("confirm");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-approval", protocol: "ssh", connected: true },
|
|
], "chat-approval");
|
|
|
|
const pending = bridge.dispatchBuiltinRpc("netcatty/exec", {
|
|
sessionId: "ssh-approval",
|
|
command: "pwd",
|
|
chatSessionId: "chat-approval",
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
assert.ok(approvalId);
|
|
|
|
bridge.updateSessionMetadata([], "chat-approval");
|
|
bridge.resolveApprovalFromRenderer(approvalId, true);
|
|
const result = await pending;
|
|
|
|
assert.equal(result.ok, false);
|
|
assert.match(result.error, /scope/);
|
|
assert.equal(workerRequestCount, 0);
|
|
});
|
|
|
|
test("MCP/Catty SFTP tools proxy to worker when terminal sessions live in worker", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:sftp:openForSession") {
|
|
return Promise.resolve({ ok: true, sftpId: "worker-sftp-1" });
|
|
}
|
|
if (channel === "netcatty:sftp:list") {
|
|
return Promise.resolve([
|
|
{ name: "app.log", type: "file", size: "12 bytes" },
|
|
]);
|
|
}
|
|
if (channel === "netcatty:sftp:close") {
|
|
return Promise.resolve({ ok: true });
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandTimeout(23);
|
|
bridge.updateSessionMetadata([
|
|
{
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
protocol: "ssh",
|
|
connected: true,
|
|
},
|
|
], "chat-1");
|
|
|
|
const result = await bridge.dispatchBuiltinRpc("netcatty/sftp/list", {
|
|
sessionId: "ssh-1",
|
|
path: "/var/log",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
|
|
assert.deepEqual(result, {
|
|
ok: true,
|
|
entries: [{ name: "app.log", type: "file", size: "12 bytes" }],
|
|
});
|
|
assert.deepEqual(requests, [
|
|
{
|
|
channel: "netcatty:sftp:openForSession",
|
|
payload: {
|
|
sessionId: "ssh-1",
|
|
encodingStateKey: "chat:chat-1:session:ssh-1",
|
|
timeoutMs: 23000,
|
|
},
|
|
options: {},
|
|
},
|
|
{
|
|
channel: "netcatty:sftp:list",
|
|
payload: {
|
|
sessionId: "ssh-1",
|
|
path: "/var/log",
|
|
chatSessionId: "chat-1",
|
|
sftpId: "worker-sftp-1",
|
|
timeoutMs: 23000,
|
|
},
|
|
options: {},
|
|
},
|
|
{
|
|
channel: "netcatty:sftp:close",
|
|
payload: {
|
|
sftpId: "worker-sftp-1",
|
|
encodingStateKey: "chat:chat-1:session:ssh-1",
|
|
},
|
|
options: {},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test("worker SFTP cancellation waits for a pending open and closes its late handle", async () => {
|
|
let resolveOpen;
|
|
const openPromise = new Promise((resolve) => {
|
|
resolveOpen = resolve;
|
|
});
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:sftp:openForSession") return openPromise;
|
|
if (channel === "netcatty:sftp:close") return Promise.resolve({ ok: true });
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandTimeout(23);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-pending", hostname: "host.example", protocol: "ssh", connected: true },
|
|
], "chat-pending");
|
|
|
|
const operation = bridge.dispatchBuiltinRpc("netcatty/sftp/list", {
|
|
sessionId: "ssh-pending",
|
|
path: "/var/log",
|
|
chatSessionId: "chat-pending",
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const cancellation = bridge.cancelSftpOpsForSession("chat-pending");
|
|
|
|
resolveOpen({ ok: true, sftpId: "worker-sftp-late" });
|
|
await cancellation;
|
|
await assert.rejects(operation, /Cancelled/);
|
|
|
|
assert.deepEqual(requests.map((entry) => entry.channel), [
|
|
"netcatty:sftp:openForSession",
|
|
"netcatty:sftp:close",
|
|
]);
|
|
assert.equal(requests[1].payload.sftpId, "worker-sftp-late");
|
|
});
|
|
|
|
test("worker SFTP cancellation stays bounded when open never responds", async () => {
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel) {
|
|
if (channel === "netcatty:sftp:openForSession") return new Promise(() => {});
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandTimeout(0.01);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-stalled", hostname: "host.example", protocol: "ssh", connected: true },
|
|
], "chat-stalled");
|
|
|
|
const operation = bridge.dispatchBuiltinRpc("netcatty/sftp/list", {
|
|
sessionId: "ssh-stalled",
|
|
path: "/var/log",
|
|
chatSessionId: "chat-stalled",
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
const startedAt = Date.now();
|
|
const cancellation = bridge.cancelSftpOpsForSession("chat-stalled");
|
|
|
|
await assert.rejects(operation, /timed out/);
|
|
await cancellation;
|
|
assert.ok(Date.now() - startedAt < 2000, "cancellation should honor the bounded open timeout");
|
|
});
|
|
|
|
test("MCP/Catty terminal_start, poll, and stop proxy worker background jobs", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: "worker-job-1",
|
|
sessionId: payload.sessionId,
|
|
command: payload.command,
|
|
status: "running",
|
|
});
|
|
}
|
|
if (channel === "netcatty:ai:jobPoll") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: payload.jobId,
|
|
sessionId: "ssh-1",
|
|
command: "npm test",
|
|
status: "running",
|
|
completed: false,
|
|
output: "done\n",
|
|
nextOffset: 5,
|
|
});
|
|
}
|
|
if (channel === "netcatty:ai:jobStop") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: payload.jobId,
|
|
sessionId: "ssh-1",
|
|
status: "stopping",
|
|
completed: false,
|
|
});
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.setCommandTimeout(23);
|
|
bridge.updateSessionMetadata([
|
|
{
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
protocol: "ssh",
|
|
shellType: "bash",
|
|
connected: true,
|
|
},
|
|
], "chat-1");
|
|
|
|
const started = await bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-1",
|
|
command: "npm test",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
const polled = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-1",
|
|
offset: 0,
|
|
chatSessionId: "chat-1",
|
|
});
|
|
const stopped = await bridge.dispatchBuiltinRpc("netcatty/jobStop", {
|
|
jobId: "worker-job-1",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
const polledAfterStop = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-1",
|
|
offset: 5,
|
|
chatSessionId: "chat-1",
|
|
});
|
|
|
|
assert.equal(started.ok, true);
|
|
assert.equal(polled.output, "done\n");
|
|
assert.equal(stopped.status, "stopping");
|
|
assert.equal(polledAfterStop.ok, true);
|
|
assert.deepEqual(requests.map((entry) => entry.channel), [
|
|
"netcatty:ai:jobStart",
|
|
"netcatty:ai:jobPoll",
|
|
"netcatty:ai:jobStop",
|
|
"netcatty:ai:jobPoll",
|
|
]);
|
|
assert.deepEqual(requests[0].payload, {
|
|
sessionId: "ssh-1",
|
|
command: "npm test",
|
|
chatSessionId: "chat-1",
|
|
commandTimeoutMs: 23000,
|
|
sessionMeta: {
|
|
hostname: "host.example",
|
|
label: "",
|
|
os: "",
|
|
username: "",
|
|
protocol: "ssh",
|
|
shellType: "bash",
|
|
deviceType: "",
|
|
connected: true,
|
|
hostId: "",
|
|
savedHostId: "",
|
|
hostChain: [],
|
|
activePortForwards: [],
|
|
},
|
|
commandBlocklist: [],
|
|
});
|
|
});
|
|
|
|
test("idle cleanup drops completed worker jobs even when the agent never polled them", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload) {
|
|
requests.push({ channel, payload });
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: "worker-job-unpolled",
|
|
sessionId: payload.sessionId,
|
|
status: "running",
|
|
});
|
|
}
|
|
if (channel === "netcatty:ai:jobPoll") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: payload.jobId,
|
|
sessionId: payload.sessionId,
|
|
status: "completed",
|
|
completed: true,
|
|
});
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-unpolled", protocol: "ssh", connected: true },
|
|
], "chat-unpolled");
|
|
|
|
const started = await bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-unpolled",
|
|
command: "sleep 1",
|
|
chatSessionId: "chat-unpolled",
|
|
});
|
|
assert.equal(started.ok, true);
|
|
|
|
assert.equal(await bridge.hasActiveWorkerJobForTerminalSession("ssh-unpolled"), false);
|
|
assert.deepEqual(requests.map((entry) => entry.channel), [
|
|
"netcatty:ai:jobStart",
|
|
"netcatty:ai:jobPoll",
|
|
]);
|
|
|
|
const stalePoll = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-unpolled",
|
|
chatSessionId: "chat-unpolled",
|
|
});
|
|
assert.equal(stalePoll.ok, false);
|
|
assert.match(stalePoll.error, /not found/i);
|
|
});
|
|
|
|
test("MCP/Catty chat cancellation forwards to worker background jobs", async () => {
|
|
const requests = [];
|
|
const sends = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({
|
|
ok: true,
|
|
jobId: "worker-job-1",
|
|
sessionId: payload.sessionId,
|
|
command: payload.command,
|
|
status: "running",
|
|
});
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
send(channel, payload, options) {
|
|
sends.push({ channel, payload, options });
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{
|
|
sessionId: "ssh-1",
|
|
hostname: "host.example",
|
|
protocol: "ssh",
|
|
connected: true,
|
|
},
|
|
], "chat-1");
|
|
|
|
const started = await bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-1",
|
|
command: "sleep 30",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
assert.equal(started.ok, true);
|
|
|
|
const cancelled = await bridge.applyChatSessionCancelled("chat-1", true);
|
|
assert.deepEqual(cancelled, {
|
|
ok: true,
|
|
chatSessionId: "chat-1",
|
|
cancelled: true,
|
|
});
|
|
assert.deepEqual(sends, [
|
|
{
|
|
channel: "netcatty:ai:catty:cancel",
|
|
payload: { chatSessionId: "chat-1" },
|
|
options: {},
|
|
},
|
|
]);
|
|
|
|
const pollAfterCancel = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-1",
|
|
chatSessionId: "chat-1",
|
|
});
|
|
assert.deepEqual(pollAfterCancel, {
|
|
ok: false,
|
|
error: "Background job not found",
|
|
});
|
|
});
|
|
|
|
test("terminal close stops and forgets worker background jobs for that terminal", async () => {
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload, options) {
|
|
requests.push({ channel, payload, options });
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({ ok: true, jobId: "worker-job-close", status: "running" });
|
|
}
|
|
if (channel === "netcatty:ai:jobStop") {
|
|
return Promise.resolve({ ok: true, jobId: payload.jobId, completed: true });
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([{ sessionId: "ssh-close", protocol: "ssh", connected: true }], "chat-close");
|
|
|
|
const started = await bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-close",
|
|
command: "sleep 30",
|
|
chatSessionId: "chat-close",
|
|
});
|
|
assert.equal(started.ok, true);
|
|
|
|
await bridge.cancelWorkerBackgroundJobsForTerminalSession("ssh-close");
|
|
|
|
assert.equal(requests.at(-1).channel, "netcatty:ai:jobStop");
|
|
assert.equal(requests.at(-1).payload.jobId, "worker-job-close");
|
|
const polled = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-close",
|
|
chatSessionId: "chat-close",
|
|
});
|
|
assert.deepEqual(polled, { ok: false, error: "Background job not found" });
|
|
});
|
|
|
|
test("terminal close stays bounded when worker job stop never responds", async () => {
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel) {
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({ ok: true, jobId: "worker-job-stalled", status: "running" });
|
|
}
|
|
if (channel === "netcatty:ai:jobStop") return new Promise(() => {});
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.setCommandTimeout(0.01);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-stalled-job", protocol: "ssh", connected: true },
|
|
], "chat-stalled-job");
|
|
|
|
const started = await bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-stalled-job",
|
|
command: "sleep 30",
|
|
chatSessionId: "chat-stalled-job",
|
|
});
|
|
assert.equal(started.ok, true);
|
|
|
|
const startedAt = Date.now();
|
|
await bridge.cancelWorkerBackgroundJobsForTerminalSession("ssh-stalled-job");
|
|
assert.ok(Date.now() - startedAt < 2000, "job cleanup should honor the bounded stop timeout");
|
|
|
|
const polled = await bridge.dispatchBuiltinRpc("netcatty/jobPoll", {
|
|
jobId: "worker-job-stalled",
|
|
chatSessionId: "chat-stalled-job",
|
|
});
|
|
assert.deepEqual(polled, { ok: false, error: "Background job not found" });
|
|
});
|
|
|
|
test("terminal close cancels a worker job start that finishes late", async () => {
|
|
let resolveStart;
|
|
const pendingStart = new Promise((resolve) => {
|
|
resolveStart = resolve;
|
|
});
|
|
const requests = [];
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload) {
|
|
requests.push({ channel, payload });
|
|
if (channel === "netcatty:ai:jobStart") return pendingStart;
|
|
if (channel === "netcatty:ai:jobStop") {
|
|
return Promise.resolve({ ok: true, jobId: payload.jobId, completed: true });
|
|
}
|
|
return Promise.reject(new Error(`unexpected worker request: ${channel}`));
|
|
},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-late-job", protocol: "ssh", connected: true },
|
|
], "chat-late-job");
|
|
|
|
const starting = bridge.dispatchBuiltinRpc("netcatty/jobStart", {
|
|
sessionId: "ssh-late-job",
|
|
command: "sleep 30",
|
|
chatSessionId: "chat-late-job",
|
|
});
|
|
await new Promise((resolve) => setImmediate(resolve));
|
|
await bridge.cancelWorkerBackgroundJobsForTerminalSession("ssh-late-job");
|
|
resolveStart({ ok: true, jobId: "worker-job-late", status: "running" });
|
|
|
|
const result = await starting;
|
|
assert.equal(result.ok, false);
|
|
assert.match(result.error, /closing/i);
|
|
assert.deepEqual(requests.map((entry) => entry.channel), [
|
|
"netcatty:ai:jobStart",
|
|
"netcatty:ai:jobStop",
|
|
]);
|
|
});
|
|
|
|
test("job diagnostics tell a scope mismatch from a lost route and log chat cancellation", async (t) => {
|
|
process.env.NETCATTY_JOB_DIAG = "1";
|
|
const lines = [];
|
|
t.mock.method(console, "info", (...args) => { lines.push(args.join(" ")); });
|
|
t.after(() => { delete process.env.NETCATTY_JOB_DIAG; });
|
|
const events = () => lines
|
|
.filter((line) => line.startsWith("[Netcatty JobDiag] "))
|
|
.map((line) => JSON.parse(line.slice("[Netcatty JobDiag] ".length)));
|
|
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload) {
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({ ok: true, jobId: "worker-job-1", sessionId: payload.sessionId, status: "running" });
|
|
}
|
|
return Promise.resolve({ ok: true, jobId: payload.jobId, status: "running", completed: false });
|
|
},
|
|
send() {},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-1", hostname: "host.example", protocol: "ssh", shellType: "bash", connected: true },
|
|
], "chat-1");
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobStart", { sessionId: "ssh-1", command: "sleep 1", chatSessionId: "chat-1" });
|
|
|
|
// The route exists but belongs to another chat session: not a lost route.
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobPoll", { jobId: "worker-job-1", chatSessionId: "chat-2" });
|
|
bridge.cancelWorkerBackgroundJobsForSession("chat-1");
|
|
// The worker route is gone now, so these fall through to the main-process
|
|
// handlers; the miss must still be logged and explained.
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobPoll", { jobId: "worker-job-1", chatSessionId: "chat-1" });
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobStop", { jobId: "worker-job-1", chatSessionId: "chat-1" });
|
|
|
|
const misses = events().filter((event) => event.event === "job-stop-miss");
|
|
assert.deepEqual(misses.map((event) => [event.op, event.reason]), [
|
|
["poll", "scope-mismatch"],
|
|
["poll", "job-missing"],
|
|
["stop", "job-missing"],
|
|
]);
|
|
const removed = events().filter((event) => event.event === "route-removed");
|
|
assert.deepEqual(removed.map((event) => [event.jobId, event.via]), [["worker-job-1", "chat-session-cancel"]]);
|
|
});
|
|
|
|
test("route-removed is emitted once when a concurrent cancel removes the route during terminal cleanup", async (t) => {
|
|
process.env.NETCATTY_JOB_DIAG = "1";
|
|
const lines = [];
|
|
t.mock.method(console, "info", (...args) => { lines.push(args.join(" ")); });
|
|
t.after(() => { delete process.env.NETCATTY_JOB_DIAG; });
|
|
const removedEvents = () => lines
|
|
.filter((line) => line.startsWith("[Netcatty JobDiag] "))
|
|
.map((line) => JSON.parse(line.slice("[Netcatty JobDiag] ".length)))
|
|
.filter((event) => event.event === "route-removed");
|
|
|
|
let releaseStop;
|
|
const stopGate = new Promise((resolve) => { releaseStop = resolve; });
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload) {
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({ ok: true, jobId: "worker-job-1", sessionId: payload.sessionId, status: "running" });
|
|
}
|
|
if (channel === "netcatty:ai:jobStop") return stopGate.then(() => ({ ok: true }));
|
|
return Promise.resolve({ ok: true });
|
|
},
|
|
send() {},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-1", hostname: "host.example", protocol: "ssh", shellType: "bash", connected: true },
|
|
], "chat-1");
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobStart", { sessionId: "ssh-1", command: "sleep 1", chatSessionId: "chat-1" });
|
|
|
|
const cleanup = bridge.cancelWorkerBackgroundJobsForTerminalSession("ssh-1");
|
|
bridge.cancelWorkerBackgroundJobsForSession("chat-1");
|
|
releaseStop();
|
|
await cleanup;
|
|
|
|
assert.deepEqual(removedEvents().map((event) => [event.jobId, event.via]), [["worker-job-1", "chat-session-cancel"]]);
|
|
});
|
|
|
|
test("job diagnostics log a worker-side miss while the main-process route still exists", async (t) => {
|
|
process.env.NETCATTY_JOB_DIAG = "1";
|
|
const lines = [];
|
|
t.mock.method(console, "info", (...args) => { lines.push(args.join(" ")); });
|
|
t.after(() => { delete process.env.NETCATTY_JOB_DIAG; });
|
|
const misses = () => lines
|
|
.filter((line) => line.startsWith("[Netcatty JobDiag] "))
|
|
.map((line) => JSON.parse(line.slice("[Netcatty JobDiag] ".length)))
|
|
.filter((event) => event.event === "job-stop-miss");
|
|
|
|
const bridge = loadFreshBridge();
|
|
bridge.init({
|
|
sessions: new Map(),
|
|
electronModule: null,
|
|
terminalWorkerManager: {
|
|
request(channel, payload) {
|
|
if (channel === "netcatty:ai:jobStart") {
|
|
return Promise.resolve({ ok: true, jobId: "worker-job-1", sessionId: payload.sessionId, status: "running" });
|
|
}
|
|
// The worker evicted the job (pruned or restarted) but the route stays.
|
|
return Promise.resolve({ ok: false, error: "Background job not found" });
|
|
},
|
|
send() {},
|
|
},
|
|
});
|
|
bridge.setPermissionMode("auto");
|
|
bridge.setCommandBlocklist([]);
|
|
bridge.updateSessionMetadata([
|
|
{ sessionId: "ssh-1", hostname: "host.example", protocol: "ssh", shellType: "bash", connected: true },
|
|
], "chat-1");
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobStart", { sessionId: "ssh-1", command: "sleep 1", chatSessionId: "chat-1" });
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobPoll", { jobId: "worker-job-1", chatSessionId: "chat-1" });
|
|
await bridge.dispatchBuiltinRpc("netcatty/jobStop", { jobId: "worker-job-1", chatSessionId: "chat-1" });
|
|
|
|
assert.deepEqual(misses().map((event) => [event.op, event.reason]), [
|
|
["poll", "worker-job-missing"],
|
|
["stop", "worker-job-missing"],
|
|
]);
|
|
});
|