@bastani/atomic 0.6.8 → 0.7.0-2

package/src/sdk/providers/headless-hil-policy.test.ts

@@ -1,211 +0,0 @@
-/**
- * Tests for the headless human-in-the-loop (HIL) auto-deny policy.
- *
- * In unattended runs (headless stages), no human is attached to answer
- * interactive questions from the agent. If the SDK's ask-user tool is
- * not disabled, a query will sit blocked forever. These tests verify
- * each provider's headless integration blocks the relevant tool.
- */
-
-import { test, expect, describe } from "bun:test";
-import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mergeDisallowedTools, resolveHeadlessClaudeBin } from "./claude.ts";
-import {
-  HEADLESS_OPENCODE_CLIENT_ID,
-  withHeadlessOpencodeEnv,
-} from "./opencode.ts";
-import { mergeExcludedTools } from "../runtime/executor.ts";
-
-// ---------------------------------------------------------------------------
-// Claude — disallowedTools: ["AskUserQuestion"]
-// ---------------------------------------------------------------------------
-
-describe("mergeDisallowedTools (Claude)", () => {
-  test("adds AskUserQuestion when no existing disallow list", () => {
-    expect(mergeDisallowedTools(undefined, ["AskUserQuestion"])).toEqual([
-      "AskUserQuestion",
-    ]);
-  });
-
-  test("preserves caller-supplied entries", () => {
-    expect(
-      mergeDisallowedTools(["Bash", "WebFetch"], ["AskUserQuestion"]),
-    ).toEqual(["Bash", "WebFetch", "AskUserQuestion"]);
-  });
-
-  test("does not duplicate AskUserQuestion if caller already disallowed it", () => {
-    expect(
-      mergeDisallowedTools(["AskUserQuestion", "Bash"], ["AskUserQuestion"]),
-    ).toEqual(["AskUserQuestion", "Bash"]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Copilot — excludedTools: ["ask_user"]
-// ---------------------------------------------------------------------------
-
-describe("mergeExcludedTools (Copilot)", () => {
-  test("adds ask_user when no existing excluded list", () => {
-    expect(mergeExcludedTools(undefined, ["ask_user"])).toEqual(["ask_user"]);
-  });
-
-  test("preserves caller-supplied entries", () => {
-    expect(mergeExcludedTools(["bash"], ["ask_user"])).toEqual([
-      "bash",
-      "ask_user",
-    ]);
-  });
-
-  test("does not duplicate ask_user if caller already excluded it", () => {
-    expect(mergeExcludedTools(["ask_user", "bash"], ["ask_user"])).toEqual([
-      "ask_user",
-      "bash",
-    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Claude — headless binary resolution pins to the PATH `claude` CLI
-// ---------------------------------------------------------------------------
-
-describe("resolveHeadlessClaudeBin", () => {
-  const withPath = (path: string, fn: () => void) => {
-    const before = process.env.PATH;
-    process.env.PATH = path;
-    try {
-      fn();
-    } finally {
-      if (before === undefined) delete process.env.PATH;
-      else process.env.PATH = before;
-    }
-  };
-
-  test("returns the `claude` binary when present on PATH", () => {
-    const dir = mkdtempSync(join(tmpdir(), "atomic-claude-bin-"));
-    const bin = join(dir, "claude");
-    writeFileSync(bin, "#!/usr/bin/env sh\nexit 0\n");
-    chmodSync(bin, 0o755);
-    withPath(dir, () => {
-      expect(resolveHeadlessClaudeBin()).toBe(bin);
-    });
-  });
-
-  test("throws with installer URL when PATH has no `claude`", () => {
-    const empty = mkdtempSync(join(tmpdir(), "atomic-empty-path-"));
-    withPath(empty, () => {
-      expect(() => resolveHeadlessClaudeBin()).toThrow(/CLI not found on PATH/);
-      expect(() => resolveHeadlessClaudeBin()).toThrow(
-        /docs\.claude\.com.*claude-code/,
-      );
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// OpenCode — OPENCODE_CLIENT override excludes the question tool
-// ---------------------------------------------------------------------------
-//
-// Upstream (`packages/opencode/src/tool/registry.ts`) gates the question
-// tool on `["app","cli","desktop"].includes(OPENCODE_CLIENT)`. The SDK
-// spawns `opencode serve` via cross-spawn and inherits `process.env` at
-// fork time, so scoping the override around `createOpencode()` is
-// sufficient to keep the tool off the registry.
-
-describe("withHeadlessOpencodeEnv", () => {
-  test("sets OPENCODE_CLIENT to the headless id while fn runs", async () => {
-    const seen: string | undefined = await withHeadlessOpencodeEnv(async () =>
-      process.env.OPENCODE_CLIENT,
-    );
-    expect(seen).toBe(HEADLESS_OPENCODE_CLIENT_ID);
-  });
-
-  test("restores prior value when it was set before", async () => {
-    const before = process.env.OPENCODE_CLIENT;
-    process.env.OPENCODE_CLIENT = "preexisting";
-    try {
-      await withHeadlessOpencodeEnv(async () => {});
-      expect(process.env.OPENCODE_CLIENT).toBe("preexisting");
-    } finally {
-      if (before === undefined) delete process.env.OPENCODE_CLIENT;
-      else process.env.OPENCODE_CLIENT = before;
-    }
-  });
-
-  test("unsets the variable when it was unset before", async () => {
-    const before = process.env.OPENCODE_CLIENT;
-    delete process.env.OPENCODE_CLIENT;
-    try {
-      await withHeadlessOpencodeEnv(async () => {});
-      expect(
-        Object.prototype.hasOwnProperty.call(process.env, "OPENCODE_CLIENT"),
-      ).toBe(false);
-    } finally {
-      if (before === undefined) delete process.env.OPENCODE_CLIENT;
-      else process.env.OPENCODE_CLIENT = before;
-    }
-  });
-
-  test("restores prior value even when fn throws", async () => {
-    const before = process.env.OPENCODE_CLIENT;
-    process.env.OPENCODE_CLIENT = "preexisting";
-    try {
-      await expect(
-        withHeadlessOpencodeEnv(async () => {
-          throw new Error("boom");
-        }),
-      ).rejects.toThrow("boom");
-      expect(process.env.OPENCODE_CLIENT).toBe("preexisting");
-    } finally {
-      if (before === undefined) delete process.env.OPENCODE_CLIENT;
-      else process.env.OPENCODE_CLIENT = before;
-    }
-  });
-
-  test("is not one of the values that would enable the question tool", () => {
-    // Guard against accidental future edits: picking "cli", "app", or
-    // "desktop" here would silently re-enable the interactive question tool
-    // and make headless stages hang again.
-    expect(["app", "cli", "desktop"]).not.toContain(
-      HEADLESS_OPENCODE_CLIENT_ID,
-    );
-  });
-
-  test("concurrent uses do not leak the override after both unwind", async () => {
-    // Race regression: without a reference counter, the second concurrent
-    // stage reads the first's already-overridden value as its "prior" and
-    // restores "sdk" instead of the true original on unwind.
-    const before = process.env.OPENCODE_CLIENT;
-    delete process.env.OPENCODE_CLIENT;
-    try {
-      let releaseA!: () => void;
-      let releaseB!: () => void;
-      const waitA = new Promise<void>((r) => {
-        releaseA = r;
-      });
-      const waitB = new Promise<void>((r) => {
-        releaseB = r;
-      });
-
-      const a = withHeadlessOpencodeEnv(async () => {
-        await waitA;
-      });
-      const b = withHeadlessOpencodeEnv(async () => {
-        await waitB;
-      });
-
-      // Release A first, then B — the order that exposes the naive bug.
-      releaseA();
-      releaseB();
-      await Promise.all([a, b]);
-
-      expect(
-        Object.prototype.hasOwnProperty.call(process.env, "OPENCODE_CLIENT"),
-      ).toBe(false);
-    } finally {
-      if (before === undefined) delete process.env.OPENCODE_CLIENT;
-      else process.env.OPENCODE_CLIENT = before;
-    }
-  });
-});

package/src/sdk/providers/opencode.ts

@@ -1,88 +0,0 @@
-/**
- * OpenCode workflow source validation + headless env helper.
- *
- * Checks that OpenCode workflow source files use the runtime-managed
- * `s.client` and `s.session` instead of manual SDK client creation, and
- * exports the `OPENCODE_CLIENT` override used to keep the interactive
- * `question` tool out of headless stages.
- */
-
-import { createProviderValidator } from "../types.ts";
-
-/**
- * Client identifier passed to SDK-spawned OpenCode subprocesses in headless
- * stages.
- *
- * OpenCode only registers its interactive `question` tool when
- * `OPENCODE_CLIENT` is one of `"app" | "cli" | "desktop"` (see
- * `packages/opencode/src/tool/registry.ts` upstream — the `questionEnabled`
- * gate). In unattended runs nobody is attached to answer, so we identify
- * ourselves as `"sdk"` to keep the tool off the registry entirely. This
- * mirrors how the upstream ACP integration excludes the tool by default
- * (`packages/opencode/src/cli/cmd/acp.ts` sets `OPENCODE_CLIENT=acp`).
- */
-export const HEADLESS_OPENCODE_CLIENT_ID = "sdk";
-
-/**
- * Run `fn` with `process.env.OPENCODE_CLIENT` set to
- * `HEADLESS_OPENCODE_CLIENT_ID`, restoring the prior value afterward. The
- * SDK spawns `opencode serve` via `cross-spawn` and inherits the parent's
- * env at spawn time, so scoping the override around `createOpencode(...)`
- * is enough to influence the subprocess without leaking into later work.
- *
- * A reference counter keeps the override in place while any concurrent
- * headless spawn is still running — otherwise two parallel stages can
- * race, and the second one restores the first one's already-overridden
- * value as if it were the original. The captured "pre-override" state is
- * only read on the outermost entry and only replayed on the outermost
- * exit.
- *
- * Prior value handling is explicit so we distinguish "was unset" from
- * "was set to empty string".
- */
-let headlessEnvDepth = 0;
-let headlessEnvHadPrior = false;
-let headlessEnvPrior: string | undefined;
-
-export async function withHeadlessOpencodeEnv<T>(
-  fn: () => Promise<T>,
-): Promise<T> {
-  if (headlessEnvDepth === 0) {
-    headlessEnvHadPrior = Object.prototype.hasOwnProperty.call(
-      process.env,
-      "OPENCODE_CLIENT",
-    );
-    headlessEnvPrior = process.env.OPENCODE_CLIENT;
-  }
-  headlessEnvDepth++;
-  try {
-    process.env.OPENCODE_CLIENT = HEADLESS_OPENCODE_CLIENT_ID;
-    return await fn();
-  } finally {
-    headlessEnvDepth--;
-    if (headlessEnvDepth === 0) {
-      if (headlessEnvHadPrior) process.env.OPENCODE_CLIENT = headlessEnvPrior;
-      else delete process.env.OPENCODE_CLIENT;
-    }
-  }
-}
-
-/**
- * Validate an OpenCode workflow source file for common mistakes.
- */
-export const validateOpenCodeWorkflow = createProviderValidator([
-  {
-    pattern: /\bcreateOpencodeClient\b/,
-    rule: "opencode/manual-client",
-    message:
-      "Manual createOpencodeClient() call detected. Use s.client instead — " +
-      "the runtime auto-creates the client. Pass client config as the second arg to ctx.stage().",
-  },
-  {
-    pattern: /\bclient\.session\.create\b/,
-    rule: "opencode/manual-session",
-    message:
-      "Manual client.session.create() call detected. Use s.session instead — " +
-      "the runtime auto-creates the session. Pass session config as the third arg to ctx.stage().",
-  },
-]);

package/src/sdk/registry.ts

@@ -1,132 +0,0 @@
-/**
- * Workflow Registry — immutable, chainable registry of WorkflowDefinition objects.
- *
- * Key scheme: `${agent}/${name}` — each (agent, name) pair is unique.
- * Registering the same key twice throws — no silent overwrites.
- * `register()` is immutable: returns a new Registry, original is unchanged.
- */
-
-import type { AgentType, Registry, RegistrableWorkflow, WorkflowDefinition } from "./types.ts";
-import { validateCopilotWorkflow } from "./providers/copilot.ts";
-import { validateOpenCodeWorkflow } from "./providers/opencode.ts";
-import { validateClaudeWorkflow } from "./providers/claude.ts";
-import type { ValidationWarning } from "./types.ts";
-
-// Registry type is declared in types.ts; re-export it from here for convenience.
-export type { Registry };
-
-// ─── Validator dispatch ──────────────────────────────────────────────────────
-
-/** Map agent type to its provider validator. */
-const providerValidators: Record<
-  AgentType,
-  (source: string) => ValidationWarning[]
-> = {
-  claude: validateClaudeWorkflow,
-  opencode: validateOpenCodeWorkflow,
-  copilot: validateCopilotWorkflow,
-};
-
-/**
- * Run provider-specific source validation for a workflow definition.
- *
- * Derives source text from `wf.run.toString()` — the function body contains
- * the SDK API calls the validators check via regex. Hard failures (thrown
- * errors from the validator itself) propagate; warnings are returned.
- */
-function runProviderValidation(wf: WorkflowDefinition): ValidationWarning[] {
-  const validator = providerValidators[wf.agent];
-  const source = wf.run.toString();
-  return validator(source);
-}
-
-/**
- * Validate a single workflow definition at registration time.
- * Throws on hard failures; logs warnings via console.warn with `[registry]` prefix.
- */
-function validateAtRegistration(wf: WorkflowDefinition): void {
-  const warnings = runProviderValidation(wf);
-  for (const w of warnings) {
-    console.warn(
-      `[registry] workflow "${wf.agent}/${wf.name}" — ${w.rule}: ${w.message}`,
-    );
-  }
-}
-
-// ─── Implementation ──────────────────────────────────────────────────────────
-
-/**
- * Internal implementation — typed separately from the public `Registry<T>`
- * so the accumulating generic can be rebuilt on each `register()` call
- * without leaking the implementation detail.
- */
-class RegistryImpl<T extends Record<string, WorkflowDefinition>> {
-  /** Immutable snapshot of registered definitions, keyed by `${agent}/${name}`. */
-  private readonly map: ReadonlyMap<string, WorkflowDefinition>;
-
-  constructor(map: ReadonlyMap<string, WorkflowDefinition>) {
-    this.map = map;
-  }
-
-  register<W extends RegistrableWorkflow>(
-    wf: W,
-  ): Registry<T & Record<`${W["agent"]}/${W["name"]}`, W>> {
-    const key = `${wf.agent}/${wf.name}` as `${W["agent"]}/${W["name"]}`;
-
-    if (this.map.has(key)) {
-      throw new Error(
-        `[atomic] Duplicate workflow registration: "${key}" is already registered. ` +
-          `Each (agent, name) pair must be unique.`,
-      );
-    }
-
-    validateAtRegistration(wf);
-
-    const next = new Map(this.map);
-    next.set(key, wf);
-    return new RegistryImpl<T & Record<`${W["agent"]}/${W["name"]}`, W>>(next) as Registry<
-      T & Record<`${W["agent"]}/${W["name"]}`, W>
-    >;
-  }
-
-  get<K extends keyof T>(key: K): T[K] {
-    const entry = this.map.get(key as string);
-    if (!entry) {
-      throw new Error(`[atomic] Workflow "${String(key)}" is not registered.`);
-    }
-    return entry as T[K];
-  }
-
-  has(key: string): boolean {
-    return this.map.has(key);
-  }
-
-  list(): readonly WorkflowDefinition[] {
-    return Object.freeze(Array.from(this.map.values()));
-  }
-
-  resolve(name: string, agent: AgentType): WorkflowDefinition | undefined {
-    return this.map.get(`${agent}/${name}`);
-  }
-}
-
-// ─── Factory ─────────────────────────────────────────────────────────────────
-
-/**
- * Create an empty workflow registry.
- *
- * @example
- * ```typescript
- * import { createRegistry } from "@bastani/atomic/workflows";
- * import { myWorkflow } from "./workflows/my-workflow.workflow";
- *
- * const registry = createRegistry()
- *   .register(myWorkflow);
- * ```
- */
-export function createRegistry(): Registry<Record<string, never>> {
-  return new RegistryImpl<Record<string, never>>(new Map()) as Registry<Record<string, never>>;
-}
-
-// ─── Re-export validators for external use ───────────────────────────────────
-export { validateCopilotWorkflow, validateOpenCodeWorkflow, validateClaudeWorkflow };

package/src/sdk/runtime/attached-footer.ts

@@ -1,155 +0,0 @@
-/**
- * Helper for spawning the attached `atomic _footer` pane inside an agent
- * tmux window.
- *
- * Shared between the workflow executor (per-agent windows) and the chat
- * command (single-agent window). Splits the target pane vertically so the
- * top pane keeps running the agent CLI and the bottom pane hosts the
- * React footer.
- *
- * Resolves the CLI entrypoint relative to this module (runtime/ lives at
- * src/sdk/runtime/, so ../../cli.ts is the CLI). `process.argv[1]` points
- * at the worker entrypoint when called from the orchestrator,
- * so it can't be used here.
- */
-
-import { posix, win32 } from "node:path";
-import type { AgentType } from "../types.ts";
-import { getMuxBinary, tmuxRun } from "./tmux.ts";
-
-/**
- * Rows reserved for the footer pane. Matches the single-row height of
- * `AttachedStatusline` so the agent pane absorbs all remaining space.
- */
-const FOOTER_PANE_LINES = 1;
-
-/** Escape a string for safe interpolation inside a bash double-quoted string. */
-function escBash(s: string): string {
-  return s
-    .replace(/\x00/g, "")
-    .replace(/[\n\r]+/g, " ")
-    .replace(/[\\"$`!]/g, "\\$&");
-}
-
-/** Escape a string as a PowerShell single-quoted literal. */
-function quotePwshLiteral(s: string): string {
-  return `'${s
-    .replace(/\x00/g, "")
-    .replace(/[\n\r]+/g, " ")
-    .replace(/'/g, "''")}'`;
-}
-
-function encodePwshCommand(script: string): string {
-  return Buffer.from(script, "utf16le").toString("base64");
-}
-
-export function resolveAttachedFooterCliPath(
-  runtimeDir = import.meta.dir,
-  platform: NodeJS.Platform = process.platform,
-): string {
-  return platform === "win32"
-    ? win32.join(runtimeDir, "..", "..", "cli.ts")
-    : posix.join(runtimeDir, "..", "..", "cli.ts");
-}
-
-export function buildAttachedFooterCommand({
-  runtime,
-  cliPath,
-  windowName,
-  agentType,
-  platform = process.platform,
-}: {
-  runtime: string;
-  cliPath: string;
-  windowName: string;
-  agentType?: AgentType;
-  platform?: NodeJS.Platform;
-}): string {
-  if (platform === "win32") {
-    const script = [
-      quotePwshLiteral(runtime),
-      quotePwshLiteral(cliPath),
-      quotePwshLiteral("_footer"),
-      quotePwshLiteral("--name"),
-      quotePwshLiteral(windowName),
-      ...(agentType
-        ? [quotePwshLiteral("--agent"), quotePwshLiteral(agentType)]
-        : []),
-    ].join(" ");
-    return `pwsh -NoProfile -EncodedCommand ${encodePwshCommand(`& ${script}`)}`;
-  }
-
-  const agentFlag = agentType ? ` --agent "${escBash(agentType)}"` : "";
-  return (
-    `"${escBash(runtime)}" "${escBash(cliPath)}" _footer ` +
-    `--name "${escBash(windowName)}"${agentFlag}`
-  );
-}
-
-export function buildAttachedFooterCloseHooks(
-  agentPaneId: string,
-  footerPaneId: string,
-  options: { guardAgentPane?: boolean } = {},
-): Array<{ event: string; command: string }> {
-  const killFooter = `kill-pane -t ${footerPaneId}`;
-  const paneExitedCommand = options.guardAgentPane === false
-    ? killFooter
-    : `if -F '#{==:#{hook_pane},${agentPaneId}}' '${killFooter}'`;
-
-  return [
-    { event: "pane-exited", command: paneExitedCommand },
-    { event: "after-kill-pane", command: killFooter },
-  ];
-}
-
-function muxSupportsHookPaneFormat(): boolean {
-  const binary = getMuxBinary();
-  return binary !== "psmux" && binary !== "pmux";
-}
-
-export function spawnAttachedFooter(
-  windowName: string,
-  paneId: string,
-  agentType?: AgentType,
-): void {
-  const runtime = process.execPath;
-  if (!runtime) return;
-  const cliPath = resolveAttachedFooterCliPath();
-  const cmd = buildAttachedFooterCommand({
-    runtime,
-    cliPath,
-    windowName,
-    agentType,
-  });
-  const split = tmuxRun([
-    "split-window",
-    "-t", paneId,
-    "-v", "-l", String(FOOTER_PANE_LINES), "-d",
-    "-P", "-F", "#{pane_id}",
-    cmd,
-  ]);
-  if (!split.ok) return;
-  const footerPaneId = split.stdout.trim();
-  if (!footerPaneId) return;
-  tmuxRun(["select-pane", "-t", paneId]);
-  for (const hook of buildAttachedFooterCloseHooks(paneId, footerPaneId, {
-    guardAgentPane: muxSupportsHookPaneFormat(),
-  })) {
-    tmuxRun([
-      "set-hook",
-      "-w", "-t", footerPaneId,
-      hook.event,
-      hook.command,
-    ]);
-  }
-  // Pin the footer to FOOTER_PANE_LINES on every resize so the agent pane
-  // absorbs all new space. Tmux's default proportional redistribution
-  // would otherwise grow the footer on larger windows. Window-scoped
-  // (`-w`) so other windows (e.g. the orchestrator graph) are unaffected.
-  tmuxRun([
-    "set-hook",
-    "-w", "-t", footerPaneId,
-    "window-resized",
-    `resize-pane -t ${footerPaneId} -y ${FOOTER_PANE_LINES}`,
-  ]);
-}

package/src/sdk/runtime/cc-debounce.ts

@@ -1,104 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Ctrl+C debounce helper for Atomic-managed tmux panes.
- *
- * Invoked from `tmux.conf` on every root-table Ctrl+C:
- *
- *   bind -n C-c run-shell -b '"#{@atomic-bun}" "#{@atomic-cc-debounce}" "#{pane_id}"'
- *
- * The binding sits on the shared atomic tmux server, so the debounce
- * applies uniformly to every pane — Claude Code, OpenCode, and Copilot
- * CLI, in both chat and workflow sessions.
- *
- * Rule: forward Ctrl+C only if the previous press is more than QUIET_MS
- * ago. The state file is touched on *every* press (forwarded or
- * swallowed) so sustained spam keeps extending the cooldown instead of
- * letting a press leak through every QUIET_MS interval — which is what
- * would otherwise still trigger an agent CLI's "double-tap to exit"
- * confirmation.
- */
-
-import { join } from "node:path";
-import { readFileSync, writeFileSync } from "node:fs";
-import { ensureAtomicTempDir } from "../../lib/atomic-temp.ts";
-
-/** Quiet period (ms) the user must leave between presses for the next
- *  one to be forwarded. Must exceed every integrated agent's exit-confirm
- *  window — Claude Code's is the widest (~1.5 s), so 1200 ms is a safe
- *  margin that still feels responsive for legitimate double-interrupts. */
-export const QUIET_MS = 1200;
-
-/** Pure decision helper — exported so tests can exercise it without
- *  touching the filesystem or spawning tmux. Returns `true` when the
- *  press should be forwarded, `false` when it should be swallowed. */
-export function shouldForward(
-  nowMs: number,
-  lastMs: number,
-  quietMs: number = QUIET_MS,
-): boolean {
-  return nowMs - lastMs > quietMs;
-}
-
-/** Filesystem-safe transform for a tmux pane id (typically `%0`, `%12`).
- *  A defensive sanitise keeps the path portable if tmux ever hands us
- *  something with shell metacharacters. */
-function stateFileFor(paneId: string): string {
-  const safe = paneId.replace(/[^a-zA-Z0-9_%-]/g, "_");
-  return join(ensureAtomicTempDir(), `atomic-cc-${safe}`);
-}
-
-function readLastPress(stateFile: string): number {
-  try {
-    const parsed = Number.parseInt(readFileSync(stateFile, "utf8").trim(), 10);
-    return Number.isFinite(parsed) ? parsed : 0;
-  } catch {
-    return 0;
-  }
-}
-
-/** Resolve the multiplexer binary for `tmux send-keys`. When `run-shell`
- *  spawns this script the `TMUX` / `PSMUX` env var is already set to the
- *  atomic socket, so plain `tmux` / `psmux` routes correctly without
- *  `-L`. We only need to pick the right executable name for the host. */
-function resolveMuxBinary(): string {
-  if (process.platform === "win32") {
-    for (const candidate of ["psmux", "pmux", "tmux"]) {
-      if (Bun.which(candidate)) return candidate;
-    }
-    return "psmux";
-  }
-  return "tmux";
-}
-
-function main(): number {
-  const paneId = process.argv[2];
-  if (!paneId) return 0;
-
-  const stateFile = stateFileFor(paneId);
-  const now = Date.now();
-  const last = readLastPress(stateFile);
-
-  // Always bump the timestamp so held-down or spammed presses keep
-  // extending the cooldown — this is what turns the single-press gate
-  // into a true quiet-period debounce.
-  try {
-    writeFileSync(stateFile, String(now));
-  } catch {
-    // Best-effort: if the tmp dir is read-only we'd rather forward every
-    // press than drop them silently.
-  }
-
-  if (!shouldForward(now, last)) return 0;
-
-  const proc = Bun.spawnSync({
-    cmd: [resolveMuxBinary(), "send-keys", "-t", paneId, "C-c"],
-    stdin: "ignore",
-    stdout: "ignore",
-    stderr: "ignore",
-  });
-  return proc.exitCode ?? 0;
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}