Files
Netcatty/electron/bridges/terminalBridge.workerSessionLogMirror.test.cjs
T
陈大猫andCursor 2d95c71b85 Fix manual session log capture in terminal worker mode (#1944)
* Fix manual session log capture in terminal worker mode

Manual session logs (and script session logs) start their write stream in
the main process, but with the default terminal worker runtime all session
output is appended to the worker process's own sessionLogStreamManager
instance, so the saved file only ever contained the initial prompt line.

Tap the worker output mirror into the main-process stream manager so
main-process log streams receive terminal output, and mirror sudo-autofill
and programmatic command log rewrites when forwarding writes to the worker
so those logs stay sanitized like worker-owned auto session logs.

Fixes #1938

Co-authored-by: Cursor <cursoragent@cursor.com>

* Dedupe fallback worker output before session log taps

The runtime sender announces every chunk with an output-tap message and
falls back to a plain output message when the output port is unusable;
the manager notified taps for both, double-writing manual/script session
logs in the fallback path. Mark fallback output as already tapped so taps
fire exactly once per chunk.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-07-05 22:27:16 +08:00

113 lines
4.0 KiB
JavaScript

const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const terminalBridge = require("./terminalBridge.cjs");
const sessionLogStreamManager = require("./sessionLogStreamManager.cjs");
const TEMP_ROOT = path.join(__dirname, ".tmp-terminal-bridge-worker-log-mirror-tests");
function registerWorkerHandlers(sent) {
const listeners = new Map();
const handlers = new Map();
terminalBridge.registerHandlers(
{
handle(channel, handler) {
handlers.set(channel, handler);
},
on(channel, listener) {
listeners.set(channel, listener);
},
},
{
terminalWorkerManager: {
request: async () => ({}),
send(channel, payload, options) {
sent.push([channel, payload, options]);
},
},
},
);
return { listeners, handlers };
}
test("worker-mode write forward still delivers the payload to the worker", () => {
const sent = [];
const { listeners } = registerWorkerHandlers(sent);
const write = listeners.get("netcatty:write");
write({ sender: { id: 7 } }, { sessionId: "session-x", data: "ls\r" });
assert.deepEqual(sent, [
["netcatty:write", { sessionId: "session-x", data: "ls\r" }, { webContentsId: 7 }],
]);
});
test("worker-mode write forward mirrors sudo autofill rewrites into main-process session logs", async () => {
const directory = path.join(TEMP_ROOT, `sudo-${Date.now()}-${Math.random().toString(16).slice(2)}`);
const filePath = path.join(directory, "manual.log");
const sessionId = `session-${Date.now()}-${Math.random().toString(16).slice(2)}`;
const sent = [];
const { listeners } = registerWorkerHandlers(sent);
const write = listeners.get("netcatty:write");
try {
const startResult = sessionLogStreamManager.startStreamToFile(sessionId, {
filePath,
format: "raw",
hostLabel: "manual",
stopRequiresToken: true,
});
assert.equal(startResult.ok, true);
const prepared = "sudo -p '[sudo] password for %p: __NETCATTY_SUDO_abc123__' apt update\r";
write({ sender: { id: 7 } }, { sessionId, data: prepared });
assert.equal(sent.length, 1);
// The remote echo of the prepared command arrives as terminal output.
sessionLogStreamManager.appendData(sessionId, `${prepared}\n`);
const finalPath = await sessionLogStreamManager.stopStream(sessionId, startResult.token);
assert.equal(finalPath, filePath);
assert.equal(fs.readFileSync(filePath, "utf8"), "sudo apt update\r\n");
} finally {
await sessionLogStreamManager.cleanupAll();
fs.rmSync(directory, { recursive: true, force: true });
}
});
test("worker-mode write forward mirrors programmatic command rewrites into main-process session logs", async () => {
const directory = path.join(TEMP_ROOT, `programmatic-${Date.now()}-${Math.random().toString(16).slice(2)}`);
const filePath = path.join(directory, "manual.log");
const sessionId = `session-${Date.now()}-${Math.random().toString(16).slice(2)}`;
const sent = [];
const { listeners } = registerWorkerHandlers(sent);
const write = listeners.get("netcatty:write");
try {
const startResult = sessionLogStreamManager.startStreamToFile(sessionId, {
filePath,
format: "raw",
hostLabel: "manual",
stopRequiresToken: true,
});
assert.equal(startResult.ok, true);
write({ sender: { id: 7 } }, {
sessionId,
data: " netcatty-internal-reload\r",
logRewrite: { sentCommand: " netcatty-internal-reload", displayCommand: "" },
});
sessionLogStreamManager.appendData(sessionId, " netcatty-internal-reload\r\nuser@host:~$ ");
const finalPath = await sessionLogStreamManager.stopStream(sessionId, startResult.token);
assert.equal(finalPath, filePath);
assert.equal(fs.readFileSync(filePath, "utf8"), "\r\nuser@host:~$ ");
} finally {
await sessionLogStreamManager.cleanupAll();
fs.rmSync(directory, { recursive: true, force: true });
}
});