@hellcoder/companion 0.99.2-preview.20260610105829.5d5d2f3 → 0.100.0

package/server/cli-launcher.test.ts

@@ -84,12 +84,16 @@ function createMockProc(pid = 12345) {
     resolve = r;
   });
   exitResolve = resolve!;
+  // The Claude stdio transport (ClaudeAdapter.attachStdio) needs a writable
+  // stdin and a readable stdout to bridge NDJSON. Provide inert streams that
+  // accept writes and never emit so launcher-lifecycle tests stay deterministic.
   return {
     pid,
     kill: vi.fn(),
     exited: exitedPromise,
-    stdout: null,
-    stderr: null,
+    stdin: new WritableStream<Uint8Array>(),
+    stdout: new ReadableStream<Uint8Array>({ start() {} }),
+    stderr: new ReadableStream<Uint8Array>({ start() {} }),
   };
 }
 
@@ -156,7 +160,7 @@ beforeEach(() => {
   tempDir = mkdtempSync(join(tmpdir(), "launcher-test-"));
   resetSettings(join(tempDir, "settings.json"));
   store = new SessionStore(tempDir);
-  launcher = new CliLauncher(3456);
+  launcher = new CliLauncher();
   launcher.setStore(store);
   mockSpawn.mockReturnValue(createMockProc());
   mockListen.mockImplementation(() => ({ stop: vi.fn() }));
@@ -174,16 +178,18 @@ afterEach(() => {
 // ─── launch ──────────────────────────────────────────────────────────────────
 
 describe("launch", () => {
-  it("creates a session with a UUID and starting state", () => {
+  it("creates a session with a UUID and connects immediately over stdio", () => {
     const info = launcher.launch({ cwd: "/tmp/project" });
 
     expect(info.sessionId).toBe("test-session-id");
-    expect(info.state).toBe("starting");
+    // The stdio transport owns the process and attaches synchronously — there
+    // is no WebSocket handshake to wait for, so the session is "connected".
+    expect(info.state).toBe("connected");
     expect(info.cwd).toBe("/tmp/project");
     expect(info.createdAt).toBeGreaterThan(0);
   });
 
-  it("spawns CLI with correct --sdk-url and flags", () => {
+  it("spawns CLI with the stdio stream-json transport and flags", () => {
     launcher.launch({ cwd: "/tmp/project" });
 
     expect(mockSpawn).toHaveBeenCalledOnce();
@@ -192,26 +198,36 @@ describe("launch", () => {
     // Binary should be resolved via execSync
     expect(cmdAndArgs[0]).toBe("/usr/bin/claude");
 
-    // Core required flags
-    expect(cmdAndArgs).toContain("--sdk-url");
-    expect(cmdAndArgs).toContain("ws://127.0.0.1:3456/ws/cli/test-session-id");
+    // Stdio stream-json transport — NOT the legacy --sdk-url WebSocket bridge.
+    expect(cmdAndArgs).not.toContain("--sdk-url");
     expect(cmdAndArgs).toContain("--print");
     expect(cmdAndArgs).toContain("--output-format");
     expect(cmdAndArgs).toContain("stream-json");
     expect(cmdAndArgs).toContain("--input-format");
     expect(cmdAndArgs).toContain("--include-partial-messages");
     expect(cmdAndArgs).toContain("--verbose");
+    // Routes permission prompts back as can_use_tool over the same pipes.
+    const pptIdx = cmdAndArgs.indexOf("--permission-prompt-tool");
+    expect(pptIdx).toBeGreaterThan(-1);
+    expect(cmdAndArgs[pptIdx + 1]).toBe("stdio");
 
-    // Headless prompt
-    expect(cmdAndArgs).toContain("-p");
-    expect(cmdAndArgs).toContain("");
+    // No trailing `-p ""` — the prompt arrives as a stream-json user message.
+    expect(cmdAndArgs[cmdAndArgs.length - 1]).not.toBe("");
 
-    // Spawn options
+    // Spawn options: stdin is piped so the server can write NDJSON to the child.
     expect(options.cwd).toBe("/tmp/project");
+    expect(options.stdin).toBe("pipe");
     expect(options.stdout).toBe("pipe");
     expect(options.stderr).toBe("pipe");
   });
 
+  it("emits backend:claude-adapter-created so the bridge can attach the adapter", () => {
+    const seen: string[] = [];
+    companionBus.on("backend:claude-adapter-created", ({ sessionId }) => { seen.push(sessionId); });
+    const info = launcher.launch({ cwd: "/tmp/project" });
+    expect(seen).toEqual([info.sessionId]);
+  });
+
   it("passes --model when provided", () => {
     launcher.launch({ model: "claude-opus-4-20250514", cwd: "/tmp" });
 
@@ -271,8 +287,7 @@ describe("launch", () => {
     }
   });
 
-  it("uses COMPANION_CONTAINER_SDK_HOST for containerized sdk-url when set", () => {
-    process.env.COMPANION_CONTAINER_SDK_HOST = "172.17.0.1";
+  it("runs containerized Claude over `docker exec -i` with stdio stream-json (no --sdk-url)", () => {
     launcher.launch({
       cwd: "/tmp/project",
       containerId: "abc123def456",
@@ -280,10 +295,15 @@ describe("launch", () => {
     });
 
     const [cmdAndArgs] = mockSpawn.mock.calls[0];
+    // `docker exec -i` keeps stdin open so the server can drive the CLI.
+    expect(cmdAndArgs.slice(0, 3)).toEqual(["docker", "exec", "-i"]);
+    expect(cmdAndArgs).toContain("abc123def456");
     // With bash -lc wrapping, CLI args are in the last element as a single string
     const bashCmd = cmdAndArgs[cmdAndArgs.length - 1];
-    expect(bashCmd).toContain("--sdk-url");
-    expect(bashCmd).toContain("ws://172.17.0.1:3456/ws/cli/test-session-id");
+    expect(bashCmd).not.toContain("--sdk-url");
+    expect(bashCmd).toContain("--input-format");
+    expect(bashCmd).toContain("stream-json");
+    expect(bashCmd).toContain("--permission-prompt-tool");
   });
 
   it("passes --allowedTools for each tool", () => {
@@ -705,8 +725,9 @@ describe("relaunch", () => {
       pid: 12345,
       kill: vi.fn(() => { resolveFirst(0); }),
       exited: new Promise<number>((r) => { resolveFirst = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     mockSpawn.mockReturnValueOnce(firstProc);
 
@@ -729,11 +750,12 @@ describe("relaunch", () => {
     expect(cmdAndArgs).toContain("--resume");
     expect(cmdAndArgs).toContain("cli-resume-id");
 
-    // Session state should be reset to starting (set by relaunch before spawnCLI)
+    // After relaunch the stdio transport attaches synchronously, so the session
+    // moves straight to "connected" (no WebSocket reconnect to wait for).
     // Allow microtask queue to flush
     await new Promise((r) => setTimeout(r, 10));
     const session = launcher.getSession("test-session-id");
-    expect(session?.state).toBe("starting");
+    expect(session?.state).toBe("connected");
   });
 
   it("reuses launch env variables during relaunch", async () => {
@@ -742,8 +764,9 @@ describe("relaunch", () => {
       pid: 12345,
       kill: vi.fn(() => { resolveFirst(0); }),
       exited: new Promise<number>((r) => { resolveFirst = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     mockSpawn.mockReturnValueOnce(firstProc);
 
@@ -803,8 +826,9 @@ describe("relaunch", () => {
       pid: 12345,
       kill: vi.fn(() => { resolveFirst(0); }),
       exited: new Promise<number>((r) => { resolveFirst = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     mockSpawn.mockReturnValueOnce(firstProc);
 
@@ -872,8 +896,9 @@ describe("relaunch", () => {
       pid: 12345,
       kill: vi.fn(() => { resolveFirst(0); }),
       exited: new Promise<number>((r) => { resolveFirst = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     mockSpawn.mockReturnValueOnce(firstProc);
 
@@ -999,8 +1024,9 @@ describe("codex websocket launcher", () => {
       pid: 3001,
       kill: vi.fn(() => resolveCodex1(0)),
       exited: new Promise<number>((r) => { resolveCodex1 = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     const proxy1 = createPendingCodexWsProxyProc(3002);
     proxy1.proc.kill.mockImplementation(() => proxy1.resolveExit(0));
@@ -1061,8 +1087,9 @@ describe("codex websocket launcher", () => {
       pid: 5001,
       kill: vi.fn(),
       exited: new Promise<number>((r) => { resolveLauncherProc = r; }),
-      stdout: null,
-      stderr: null,
+      stdin: new WritableStream<Uint8Array>(),
+      stdout: new ReadableStream<Uint8Array>({ start() {} }),
+      stderr: new ReadableStream<Uint8Array>({ start() {} }),
     };
     const proxy = createPendingCodexWsProxyProc(5002);
 
@@ -1132,7 +1159,7 @@ describe("persistence", () => {
         return origKill.call(process, pid, signal as any);
       }) as any);
 
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       const recovered = newLauncher.restoreFromDisk();
 
@@ -1168,7 +1195,7 @@ describe("persistence", () => {
         return true;
       }) as any);
 
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       const recovered = newLauncher.restoreFromDisk();
 
@@ -1184,13 +1211,13 @@ describe("persistence", () => {
     });
 
     it("returns 0 when no store is set", () => {
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       // No setStore call
       expect(newLauncher.restoreFromDisk()).toBe(0);
     });
 
     it("returns 0 when store has no launcher data", () => {
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       // Store is empty, no launcher.json file
       expect(newLauncher.restoreFromDisk()).toBe(0);
@@ -1215,7 +1242,7 @@ describe("persistence", () => {
 
       mockIsContainerAlive.mockReturnValueOnce("running");
 
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       const recovered = newLauncher.restoreFromDisk();
 
@@ -1243,7 +1270,7 @@ describe("persistence", () => {
 
       mockIsContainerAlive.mockReturnValueOnce("stopped");
 
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       const recovered = newLauncher.restoreFromDisk();
 
@@ -1269,7 +1296,7 @@ describe("persistence", () => {
       ];
       store.saveLauncher(savedSessions);
 
-      const newLauncher = new CliLauncher(3456);
+      const newLauncher = new CliLauncher();
       newLauncher.setStore(store);
       const recovered = newLauncher.restoreFromDisk();
 
@@ -1285,18 +1312,26 @@ describe("persistence", () => {
 // ─── getStartingSessions ─────────────────────────────────────────────────────
 
 describe("getStartingSessions", () => {
-  it("returns only sessions in starting state", () => {
-    launcher.launch({ cwd: "/tmp" });
-
-    const starting = launcher.getStartingSessions();
+  it("returns only sessions in starting state (restored, awaiting relaunch)", () => {
+    // Fresh stdio launches connect immediately, so "starting" only arises on
+    // restore: restoreFromDisk marks live-PID sessions "starting" until they
+    // are relaunched. Persist such a session and restore it via a new launcher.
+    store.saveLauncher([
+      { sessionId: "restored-1", state: "connected", cwd: "/tmp", createdAt: Date.now(), pid: process.pid, backendType: "claude" },
+    ]);
+    const restored = new CliLauncher();
+    restored.setStore(store);
+    restored.restoreFromDisk();
+
+    const starting = restored.getStartingSessions();
     expect(starting).toHaveLength(1);
     expect(starting[0].state).toBe("starting");
+    expect(starting[0].sessionId).toBe("restored-1");
   });
 
-  it("excludes sessions that have been connected", () => {
+  it("excludes freshly launched sessions (stdio connects immediately)", () => {
     launcher.launch({ cwd: "/tmp" });
-    launcher.markConnected("test-session-id");
-
+    // No WebSocket handshake to await — the session is already "connected".
     const starting = launcher.getStartingSessions();
     expect(starting).toHaveLength(0);
   });

package/server/cli-launcher.ts

@@ -5,21 +5,18 @@ import {
   copyFileSync,
   cpSync,
   realpathSync,
-  writeFileSync,
-  unlinkSync,
 } from "node:fs";
 import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import type { Subprocess } from "bun";
 import type { SessionStore } from "./session-store.js";
 import type { BackendType } from "./session-types.js";
 import type { RecorderManager } from "./recorder.js";
 import { CodexAdapter } from "./codex-adapter.js";
+import { ClaudeAdapter } from "./claude-adapter.js";
 import { resolveBinary, getEnrichedPath } from "./path-resolver.js";
 import { containerManager } from "./container-manager.js";
 import { companionBus } from "./event-bus.js";
-import { getSettings } from "./settings-manager.js";
 import {
   getLegacyCodexHome,
   resolveCompanionCodexSessionHome,
@@ -192,12 +189,8 @@ export class CliLauncher {
   private claimedCodexWsPorts = new Set<number>();
   /** Runtime-only env vars per session (kept out of persisted launcher state). */
   private sessionEnvs = new Map<string, Record<string, string>>();
-  private port: number;
   private store: SessionStore | null = null;
   private recorder: RecorderManager | null = null;
-  constructor(port: number) {
-    this.port = port;
-  }
 
   /** Attach a persistent store for surviving server restarts. */
   setStore(store: SessionStore): void {
@@ -490,36 +483,6 @@ export class CliLauncher {
       }
     }
 
-    // Allow overriding the host alias used by containerized Claude sessions.
-    // Useful when host.docker.internal is unavailable in a given Docker setup.
-    const containerSdkHost = (process.env.COMPANION_CONTAINER_SDK_HOST || "host.docker.internal").trim()
-      || "host.docker.internal";
-
-    // When running inside a container, the SDK URL targets the host alias so
-    // the CLI can connect back to the Hono server running on the host.
-    //
-    // For host sessions there are two paths depending on settings:
-    //   * "patched" — the companion has byte-patched the local Claude binary
-    //     so it accepts [::1] in --sdk-url, and a parallel TLS WS listener is
-    //     running on wss://[::1]:<ingress-port>. We emit that URL and set
-    //     NODE_TLS_REJECT_UNAUTHORIZED=0 below so the self-signed cert is
-    //     accepted. Required on Claude Code >= 2.1.121, where the validator
-    //     rejects every non-Anthropic host. See claude-versions.ts.
-    //   * "none" (default) — plain ws://127.0.0.1:<port>/... Works on
-    //     2.1.120 and earlier; sessions on a stock 2.1.121+ binary will fail
-    //     immediately with "host 127.0.0.1 is not an approved Anthropic
-    //     endpoint" (visible only on direct CLI stderr).
-    const settings = getSettings();
-    const patchedBridge = !isContainerized
-      && settings.claudeBridgeMode === "patched"
-      && typeof settings.claudeBridgeIngressUrl === "string"
-      && settings.claudeBridgeIngressUrl.length > 0;
-    const sdkUrl = isContainerized
-      ? `ws://${containerSdkHost}:${this.port}/ws/cli/${sessionId}`
-      : patchedBridge
-        ? `${settings.claudeBridgeIngressUrl}/ws/cli/${sessionId}`
-        : `ws://127.0.0.1:${this.port}/ws/cli/${sessionId}`;
-
     let effectivePermissionMode = options.permissionMode;
     const shouldDowngradeContainerBypass =
       isContainerized
@@ -535,43 +498,22 @@ export class CliLauncher {
       info.permissionMode = "acceptEdits";
     }
 
-    // Optional: just-every/code-style JSON handoff. When enabled (and not
-    // containerized — the temp file path wouldn't be visible inside the
-    // container), write a temp descriptor with a one-shot token and pass its
-    // path via CLAUDE_BRIDGE_CONFIG env var instead of --sdk-url on argv.
-    // This is forward-compatible if Anthropic further restricts --sdk-url
-    // (e.g. drops it entirely or adds origin/handshake checks).
-    const bridgeMode = settings.cliBridgeMode ?? "loopback";
-    const useJsonHandoff = bridgeMode === "jsonHandoff" && !isContainerized;
-    let bridgeConfigPath: string | undefined;
-    if (useJsonHandoff) {
-      bridgeConfigPath = join(tmpdir(), `companion-bridge-${sessionId}.json`);
-      const token = randomUUID();
-      const descriptor = {
-        version: 1,
-        transport: "ws",
-        url: sdkUrl,
-        sessionId,
-        token,
-      };
-      try {
-        writeFileSync(bridgeConfigPath, JSON.stringify(descriptor), { mode: 0o600 });
-        info.bridgeToken = token;
-        info.bridgeConfigPath = bridgeConfigPath;
-      } catch (err) {
-        console.warn(`[cli-launcher] Failed to write bridge descriptor for ${sessionId}: ${err}. Falling back to --sdk-url.`);
-        bridgeConfigPath = undefined;
-      }
-    }
-
+    // Stdio stream-json transport (the supported integration path). The server
+    // owns the process and bridges over its stdin/stdout pipes via ClaudeAdapter
+    // — no `--sdk-url`, so we're immune to the 2.1.121 host allowlist and the
+    // 2.1.170 worker-registration handshake that broke the WebSocket bridge.
+    //
+    //   --permission-prompt-tool stdio  routes permission prompts back as
+    //   `can_use_tool` control_requests over the same pipes (the adapter sends
+    //   the one-time `initialize` handshake that enables this).
     const args: string[] = [
-      ...(bridgeConfigPath ? [] : ["--sdk-url", sdkUrl]),
       "--print",
-      "--output-format", "stream-json",
       "--input-format", "stream-json",
-      // Required on newer Claude Code versions to emit streaming chunk events.
+      "--output-format", "stream-json",
+      // Emit streaming chunk events (partial assistant messages).
       "--include-partial-messages",
       "--verbose",
+      "--permission-prompt-tool", "stdio",
     ];
 
     if (options.model) {
@@ -591,26 +533,20 @@ export class CliLauncher {
     if (options.forkSession) {
       args.push("--fork-session");
     }
-
-    // Always pass -p "" for headless mode. When relaunching, also pass --resume
-    // to restore the CLI's conversation context.
+    // On relaunch, --resume restores the CLI's conversation context. The prompt
+    // itself arrives as a stream-json `user` message on stdin (no trailing -p "").
     if (options.resumeSessionId) {
       args.push("--resume", options.resumeSessionId);
     }
 
-    args.push("-p", "");
-
     let spawnCmd: string[];
     let spawnEnv: Record<string, string | undefined>;
     let spawnCwd: string | undefined;
 
     if (isContainerized) {
-      // Run CLI inside the container via docker exec -i.
-      // Keeping stdin open avoids premature EOF-driven exits in SDK mode.
-      // Environment variables are passed via -e flags to docker exec.
+      // Run CLI inside the container via `docker exec -i` so the server can
+      // drive it over stdin/stdout. Env vars are passed via -e flags.
       const dockerArgs = ["docker", "exec", "-i"];
-
-      // Pass env vars via -e flags
       if (options.env) {
         for (const [k, v] of Object.entries(options.env)) {
           dockerArgs.push("-e", `${k}=${v}`);
@@ -629,7 +565,7 @@ export class CliLauncher {
       spawnEnv = { ...process.env, PATH: getEnrichedPath() };
       spawnCwd = undefined; // cwd is set inside the container via -w at creation
     } else {
-      // Host-based spawn (original behavior)
+      // Host-based spawn.
       // On Windows, .cmd/.bat files cannot be spawned directly by Bun.spawn;
       // they must be invoked via cmd.exe /c.
       const isCmdScript = process.platform === "win32" && (binary.endsWith(".cmd") || binary.endsWith(".bat"));
@@ -639,11 +575,6 @@ export class CliLauncher {
         CLAUDECODE: undefined,
         ...options.env,
         PATH: getEnrichedPath(),
-        ...(bridgeConfigPath ? { CLAUDE_BRIDGE_CONFIG: bridgeConfigPath } : {}),
-        // Patched-bridge mode terminates --sdk-url at our self-signed wss://[::1]
-        // listener. Tell Bun/Node to trust the self-signed cert without involving
-        // the user's CA store.
-        ...(patchedBridge ? { NODE_TLS_REJECT_UNAUTHORIZED: "0" } : {}),
       };
       spawnCwd = info.cwd;
     }
@@ -656,6 +587,7 @@ export class CliLauncher {
     const proc = Bun.spawn(spawnCmd, {
       cwd: spawnCwd,
       env: spawnEnv,
+      stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
     });
@@ -663,10 +595,27 @@ export class CliLauncher {
     info.pid = proc.pid;
     this.processes.set(sessionId, proc);
 
-    // Stream stdout/stderr for debugging
-    this.pipeOutput(sessionId, proc);
+    // stdout carries the NDJSON protocol stream — it is owned by the adapter
+    // (below). Pipe only stderr for diagnostics so we don't steal stdout bytes.
+    const stderr = proc.stderr;
+    if (stderr && typeof stderr !== "number") {
+      this.pipeStream(sessionId, stderr, "stderr");
+    }
 
-    // Monitor process exit
+    // Create the ClaudeAdapter and bind it to the process's stdio. The adapter
+    // owns NDJSON translation; the bridge attaches via backend:claude-adapter-created
+    // (mirrors the Codex stdio path). State is "connected" immediately — there is
+    // no WebSocket handshake to wait for.
+    const adapter = new ClaudeAdapter(sessionId, {
+      recorder: this.recorder ?? undefined,
+      cwd: info.cwd,
+    });
+    adapter.attachStdio(proc);
+    companionBus.emit("backend:claude-adapter-created", { sessionId, adapter });
+    info.state = "connected";
+
+    // Monitor process exit. Relaunch is driven by the orchestrator's proactive
+    // keepalive on session:exited (it relaunches with --resume).
     const spawnedAt = Date.now();
     proc.exited.then((exitCode) => {
       console.log(`[cli-launcher] Session ${sessionId} exited (code=${exitCode})`);
@@ -684,9 +633,6 @@ export class CliLauncher {
         }
       }
       this.processes.delete(sessionId);
-      if (bridgeConfigPath) {
-        try { unlinkSync(bridgeConfigPath); } catch { /* already gone */ }
-      }
       this.persistState();
       companionBus.emit("session:exited", { sessionId, exitCode });
     });

package/server/event-bus-types.ts

@@ -3,6 +3,7 @@
 
 import type { BrowserIncomingMessage } from "./session-types.js";
 import type { CodexAdapter } from "./codex-adapter.js";
+import type { ClaudeAdapter } from "./claude-adapter.js";
 import type { SessionPhase } from "./session-state-machine.js";
 
 export interface CompanionEventMap {
@@ -45,6 +46,12 @@ export interface CompanionEventMap {
     adapter: CodexAdapter;
   };
 
+  /** Claude adapter (stdio stream-json transport) created and ready to attach. */
+  "backend:claude-adapter-created": {
+    sessionId: string;
+    adapter: ClaudeAdapter;
+  };
+
   // ── Per-session messages (high volume) ─────────────────────────────
 
   /** An assistant message was processed and broadcast to browsers. */

package/server/index.ts

@@ -60,7 +60,7 @@ const sessionStore = new SessionStore(
   process.env.COMPANION_SESSION_DIR || process.env.COMPANION_SESSIONS_DIR,
 );
 const wsBridge = new WsBridge();
-const launcher = new CliLauncher(port);
+const launcher = new CliLauncher();
 const worktreeTracker = new WorktreeTracker();
 const CONTAINER_STATE_PATH = join(COMPANION_HOME, "containers.json");
 const terminalManager = new TerminalManager();

package/server/session-orchestrator.ts

@@ -167,6 +167,13 @@ export class SessionOrchestrator {
       this.wsBridge.attachBackendAdapter(sessionId, adapter, "codex");
     });
 
+    // When a Claude adapter (stdio stream-json transport) is created, attach it.
+    // Unlike the legacy --sdk-url path (where handleCLIOpen creates+attaches the
+    // adapter on WS connect), the launcher now owns the process and emits this.
+    companionBus.on("backend:claude-adapter-created", ({ sessionId, adapter }) => {
+      this.wsBridge.attachBackendAdapter(sessionId, adapter, "claude");
+    });
+
     // When a CLI/Codex process exits, notify agent executor and external listeners
     // separately so a throw in one doesn't skip the other (bus isolates each handler).
     companionBus.on("session:exited", ({ sessionId, exitCode }) => {

package/server/ws-bridge.ts

@@ -392,13 +392,21 @@ export class WsBridge {
     const session = this.getOrCreateSession(sessionId, backendType);
     session.backendAdapter = adapter;
 
+    // The legacy `--sdk-url` Claude transport has the CLI dial back in over a
+    // WebSocket, so its lifecycle (state machine advance, disconnect debounce)
+    // is driven by handleCLIOpen/handleCLIClose. Every other adapter — Codex,
+    // and the stdio stream-json Claude transport — has the server own the
+    // process, so attachment IS the transport-open event and disconnect is a
+    // process-exit, handled here like Codex.
+    const isLegacyWsClaude = adapter instanceof ClaudeAdapter && !adapter.usesProcessTransport();
+
     // Advance the state machine so that system_init (starting → ready) is reachable.
-    // For Claude, handleCLIOpen does starting → initializing via cli_ws_open.
-    // For Codex (and any non-Claude adapter), the adapter attachment IS the transport
-    // open event — no separate WS open fires — so do the equivalent transition here.
+    // For legacy WS Claude, handleCLIOpen does starting → initializing via cli_ws_open.
+    // For server-owned adapters, the adapter attachment IS the transport open event —
+    // no separate WS open fires — so do the equivalent transition here.
     // Also handles relaunched sessions stuck in "terminated": step through
     // terminated → starting → initializing so system_init can land on "ready".
-    if (!(adapter instanceof ClaudeAdapter)) {
+    if (!isLegacyWsClaude) {
       // Cancel any pending disconnect debounce — new adapter is reconnecting
       this.cancelDisconnectTimer(sessionId);
       const phase = session.stateMachine.phase;
@@ -624,14 +632,15 @@ export class WsBridge {
         return;
       }
 
-      // For ClaudeAdapter, disconnect is handled by handleCLIClose debounce logic
-      if (adapter instanceof ClaudeAdapter) {
-        // Do nothing here — handleCLIClose manages the debounce timer
+      // For the legacy WS Claude transport, disconnect is handled by the
+      // handleCLIClose debounce logic — do nothing here.
+      if (isLegacyWsClaude) {
         return;
       }
 
-      // For Codex adapters: transition to "reconnecting" with a short debounce
-      // (5s vs 15s for Claude Code, since Codex doesn't cycle its WebSocket).
+      // For server-owned adapters (Codex + stdio Claude): transition to
+      // "reconnecting" with a short debounce (5s vs 15s for the legacy WS
+      // Claude transport, since there's no WebSocket cycling).
       session.backendAdapter = null;
       session.stateMachine.transition("reconnecting", "codex_adapter_disconnected");
       this.persistSession(session);
@@ -665,10 +674,10 @@ export class WsBridge {
       this.broadcastToBrowsers(session, { type: "error", message: error });
     });
 
-    // Flush pending messages for non-Claude backends (Codex uses stdio, not
-    // a CLI WebSocket, so handleCLIOpen never runs to flush the queue).
-    // For Claude backends, handleCLIOpen handles this after attachWebSocket.
-    if (!(adapter instanceof ClaudeAdapter) && session.pendingMessages.length > 0) {
+    // Flush pending messages for server-owned backends (Codex + stdio Claude),
+    // where attachment is the transport-open event. The legacy WS Claude
+    // transport flushes in handleCLIOpen after attachWebSocket instead.
+    if (!isLegacyWsClaude && session.pendingMessages.length > 0) {
       this.flushQueuedBrowserMessages(session, adapter, "adapter_attach");
       this.persistSession(session);
     }