@dondetir/ccmux 0.1.0

package/src/responses-stream.ts

@@ -0,0 +1,231 @@
+// OpenAI Responses API SSE stream -> Anthropic SSE event protocol.
+// Key differences from Chat Completions (stream.ts):
+//   - Items opened via response.output_item.added; routed by item.id (NOT call_id)
+//   - Text deltas: response.output_text.delta; tool arg deltas: response.function_call_arguments.delta
+//   - Items close via response.output_item.done
+//   - Usage arrives on response.completed (not a final empty-choices chunk)
+
+import { sse } from "./stream.js";
+import { responsesStatusToStopReason } from "./translate-responses.js";
+
+export async function* translateResponsesStream(
+  upstream: ReadableStream<Uint8Array>,
+  onUsage: (usage: { input_tokens: number; output_tokens: number }) => void = () => {},
+  factor = 1,
+  onAbort: () => void = () => {},
+): AsyncGenerator<string> {
+  const msgId = "msg_" + Date.now();
+  yield sse("message_start", {
+    type: "message_start",
+    message: {
+      id: msgId,
+      type: "message",
+      role: "assistant",
+      model: "",
+      content: [],
+      stop_reason: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  });
+  yield sse("ping", { type: "ping" });
+
+  const reader = upstream.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+
+  let nextIndex = 0;
+  const itemIdToIndex = new Map<string, number>(); // item.id -> Anthropic block index
+  let openBlock: number | null = null;
+  let stopReason = "end_turn";
+  let hadToolUse = false; // true if any function_call item was opened
+  // Tracks which item_ids have emitted at least one delta (for .done no-delta fallback)
+  const emittedDelta = new Set<string>();
+  let outTokens = 0;
+  let inTokens = 0;
+
+  const closeOpen = function* () {
+    if (openBlock !== null) {
+      yield sse("content_block_stop", { type: "content_block_stop", index: openBlock });
+      openBlock = null;
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const frames = buf.split("\n\n");
+      buf = frames.pop() ?? "";
+
+      for (const frame of frames) {
+        if (!frame.trim()) continue;
+
+        let eventType = "";
+        let dataStr = "";
+        for (const line of frame.split("\n")) {
+          if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+          else if (line.startsWith("data: ")) dataStr = line.slice(6).trim();
+        }
+
+        if (!eventType || !dataStr || dataStr === "[DONE]") continue;
+
+        let ev: any;
+        try {
+          ev = JSON.parse(dataStr);
+        } catch {
+          continue; // malformed frame: skip, keep streaming
+        }
+
+        switch (eventType) {
+          case "response.output_item.added": {
+            const item = ev.item;
+            if (!item) break;
+
+            if (item.type === "reasoning") {
+              // No Anthropic equivalent; skip. output_item.done will no-op via idx === undefined.
+              break;
+            }
+
+            yield* closeOpen();
+            const idx = nextIndex++;
+            itemIdToIndex.set(item.id, idx);
+            openBlock = idx;
+
+            if (item.type === "function_call") {
+              hadToolUse = true;
+              yield sse("content_block_start", {
+                type: "content_block_start",
+                index: idx,
+                content_block: {
+                  type: "tool_use",
+                  id: item.call_id, // Anthropic tool_use id matches the call_id we sent in
+                  name: item.name ?? "",
+                  input: {},
+                },
+              });
+            } else {
+              yield sse("content_block_start", {
+                type: "content_block_start",
+                index: idx,
+                content_block: { type: "text", text: "" },
+              });
+            }
+            break;
+          }
+
+          case "response.output_text.delta": {
+            const idx = itemIdToIndex.get(ev.item_id);
+            if (idx === undefined) break;
+            if (openBlock !== idx) {
+              yield* closeOpen();
+              openBlock = idx;
+            }
+            if (ev.delta) {
+              emittedDelta.add(ev.item_id);
+              yield sse("content_block_delta", {
+                type: "content_block_delta",
+                index: idx,
+                delta: { type: "text_delta", text: ev.delta },
+              });
+            }
+            break;
+          }
+
+          case "response.output_text.done": {
+            // If no deltas arrived, emit full text now so short payloads are not lost.
+            if (!emittedDelta.has(ev.item_id) && ev.text) {
+              const idx = itemIdToIndex.get(ev.item_id);
+              if (idx !== undefined) {
+                yield sse("content_block_delta", {
+                  type: "content_block_delta",
+                  index: idx,
+                  delta: { type: "text_delta", text: ev.text },
+                });
+              }
+            }
+            break;
+          }
+
+          case "response.function_call_arguments.delta": {
+            const idx = itemIdToIndex.get(ev.item_id);
+            if (idx === undefined) break;
+            if (openBlock !== idx) {
+              yield* closeOpen();
+              openBlock = idx;
+            }
+            if (ev.delta) {
+              emittedDelta.add(ev.item_id);
+              yield sse("content_block_delta", {
+                type: "content_block_delta",
+                index: idx,
+                delta: { type: "input_json_delta", partial_json: ev.delta },
+              });
+            }
+            break;
+          }
+
+          case "response.function_call_arguments.done": {
+            // If no deltas arrived, emit full arguments now so short tool calls are not empty.
+            if (!emittedDelta.has(ev.item_id) && ev.arguments) {
+              const idx = itemIdToIndex.get(ev.item_id);
+              if (idx !== undefined) {
+                yield sse("content_block_delta", {
+                  type: "content_block_delta",
+                  index: idx,
+                  delta: { type: "input_json_delta", partial_json: ev.arguments },
+                });
+              }
+            }
+            break;
+          }
+
+          case "response.output_item.done": {
+            const item = ev.item;
+            const idx = item ? itemIdToIndex.get(item.id) : undefined;
+            if (idx !== undefined) {
+              yield sse("content_block_stop", { type: "content_block_stop", index: idx });
+              if (openBlock === idx) openBlock = null;
+            }
+            break;
+          }
+
+          case "response.reasoning_summary_text.delta":
+            break; // no Anthropic equivalent; drop
+
+          case "response.completed": {
+            const response = ev.response;
+            if (response?.usage) {
+              inTokens = response.usage.input_tokens ?? 0;
+              outTokens = response.usage.output_tokens ?? 0;
+            }
+            stopReason = responsesStatusToStopReason(response?.status, response?.incomplete_details);
+            // Tool calls need "tool_use" stop_reason so the agent loop continues.
+            if (response?.status === "completed" && !response?.incomplete_details && hadToolUse) {
+              stopReason = "tool_use";
+            }
+            break;
+          }
+
+          case "error":
+            onAbort();
+            break;
+
+          default:
+            break;
+        }
+      }
+    }
+  } catch {
+    onAbort();
+  }
+
+  yield* closeOpen();
+  onUsage({ input_tokens: inTokens, output_tokens: outTokens }); // raw, for cost tracking
+  yield sse("message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: stopReason, stop_sequence: null },
+    usage: { input_tokens: Math.round(inTokens * factor), output_tokens: outTokens },
+  });
+  yield sse("message_stop", { type: "message_stop" });
+}

