[Init] Initial commit - NetMesh terminal manager

electron/bridges/terminalBridge.sessionActivity.test.cjs

@@ -0,0 +1,161 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const terminalBridge = require("./terminalBridge.cjs");
+
+test("renderer terminal input reports activity for the matching session", () => {
+  const writes = [];
+  const activity = [];
+  const sessions = new Map([
+    ["session-1", {
+      proc: { write: (data) => writes.push(data) },
+      webContentsId: 1,
+    }],
+  ]);
+  terminalBridge.init({
+    sessions,
+    electronModule: { webContents: { fromId: () => null } },
+    reportOpenedSessionActivity: (event) => activity.push(event),
+  });
+
+  terminalBridge.writeToSession({ sender: {} }, {
+    sessionId: "session-1",
+    data: "pwd\r",
+  });
+
+  assert.deepEqual(writes, ["pwd\r"]);
+  assert.deepEqual(activity, [
+    { sessionId: "session-1", phase: "touch" },
+  ]);
+});
+
+test("direct-mode close reports ownership cleanup after the backend already exited", () => {
+  const activity = [];
+  terminalBridge.init({
+    sessions: new Map(),
+    electronModule: {},
+    reportOpenedSessionActivity: (event) => activity.push(event),
+  });
+
+  const result = terminalBridge.closeSession({ sender: {} }, {
+    sessionId: "already-exited",
+    bootEpoch: 3,
+  });
+
+  assert.deepEqual(result, { closed: false, reason: "missing" });
+  assert.deepEqual(activity, [{ sessionId: "already-exited", phase: "closed" }]);
+});
+
+test("direct-mode disconnect close keeps host_open ownership for reconnect", () => {
+  const activity = [];
+  const sessions = new Map([
+    ["session-keep", {
+      proc: { kill() {} },
+      webContentsId: 1,
+    }],
+  ]);
+  terminalBridge.init({
+    sessions,
+    electronModule: { webContents: { fromId: () => ({ isDestroyed: () => true, send() {} }) } },
+    reportOpenedSessionActivity: (event) => activity.push(event),
+  });
+
+  const result = terminalBridge.closeSession({ sender: {} }, {
+    sessionId: "session-keep",
+    retainOwnership: true,
+  });
+
+  assert.deepEqual(result, { closed: true });
+  assert.equal(sessions.has("session-keep"), false);
+  assert.deepEqual(activity, []);
+});
+
+test("direct-mode disconnect close of an already-exited session keeps ownership", () => {
+  const activity = [];
+  terminalBridge.init({
+    sessions: new Map(),
+    electronModule: {},
+    reportOpenedSessionActivity: (event) => activity.push(event),
+  });
+
+  const result = terminalBridge.closeSession({ sender: {} }, {
+    sessionId: "already-exited",
+    bootEpoch: 3,
+    retainOwnership: true,
+  });
+
+  assert.deepEqual(result, { closed: false, reason: "missing" });
+  assert.deepEqual(activity, []);
+});
+
+test("stale direct-mode close cannot clean up a newer same-id boot", () => {
+  const activity = [];
+  const { claimSessionSlot } = require("./sessionBootEpoch.cjs");
+  const lifecycle = new Map();
+  claimSessionSlot(lifecycle, "reconnected", {}, 4);
+  lifecycle.delete("reconnected");
+  terminalBridge.init({
+    sessions: new Map(),
+    electronModule: {},
+    reportOpenedSessionActivity: (event) => activity.push(event),
+  });
+
+  const stale = terminalBridge.closeSession({ sender: {} }, {
+    sessionId: "reconnected",
+    bootEpoch: 3,
+  });
+  assert.deepEqual(stale, { skipped: true, reason: "boot-epoch-mismatch" });
+  assert.deepEqual(activity, []);
+
+  const current = terminalBridge.closeSession({ sender: {} }, {
+    sessionId: "reconnected",
+    bootEpoch: 4,
+  });
+  assert.deepEqual(current, { closed: false, reason: "missing" });
+  assert.deepEqual(activity, [{ sessionId: "reconnected", phase: "closed" }]);
+});
+
+test("only a submitted non-sensitive user command arms cwd recovery", () => {
+  const stream = { write() { return true; } };
+  const session = { stream, webContentsId: 1, blockUntargetedCwdProbe: true };
+  const sessions = new Map([["session-1", session]]);
+  terminalBridge.init({ sessions, electronModule: { webContents: { fromId: () => null } } });
+
+  terminalBridge.writeToSession({ sender: {} }, {
+    sessionId: "session-1", data: "pwd", automated: false,
+  });
+  assert.notEqual(session.pendingCwdRecoveryAfterUserCommand, true);
+
+  terminalBridge.writeToSession({ sender: {} }, {
+    sessionId: "session-1", data: "secret\r", sensitive: true,
+  });
+  assert.notEqual(session.pendingCwdRecoveryAfterUserCommand, true);
+
+  terminalBridge.writeToSession({ sender: {} }, {
+    sessionId: "session-1", data: "pwd\r", automated: false,
+  });
+  assert.equal(session.pendingCwdRecoveryAfterUserCommand, true);
+});
+
+test("blocked transfer input and failed writes do not arm cwd recovery", () => {
+  const blocked = {
+    stream: { write() { throw new Error("must not write during transfer"); } },
+    webContentsId: 1,
+    blockUntargetedCwdProbe: true,
+    zmodemSentry: { isActive: () => true, cancel() {} },
+  };
+  const failed = {
+    stream: { write() { throw Object.assign(new Error("closed"), { code: "EPIPE" }); } },
+    webContentsId: 1,
+    blockUntargetedCwdProbe: true,
+  };
+  const sessions = new Map([["blocked", blocked], ["failed", failed]]);
+  terminalBridge.init({ sessions, electronModule: { webContents: { fromId: () => null } } });
+
+  terminalBridge.writeToSession({ sender: {} }, { sessionId: "blocked", data: "pwd\r" });
+  terminalBridge.writeToSession({ sender: {} }, { sessionId: "failed", data: "pwd\r" });
+
+  assert.notEqual(blocked.pendingCwdRecoveryAfterUserCommand, true);
+  assert.notEqual(failed.pendingCwdRecoveryAfterUserCommand, true);
+});