tmux-ide 2.9.2 → 2.9.3

package/packages/tmux-bridge/src/runner.test.ts

@@ -1,614 +0,0 @@
-import { describe, it, beforeEach, afterEach, mock, expect } from "bun:test";
-import {
-  _setExecutor,
-  _setSpawner,
-  TmuxError,
-  getSessionState,
-  hasSession,
-  killSession,
-  listPanes,
-  createDetachedSession,
-  splitPane,
-  sendLiteral,
-  getSessionVariable,
-  setSessionVariable,
-  startSessionMonitor,
-  stopSessionMonitor,
-  setPaneTitle,
-  setWindowOption,
-  selectPane,
-  getPaneCurrentCommand,
-  setSessionEnvironment,
-  attachSession,
-  runSessionCommand,
-  runTmux,
-  runTmuxBinary,
-  runTmuxBinaryAsync,
-} from "./index.ts";
-
-let mockExec;
-let restoreExec;
-
-beforeEach(() => {
-  mockExec = mock();
-  restoreExec = _setExecutor(mockExec);
-});
-
-afterEach(() => {
-  restoreExec();
-});
-
-// --- Helpers ---
-
-function makeExecError(stderr) {
-  const err = new Error("Command failed");
-  err.stderr = stderr;
-  return err;
-}
-
-// --- Error classification (via public API) ---
-
-describe("getSessionState", () => {
-  it("returns running: true when has-session succeeds", () => {
-    mockExec.mockImplementation(() => "");
-    const result = getSessionState("my-session");
-    expect(result).toEqual({ running: true, reason: null });
-    expect(mockExec.mock.calls[0][1]).toEqual(["has-session", "-t", "my-session"]);
-  });
-
-  it('returns SESSION_NOT_FOUND for "can\'t find session"', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find session: my-session");
-    });
-    const result = getSessionState("my-session");
-    expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
-  });
-
-  it('returns TMUX_UNAVAILABLE for "connection refused"', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("error connecting to /tmp/tmux-1000/default (connection refused)");
-    });
-    const result = getSessionState("my-session");
-    expect(result).toEqual({ running: false, reason: "TMUX_UNAVAILABLE" });
-  });
-
-  it('returns TMUX_UNAVAILABLE for "no server running"', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("no server running on /tmp/tmux-1000/default");
-    });
-    const result = getSessionState("my-session");
-    expect(result).toEqual({ running: false, reason: "TMUX_UNAVAILABLE" });
-  });
-
-  it("throws for unknown errors", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("something totally unexpected");
-    });
-    expect(() => getSessionState("my-session")).toThrow(TmuxError);
-  });
-});
-
-describe("hasSession", () => {
-  it("returns true when session exists", () => {
-    mockExec.mockImplementation(() => "");
-    expect(hasSession("proj")).toBe(true);
-  });
-
-  it("returns false for SESSION_NOT_FOUND", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find session: proj");
-    });
-    expect(hasSession("proj")).toBe(false);
-  });
-
-  it("returns false for TMUX_UNAVAILABLE", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("no server running on /tmp/tmux-1000/default");
-    });
-    expect(hasSession("proj")).toBe(false);
-  });
-
-  it("throws for unknown errors", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("unexpected failure");
-    });
-    expect(() => hasSession("proj")).toThrow(TmuxError);
-  });
-});
-
-describe("killSession", () => {
-  it("returns stopped: true when kill succeeds", () => {
-    mockExec.mockImplementation(() => "");
-    const result = killSession("proj");
-    expect(result).toEqual({ stopped: true, reason: null });
-    expect(mockExec.mock.calls[0][1]).toEqual(["kill-session", "-t", "proj"]);
-  });
-
-  it("returns stopped: false for missing session", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find session: proj");
-    });
-    const result = killSession("proj");
-    expect(result).toEqual({ stopped: false, reason: "SESSION_NOT_FOUND" });
-  });
-
-  it("returns stopped: false for unavailable tmux", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("failed to connect to server");
-    });
-    const result = killSession("proj");
-    expect(result).toEqual({ stopped: false, reason: "TMUX_UNAVAILABLE" });
-  });
-
-  it("throws for unknown errors", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("disk error");
-    });
-    expect(() => killSession("proj")).toThrow(TmuxError);
-  });
-});
-
-// --- listPanes ---
-
-describe("listPanes", () => {
-  it("parses multi-pane output correctly", () => {
-    mockExec.mockImplementation(() => "0|Editor|120|40|1\n1|Shell|80|40|0\n");
-    const panes = listPanes("proj");
-    expect(panes).toEqual([
-      { index: 0, title: "Editor", width: 120, height: 40, active: true },
-      { index: 1, title: "Shell", width: 80, height: 40, active: false },
-    ]);
-  });
-
-  it("returns empty array for empty output", () => {
-    mockExec.mockImplementation(() => "  \n");
-    const panes = listPanes("proj");
-    expect(panes).toEqual([]);
-  });
-
-  it("handles pane titles containing pipe characters", () => {
-    // The split("|") will split on the first pipe in the title, causing misparse.
-    // This documents the current behavior — titles with pipes are truncated.
-    mockExec.mockImplementation(() => "0|A|B|120|40|0\n");
-    const panes = listPanes("proj");
-    // With pipe in title, index=0, title="A", width=NaN (from "B"), ...
-    expect(panes[0].index).toBe(0);
-    expect(panes[0].title).toBe("A");
-  });
-});
-
-// --- createDetachedSession ---
-
-describe("createDetachedSession", () => {
-  it("returns trimmed pane ID", () => {
-    mockExec.mockImplementation(() => "  %0\n");
-    const id = createDetachedSession("proj", "/workspace");
-    expect(id).toBe("%0");
-    expect(mockExec.mock.calls.map((call) => call[1])).toContainEqual([
-      "set-environment",
-      "-r",
-      "-t",
-      "=proj",
-      "NO_COLOR",
-    ]);
-  });
-
-  it("uses default dimensions when not specified", () => {
-    mockExec.mockImplementation(() => "%0\n");
-    createDetachedSession("proj", "/workspace");
-    const args = mockExec.mock.calls[0][1];
-    expect(args.includes("200")).toBeTruthy(); // default cols
-    expect(args.includes("50")).toBeTruthy(); // default lines
-    expect(args.at(-1)).toBe(
-      "exec env -u NO_COLOR COLORTERM=truecolor COLORFGBG='15;0' \"${SHELL:-/bin/sh}\" -l",
-    );
-  });
-
-  it("passes custom dimensions", () => {
-    mockExec.mockImplementation(() => "%0\n");
-    createDetachedSession("proj", "/workspace", { cols: 300, lines: 80 });
-    const args = mockExec.mock.calls[0][1];
-    expect(args.includes("300")).toBeTruthy();
-    expect(args.includes("80")).toBeTruthy();
-    expect(args.at(-1)).toBe(
-      "exec env -u NO_COLOR COLORTERM=truecolor COLORFGBG='15;0' \"${SHELL:-/bin/sh}\" -l",
-    );
-  });
-});
-
-// --- splitPane ---
-
-describe("splitPane", () => {
-  it("uses -v for vertical direction", () => {
-    mockExec.mockImplementation(() => "%1\n");
-    splitPane("%0", "vertical", "/workspace", 30);
-    const args = mockExec.mock.calls[0][1];
-    expect(args.includes("-v")).toBeTruthy();
-    expect(!args.includes("-h")).toBeTruthy();
-  });
-
-  it("uses -h for horizontal direction", () => {
-    mockExec.mockImplementation(() => "%2\n");
-    splitPane("%0", "horizontal", "/workspace", 50);
-    const args = mockExec.mock.calls[0][1];
-    expect(args.includes("-h")).toBeTruthy();
-    expect(!args.includes("-v")).toBeTruthy();
-  });
-
-  it("passes percent correctly", () => {
-    mockExec.mockImplementation(() => "%3\n");
-    splitPane("%0", "vertical", "/workspace", 42);
-    const args = mockExec.mock.calls[0][1];
-    const pIdx = args.indexOf("-p");
-    expect(args[pIdx + 1]).toBe("42");
-  });
-
-  it("returns trimmed pane ID", () => {
-    mockExec.mockImplementation(() => "  %5\n");
-    const id = splitPane("%0", "vertical", "/workspace", 30);
-    expect(id).toBe("%5");
-  });
-});
-
-// --- sendLiteral ---
-
-describe("sendLiteral", () => {
-  it("sends text with -l flag then Enter", () => {
-    mockExec.mockImplementation(() => "");
-    sendLiteral("%0", "echo hello");
-    expect(mockExec.mock.calls.length).toBe(2);
-    // First call: send-keys with -l and the text
-    const firstArgs = mockExec.mock.calls[0][1];
-    expect(firstArgs).toEqual(["send-keys", "-t", "%0", "-l", "--", "echo hello"]);
-    // Second call: send Enter
-    const secondArgs = mockExec.mock.calls[1][1];
-    expect(secondArgs).toEqual(["send-keys", "-t", "%0", "Enter"]);
-  });
-});
-
-// --- getSessionVariable / setSessionVariable ---
-
-describe("getSessionVariable", () => {
-  it("returns trimmed value when variable exists", () => {
-    mockExec.mockImplementation(() => "  some-value\n");
-    const value = getSessionVariable("proj", "@my_var");
-    expect(value).toBe("some-value");
-  });
-
-  it("returns null when variable is empty", () => {
-    mockExec.mockImplementation(() => "\n");
-    const value = getSessionVariable("proj", "@my_var");
-    expect(value).toBe(null);
-  });
-
-  it("returns null when show-option throws", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find session: proj");
-    });
-    const value = getSessionVariable("proj", "@my_var");
-    expect(value).toBe(null);
-  });
-});
-
-describe("setSessionVariable", () => {
-  it("sets variable with correct args", () => {
-    mockExec.mockImplementation(() => "");
-    setSessionVariable("proj", "@my_var", "hello");
-    expect(mockExec.mock.calls[0][1]).toEqual(["set-option", "-t", "proj", "@my_var", "hello"]);
-  });
-});
-
-// --- startSessionMonitor / stopSessionMonitor ---
-
-describe("startSessionMonitor", () => {
-  it("spawns detached process and stores PID", () => {
-    const fakeChild = { pid: 12345, unref: mock() };
-    const restoreSpawn = _setSpawner(mock(() => fakeChild));
-
-    mockExec.mockImplementation(() => "");
-    startSessionMonitor("proj", "/path/to/monitor.js");
-
-    // Check spawn was called correctly
-    expect(fakeChild.unref.mock.calls.length).toBe(1);
-
-    // First call checks for existing PID (show-option), then stores new PID (set-option)
-    const lastCall = mockExec.mock.calls[mockExec.mock.calls.length - 1];
-    const setArgs = lastCall[1];
-    expect(setArgs).toEqual(["set-option", "-t", "proj", "@monitor_pid", "12345"]);
-
-    restoreSpawn();
-  });
-
-  it("spawns the daemon under tsx (never bun — see T085/T087)", () => {
-    // Pinned to tsx so node-pty's onData callback fires; bun breaks it.
-    const fakeChild = { pid: 99, unref: mock() };
-    const mockSpawn = mock(() => fakeChild);
-    const restoreSpawn = _setSpawner(mockSpawn);
-
-    mockExec.mockImplementation(() => "");
-    startSessionMonitor("proj", "/path/to/monitor.ts");
-
-    const spawnCall = mockSpawn.mock.calls[0];
-    expect(spawnCall[0]).toBe("tsx");
-    const args = spawnCall[1];
-    expect(args).toEqual(["/path/to/monitor.ts", "proj", "0"]);
-
-    restoreSpawn();
-  });
-});
-
-describe("stopSessionMonitor", () => {
-  it("kills process group by stored PID", () => {
-    mockExec.mockImplementation(() => "  42\n");
-    const origKill = process.kill;
-    const killCalls: Array<{ pid: number; signal?: string }> = [];
-    process.kill = ((pid: number, signal?: string) => {
-      killCalls.push({ pid, signal });
-    }) as typeof process.kill;
-    try {
-      stopSessionMonitor("proj");
-      // First tries process group kill (negative PID)
-      expect(killCalls[0]?.pid).toBe(-42);
-      expect(killCalls[0]?.signal).toBe("SIGTERM");
-    } finally {
-      process.kill = origKill;
-    }
-  });
-
-  it("handles missing PID gracefully", () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find session: proj");
-    });
-    // Should not throw
-    stopSessionMonitor("proj");
-  });
-
-  it("handles empty PID gracefully", () => {
-    mockExec.mockImplementation(() => "\n");
-    // Should not throw (no pid to kill)
-    stopSessionMonitor("proj");
-  });
-});
-
-// --- Other public functions ---
-
-describe("setPaneTitle", () => {
-  it("calls select-pane with -T flag", () => {
-    mockExec.mockImplementation(() => "");
-    setPaneTitle("%0", "My Pane");
-    expect(mockExec.mock.calls[0][1]).toEqual(["select-pane", "-t", "%0", "-T", "My Pane"]);
-  });
-});
-
-describe("setWindowOption", () => {
-  it("sets a quiet window-local option through a pane target", () => {
-    mockExec.mockImplementation(() => "");
-    setWindowOption("%0", "@tmux_ide_window_id", "window.launch.abc123");
-    expect(mockExec.mock.calls[0][1]).toEqual([
-      "set-option",
-      "-wqt",
-      "%0",
-      "@tmux_ide_window_id",
-      "window.launch.abc123",
-    ]);
-  });
-});
-
-describe("selectPane", () => {
-  it("calls select-pane with target", () => {
-    mockExec.mockImplementation(() => "");
-    selectPane("%2");
-    expect(mockExec.mock.calls[0][1]).toEqual(["select-pane", "-t", "%2"]);
-  });
-});
-
-describe("getPaneCurrentCommand", () => {
-  it("returns trimmed command name", () => {
-    mockExec.mockImplementation(() => "  zsh\n");
-    expect(getPaneCurrentCommand("%0")).toBe("zsh");
-  });
-});
-
-describe("setSessionEnvironment", () => {
-  it("calls set-environment with correct args", () => {
-    mockExec.mockImplementation(() => "");
-    setSessionEnvironment("proj", "PORT", 3000);
-    expect(mockExec.mock.calls[0][1]).toEqual(["set-environment", "-t", "proj", "PORT", "3000"]);
-  });
-});
-
-describe("attachSession", () => {
-  it("calls attach with correct args and stdio inherit", () => {
-    mockExec.mockImplementation(() => "");
-    attachSession("proj");
-    expect(mockExec.mock.calls[0][1]).toEqual(["attach", "-t", "proj"]);
-    expect(mockExec.mock.calls[0][2].stdio).toBe("inherit");
-  });
-});
-
-describe("runSessionCommand", () => {
-  it("passes args through to tmux", () => {
-    mockExec.mockImplementation(() => "");
-    runSessionCommand(["resize-pane", "-t", "%0", "-x", "100"]);
-    expect(mockExec.mock.calls[0][1]).toEqual(["resize-pane", "-t", "%0", "-x", "100"]);
-  });
-});
-
-// --- Debug logging ---
-
-describe("debug logging", () => {
-  it("logs to stderr when globalThis.__tmuxIdeVerbose is true", () => {
-    const origVerbose = globalThis.__tmuxIdeVerbose;
-    const stderrCalls = [];
-    const origConsoleError = console.error;
-    console.error = (...args) => stderrCalls.push(args.join(" "));
-
-    globalThis.__tmuxIdeVerbose = true;
-    mockExec.mockImplementation(() => "");
-
-    try {
-      hasSession("test-session");
-      expect(stderrCalls.some((msg) => msg.includes("[tmux]"))).toBeTruthy();
-      expect(stderrCalls.some((msg) => msg.includes("has-session"))).toBeTruthy();
-    } finally {
-      globalThis.__tmuxIdeVerbose = origVerbose;
-      console.error = origConsoleError;
-    }
-  });
-
-  it("does not log when neither DEBUG nor verbose is set", () => {
-    const origVerbose = globalThis.__tmuxIdeVerbose;
-    const stderrCalls = [];
-    const origConsoleError = console.error;
-    console.error = (...args) => stderrCalls.push(args.join(" "));
-
-    globalThis.__tmuxIdeVerbose = false;
-    mockExec.mockImplementation(() => "");
-
-    try {
-      hasSession("test-session");
-      expect(stderrCalls.length).toBe(0);
-    } finally {
-      globalThis.__tmuxIdeVerbose = origVerbose;
-      console.error = origConsoleError;
-    }
-  });
-});
-
-// --- Error classification edge cases ---
-
-describe("error classification", () => {
-  it("executes an explicitly pinned binary without replacing it with ambient tmux", () => {
-    mockExec.mockImplementation(() => "ok");
-    expect(runTmuxBinary("/trusted/bin/tmux", ["-S", "/trusted/socket", "list-panes"])).toBe("ok");
-    expect(mockExec.mock.calls[0][0]).toBe("/trusted/bin/tmux");
-    expect(mockExec.mock.calls[0][1]).toEqual(["-S", "/trusted/socket", "list-panes"]);
-  });
-
-  it("sanitizes a hostile client environment before it can cold-start the server", () => {
-    mockExec.mockImplementation(() => "ok");
-    runTmux(["list-sessions"], {
-      env: { PATH: "/trusted/bin", TERM: "dumb", NO_COLOR: "1", COLORTERM: "disabled" },
-    });
-    expect(mockExec.mock.calls[0][2].env).toEqual({
-      PATH: "/trusted/bin",
-      TERM: "dumb",
-      COLORTERM: "truecolor",
-      COLORFGBG: "15;0",
-    });
-  });
-
-  it('classifies an exact show-environment "unknown variable" separately', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("unknown variable: TMUX_IDE_ATTACHMENT_VIEW");
-    });
-
-    expect(() => runTmux(["show-environment", "-t", "$12", "TMUX_IDE_ATTACHMENT_VIEW"])).toThrow(
-      expect.objectContaining({
-        code: "ENVIRONMENT_VARIABLE_NOT_FOUND",
-        message: "tmux environment variable was not found",
-      }),
-    );
-  });
-
-  it('classifies "can\'t find window" as SESSION_NOT_FOUND', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find window: proj:0");
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
-  });
-
-  it('classifies "can\'t find pane" as SESSION_NOT_FOUND', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("can't find pane: %42");
-    });
-    expect(() => runTmux(["list-panes", "-t", "%42"])).toThrow(
-      expect.objectContaining({ code: "SESSION_NOT_FOUND" }),
-    );
-  });
-
-  it('classifies "unknown target" as SESSION_NOT_FOUND', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("unknown target: proj");
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
-  });
-
-  it('classifies "failed to connect to server" as TMUX_UNAVAILABLE', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("failed to connect to server: /tmp/tmux-1000/default");
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "TMUX_UNAVAILABLE" });
-  });
-
-  it('classifies "error connecting to" as TMUX_UNAVAILABLE', () => {
-    mockExec.mockImplementation(() => {
-      throw makeExecError("error connecting to /tmp/tmux-1000/default");
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "TMUX_UNAVAILABLE" });
-  });
-
-  it("handles Buffer stderr in error", () => {
-    mockExec.mockImplementation(() => {
-      const err = new Error("Command failed");
-      err.stderr = Buffer.from("can't find session: proj");
-      throw err;
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
-  });
-
-  it("falls back to error.message when stderr is empty", () => {
-    mockExec.mockImplementation(() => {
-      const err = new Error("can't find session: proj");
-      err.stderr = "";
-      throw err;
-    });
-    const result = getSessionState("proj");
-    expect(result).toEqual({ running: false, reason: "SESSION_NOT_FOUND" });
-  });
-});
-
-// --- Async pinned runner (real child processes; no executor mock) ---
-
-describe("runTmuxBinaryAsync", () => {
-  it("resolves stdout of a pinned executable off the event loop", async () => {
-    await expect(runTmuxBinaryAsync("/bin/sh", ["-c", "printf ok"])).resolves.toBe("ok");
-  });
-
-  it("classifies a missing target exactly like the sync runner, keeping the cause", async () => {
-    let caught;
-    try {
-      await runTmuxBinaryAsync("/bin/sh", ["-c", 'echo "can\'t find session: nope" >&2; exit 1']);
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(TmuxError);
-    expect(caught.code).toBe("SESSION_NOT_FOUND");
-    expect(caught.cause).toBeInstanceOf(Error);
-  });
-
-  it("classifies an unreachable server as TMUX_UNAVAILABLE", async () => {
-    let caught;
-    try {
-      await runTmuxBinaryAsync("/bin/sh", ["-c", "echo 'no server running on /x' >&2; exit 1"]);
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(TmuxError);
-    expect(caught.code).toBe("TMUX_UNAVAILABLE");
-  });
-
-  it("sanitizes the client environment it hands the child", async () => {
-    const output = await runTmuxBinaryAsync(
-      "/bin/sh",
-      ["-c", 'printf "%s|%s" "$COLORTERM" "$NO_COLOR"'],
-      { env: { PATH: "/usr/bin:/bin", NO_COLOR: "1" } },
-    );
-    expect(output).toBe("truecolor|");
-  });
-});