package/src/sessions.ts

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR } from "./env.js";
+
+// Each `ccmux claude` launcher writes an empty file named by its PID here
+// while its Claude Code session is alive, and removes it on exit. Launcher
+// lifetime equals session lifetime, so PID liveness is session liveness.
+export const SESSIONS_DIR = path.join(CONFIG_DIR, "sessions");
+
+// Count live sessions, pruning stale PID files via kill(pid, 0).
+export function liveSessions(dir = SESSIONS_DIR): number {
+  let files: string[];
+  try {
+    files = fs.readdirSync(dir);
+  } catch {
+    return 0; // dir not created yet = no sessions
+  }
+  let live = 0;
+  for (const f of files) {
+    const pid = Number(f);
+    let alive = false;
+    if (pid > 0) {
+      try {
+        process.kill(pid, 0);
+        alive = true;
+      } catch {
+        /* dead */
+      }
+    }
+    if (alive) live++;
+    else {
+      try {
+        fs.unlinkSync(path.join(dir, f));
+      } catch {
+        /* race with another reaper — fine */
+      }
+    }
+  }
+  return live;
+}
+
+// Managed mode (`ccmux claude`): self-exit after the grace window with no live
+// sessions. A session restarting within the window reuses the warm proxy.
+// `ccmux serve` / hook-started proxies don't set CCMUX_MANAGED and stay up.
+export function startIdleReaper(
+  exit: () => void = () => process.exit(0),
+  count: () => number = liveSessions, // injectable for tests
+): void {
+  if (process.env.CCMUX_MANAGED !== "1") return;
+  const grace = Number(process.env.CCMUX_IDLE_GRACE_MS ?? 120_000);
+  const boot = Date.now();
+  let emptySince = 0;
+  const t = setInterval(() => {
+    if (count() > 0) {
+      emptySince = 0;
+      return;
+    }
+    if (Date.now() - boot < grace) return; // startup grace window
+    if (!emptySince) emptySince = Date.now();
+    if (Date.now() - emptySince >= grace) {
+      console.log("ccmux: no active sessions; stopping idle proxy");
+      exit();
+    }
+  }, Math.min(30_000, grace)); // cap tick at 30s so small grace values (tests) tick faster
+  t.unref();
+}

