Files
Netcatty/components/terminal/osc7Setup.test.ts
T
2026-10-29 12:48:32 +08:00

1566 lines
60 KiB
TypeScript

import test from "node:test";
import * as pty from "node-pty";
import assert from "node:assert/strict";
import { execFileSync, spawnSync } from "node:child_process";
import {
chmodSync,
existsSync,
lstatSync,
mkdirSync,
mkdtempSync,
readFileSync,
readlinkSync,
realpathSync,
rmSync,
symlinkSync,
writeFileSync,
} from "node:fs";
import { tmpdir } from "node:os";
import { basename, join } from "node:path";
import { isIdleShellReadyForCommandInjection } from "../../domain/terminalCommandInjectionReady";
import {
isTerminalReadyForCommandInjection,
registerTerminalCommandInjectionReadyReader,
} from "./runtime/terminalCommandInjectionReadyRegistry";
import {
OSC7_MARKER,
OSC7_SETUP_OTHER_USER_MARKER,
OSC7_SETUP_STAGED_MARKER,
OSC7_PTY_SHELL_MARKER,
OSC7_PTY_ACK_MARKER,
OSC7_PTY_DONE_MARKER,
OSC7_PTY_FAILED_MARKER,
buildOsc7PtyShellProbeCommand,
buildOsc7PtySetupCommands,
buildOsc7ReloadCommand,
buildOsc7SetupCommand,
buildOsc7SetupExecCommand,
buildOsc7StageScriptCommand,
buildOsc7TypedSetupCommand,
getOsc7StagedScriptSha256,
parseOsc7SetupStagedPath,
runOsc7SetupAction,
shouldOfferOsc7SetupAction,
waitForOsc7SessionOutput,
type RunOsc7SetupActionOptions,
} from "./osc7Setup";
const runSetup = (env: NodeJS.ProcessEnv) => {
execFileSync("/bin/sh", ["-c", buildOsc7SetupCommand()], {
env: { ...process.env, ZDOTDIR: "", XDG_CONFIG_HOME: "", ...env },
stdio: "pipe",
});
};
const withTempHome = (prefix: string, fn: (home: string) => void) => {
const home = mkdtempSync(join(tmpdir(), prefix));
try {
fn(home);
} finally {
rmSync(home, { recursive: true, force: true });
}
};
const markerCount = (content: string) => content.split(OSC7_MARKER).length - 1;
const existingShells = (paths: string[]) => Array.from(new Set(paths.filter(existsSync)));
const supportedShells = () => existingShells(["/bin/bash", "/bin/zsh", "/usr/bin/zsh", "/opt/homebrew/bin/fish", "/usr/bin/fish"]);
const quoteShellArg = (value: string) => `'${value.replace(/'/g, "'\\''")}'`;
const extractOsc7Path = (output: string) => {
const escape = String.fromCharCode(0x1b);
const bell = String.fromCharCode(0x07);
const payloadStart = output.indexOf(`${escape}]7;`);
assert.notEqual(payloadStart, -1, "expected OSC 7 output");
const payload = output.slice(payloadStart + `${escape}]7;`.length);
const terminators = [payload.indexOf(escape), payload.indexOf(bell)].filter((index) => index >= 0);
const payloadEnd = terminators.length > 0 ? Math.min(...terminators) : payload.length;
const fileUrl = payload.slice(0, payloadEnd);
assert.ok(fileUrl.startsWith("file://"), "expected OSC 7 file URL");
return decodeURIComponent(new URL(fileUrl).pathname);
};
const runInteractiveHistoryProbe = ({
shellPath,
shellArgs,
dumpHistoryCommand,
dumpPath,
env,
input = buildOsc7SetupCommand(),
}: {
shellPath: string;
shellArgs: string[];
dumpHistoryCommand: string;
dumpPath: string;
env: NodeJS.ProcessEnv;
input?: string;
}) => {
const result = spawnSync(shellPath, shellArgs, {
env: { ...process.env, ZDOTDIR: "", XDG_CONFIG_HOME: "", ...env },
input: `${input.replace(/\r/g, "\n")}\n${dumpHistoryCommand}\nexit\n`,
encoding: "utf8",
});
assert.equal(result.status, 0, result.stderr || result.stdout);
assert.ok(existsSync(dumpPath), result.stderr || result.stdout);
return readFileSync(dumpPath, "utf8");
};
test("shouldOfferOsc7SetupAction only allows remote shell-style sessions", () => {
assert.equal(shouldOfferOsc7SetupAction({ protocol: "ssh" }), true);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "mosh" }), true);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "et" }), true);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "telnet" }), false);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "ssh", isNetworkDevice: true }), false);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "local", isLocalConnection: true }), false);
assert.equal(shouldOfferOsc7SetupAction({ protocol: "serial", isSerialConnection: true }), false);
});
test("runOsc7SetupAction configures in the background and only sends a small reload command", async () => {
const writes: Array<{ sessionId: string; data: string; automated?: boolean }> = [];
const localData: string[] = [];
let setupArgs: { sessionId: string; command: string } | null = null;
const result = await runOsc7SetupAction({
status: "connected",
sessionId: "session-1",
setupCommand: "printf setup-script",
setupOsc7Tracking: async (sessionId, command) => {
setupArgs = { sessionId, command };
return {
success: true,
stdout: "__NETCATTY_OSC7_SETUP_SHELL__=bash\n__NETCATTY_OSC7_SETUP_CONFIG__=/home/me/.bashrc\n\u001b]7;file://host/home/me\u0007",
stderr: "",
code: 0,
};
},
writeToSession: (sessionId, data, options) => {
writes.push({ sessionId, data, automated: options?.automated });
},
writeLocalTerminalData: (data) => {
localData.push(data);
},
});
assert.equal(result.success, true);
assert.deepEqual(setupArgs, { sessionId: "session-1", command: "printf setup-script" });
assert.equal(writes.length, 1);
assert.equal(writes[0].sessionId, "session-1");
assert.equal(writes[0].automated, true);
assert.match(writes[0].data, /source '\/home\/me\/\.bashrc'/);
assert.doesNotMatch(writes[0].data, /setup-script/);
assert.deepEqual(localData, ["\u001b]7;file://host/home/me\u0007"]);
});
test("runOsc7SetupAction stages the script and types a short runner for user-switched shells", async () => {
const writes: Array<{ sessionId: string; data: string; automated?: boolean }> = [];
const localData: string[] = [];
const setupCommands: string[] = [];
const result = await runOsc7SetupAction({
status: "connected",
sessionId: "session-1",
setupCommand: "printf setup-script",
setupOsc7Tracking: async (_sessionId, command) => {
setupCommands.push(command);
if (setupCommands.length === 1) {
return {
success: false,
stdout: `${OSC7_SETUP_OTHER_USER_MARKER}bash\n`,
stderr: "Netcatty OSC 7 setup: the active terminal shell belongs to another user\n",
code: 5,
error: "Netcatty OSC 7 setup: the active terminal shell belongs to another user",
};
}
return {
success: true,
stdout: `${OSC7_SETUP_STAGED_MARKER}/tmp/.netcatty-osc7-setup.abc123\n`,
stderr: "",
code: 0,
};
},
writeToSession: (sessionId, data, options) => {
writes.push({ sessionId, data, automated: options?.automated });
},
writeLocalTerminalData: (data) => {
localData.push(data);
},
});
assert.equal(result.success, true);
assert.equal(result.sentToTerminal, true);
assert.equal(setupCommands.length, 2);
assert.match(setupCommands[1], /mktemp/);
assert.equal(writes.length, 1);
assert.equal(writes[0].sessionId, "session-1");
assert.equal(writes[0].automated, true);
assert.match(writes[0].data, /NETCATTY_OSC7_FORCE_SHELL=bash/);
assert.match(writes[0].data, /'\/tmp\/\.netcatty-osc7-setup\.abc123'/);
assert.match(writes[0].data, /\.bashrc/);
// Single line: one history entry, so the appended bash cleanup deletes it.
assert.doesNotMatch(writes[0].data.slice(0, -1), /[\r\n]/);
assert.deepEqual(localData, []);
});
// Model separate exec/PTY identities (e.g. Koko) with live output observers.
// Echo input first, then deliver acknowledgements in separate chunks.
const createExit4PtyHarness = (shell: string | null = "bash", completion: "done" | "failed" | null = "done") => {
const writes: string[] = [];
const setupCommands: string[] = [];
const timeouts: number[] = [];
let onData: ((chunk: string) => void) | undefined;
let disposed = 0;
let ready = true;
const options: RunOsc7SetupActionOptions = {
status: "connected",
sessionId: "pty-session",
setupCommand: "exec-only-setup",
setupOsc7Tracking: async (_id, command) => {
setupCommands.push(command);
return { success: false, code: 4, error: "exec identity mismatch" };
},
isTerminalReadyForCommandInjection: () => ready,
waitForSessionOutput: (id, predicate, timeout) => {
timeouts.push(timeout);
return waitForOsc7SessionOutput((observedId, callback) => {
assert.equal(observedId, options.sessionId);
onData = callback;
return () => { onData = undefined; disposed += 1; };
}, id, predicate, 10);
},
writeToSession: (id, command, writeOptions) => {
assert.equal(id, options.sessionId);
assert.equal(writeOptions?.automated, true);
assert.deepEqual(writeOptions?.logRewrite, { sentCommand: command, displayCommand: "" });
assert.ok(onData, "subscribe before writing so fast replies cannot be lost");
writes.push(command);
onData(`prompt> ${command.replace(/\r$/, "\r\n")}`);
assert.ok(onData, "input echo must not satisfy the output predicate");
const final = command.includes("base64 -d");
const marker = writes.length === 1 ? OSC7_PTY_SHELL_MARKER
: !final ? OSC7_PTY_ACK_MARKER
: completion === "failed" ? OSC7_PTY_FAILED_MARKER : OSC7_PTY_DONE_MARKER;
const value = writes.length === 1 ? shell : !final ? String(writes.length - 2) : completion && shell;
if (value) {
onData(`\r\n${marker.slice(0, 12)}`);
onData?.(`${marker.slice(12)}${value}\r`);
assert.ok(onData, "wait for the complete line, not a partial shell name");
onData?.("\n");
}
},
};
return {
options, writes, setupCommands, timeouts,
setReady: (value: boolean) => { ready = value; },
disposed: () => disposed,
};
};
test("exit 4 probes the foreground shell and waits for chunked installation DONE, without exec staging", async () => {
for (const shell of ["bash", "zsh"]) {
const h = createExit4PtyHarness(shell);
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, true);
assert.equal(result.sentToTerminal, true);
assert.equal(result.error, undefined);
assert.deepEqual(h.setupCommands, ["exec-only-setup"]);
assert.deepEqual(h.writes, [buildOsc7PtyShellProbeCommand(), ...buildOsc7PtySetupCommands(shell as "bash" | "zsh")]);
assert.match(h.writes[0], /ZSH_VERSION.*BASH_VERSION/);
assert.match(h.writes[1], /mktemp/);
assert.match(h.writes.at(-1)!, new RegExp(`NETCATTY_OSC7_FORCE_SHELL=${shell}`));
for (const command of h.writes) assert.ok(Buffer.byteLength(command) < 3000);
assert.deepEqual(h.timeouts, h.writes.map((_, i) => i === h.writes.length - 1 ? 20000 : 5000));
assert.equal(h.disposed(), h.writes.length);
}
});
test("exit-4 stderr messages also select the dedicated PTY path", async () => {
for (const stderr of [
"Netcatty OSC 7 setup: could not identify the active terminal shell",
"Netcatty OSC 7 setup: active terminal shell did not match the current tab",
]) {
const h = createExit4PtyHarness();
h.options.setupOsc7Tracking = async () => ({ success: false, stderr: `${stderr}\n` });
assert.equal((await runOsc7SetupAction(h.options)).success, true);
assert.equal(h.writes.length, 1 + buildOsc7PtySetupCommands("bash").length);
}
});
test("exit 4 fails closed with an unsafe prompt or missing safety callbacks", async () => {
for (const missing of ["unsafe", "isTerminalReadyForCommandInjection", "waitForSessionOutput"] as const) {
const h = createExit4PtyHarness();
if (missing === "unsafe") h.setReady(false);
else delete h.options[missing];
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.match(result.error || "", /idle bash\/zsh prompt.*empty input/);
assert.deepEqual(h.writes, []);
assert.deepEqual(h.timeouts, []);
}
});
test("exit 4 blocks recalled input, editors, alt-screen and sensitive prompts with an empty command buffer", async () => {
for (const unsafe of [
{ userInputLength: 12 }, // ESC-prefixed history recall need not enter commandBufferRef.
{ isAtPrompt: false },
{ alternateScreenActive: true },
{ sensitiveInputActive: true },
{ hasLiveTerminal: false },
]) {
const h = createExit4PtyHarness();
const unregister = registerTerminalCommandInjectionReadyReader(h.options.sessionId, () =>
isIdleShellReadyForCommandInjection({
hasLiveTerminal: true, isAtPrompt: true, userInputLength: 0,
pendingTypedInputLength: 0, alternateScreenActive: false,
sensitiveInputActive: false, ...unsafe,
}));
h.options.isTerminalReadyForCommandInjection = () => isTerminalReadyForCommandInjection(h.options.sessionId);
try {
assert.equal((await runOsc7SetupAction(h.options)).success, false);
assert.deepEqual(h.writes, []);
} finally {
unregister();
}
assert.equal(isTerminalReadyForCommandInjection(h.options.sessionId), false);
}
});
test("Terminal wires the live command-injection readiness registry into OSC7 setup", () => {
const source = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
assert.match(source, /runOsc7SetupAction\(\{[^]*?isTerminalReadyForCommandInjection: \(\) => isTerminalReadyForCommandInjection\(sessionId\)/);
});
test("exit 4 refuses installation after probe timeout, unknown shell, or unsupported fish", async () => {
for (const shell of [null, "unknown", "fish"]) {
const h = createExit4PtyHarness(shell);
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.match(result.error || "", /idle bash\/zsh prompt.*OSC 7 manually/);
assert.equal(h.writes.length, 1);
assert.equal(h.disposed(), 1);
}
});
test("exit 4 rechecks prompt readiness after the probe and between payload chunks", async () => {
for (const stopAfter of [1, 3]) {
const h = createExit4PtyHarness();
const write = h.options.writeToSession;
h.options.writeToSession = (...args) => {
write(...args);
if (h.writes.length === stopAfter) h.setReady(false);
};
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.equal(h.writes.length, stopAfter);
}
});
test("exit 4 does not claim success when installation times out or reports failure", async () => {
for (const completion of [null, "failed"] as const) {
const h = createExit4PtyHarness("bash", completion);
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.notEqual(result.sentToTerminal, true);
assert.match(result.error || "", /failed or did not finish/);
assert.equal(h.writes.length, 1 + buildOsc7PtySetupCommands("bash").length);
assert.equal(h.disposed(), h.writes.length);
}
});
test("exit 4 stops on a missing, stale or failed chunk acknowledgement", async () => {
for (const reply of [null, `${OSC7_PTY_ACK_MARKER}0`, `${OSC7_PTY_FAILED_MARKER}bash`]) {
const h = createExit4PtyHarness();
let count = 0;
let observer: ((chunk: string) => void) | undefined;
h.options.waitForSessionOutput = (id, predicate) => waitForOsc7SessionOutput((_id, callback) => {
observer = callback;
return () => { observer = undefined; };
}, id, predicate, 10);
h.options.writeToSession = (id, command, options) => {
count += 1;
if (count === 3) {
observer?.(`prompt> ${command}\r\n`);
if (reply) observer?.(`\r\n${reply}\r\n`);
} else {
observer?.(`prompt> ${command}\r\n`);
observer?.(`\r\n${count === 1 ? OSC7_PTY_SHELL_MARKER + "bash" : OSC7_PTY_ACK_MARKER + "0"}\r\n`);
}
assert.equal(id, h.options.sessionId);
assert.equal(options?.automated, true);
};
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.equal(count, 3, "no later chunk or final installer after a failed ack");
assert.match(result.error || "", /failed or did not finish/);
}
});
test("unrelated exec failures never select the exit-4 PTY transport", async () => {
for (const code of [1, 2, 3, 5]) {
const h = createExit4PtyHarness();
h.options.setupOsc7Tracking = async () => ({ success: false, code, stderr: "unrelated failure" });
const result = await runOsc7SetupAction(h.options);
assert.equal(result.success, false);
assert.deepEqual(h.writes, []);
assert.deepEqual(h.timeouts, []);
}
});
test("waitForOsc7SessionOutput disposes even if subscription immediately delivers output", async () => {
let disposed = false;
const result = await waitForOsc7SessionOutput((_id, callback) => {
callback("done");
return () => { disposed = true; };
}, "session", (output) => output === "done", 100);
assert.equal(result, "done");
assert.equal(disposed, true);
});
test("exit 4 sends no probe when the output subscription is unavailable", async () => {
const h = createExit4PtyHarness();
h.options.waitForSessionOutput = (id, predicate, timeout) => waitForOsc7SessionOutput(() => {
throw new Error("Session output unavailable");
}, id, predicate, timeout);
await assert.rejects(runOsc7SetupAction(h.options), /Session output unavailable/);
assert.deepEqual(h.writes, []);
});
test("runOsc7SetupAction fails when the setup script cannot be staged", async () => {
const writes: string[] = [];
let calls = 0;
const result = await runOsc7SetupAction({
status: "connected",
sessionId: "session-1",
setupCommand: "printf setup-script",
setupOsc7Tracking: async () => {
calls += 1;
if (calls === 1) {
return {
success: false,
stdout: `${OSC7_SETUP_OTHER_USER_MARKER}bash\n`,
stderr: "",
code: 5,
};
}
return { success: false, stdout: "", stderr: "mktemp: failed", code: 1 };
},
writeToSession: (_sessionId, data) => {
writes.push(data);
},
});
assert.equal(result.success, false);
assert.match(result.error || "", /mktemp: failed|setup failed/);
assert.deepEqual(writes, []);
});
test("runOsc7SetupAction reports unsupported user-switched shells instead of typing", async () => {
const writes: string[] = [];
const result = await runOsc7SetupAction({
status: "connected",
sessionId: "session-1",
setupCommand: "printf setup-script",
setupOsc7Tracking: async () => ({
success: false,
stdout: `${OSC7_SETUP_OTHER_USER_MARKER}dash\n`,
stderr: "",
code: 5,
}),
writeToSession: (_sessionId, data) => {
writes.push(data);
},
});
assert.equal(result.success, false);
assert.match(result.error || "", /does not support/);
assert.deepEqual(writes, []);
});
test("runOsc7SetupAction fails without reload metadata instead of reporting a partial setup", async () => {
const writes: string[] = [];
const localData: string[] = [];
const result = await runOsc7SetupAction({
status: "connected",
sessionId: "session-1",
setupCommand: "printf setup-script",
setupOsc7Tracking: async () => ({
success: true,
stdout: "\u001b]7;file://host/home/me\u0007",
stderr: "",
code: 0,
}),
writeToSession: (_sessionId, data) => {
writes.push(data);
},
writeLocalTerminalData: (data) => {
localData.push(data);
},
});
assert.equal(result.success, false);
assert.match(result.error || "", /reload metadata/);
assert.deepEqual(writes, []);
assert.deepEqual(localData, []);
});
test("buildOsc7SetupCommand configures bash once and prompt loading stays idempotent", () => {
withTempHome("netcatty-osc7-bash-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
const bashrc = readFileSync(bashrcPath, "utf8");
assert.equal(markerCount(bashrc), 2);
assert.match(bashrc, /PROMPT_COMMAND/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /declare -\[A-Za-z\]\*a|declare -p PROMPT_COMMAND/);
const output = execFileSync(
"/bin/bash",
[
"-lc",
`PROMPT_COMMAND=existing; source ${JSON.stringify(bashrcPath)}; source ${JSON.stringify(bashrcPath)}; printf '%s' "$PROMPT_COMMAND"`,
],
{ env: { ...process.env, HOME: home } },
).toString("utf8");
assert.match(output, /existing/);
// Guarded hook installed once even after double-source.
assert.equal(output.split("declare -F __netcatty_osc7_prompt").length - 1, 1);
// Bare v1 hook must not remain in PROMPT_COMMAND (only the function body may mention osc7_cwd).
assert.doesNotMatch(output, /(^|\n)osc7_cwd(\n|$)/);
});
});
test("buildOsc7SetupCommand upgrades legacy bash snippet in place", () => {
withTempHome("netcatty-osc7-bash-upgrade-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# user preamble",
"",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"osc7_cwd() {",
" printf 'legacy'\\n",
"}",
'PROMPT_COMMAND="osc7_cwd"',
"# <<< Netcatty OSC 7 cwd tracking <<<",
"",
"# user epilogue",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.equal(markerCount(bashrc), 2);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.match(bashrc, /# user preamble/);
assert.match(bashrc, /# user epilogue/);
assert.doesNotMatch(bashrc, /printf 'legacy'/);
assert.equal(bashrc.split("PROMPT_COMMAND=\"osc7_cwd\"").length - 1, 0);
// Second run is a no-op once version 2 is present.
runSetup({ HOME: home, SHELL: "/bin/bash" });
assert.equal(markerCount(readFileSync(bashrcPath, "utf8")), 2);
});
});
test("buildOsc7SetupCommand does not truncate bashrc when start marker lacks end", () => {
withTempHome("netcatty-osc7-bash-incomplete-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# keep-me-before",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"osc7_cwd() { :; }",
"# important-user-config-after-open-marker",
"alias ll='ls -la'",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /# keep-me-before/);
assert.match(bashrc, /# important-user-config-after-open-marker/);
assert.match(bashrc, /alias ll=/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
// Open region kept + complete v2 appended (no truncation of user lines).
assert.equal((bashrc.match(/# >>> Netcatty OSC 7 cwd tracking >>>/g) || []).length, 2);
assert.equal((bashrc.match(/# <<< Netcatty OSC 7 cwd tracking <<</g) || []).length, 1);
});
});
test("buildOsc7SetupCommand appends when markers are present but unbalanced", () => {
withTempHome("netcatty-osc7-bash-unbalanced-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# orphan end first",
"# <<< Netcatty OSC 7 cwd tracking <<<",
"# user config",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"alias ll='ls -la'",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /# orphan end first/);
assert.match(bashrc, /# user config/);
assert.match(bashrc, /alias ll=/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
// Original markers kept; complete v2 appended.
assert.equal((bashrc.match(/# >>> Netcatty OSC 7 cwd tracking >>>/g) || []).length, 2);
assert.equal((bashrc.match(/# <<< Netcatty OSC 7 cwd tracking <<</g) || []).length, 2);
});
});
test("buildOsc7SetupCommand recovers from partial v2 write missing end marker", () => {
withTempHome("netcatty-osc7-bash-partial-v2-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# keep-me",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"# netcatty-osc7-version: 2",
"osc7_cwd() { :; }",
"# interrupted before end marker",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /# keep-me/);
assert.match(bashrc, /# interrupted before end marker/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.match(bashrc, /declare -F __netcatty_osc7_prompt/);
// Partial open kept + one recovered complete block; second setup is a no-op.
assert.equal((bashrc.match(/# <<< Netcatty OSC 7 cwd tracking <<</g) || []).length, 1);
assert.equal((bashrc.match(/# netcatty-osc7-version: 2/g) || []).length, 2);
});
});
test("buildOsc7SetupCommand preserves user lines after mid-construct interruption", () => {
withTempHome("netcatty-osc7-bash-mid-construct-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# keep-me",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"# netcatty-osc7-version: 2",
"osc7_cwd() {",
"alias keep_user_alias='yes'",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
// Do not rewrite/truncate even if the partial body is already unusable.
assert.match(bashrc, /# keep-me/);
assert.match(bashrc, /alias keep_user_alias=/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
});
});
test("buildOsc7SetupCommand recovers when version line exists with unbalanced markers", () => {
withTempHome("netcatty-osc7-bash-version-unbalanced-", (home) => {
const bashrcPath = join(home, ".bashrc");
// Orphan end + open start with version: grepping version+end alone would
// falsely treat this as complete; balanced/complete-v2 checks must force append.
writeFileSync(
bashrcPath,
[
"# <<< Netcatty OSC 7 cwd tracking <<<",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"# netcatty-osc7-version: 2",
"osc7_cwd() { :; }",
"# interrupted before end marker",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /# interrupted before end marker/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.match(bashrc, /declare -F __netcatty_osc7_prompt/);
// Orphan end + one recovered complete block; second run no-ops.
assert.equal((bashrc.match(/# <<< Netcatty OSC 7 cwd tracking <<</g) || []).length, 2);
assert.equal((bashrc.match(/# netcatty-osc7-version: 2/g) || []).length, 2);
});
});
test("buildOsc7SetupCommand ignores marker text embedded in echo commands", () => {
withTempHome("netcatty-osc7-bash-echo-marker-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
'echo "# >>> Netcatty OSC 7 cwd tracking >>>"',
"alias keep_me='yes'",
'echo "# <<< Netcatty OSC 7 cwd tracking <<<"',
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /alias keep_me=/);
assert.match(bashrc, /echo "# >>> Netcatty OSC 7 cwd tracking >>>"/);
assert.match(bashrc, /echo "# <<< Netcatty OSC 7 cwd tracking <<<"/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
});
});
test("buildOsc7SetupCommand upgrades a legacy block wrapped in control flow in place", () => {
withTempHome("netcatty-osc7-bash-if-wrap-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"if true; then",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"osc7_cwd() { :; }",
'PROMPT_COMMAND="osc7_cwd"',
"# <<< Netcatty OSC 7 cwd tracking <<<",
"fi",
"echo after",
"",
].join("\n"),
);
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /if true; then/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.match(bashrc, /^fi$/m);
assert.match(bashrc, /echo after/);
// v2 stays inside the if/fi, not only after it.
const ifIdx = bashrc.indexOf("if true; then");
const fiIdx = bashrc.indexOf("\nfi\n");
const v2Idx = bashrc.indexOf("netcatty-osc7-version: 2");
assert.ok(ifIdx >= 0 && fiIdx > ifIdx && v2Idx > ifIdx && v2Idx < fiIdx);
execFileSync("/bin/bash", ["-n", bashrcPath], { stdio: "pipe" });
});
});
test("buildOsc7SetupCommand upgrades a read-only legacy bashrc in one atomic write", () => {
withTempHome("netcatty-osc7-bash-readonly-", (home) => {
const bashrcPath = join(home, ".bashrc");
writeFileSync(
bashrcPath,
[
"# before",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"legacy",
"# <<< Netcatty OSC 7 cwd tracking <<<",
"# after",
"",
].join("\n"),
);
chmodSync(bashrcPath, 0o444);
runSetup({ HOME: home, SHELL: "/bin/bash" });
assert.equal(lstatSync(bashrcPath).mode & 0o777, 0o444);
const bashrc = readFileSync(bashrcPath, "utf8");
assert.match(bashrc, /# before/);
assert.match(bashrc, /# after/);
assert.match(bashrc, /netcatty-osc7-version: 2/);
assert.match(bashrc, /__netcatty_osc7_prompt/);
assert.doesNotMatch(bashrc, /^legacy$/m);
});
});
test("buildOsc7SetupCommand upgrades through a symlinked bashrc without replacing the link", () => {
withTempHome("netcatty-osc7-bash-symlink-", (home) => {
const realPath = join(home, "dotfiles", "bashrc.real");
const midLink = join(home, "dotfiles", "bashrc.link");
const bashrcPath = join(home, ".bashrc");
mkdirSync(join(home, "dotfiles"), { recursive: true });
writeFileSync(
realPath,
[
"# managed-preamble",
"# >>> Netcatty OSC 7 cwd tracking >>>",
"osc7_cwd() {",
" printf 'legacy'\\n",
"}",
'PROMPT_COMMAND="osc7_cwd"',
"# <<< Netcatty OSC 7 cwd tracking <<<",
"# managed-epilogue",
"",
].join("\n"),
);
chmodSync(realPath, 0o644);
// Chain: ~/.bashrc -> dotfiles/bashrc.link -> bashrc.real
symlinkSync("bashrc.real", midLink);
symlinkSync(join("dotfiles", "bashrc.link"), bashrcPath);
assert.ok(lstatSync(bashrcPath).isSymbolicLink());
assert.ok(lstatSync(midLink).isSymbolicLink());
runSetup({ HOME: home, SHELL: "/bin/bash" });
assert.ok(lstatSync(bashrcPath).isSymbolicLink(), "bashrc must remain a symlink");
assert.ok(lstatSync(midLink).isSymbolicLink(), "intermediate link must remain a symlink");
assert.equal(readlinkSync(bashrcPath), join("dotfiles", "bashrc.link"));
assert.equal(readlinkSync(midLink), "bashrc.real");
assert.equal(lstatSync(realPath).mode & 0o777, 0o644, "target mode should be preserved");
const content = readFileSync(realPath, "utf8");
assert.match(content, /# managed-preamble/);
assert.match(content, /# managed-epilogue/);
assert.match(content, /netcatty-osc7-version: 2/);
assert.match(content, /__netcatty_osc7_prompt/);
assert.doesNotMatch(content, /printf 'legacy'/);
});
});
test("bash snippet does not error when PROMPT_COMMAND is inherited without osc7_cwd", () => {
withTempHome("netcatty-osc7-bash-su-inherit-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
// Simulate non-login su: child gets exported PROMPT_COMMAND but no function defs.
const result = spawnSync(
"/bin/bash",
[
"--noprofile",
"--norc",
"-c",
[
`source ${JSON.stringify(bashrcPath)}`,
"export PROMPT_COMMAND",
// Child env has PROMPT_COMMAND but not the function (fresh bash -c without rc).
`env PROMPT_COMMAND="$PROMPT_COMMAND" /bin/bash --noprofile --norc -c 'eval "$PROMPT_COMMAND"; echo OK'`,
].join("; "),
],
{
env: { ...process.env, HOME: home },
encoding: "utf8",
},
);
assert.equal(result.status, 0, result.stderr || result.stdout);
assert.match(result.stdout, /OK/);
assert.doesNotMatch(result.stderr + result.stdout, /command not found/);
});
});
test("bash snippet still emits OSC 7 when functions are defined", () => {
withTempHome("netcatty-osc7-bash-emit-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
const output = execFileSync(
"/bin/bash",
["-lc", `source ${JSON.stringify(bashrcPath)}; __netcatty_osc7_prompt; true`],
{ env: { ...process.env, HOME: home, PWD: home }, cwd: home },
).toString("utf8");
assert.ok(output.includes("\u001b]7;file://"), "expected OSC 7 output");
assert.equal(realpathSync(extractOsc7Path(output)), realpathSync(home));
});
});
test("bash snippet preserves an intentional PROMPT_COMMAND export", () => {
withTempHome("netcatty-osc7-bash-export-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
const output = execFileSync(
"/bin/bash",
[
"-lc",
[
"export PROMPT_COMMAND=preexisting",
`source ${JSON.stringify(bashrcPath)}`,
'if declare -p PROMPT_COMMAND 2>/dev/null | grep -q "declare -x"; then echo EXPORTED; else echo LOCAL; fi',
].join("; "),
],
{ env: { ...process.env, HOME: home } },
).toString("utf8");
assert.match(output, /EXPORTED/);
});
});
test("bash snippet dedupes hooks across array PROMPT_COMMAND elements", () => {
withTempHome("netcatty-osc7-bash-array-pc-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
const output = execFileSync(
"/bin/bash",
[
"--noprofile",
"--norc",
"-c",
[
'PROMPT_COMMAND=("first" "osc7_cwd" "echo KEEP")',
`source ${JSON.stringify(bashrcPath)}`,
`source ${JSON.stringify(bashrcPath)}`,
'declare -p PROMPT_COMMAND',
].join("; "),
],
{ env: { ...process.env, HOME: home } },
).toString("utf8");
assert.match(output, /first/);
assert.match(output, /echo KEEP/);
assert.equal(output.split("declare -F __netcatty_osc7_prompt").length - 1, 1);
assert.doesNotMatch(output, /\[1\]="osc7_cwd"/);
});
});
test("bash snippet handles exported array PROMPT_COMMAND", () => {
withTempHome("netcatty-osc7-bash-ax-pc-", (home) => {
runSetup({ HOME: home, SHELL: "/bin/bash" });
const bashrcPath = join(home, ".bashrc");
const output = execFileSync(
"/bin/bash",
[
"--noprofile",
"--norc",
"-c",
[
'declare -ax PROMPT_COMMAND=("echo one" "osc7_cwd")',
`source ${JSON.stringify(bashrcPath)}`,
`source ${JSON.stringify(bashrcPath)}`,
'declare -p PROMPT_COMMAND',
].join("; "),
],
{ env: { ...process.env, HOME: home } },
).toString("utf8");
assert.match(output, /echo one/);
assert.equal(output.split("declare -F __netcatty_osc7_prompt").length - 1, 1);
assert.doesNotMatch(output, /osc7_cwd"/);
});
});
test("buildOsc7SetupCommand preserves setup failure status", () => {
withTempHome("netcatty-osc7-unsupported-shell-", (home) => {
const result = spawnSync("/bin/sh", ["-c", buildOsc7SetupCommand()], {
env: {
...process.env,
HOME: home,
SHELL: "/bin/unknown",
ZDOTDIR: "",
XDG_CONFIG_HOME: "",
},
encoding: "utf8",
});
assert.equal(result.status, 2, result.stderr || result.stdout);
assert.match(result.stderr, /unsupported shell unknown/);
});
});
test("buildOsc7SetupExecCommand configures bash through a background exec shell", () => {
withTempHome("netcatty-osc7-exec-bash-", (home) => {
const output = execFileSync("/bin/sh", ["-c", buildOsc7SetupExecCommand()], {
env: { ...process.env, HOME: home, SHELL: "/bin/bash" },
stdio: "pipe",
}).toString("utf8");
assert.match(output, /__NETCATTY_OSC7_SETUP_SHELL__=bash/);
assert.match(output, new RegExp(`__NETCATTY_OSC7_SETUP_CONFIG__=${home.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/\\.bashrc`));
const bashrc = readFileSync(join(home, ".bashrc"), "utf8");
assert.equal(markerCount(bashrc), 2);
});
});
const withStagedSetupScript = (fn: (scriptPath: string) => void) => {
const output = execFileSync("/bin/sh", ["-c", buildOsc7StageScriptCommand()], {
stdio: "pipe",
}).toString("utf8");
const scriptPath = parseOsc7SetupStagedPath(output);
assert.ok(scriptPath, "expected staged script path");
try {
fn(scriptPath);
} finally {
rmSync(scriptPath, { force: true });
}
};
test("PTY builders chunk the exact shared script into lines below the canonical limit", () => {
for (const shell of ["bash", "zsh"] as const) {
const commands = buildOsc7PtySetupCommands(shell);
assert.ok(commands.length > 3);
for (const command of commands) {
assert.ok(command.startsWith(" "));
assert.ok(command.endsWith("\r"));
assert.doesNotMatch(command.slice(0, -1), /[\r\n]/);
assert.ok(Buffer.byteLength(command) < 3000);
}
assert.match(commands[0], /mktemp/);
assert.match(commands.at(-1)!, new RegExp(`NETCATTY_OSC7_FORCE_SHELL=${shell}`));
assert.doesNotMatch(commands.join(""), /NETCATTY_OSC7_EXPECTED_CWD/);
const payload = commands.flatMap((command) => {
const match = command.match(/printf '%s' '([A-Za-z0-9+/=]+)'/);
return match ? [match[1]] : [];
}).join("");
const script = Buffer.from(payload, "base64").toString("utf8");
assert.ok(buildOsc7SetupExecCommand().includes(quoteShellArg(script)), "reuse exact POSIX setup script");
assert.match(script, /netcatty-osc7-version: 2/);
}
});
test("exit-4 transport installs through a real canonical Bash PTY without exceeding its line limit", { timeout: 30000 }, async () => {
const home = mkdtempSync(join(tmpdir(), "netcatty-osc7-canonical-"));
const prompt = "__NETCATTY_TEST_PROMPT__> ";
const terminal = pty.spawn("/bin/bash", ["--noprofile", "--norc", "--noediting", "-i"], {
name: "xterm", cols: 120, rows: 24,
env: { ...process.env, HOME: home, SHELL: "/bin/unknown", PS1: prompt, PS2: "CONTINUATION> ", PROMPT_COMMAND: "", ZDOTDIR: "", XDG_CONFIG_HOME: "" },
});
let screen = "";
let transcript = "";
const capture = terminal.onData((chunk) => { screen += chunk; transcript += chunk; });
const wait = (predicate: (output: string) => boolean, timeout = 5000) =>
waitForOsc7SessionOutput((_id, callback) => {
const listener = terminal.onData(callback);
return () => listener.dispose();
}, "real-pty", predicate, timeout);
try {
assert.ok(await wait((output) => output.endsWith(prompt)), "initial Bash prompt");
// --noediting keeps Bash on the kernel's canonical input path, unlike Readline.
const canonical = wait((output) => output.endsWith(prompt));
screen = "";
terminal.write("stty icanon; stty -a\r");
assert.match(await canonical || "", /(?:^|[;\s])icanon(?:[;\s]|$)/);
const writes: string[] = [];
const result = await runOsc7SetupAction({
status: "connected", sessionId: "real-pty", setupCommand: "exec-only-setup",
setupOsc7Tracking: async () => ({ success: false, code: 4 }),
isTerminalReadyForCommandInjection: () => screen.endsWith(prompt),
waitForSessionOutput: (_id, predicate, timeout) => wait(predicate, timeout),
writeToSession: (_id, command) => {
assert.ok(Buffer.byteLength(command) < 3000, "each typed line fits canonical input");
writes.push(command);
screen = "";
// Preserve the path for a shell-side cleanup assertion after the final command.
terminal.write(command.includes("base64 -d")
? ` __netcatty_test_file="$__netcatty_osc7_pty_file"; ${command}` : command);
},
});
assert.equal(result.success, true, `${result.error}\n${transcript.slice(-4000)}`);
assert.ok(writes.length > 3);
assert.ok(writes.reduce((total, command) => total + command.length, 0) > 4096);
assert.equal(markerCount(readFileSync(join(home, ".bashrc"), "utf8")), 2);
assert.ok(transcript.includes("\u001b]7;file://"));
assert.match(transcript, new RegExp(`\r?\n${OSC7_PTY_DONE_MARKER}bash\r?\n`));
assert.doesNotMatch(transcript, /CONTINUATION> /);
// A final shell assertion covers cleanup without exec sharing any staging file.
if (!screen.endsWith(prompt)) assert.ok(await wait((output) => output.endsWith(prompt)));
const cleaned = wait((output) => output.includes("\r\nCLEANED\r\n"));
terminal.write("test -n \"$__netcatty_test_file\" && test ! -e \"$__netcatty_test_file\" && test -z \"${__netcatty_osc7_pty_file-}\" && printf '\\n%s\\n' CLEANED\r");
assert.ok(await cleaned, "transport removes the PTY-local file and unsets its path");
} finally {
capture.dispose();
terminal.kill();
rmSync(home, { recursive: true, force: true });
}
});
test("PTY probe recognizes interactive bash and rejects a noninteractive shell", () => {
for (const interactive of [true, false]) {
const args = ["--noprofile", "--norc", ...(interactive ? ["-i"] : []), "-c",
buildOsc7PtyShellProbeCommand().replace(/\r$/, "\n")];
const output = execFileSync("/bin/bash", args, { stdio: "pipe" }).toString("utf8");
assert.match(output, new RegExp(`\n${OSC7_PTY_SHELL_MARKER}${interactive ? "bash" : "unknown"}\n`));
}
});
test("chunked PTY installer runs locally in bash, preserves hooks and stays idempotent with DONE ack", () => {
withTempHome("netcatty-osc7-inline-bash-", (home) => {
const rcPath = join(home, ".bashrc");
writeFileSync(rcPath, 'PROMPT_COMMAND="printf existing-title"\n');
const command = buildOsc7PtySetupCommands("bash").join("").replace(/\r/g, "\n");
for (let run = 0; run < 2; run += 1) {
const output = execFileSync("/bin/bash", ["--noprofile", "--norc", "-i", "-c", command], {
env: { ...process.env, HOME: home, SHELL: "/bin/unknown", ZDOTDIR: "", XDG_CONFIG_HOME: "" },
stdio: "pipe",
}).toString("utf8");
assert.match(output, new RegExp(`\n${OSC7_PTY_DONE_MARKER}bash\n`));
assert.doesNotMatch(output, /__NETCATTY_OSC7_PTY_FAILED__/);
assert.ok(output.includes("\u001b]7;file://"));
const rc = readFileSync(rcPath, "utf8");
assert.equal(markerCount(rc), 2);
assert.match(rc, /netcatty-osc7-version: 2/);
assert.match(rc, /printf existing-title/);
}
});
});
test("chunked PTY installer emits failure instead of DONE when install or reload fails", () => {
withTempHome("netcatty-osc7-inline-fail-", (home) => {
const blockedHome = join(home, "not-a-directory");
writeFileSync(blockedHome, "file");
writeFileSync(join(home, ".bashrc"), "return 1\n");
for (const targetHome of [blockedHome, home]) {
const output = execFileSync("/bin/bash", ["--noprofile", "--norc", "-c",
buildOsc7PtySetupCommands("bash").join("").replace(/\r/g, "\n")], {
env: { ...process.env, HOME: targetHome, ZDOTDIR: "", XDG_CONFIG_HOME: "" },
stdio: "pipe",
}).toString("utf8");
assert.match(output, new RegExp(`\n${OSC7_PTY_FAILED_MARKER}bash\n`));
assert.doesNotMatch(output, /__NETCATTY_OSC7_PTY_DONE__/);
}
});
});
test("PTY probe and chunked installer remove their bash history entries", () => {
withTempHome("netcatty-osc7-inline-history-", (home) => {
const output = runInteractiveHistoryProbe({
shellPath: "/bin/bash",
shellArgs: ["--noprofile", "--norc", "-i"],
dumpHistoryCommand: `history > ${quoteShellArg(join(home, "history"))}`,
dumpPath: join(home, "history"),
env: { HOME: home, HISTFILE: join(home, ".bash_history"), SHELL: "/bin/bash" },
input: `echo keepme\n${buildOsc7PtyShellProbeCommand()}${buildOsc7PtySetupCommands("bash").join("")}`,
});
assert.match(output, /echo keepme/);
assert.doesNotMatch(output, /NETCATTY_OSC7|base64|history -d/);
});
});
test("PTY probe and chunked installer support zsh with shell-local ZDOTDIR", (t) => {
const shellPath = existingShells(["/bin/zsh", "/usr/bin/zsh"])[0];
if (!shellPath) return t.skip("zsh is not installed on this runner");
withTempHome("netcatty-osc7-inline-zsh-", (home) => {
const zdotdir = join(home, "custom-zsh");
const command = `ZDOTDIR=${quoteShellArg(zdotdir)}; ${buildOsc7PtyShellProbeCommand()}${buildOsc7PtySetupCommands("zsh").join("")}`;
const output = execFileSync(shellPath, ["-f", "-i", "-c", command.replace(/\r/g, "\n")], {
env: { ...process.env, HOME: home, SHELL: "/bin/unknown", ZDOTDIR: undefined },
stdio: "pipe",
}).toString("utf8");
assert.match(output, new RegExp(`\n${OSC7_PTY_SHELL_MARKER}zsh\n`));
assert.match(output, new RegExp(`\n${OSC7_PTY_DONE_MARKER}zsh\n`));
assert.equal(markerCount(readFileSync(join(zdotdir, ".zshrc"), "utf8")), 2);
assert.equal(existsSync(join(home, ".zshrc")), false);
});
});
test("buildOsc7TypedSetupCommand stays a single line for reliable history cleanup", async () => {
const sha256 = await getOsc7StagedScriptSha256();
for (const shell of ["bash", "zsh", "fish"] as const) {
const command = buildOsc7TypedSetupCommand(shell, "/tmp/.netcatty-osc7-setup.abc123", sha256);
assert.ok(command.endsWith("\r"), shell);
assert.doesNotMatch(command.slice(0, -1), /[\r\n]/, shell);
}
});
test("buildOsc7TypedSetupCommand configures bash and removes the staged script", async () => {
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-bash-", (home) => {
withStagedSetupScript((scriptPath) => {
const command = buildOsc7TypedSetupCommand("bash", scriptPath, sha256).replace(/\r/g, "\n");
const output = execFileSync("/bin/bash", ["-c", command], {
env: { ...process.env, HOME: home, SHELL: "/bin/bash", ZDOTDIR: "", XDG_CONFIG_HOME: "" },
stdio: "pipe",
}).toString("utf8");
const bashrc = readFileSync(join(home, ".bashrc"), "utf8");
assert.equal(markerCount(bashrc), 2);
assert.match(bashrc, /PROMPT_COMMAND/);
assert.doesNotMatch(output, /__NETCATTY_OSC7_SETUP_SHELL__|__NETCATTY_OSC7_SETUP_CONFIG__/);
assert.ok(output.includes("\u001b]7;file://"), "expected OSC 7 output");
assert.equal(existsSync(scriptPath), false, "staged script should be removed");
});
});
});
test("buildOsc7TypedSetupCommand refuses to run a tampered staged script", async () => {
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-tampered-", (home) => {
withStagedSetupScript((scriptPath) => {
writeFileSync(scriptPath, `echo pwned > "$HOME/pwned"\n`);
const command = buildOsc7TypedSetupCommand("bash", scriptPath, sha256).replace(/\r/g, "\n");
const result = spawnSync("/bin/bash", ["-c", command], {
env: { ...process.env, HOME: home, SHELL: "/bin/bash", ZDOTDIR: "", XDG_CONFIG_HOME: "" },
encoding: "utf8",
});
assert.equal(result.status, 0, result.stderr || result.stdout);
assert.match(result.stderr, /verification failed/);
assert.equal(existsSync(join(home, "pwned")), false, "tampered script must not run");
assert.equal(existsSync(join(home, ".bashrc")), false);
assert.equal(existsSync(scriptPath), false, "staged script should be removed before verification");
});
});
});
test("buildOsc7TypedSetupCommand does not leave the typed runner in bash history", async () => {
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-history-bash-", (home) => {
withStagedSetupScript((scriptPath) => {
const dumpPath = join(home, "bash-history-dump");
const output = runInteractiveHistoryProbe({
shellPath: "/bin/bash",
shellArgs: ["--noprofile", "--norc", "-i"],
dumpHistoryCommand: `history > ${quoteShellArg(dumpPath)}`,
dumpPath,
env: {
HOME: home,
HISTFILE: join(home, ".bash_history"),
SHELL: "/bin/bash",
},
input: `echo keepme\n${buildOsc7TypedSetupCommand("bash", scriptPath, sha256)}`,
});
assert.match(output, /echo keepme/);
assert.doesNotMatch(output, /NETCATTY_OSC7_FORCE_SHELL|__netcatty_osc7|history -d/);
});
});
});
test("buildOsc7TypedSetupCommand stays idempotent for bash", async () => {
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-bash-idempotent-", (home) => {
const env = { ...process.env, HOME: home, SHELL: "/bin/bash", ZDOTDIR: "", XDG_CONFIG_HOME: "" };
for (let run = 0; run < 2; run += 1) {
withStagedSetupScript((scriptPath) => {
const command = buildOsc7TypedSetupCommand("bash", scriptPath, sha256).replace(/\r/g, "\n");
execFileSync("/bin/bash", ["-c", command], { env, stdio: "pipe" });
});
}
assert.equal(markerCount(readFileSync(join(home, ".bashrc"), "utf8")), 2);
});
});
test("buildOsc7TypedSetupCommand honors shell-local unexported zsh ZDOTDIR", async (t) => {
const zshPath = existingShells(["/bin/zsh", "/usr/bin/zsh"])[0];
if (!zshPath) {
t.skip("zsh is not installed on this runner");
return;
}
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-zsh-", (home) => {
const zdotdir = join(home, ".config", "zsh");
withStagedSetupScript((scriptPath) => {
const command = buildOsc7TypedSetupCommand("zsh", scriptPath, sha256).replace(/\r/g, "\n");
// ZDOTDIR is a shell-local (unexported) parameter, like a user setting
// it in .zshenv without export; the typed wrapper must forward it.
const output = execFileSync(zshPath, ["-c", `ZDOTDIR=${JSON.stringify(zdotdir)}; ${command}`], {
env: { ...process.env, HOME: home, SHELL: zshPath, ZDOTDIR: undefined, XDG_CONFIG_HOME: "" },
stdio: "pipe",
}).toString("utf8");
const zshrc = readFileSync(join(zdotdir, ".zshrc"), "utf8");
assert.equal(markerCount(zshrc), 2);
assert.match(zshrc, /precmd_functions/);
assert.equal(existsSync(join(home, ".zshrc")), false);
assert.ok(output.includes("\u001b]7;file://"), "expected OSC 7 output");
});
});
});
test("buildOsc7TypedSetupCommand configures fish through its typed fallback", async (t) => {
const fishPath = existingShells(["/opt/homebrew/bin/fish", "/usr/bin/fish"])[0];
if (!fishPath) {
t.skip("fish is not installed on this runner");
return;
}
const sha256 = await getOsc7StagedScriptSha256();
withTempHome("netcatty-osc7-typed-fish-", (home) => {
withStagedSetupScript((scriptPath) => {
const command = buildOsc7TypedSetupCommand("fish", scriptPath, sha256).replace(/\r/g, "\n");
const output = execFileSync(fishPath, ["-c", command], {
env: { ...process.env, HOME: home, SHELL: fishPath, ZDOTDIR: "", XDG_CONFIG_HOME: "" },
stdio: "pipe",
}).toString("utf8");
const fishConfig = readFileSync(join(home, ".config", "fish", "config.fish"), "utf8");
assert.equal(markerCount(fishConfig), 2);
assert.match(fishConfig, /fish_prompt/);
assert.ok(output.includes("\u001b]7;file://"), "expected OSC 7 output");
});
});
});
test("buildOsc7SetupExecCommand carries the expected cwd for current-tab matching", () => {
const command = buildOsc7SetupExecCommand("/srv/app's cwd");
assert.match(command, /NETCATTY_OSC7_EXPECTED_CWD='\/srv\/app'\\''s cwd'/);
});
test("buildOsc7SetupExecCommand honors exported zsh ZDOTDIR fallback", (t) => {
const zshPath = existingShells(["/bin/zsh", "/usr/bin/zsh"])[0];
if (!zshPath) {
t.skip("zsh is not installed on this runner");
return;
}
withTempHome("netcatty-osc7-exec-zsh-", (home) => {
const zdotdir = join(home, ".config", "zsh");
const output = execFileSync("/bin/sh", ["-c", buildOsc7SetupExecCommand()], {
env: { ...process.env, HOME: home, SHELL: zshPath, ZDOTDIR: zdotdir },
stdio: "pipe",
}).toString("utf8");
const zshrcPath = join(zdotdir, ".zshrc");
assert.match(output, /__NETCATTY_OSC7_SETUP_SHELL__=zsh/);
assert.match(output, new RegExp(`__NETCATTY_OSC7_SETUP_CONFIG__=${zshrcPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
assert.equal(markerCount(readFileSync(zshrcPath, "utf8")), 2);
});
});
test("buildOsc7SetupCommand honors zsh ZDOTDIR captured from the current shell", (t) => {
const zshPath = existingShells(["/bin/zsh", "/usr/bin/zsh"])[0];
if (!zshPath) {
t.skip("zsh is not installed on this runner");
return;
}
withTempHome("netcatty-osc7-zsh-", (home) => {
const zdotdir = join(home, ".config", "zsh");
runSetup({ HOME: home, SHELL: zshPath, ZDOTDIR: zdotdir });
runSetup({ HOME: home, SHELL: zshPath, ZDOTDIR: zdotdir });
const zshrcPath = join(zdotdir, ".zshrc");
const zshrc = readFileSync(zshrcPath, "utf8");
assert.equal(markerCount(zshrc), 2);
assert.match(zshrc, /precmd_functions/);
assert.match(zshrc, /netcatty-osc7-version: 2/);
assert.match(zshrc, /__netcatty_osc7_prompt/);
assert.equal(existsSync(join(home, ".zshrc")), false);
const precmd = execFileSync(
zshPath,
["-uc", `source ${JSON.stringify(zshrcPath)}; source ${JSON.stringify(zshrcPath)}; print -r -- "\${precmd_functions[*]}"`],
{
env: { ...process.env, HOME: home, ZDOTDIR: zdotdir },
stdio: "pipe",
},
).toString("utf8");
assert.match(precmd, /__netcatty_osc7_prompt/);
assert.equal(precmd.trim().split(/\s+/).filter((name) => name === "__netcatty_osc7_prompt").length, 1);
assert.doesNotMatch(precmd, /(?:^|\s)osc7_cwd(?:\s|$)/);
});
});
test("buildOsc7SetupCommand configures fish once with valid fish syntax", () => {
withTempHome("netcatty-osc7-fish-", (home) => {
const fishPath = existingShells(["/opt/homebrew/bin/fish", "/usr/bin/fish"])[0] ?? "/usr/bin/fish";
runSetup({ HOME: home, SHELL: fishPath });
runSetup({ HOME: home, SHELL: fishPath });
const fishConfigPath = join(home, ".config", "fish", "config.fish");
const fishConfig = readFileSync(fishConfigPath, "utf8");
assert.equal(markerCount(fishConfig), 2);
assert.match(fishConfig, /fish_prompt/);
if (existsSync(fishPath)) {
execFileSync(fishPath, ["-n", fishConfigPath], { stdio: "pipe" });
execFileSync(fishPath, ["-c", `source ${JSON.stringify(fishConfigPath)}; functions -q __netcatty_osc7_cwd`], {
env: { ...process.env, HOME: home },
stdio: "pipe",
});
}
});
});
test("buildOsc7SetupCommand can be pasted into supported shells", () => {
const shells = supportedShells();
if (process.env.CI) {
assert.ok(shells.some((shellPath) => basename(shellPath) === "fish"), "CI must exercise fish");
}
for (const shellPath of shells) {
withTempHome(`netcatty-osc7-${basename(shellPath)}-`, (home) => {
const zdotdir = join(home, "zdot");
const xdgConfigHome = join(home, "xdg");
const specialCwd = join(home, "space dir#frag?query%pct");
mkdirSync(specialCwd, { recursive: true });
const output = execFileSync(shellPath, ["-c", buildOsc7SetupCommand()], {
cwd: specialCwd,
env: {
...process.env,
HOME: home,
SHELL: shellPath,
ZDOTDIR: zdotdir,
XDG_CONFIG_HOME: xdgConfigHome,
},
stdio: "pipe",
}).toString("utf8");
const shellName = basename(shellPath);
const configPath = shellName === "bash"
? join(home, ".bashrc")
: shellName === "zsh"
? join(zdotdir, ".zshrc")
: join(xdgConfigHome, "fish", "config.fish");
const config = readFileSync(configPath, "utf8");
assert.equal(markerCount(config), 2, shellPath);
assert.equal(realpathSync(extractOsc7Path(output)), realpathSync(specialCwd), shellPath);
});
}
});
test("buildOsc7ReloadCommand does not leave reload command in bash history", () => {
withTempHome("netcatty-osc7-reload-history-bash-", (home) => {
const bashrcPath = join(home, ".bashrc");
const dumpPath = join(home, "bash-history-dump");
mkdirSync(home, { recursive: true });
writeFileSync(bashrcPath, "osc7_cwd(){ :; }\n");
const reloadCommand = buildOsc7ReloadCommand({ shell: "bash", configPath: bashrcPath });
assert.ok(reloadCommand);
assert.doesNotMatch(reloadCommand.slice(0, -1), /[\r\n]/);
const output = runInteractiveHistoryProbe({
shellPath: "/bin/bash",
shellArgs: ["--noprofile", "--norc", "-i"],
dumpHistoryCommand: `history > ${quoteShellArg(dumpPath)}`,
dumpPath,
env: {
HOME: home,
HISTFILE: join(home, ".bash_history"),
HISTCONTROL: "ignoreboth",
SHELL: "/bin/bash",
},
input: `echo keepme\n${reloadCommand}`,
});
assert.match(output, /echo keepme/);
assert.doesNotMatch(output, /osc7_cwd|source .*\.bashrc|__netcatty_osc7|history -d/);
});
});
test("buildOsc7ReloadCommand preserves bash nounset", () => {
withTempHome("netcatty-osc7-reload-nounset-bash-", (home) => {
const bashrcPath = join(home, ".bashrc");
const optionDumpPath = join(home, "bash-options-dump");
mkdirSync(home, { recursive: true });
writeFileSync(bashrcPath, "osc7_cwd(){ :; }\n");
const result = spawnSync("/bin/bash", ["--noprofile", "--norc", "-i"], {
env: {
...process.env,
HOME: home,
HISTFILE: join(home, ".bash_history"),
SHELL: "/bin/bash",
},
input: [
"set -u",
(buildOsc7ReloadCommand({ shell: "bash", configPath: bashrcPath }) ?? "").replace(/\r/g, "\n"),
`set -o | grep nounset > ${quoteShellArg(optionDumpPath)}`,
"exit",
].join("\n"),
encoding: "utf8",
});
assert.equal(result.status, 0, result.stderr || result.stdout);
assert.match(readFileSync(optionDumpPath, "utf8"), /\bon\b/);
});
});
test("buildOsc7ReloadCommand does not delete bash history when reload is not recorded", () => {
withTempHome("netcatty-osc7-reload-ignored-history-bash-", (home) => {
const bashrcPath = join(home, ".bashrc");
const dumpPath = join(home, "bash-history-dump");
mkdirSync(home, { recursive: true });
writeFileSync(bashrcPath, "osc7_cwd(){ :; }\n");
const output = runInteractiveHistoryProbe({
shellPath: "/bin/bash",
shellArgs: ["--noprofile", "--norc", "-i"],
dumpHistoryCommand: `history > ${quoteShellArg(dumpPath)}`,
dumpPath,
env: {
HOME: home,
HISTFILE: join(home, ".bash_history"),
HISTIGNORE: "*__netcatty_osc7_history_cleanup_marker__=1*",
SHELL: "/bin/bash",
},
input: `echo keepme\n${buildOsc7ReloadCommand({ shell: "bash", configPath: bashrcPath }) ?? ""}`,
});
assert.match(output, /echo keepme/);
assert.doesNotMatch(output, /osc7_cwd|source .*\.bashrc|__netcatty_osc7|history -d/);
});
});
test("buildOsc7ReloadCommand bypasses custom bash history wrappers", () => {
withTempHome("netcatty-osc7-reload-wrapped-history-bash-", (home) => {
const bashrcPath = join(home, ".bashrc");
const dumpPath = join(home, "bash-history-dump");
mkdirSync(home, { recursive: true });
writeFileSync(bashrcPath, "osc7_cwd(){ :; }\n");
const output = runInteractiveHistoryProbe({
shellPath: "/bin/bash",
shellArgs: ["--noprofile", "--norc", "-i"],
dumpHistoryCommand: `builtin history > ${quoteShellArg(dumpPath)}`,
dumpPath,
env: {
HOME: home,
HISTFILE: join(home, ".bash_history"),
SHELL: "/bin/bash",
},
input: [
'history(){ echo custom; }',
"echo keepme",
buildOsc7ReloadCommand({ shell: "bash", configPath: bashrcPath }) ?? "",
].join("\n"),
});
assert.match(output, /echo keepme/);
assert.doesNotMatch(output, /osc7_cwd|source .*\.bashrc|__netcatty_osc7|history -d/);
});
});
test("buildOsc7SetupCommand runs under strict unset-variable mode", () => {
for (const shellPath of existingShells(["/bin/bash", "/bin/zsh"])) {
withTempHome(`netcatty-osc7-strict-${basename(shellPath)}-`, (home) => {
execFileSync(shellPath, ["-uc", buildOsc7SetupCommand()], {
env: {
...process.env,
HOME: home,
SHELL: shellPath,
ZDOTDIR: undefined,
XDG_CONFIG_HOME: undefined,
},
stdio: "pipe",
});
});
}
});