package/src/stream.ts

@@ -0,0 +1,172 @@
+import { mapStopReason, THINKING_SIG } from "./models.js";
+
+export function sse(event: string, data: unknown): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+// OpenAI SSE stream -> Anthropic SSE event protocol.
+// Invariants: monotonic block indices, tool index map, RAW partial_json
+// fragments (never parse/re-stringify), close-before-open, exactly one
+// message_start/message_stop, upstream death -> close cleanly, never hang.
+export async function* translateStream(
+  upstream: ReadableStream<Uint8Array>,
+  onUsage: (usage: { input_tokens: number; output_tokens: number }) => void = () => {},
+  factor = 1, // context-scale factor for client-facing input counts
+  onAbort: () => void = () => {}, // called when upstream dies mid-stream
+): AsyncGenerator<string> {
+  const msgId = "msg_" + Date.now();
+  yield sse("message_start", {
+    type: "message_start",
+    message: {
+      id: msgId,
+      type: "message",
+      role: "assistant",
+      model: "",
+      content: [],
+      stop_reason: null,
+      usage: { input_tokens: 0, output_tokens: 0 },
+    },
+  });
+  // Anthropic sends a ping right after message_start; some clients expect early bytes.
+  yield sse("ping", { type: "ping" });
+
+  const reader = upstream.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+
+  let nextIndex = 0;
+  let textIndex: number | null = null; // index of the open text block, if any
+  let thinkingIndex: number | null = null; // index of the thinking block (Ollama reasoning), if any
+  const toolIndexMap = new Map<number, number>(); // openai tool index -> anthropic block index
+  let openBlock: number | null = null; // currently open anthropic block index
+  let stopReason = "end_turn";
+  let outTokens = 0;
+  let inTokens = 0;
+
+  const closeOpen = function* () {
+    if (openBlock !== null) {
+      // A thinking block must carry a signature; emit it as the block's last event.
+      if (openBlock === thinkingIndex)
+        yield sse("content_block_delta", {
+          type: "content_block_delta",
+          index: thinkingIndex,
+          delta: { type: "signature_delta", signature: THINKING_SIG },
+        });
+      yield sse("content_block_stop", { type: "content_block_stop", index: openBlock });
+      openBlock = null;
+    }
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const frames = buf.split("\n\n");
+      buf = frames.pop() ?? "";
+
+      for (const frame of frames) {
+        const line = frame.replace(/^data:\s*/, "").trim();
+        if (!line || line === "[DONE]") continue;
+        let chunk: any;
+        try {
+          chunk = JSON.parse(line);
+        } catch {
+          continue; // malformed frame: skip, keep streaming
+        }
+        // Usage arrives on a final chunk whose choices array is EMPTY; capture
+        // it before the choice guard or output_tokens stays 0.
+        if (chunk.usage?.completion_tokens) outTokens = chunk.usage.completion_tokens;
+        if (chunk.usage?.prompt_tokens) inTokens = chunk.usage.prompt_tokens;
+        const choice = chunk.choices?.[0];
+        if (!choice) continue;
+        const delta = choice.delta ?? {};
+
+        // ---- thinking (Ollama reasoning) ----
+        // Surface delta.reasoning as an Anthropic thinking block; never reopen a stopped index.
+        if (delta.reasoning) {
+          if (thinkingIndex === null || openBlock !== thinkingIndex) {
+            yield* closeOpen();
+            thinkingIndex = nextIndex++;
+            openBlock = thinkingIndex;
+            yield sse("content_block_start", {
+              type: "content_block_start",
+              index: thinkingIndex,
+              content_block: { type: "thinking", thinking: "" },
+            });
+          }
+          yield sse("content_block_delta", {
+            type: "content_block_delta",
+            index: thinkingIndex,
+            delta: { type: "thinking_delta", thinking: delta.reasoning },
+          });
+        }
+
+        // ---- text ----
+        if (delta.content) {
+          if (textIndex === null) {
+            yield* closeOpen();
+            textIndex = nextIndex++;
+            openBlock = textIndex;
+            yield sse("content_block_start", {
+              type: "content_block_start",
+              index: textIndex,
+              content_block: { type: "text", text: "" },
+            });
+          } else if (openBlock !== textIndex) {
+            yield* closeOpen();
+            openBlock = textIndex;
+          }
+          yield sse("content_block_delta", {
+            type: "content_block_delta",
+            index: textIndex,
+            delta: { type: "text_delta", text: delta.content },
+          });
+        }
+
+        // ---- tool calls ----
+        for (const tc of delta.tool_calls ?? []) {
+          const oaIdx = tc.index ?? 0;
+          let aIdx = toolIndexMap.get(oaIdx);
+          if (aIdx === undefined) {
+            yield* closeOpen();
+            textIndex = null; // a new tool block ends the text run
+            aIdx = nextIndex++;
+            toolIndexMap.set(oaIdx, aIdx);
+            openBlock = aIdx;
+            yield sse("content_block_start", {
+              type: "content_block_start",
+              index: aIdx,
+              content_block: { type: "tool_use", id: tc.id, name: tc.function?.name ?? "", input: {} },
+            });
+          } else if (openBlock !== aIdx) {
+            yield* closeOpen();
+            openBlock = aIdx;
+          }
+          const argFrag = tc.function?.arguments;
+          if (argFrag) {
+            yield sse("content_block_delta", {
+              type: "content_block_delta",
+              index: aIdx,
+              delta: { type: "input_json_delta", partial_json: argFrag },
+            });
+          }
+        }
+
+        if (choice.finish_reason) stopReason = mapStopReason(choice.finish_reason);
+      }
+    }
+  } catch {
+    onAbort();
+  }
+
+  yield* closeOpen();
+  onUsage({ input_tokens: inTokens, output_tokens: outTokens }); // raw, for cost tracking
+  yield sse("message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: stopReason, stop_sequence: null },
+    // input_tokens scaled so Claude Code's context tracking matches the serving model's prompt limit.
+    usage: { input_tokens: Math.round(inTokens * factor), output_tokens: outTokens },
+  });
+  yield sse("message_stop", { type: "message_stop" });
+}

package/src/token.ts

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CONFIG_DIR } from "./env.js";
+import { TOKEN_EXCHANGE_URL, COPILOT_HEADERS } from "./upstream.js";
+
+// Copilot plugin OAuth app id used for device flow. Unofficial; community-standard.
+const DEVICE_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+
+let copilotToken: string | null = null;
+let expEpoch = 0;
+let ghToken: string | null = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN ?? null;
+
+// Exchange a GitHub token for a short-lived Copilot bearer.
+// Returns null on 401/403/404 so the caller can try the next candidate.
+async function exchange(gh: string): Promise<{ token: string; expires_at: number } | null> {
+  const res = await fetch(TOKEN_EXCHANGE_URL, {
+    headers: { Authorization: `token ${gh}`, "User-Agent": COPILOT_HEADERS["User-Agent"] },
+  });
+  if (res.status === 401 || res.status === 403 || res.status === 404) return null;
+  if (!res.ok) throw new Error(`token exchange ${res.status}: ${await res.text()}`);
+  return (await res.json()) as { token: string; expires_at: number };
+}
+
+// Returns GitHub tokens previously stored by VS Code's Copilot sign-in.
+function appsJsonTokens(): string[] {
+  const tokens: string[] = [];
+  for (const file of ["apps.json", "hosts.json"]) {
+    try {
+      const p = path.join(os.homedir(), ".config", "github-copilot", file);
+      const data = JSON.parse(fs.readFileSync(p, "utf8")) as Record<string, any>;
+      for (const v of Object.values(data)) if (v?.oauth_token) tokens.push(v.oauth_token);
+    } catch {
+      /* file missing — fine */
+    }
+  }
+  return tokens;
+}
+
+async function deviceFlow(): Promise<string> {
+  const dc = (await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json" },
+    body: JSON.stringify({ client_id: DEVICE_CLIENT_ID, scope: "read:user" }),
+  }).then((r) => r.json())) as any;
+  if (!dc.device_code) throw new Error(`device flow start failed: ${JSON.stringify(dc)}`);
+
+  console.log(`\n  Copilot login required: open ${dc.verification_uri} and enter code ${dc.user_code}\n`);
+  let interval = (dc.interval ?? 5) * 1000;
+  while (true) {
+    await new Promise((r) => setTimeout(r, interval));
+    const res = (await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({
+        client_id: DEVICE_CLIENT_ID,
+        device_code: dc.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    }).then((r) => r.json())) as any;
+    if (res.access_token) return res.access_token;
+    if (res.error === "slow_down") interval += 5000;
+    else if (res.error && res.error !== "authorization_pending")
+      throw new Error(`device flow: ${res.error}`);
+  }
+}
+
+function persistToken(gh: string): void {
+  try {
+    // 0o700 on the dir prevents a first-create race from leaving it world-readable.
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    try { fs.chmodSync(CONFIG_DIR, 0o700); } catch { /* fs ignores mode */ }
+    const p = path.join(CONFIG_DIR, "env");
+    fs.appendFileSync(p, `\nGH_TOKEN=${gh}\n`, { mode: 0o600 });
+    // appendFileSync mode only applies on creation; chmod enforces it on existing files.
+    try { fs.chmodSync(p, 0o600); } catch { /* non-posix fs */ }
+    console.log(`ccmux: saved GH_TOKEN to ${p} (one-time login)`);
+  } catch {
+    console.warn("could not persist GH_TOKEN; device flow will rerun next start");
+  }
+}
+
+// Fallback chain: env token -> apps.json -> device flow.
+// Caches the Copilot bearer and refreshes ~2 minutes before expiry.
+export async function getCopilotToken(): Promise<string> {
+  if (copilotToken && Date.now() / 1000 < expEpoch - 120) return copilotToken;
+
+  const candidates = [ghToken, ...appsJsonTokens()].filter(Boolean) as string[];
+  for (const gh of candidates) {
+    const data = await exchange(gh);
+    if (data) {
+      ghToken = gh;
+      copilotToken = data.token;
+      expEpoch = data.expires_at;
+      return copilotToken;
+    }
+  }
+
+  if (!process.stdout.isTTY) {
+    throw new Error(
+      "no usable GitHub token (env GH_TOKEN rejected or missing, no apps.json) " +
+        "and cannot run device flow without a terminal — run `ccmux login` in a terminal once",
+    );
+  }
+  const gh = await deviceFlow();
+  const data = await exchange(gh);
+  if (!data) throw new Error("device-flow token failed the Copilot exchange; is Copilot enabled on this account?");
+  ghToken = gh;
+  copilotToken = data.token;
+  expEpoch = data.expires_at;
+  persistToken(gh);
+  return copilotToken;
+}
+
+// Returns the GitHub OAuth token after running the exchange chain (for api.github.com calls).
+export async function getGitHubToken(): Promise<string | null> {
+  await getCopilotToken().catch(() => {});
+  return ghToken;
+}
+
+// Startup hint only; never throws. Device flow may still succeed on first request.
+export function tokenStartupCheck(): void {
+  if (!ghToken && appsJsonTokens().length === 0) {
+    console.warn(
+      process.stdout.isTTY
+        ? "no GitHub token found (env/apps.json) — device flow will start on first request"
+        : "no GitHub token found (env/apps.json) — run `ccmux login` in a terminal to authenticate",
+    );
+  }
+}