@oxbit/cli 0.11.3 → 0.11.5

package/agent/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
 import { parseArgs } from "node:util";
 import { createInterface } from "node:readline";
 import { mkdir, readFile as readFile$1, writeFile as writeFile$1, chmod, rename, stat, rm, readdir, realpath, unlink, open, access, cp } from "node:fs/promises";
 import { join, dirname, isAbsolute, sep, basename, resolve } from "node:path";
 import { randomBytes, createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { spawn } from "node:child_process";
 import { createServer } from "node:http";
 async function* lines(chunks) {
   let buffer = "";
@@ -1124,6 +1124,73 @@ Additional focus: ${focus}` : "");
     }
   }
 }
+const OXBIT_CLI_PROVIDER = "oxbit-cli";
+const ACP_PROVIDERS = [
+  {
+    id: OXBIT_CLI_PROVIDER,
+    name: "Oxbit Agent CLI",
+    command: "oxbit-agent",
+    args: ["acp"],
+    setup: "Runs the oxbit-agent CLI that ships with Oxbit. It reads providers, keys, MCP servers, skills and hooks from ~/.oxbit/agent. Elsewhere, install @oxbit/agent from npm.",
+    url: "https://github.com/yannelli/oxbit/tree/main/apps/agent",
+    registryId: "oxbit-agent"
+  },
+  {
+    id: "codex",
+    name: "Codex ACP",
+    command: "npx",
+    args: ["-y", "@agentclientprotocol/codex-acp@2.2.2"],
+    setup: "Uses the Codex ACP adapter. Sign in through an advertised authentication method, or use your existing Codex credentials.",
+    url: "https://github.com/agentclientprotocol/codex-acp",
+    registryId: "codex-acp"
+  },
+  {
+    id: "claude",
+    name: "Claude Agent",
+    command: "npx",
+    args: ["-y", "@agentclientprotocol/claude-agent-acp@0.89.1"],
+    setup: "Uses the Claude Agent ACP adapter. Sign in through an advertised authentication method, or use your existing Claude Code credentials.",
+    url: "https://github.com/agentclientprotocol/claude-agent-acp",
+    registryId: "claude-acp"
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    command: "npx",
+    args: ["-y", "@google/gemini-cli@0.63.0", "--acp"],
+    setup: "Runs Gemini CLI in ACP mode. Sign in through an advertised authentication method, or set GEMINI_API_KEY in the runtime environment.",
+    url: "https://github.com/google-gemini/gemini-cli",
+    registryId: "gemini"
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    command: "npx",
+    args: ["-y", "@github/copilot@1.0.95", "--acp"],
+    setup: "Runs GitHub Copilot CLI in ACP mode. Sign in through an advertised authentication method, or run copilot and use /login first.",
+    url: "https://github.com/github/copilot-cli",
+    registryId: "github-copilot-cli"
+  },
+  {
+    id: "cursor",
+    name: "Cursor ACP",
+    command: "agent",
+    args: ["acp"],
+    setup: "Install Cursor CLI and run agent login first. If your executable is cursor-agent, change the command below.",
+    url: "https://cursor.com/docs/cli/acp",
+    registryId: "cursor"
+  },
+  {
+    id: "amp",
+    name: "Amp Agent ACP",
+    command: "npx",
+    args: ["-y", "amp-acp@0.10.0"],
+    setup: "Uses the community Amp ACP adapter. Install Amp CLI and run amp login first. Set AMP_CLI_PATH in the runtime environment if needed.",
+    url: "https://github.com/tao12345666333/amp-acp",
+    registryId: "amp-acp"
+  }
+];
+const acpPreset = (id2) => ACP_PROVIDERS.find((provider2) => provider2.id === id2);
 const OXBIT_SUBAGENT_TOOL = "task";
 const FORWARDED_HOOKS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure", "PreCompact", "PostCompact"]);
 const childCallId = (spawnId, id2) => `${spawnId}/${id2}`;
@@ -4796,19 +4863,18 @@ class FileCatalogCache {
   }
 }
 function agentVersion() {
-  return "0.11.3";
+  return "0.11.5";
 }
 const clone = (message2) => JSON.parse(JSON.stringify(message2));
-class MemoryConnection {
-  server;
+class AcpClient {
   client;
   listeners = /* @__PURE__ */ new Set();
   permission;
   waiting = /* @__PURE__ */ new Map();
   /** The initialize result. */
   initialized = {};
-  constructor(factory) {
-    this.client = new JsonRpcPeer((message2) => this.server.receive(clone(message2)), {
+  constructor(send) {
+    this.client = new JsonRpcPeer(send, {
       request: (method, params) => this.serve(method, params),
       notification: (method, params) => {
         if (method !== "session/update") return;
@@ -4820,16 +4886,12 @@ class MemoryConnection {
         }
       }
     });
-    this.server = new AcpServer((message2) => this.client.receive(clone(message2)), factory);
   }
-  /** Connects and sends initialize. Without fs or terminal capabilities the server serves them locally. */
-  static async open(factory, capabilities = {}) {
-    const connection = new MemoryConnection(factory);
-    connection.initialized = await connection.request(
+  async initialize(capabilities) {
+    this.initialized = await this.request(
       "initialize",
       { protocolVersion: 1, clientCapabilities: capabilities, clientInfo: { name: "oxbit-agent", version: agentVersion() } }
     );
-    return connection;
   }
   request(method, params = {}) {
     return this.client.request(method, params);
@@ -4856,8 +4918,14 @@ class MemoryConnection {
   setMode(sessionId, modeId) {
     return this.request("session/set_mode", { sessionId, modeId });
   }
-  setModel(sessionId, modelId) {
-    return this.request("session/set_model", { sessionId, modelId });
+  /** session/set_model, else the `model` config option for agents without that method. */
+  async setModel(sessionId, modelId) {
+    try {
+      return await this.request("session/set_model", { sessionId, modelId });
+    } catch (error) {
+      if (error.code !== -32601) throw error;
+      return this.setConfigOption(sessionId, "model", modelId);
+    }
   }
   setConfigOption(sessionId, configId, value2) {
     return this.request("session/set_config_option", { sessionId, configId, value: value2 });
@@ -4873,9 +4941,6 @@ class MemoryConnection {
       if (this.permission === handler2) this.permission = void 0;
     };
   }
-  close() {
-    return this.server.close("The connection was closed");
-  }
   async serve(method, params) {
     if (method !== "session/request_permission") throw Object.assign(new Error(`Method not found: ${method}`), { code: -32601 });
     const handler2 = this.permission;
@@ -4892,6 +4957,115 @@ class MemoryConnection {
     }
   }
 }
+class MemoryConnection extends AcpClient {
+  server;
+  constructor(factory) {
+    super((message2) => this.server.receive(clone(message2)));
+    this.server = new AcpServer((message2) => this.client.receive(clone(message2)), factory);
+  }
+  /** Connects and sends initialize. Without fs or terminal capabilities the server serves them locally. */
+  static async open(factory, capabilities = {}) {
+    const connection = new MemoryConnection(factory);
+    await connection.initialize(capabilities);
+    return connection;
+  }
+  close() {
+    return this.server.close("The connection was closed");
+  }
+}
+class ProcessConnection extends AcpClient {
+  constructor(child, rewrite) {
+    super((message2) => void (child.stdin.writable && child.stdin.write(`${JSON.stringify(message2)}
+`)));
+    this.child = child;
+    this.rewrite = rewrite;
+    child.stdin.on("error", () => {
+    });
+    child.stderr.on("data", (chunk) => void (this.stderr = (this.stderr + chunk).slice(-4e3)));
+    createInterface({ input: child.stdout, crlfDelay: Infinity }).on("line", (line) => {
+      if (!line.trim()) return;
+      let message2;
+      try {
+        message2 = JSON.parse(line);
+      } catch {
+        return;
+      }
+      this.client.receive(message2);
+    });
+    this.exited = new Promise((resolve2) => child.once("close", (code, signal) => {
+      this.client.close(`The agent exited (${signal ?? `code ${code}`})${this.stderr.trim() ? `: ${this.stderr.trim().split("\n").at(-1)}` : ""}`);
+      resolve2();
+    }));
+  }
+  child;
+  rewrite;
+  static CLOSE_GRACE_MS = 2e3;
+  stderr = "";
+  exited;
+  /** Starts `agent` in `cwd` and sends initialize. `rewrite` replaces error replies, such as an auth_required error with sign-in steps. */
+  static async open(agent, cwd, options = {}) {
+    const child = spawn(agent.command, agent.args, { cwd, env: agent.env ?? process.env, stdio: ["pipe", "pipe", "pipe"] });
+    const failed2 = new Promise((_, reject) => child.once("error", (error) => reject(new Error(`Could not start ${agent.command}: ${error.message}`))));
+    const connection = new ProcessConnection(child, options.rewrite);
+    try {
+      await Promise.race([connection.initialize(options.capabilities ?? {}), failed2]);
+    } catch (error) {
+      await connection.close();
+      throw error;
+    }
+    return connection;
+  }
+  async request(method, params = {}) {
+    try {
+      return await super.request(method, params);
+    } catch (error) {
+      throw this.rewrite?.(error) ?? error;
+    }
+  }
+  async close() {
+    if (this.child.pid === void 0 || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    this.child.stdin.end();
+    const timer = setTimeout(() => this.child.kill(), ProcessConnection.CLOSE_GRACE_MS);
+    await this.exited;
+    clearTimeout(timer);
+  }
+}
+const CLAUDE_PLAN = { id: "claude", name: "Claude plan", inUse: "Using Claude plan" };
+const CLAUDE_SIGN_IN = "Sign in with your Claude plan first: oxbit-agent login claude";
+const INSTALL = "Install Claude Code first: https://code.claude.com/docs/en/setup";
+const CLAUDE_MODES = { ask: "default", "accept-edits": "acceptEdits", "full-auto": "bypassPermissions" };
+function claudeAgent(env) {
+  const preset = acpPreset("claude");
+  const { ANTHROPIC_API_KEY: _key, ANTHROPIC_AUTH_TOKEN: _token, ...rest } = env;
+  return { command: preset.command, args: [...preset.args], env: rest };
+}
+const openClaude = (agent, cwd) => ProcessConnection.open(agent, cwd, {
+  rewrite: (error) => error.code === -32e3 && /auth/i.test(error.message) ? Object.assign(new Error(CLAUDE_SIGN_IN), { code: error.code }) : error
+});
+const run$1 = (args, env, stdio) => new Promise((resolve2, reject) => {
+  const child = spawn("claude", args, { env, stdio: stdio === "inherit" ? "inherit" : ["ignore", "pipe", "ignore"] });
+  let stdout = "";
+  child.stdout?.on("data", (chunk) => void (stdout += chunk));
+  child.once("error", (error) => reject(error.code === "ENOENT" ? Object.assign(new Error(INSTALL), { missing: true }) : error));
+  child.once("close", (code) => resolve2({ code, stdout }));
+});
+async function claudeStatus(env) {
+  try {
+    const { stdout } = await run$1(["auth", "status", "--json"], claudeAgent(env).env, "pipe");
+    const status2 = JSON.parse(stdout);
+    return {
+      installed: true,
+      loggedIn: status2?.loggedIn === true,
+      ...status2?.authMethod === "claude.ai" && typeof status2.subscriptionType === "string" ? { plan: status2.subscriptionType } : {}
+    };
+  } catch (error) {
+    return { installed: !error.missing, loggedIn: false };
+  }
+}
+const planText = (status2) => !status2.installed ? "Claude Code not installed" : !status2.loggedIn ? "not signed in" : status2.plan ? `signed in with Claude ${status2.plan[0].toUpperCase()}${status2.plan.slice(1)}` : "signed in";
+async function claudeAuth(command, env) {
+  return (await run$1(["auth", command], claudeAgent(env).env, "inherit")).code ?? 1;
+}
 function globSource(glob2) {
   let source = "";
   for (let index = 0; index < glob2.length; index++) {
@@ -5194,10 +5368,11 @@ function nodeMcp(config, log) {
     clientInfo: { name: "oxbit-agent", version: agentVersion() }
   });
 }
-const PROVIDER_IDS = PROVIDERS.map((spec) => spec.id);
+const PROVIDER_IDS = [...PROVIDERS.map((spec) => spec.id), CLAUDE_PLAN.id];
 const LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 const OLLAMA$1 = "http://127.0.0.1:11434";
 const DETECTED = ["anthropic", "openai", "openrouter"];
+const isClaude = (choice) => choice.id === CLAUDE_PLAN.id;
 function normalizeBase(input2) {
   let url;
   try {
@@ -5237,6 +5412,11 @@ async function methodFor(spec, input2, signedIn, baseUrl) {
   if (ids.includes("api-key") && (ids.length === 1 || await keyFor(spec, input2, baseUrl))) return "api-key";
   return ids.includes("none") ? "none" : ids.find((id2) => id2 !== "chatgpt") ?? ids[0];
 }
+async function activeProvider(input2) {
+  if ((input2.provider || input2.settings.provider) !== CLAUDE_PLAN.id) return selectProvider(input2);
+  const model = input2.model || input2.settings.providers?.[CLAUDE_PLAN.id]?.model;
+  return { id: CLAUDE_PLAN.id, ...model ? { model } : {} };
+}
 async function selectProvider(input2) {
   const { settings, env } = input2;
   const signedIn = await chatgptSignedIn(input2.auth);
@@ -5252,6 +5432,7 @@ async function selectProvider(input2) {
     }
   const name = input2.provider || settings.provider || detected || "ollama";
   const spec = providerSpec(name);
+  if (name === CLAUDE_PLAN.id) throw new Error(`${CLAUDE_PLAN.name} runs Claude Agent and has no model provider settings`);
   if (!spec) throw new Error(`Unknown provider ${name}. Use one of: ${PROVIDER_IDS.join(", ")}`);
   const baseUrl = baseFor(spec, settings, env);
   const method = await methodFor(spec, input2, signedIn, baseUrl);
@@ -6159,13 +6340,19 @@ function methodList() {
       lines2.push(`  ${spec.name.padEnd(18)} ${method.label.padEnd(24)} ${command}`);
       if (method.detail) lines2.push(`  ${"".padEnd(18)} ${method.detail}`);
     }
+  lines2.push(
+    `  ${CLAUDE_PLAN.name.padEnd(18)} ${"Claude Code sign-in".padEnd(24)} oxbit-agent login claude`,
+    `  ${"".padEnd(18)} Runs Claude Agent, which uses Claude Code's own sign-in.`
+  );
   return `${lines2.join("\n")}
 `;
 }
 async function login({ config, auth, io, input: input2 }, rest) {
   if (rest[0] === "chatgpt" && rest.length === 1) return loginChatGPT({ config, auth, io });
+  if (rest[0] === CLAUDE_PLAN.id && rest.length === 1) return loginClaude({ config, io });
   if (rest.length) throw new UsageError(`Unknown login method ${rest.join(" ")}. Run oxbit-agent login to list the methods`);
   if (!input2.provider) return void io.stdout.write(methodList()), 0;
+  if (input2.provider === CLAUDE_PLAN.id) return loginClaude({ config, io });
   const spec = providerSpec(input2.provider);
   if (!spec) throw new UsageError(`Unknown provider ${input2.provider}`);
   const choice = await apiKeyChoice(input2, spec.id);
@@ -6208,9 +6395,20 @@ ${CHATGPT_LABELS.manage}: ${CHATGPT.usageUrl}
 `);
   return 0;
 }
+async function loginClaude({ config, io }) {
+  io.stderr.write("Signing in to Claude Code with `claude auth login`\n");
+  const code = await claudeAuth("login", io.env);
+  if (code !== 0) return code;
+  if (!config.settings.provider) await config.saveSettings({ provider: CLAUDE_PLAN.id });
+  else if (config.settings.provider !== CLAUDE_PLAN.id)
+    io.stdout.write(`settings.json selects ${config.settings.provider}; run with --provider claude to use your Claude plan.
+`);
+  return 0;
+}
 async function logout({ auth, io, input: input2 }, rest) {
   if (rest.length > 1) throw new UsageError(`Unexpected argument ${rest[1]}`);
   const target = rest[0] ?? input2.provider;
+  if (target === CLAUDE_PLAN.id) return claudeAuth("logout", io.env);
   const removed = target === "chatgpt" ? [] : await removeApiKeys(auth, input2, target);
   if (!target || target === "chatgpt") {
     const revoked = await signOutChatGPT(auth, fetchOr(io.fetch));
@@ -6221,7 +6419,9 @@ async function logout({ auth, io, input: input2 }, rest) {
   return 0;
 }
 async function models({ io, input: input2 }) {
-  const choice = await selectProvider(input2);
+  const active = await activeProvider(input2);
+  if (isClaude(active)) return claudeModels(io, active);
+  const choice = active;
   if (!choice.ready) throw missingKey(choice);
   const list2 = await choice.runtime.catalog();
   io.stderr.write(`${choice.runtime.label}
@@ -6234,6 +6434,23 @@ async function models({ io, input: input2 }) {
   }
   return 0;
 }
+async function claudeModels(io, choice) {
+  const connection = await openClaude(io.claudeAgent ?? claudeAgent(io.env), io.cwd);
+  try {
+    const state = await connection.newSession({ cwd: io.cwd });
+    const option = state.configOptions?.find((item) => item.id === "model");
+    const list2 = Array.isArray(option?.options) ? option.options : [];
+    const current = choice.model ?? option?.currentValue;
+    io.stderr.write(`${CLAUDE_PLAN.inUse}
+`);
+    const width = Math.max(0, ...list2.map((model) => model.value.length));
+    for (const model of list2) io.stdout.write(`${model.value === current ? "*" : " "} ${model.value.padEnd(width)}  ${model.name}
+`);
+    return 0;
+  } finally {
+    await connection.close();
+  }
+}
 const OLLAMA = "http://127.0.0.1:11434";
 const input = (deps) => ({ settings: deps.config.settings, env: deps.env, auth: deps.auth, fetch: deps.fetch });
 const has = (spec, method) => spec.methods.some((item) => item.id === method);
@@ -6249,7 +6466,7 @@ function baseOf(spec, deps) {
 async function status(spec, deps, signedIn) {
   const parts = [];
   const current = deps.provider();
-  if (current.id === spec.id) parts.push(current.runtime.method === "chatgpt" ? "in use with your ChatGPT plan" : "in use");
+  if (current.id === spec.id) parts.push(!isClaude(current) && current.runtime.method === "chatgpt" ? "in use with your ChatGPT plan" : "in use");
   if (spec.id === "openai" && signedIn) parts.push("signed in with ChatGPT");
   const base = baseOf(spec, deps);
   let saved = false;
@@ -6273,13 +6490,20 @@ async function apply(deps, id2, message2) {
 }
 async function use(deps, spec) {
   const { config } = deps;
-  await selectProvider({ ...input(deps), provider: spec.id });
+  if (spec.id !== CLAUDE_PLAN.id) await selectProvider({ ...input(deps), provider: spec.id });
   const previous = config.settings.provider ?? deps.provider().id;
   const providers = { ...config.settings.providers };
   if (config.settings.model && !providers[previous]?.model) providers[previous] = { ...providers[previous], model: config.settings.model };
   await config.saveSettings({ provider: spec.id, model: void 0, providers });
   return apply(deps, spec.id, `Using ${spec.name}`);
 }
+async function claudeRow(deps) {
+  const inUse = deps.provider().id === CLAUDE_PLAN.id;
+  const status2 = await claudeStatus(deps.env);
+  const steps = status2.installed && !status2.loggedIn ? "run `oxbit-agent login claude` in a terminal" : void 0;
+  const detail = [inUse && "in use", planText(status2), steps, "Claude Agent with Claude Code's own sign-in"].filter(Boolean).join(", ");
+  return { id: CLAUDE_PLAN.id, section: "Providers", label: CLAUDE_PLAN.name, detail, actions: inUse ? [] : [{ id: "use", label: "Use this provider", reloads: true }] };
+}
 async function signIn(deps, context) {
   const signal = AbortSignal.any([context.signal, AbortSignal.timeout(SIGN_IN_TIMEOUT_MS)]);
   const { account, enabled } = await signInChatGPT({ config: deps.config, auth: deps.auth, fetch: fetchOr(deps.fetch), signal, open: async (url) => {
@@ -6309,6 +6533,7 @@ const providersPanel = {
       });
       return { id: spec.id, section: "Providers", label: spec.name, detail: text, enabled: !disabled.includes(spec.id), actions };
     }));
+    rows.push(await claudeRow(deps));
     return { id: "providers", title: "Providers", rows, footer: "Unchecked providers are skipped when settings name no provider; --provider and Use still pick them." };
   },
   async toggle({ config }, rowId, enabled) {
@@ -6318,6 +6543,7 @@ const providersPanel = {
     return { message: `${spec.name} is ${enabled ? "on" : "off"} for automatic selection` };
   },
   async act(deps, rowId, actionId, inputs, context) {
+    if (rowId === CLAUDE_PLAN.id && actionId === "use") return use(deps, CLAUDE_PLAN);
     const spec = providerSpec(rowId);
     if (!spec) throw unknownRow(rowId);
     const inUse = deps.provider().id === spec.id;
@@ -6751,7 +6977,7 @@ async function runPrint(options) {
   const note = (text) => stderr.write(`${text}
 `);
   try {
-    const state = options.sessionId ? await connection.loadSession(options.sessionId) : await connection.newSession(options.cwd ? { cwd: options.cwd } : {});
+    const state = options.sessionId ? await connection.loadSession(options.sessionId, options.cwd ? { cwd: options.cwd } : {}) : await connection.newSession(options.cwd ? { cwd: options.cwd } : {});
     const { sessionId } = state;
     if (options.mode) await connection.setMode(sessionId, options.mode);
     if (options.model && options.model !== state.models?.currentModelId) await connection.setModel(sessionId, options.model);
@@ -6802,8 +7028,9 @@ const USAGE = `Usage: oxbit-agent [options] [prompt]     Terminal UI
        oxbit-agent models                  List the provider's models
        oxbit-agent login                   List the sign-in methods
        oxbit-agent login chatgpt           Continue with ChatGPT to use your ChatGPT plan
+       oxbit-agent login claude            Sign in to Claude Code to use your Claude plan
        oxbit-agent login --provider <id>   Save an API key read from stdin
-       oxbit-agent logout [provider|chatgpt]  Remove saved keys, or sign out of ChatGPT
+       oxbit-agent logout [provider|chatgpt|claude]  Remove saved keys, or sign out of ChatGPT or Claude Code
 
 Options:
   -p, --print <prompt>   Run one prompt; "-" reads it from stdin
@@ -6869,49 +7096,69 @@ ${USAGE}`);
       case "logout":
         return await logout(commandContext, rest);
     }
-    let provider2 = await selectProvider(input2);
+    let provider2 = await activeProvider(input2);
     const deps = { config, auth, env: io.env, fetch: io.fetch, open: io.open, provider: () => provider2 };
     const settings = createSettingsManager(deps);
-    const setup = (generateTitles, quiet = false) => ({ root: io.cwd, config, generateTitles, log: quiet ? void 0 : log, provider: provider2, settings });
+    const claude = () => io.claudeAgent ?? claudeAgent(io.env);
+    const startClaude = () => {
+      io.stderr.write("Starting Claude Agent with npx; the first run downloads it.\n");
+      return openClaude(claude(), io.cwd);
+    };
+    const open2 = (choice, generateTitles, quiet = false) => isClaude(choice) ? startClaude() : MemoryConnection.open(agentFactory({ root: io.cwd, config, generateTitles, log: quiet ? void 0 : log, provider: choice, settings }));
+    const mode = values.mode ?? config.settings.mode;
+    const session = (connection) => isClaude(provider2) ? claudeResume(connection, values, io.cwd) : resumeId(config, values, io.cwd);
     if (command === "acp") {
+      if (isClaude(provider2)) return await relay(claude(), io);
       const rejected = (error) => log(`Unhandled rejection: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
       process.on("unhandledRejection", rejected);
       try {
-        await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory(setup(true)), log });
+        await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory({ root: io.cwd, config, generateTitles: true, log, provider: provider2, settings }), log });
       } finally {
         process.off("unhandledRejection", rejected);
       }
       return 0;
     }
-    const sessionId = await resumeId(config, values, io.cwd);
-    const mode = values.mode ?? config.settings.mode;
     if (values.print !== void 0) {
       if (positionals.length) throw new UsageError(`Unexpected argument ${positionals[0]}`);
       const prompt = values.print === "-" ? (await readAll(io.stdin)).trim() : values.print;
       if (!prompt) throw new UsageError("The prompt is empty");
-      const connection = await MemoryConnection.open(agentFactory(setup(false)));
+      const connection = await open2(provider2, false);
       const abort = new AbortController();
       const interrupt = () => abort.abort();
       process.once("SIGINT", interrupt);
       try {
-        return await runPrint({ connection, prompt, sessionId, mode, model: values.model, stdout: io.stdout, stderr: io.stderr, signal: abort.signal });
+        const sessionId = await session(connection);
+        return await runPrint({
+          connection,
+          prompt,
+          sessionId,
+          cwd: io.cwd,
+          mode: mode && isClaude(provider2) ? CLAUDE_MODES[mode] : mode,
+          model: isClaude(provider2) ? provider2.model : values.model,
+          stdout: io.stdout,
+          stderr: io.stderr,
+          signal: abort.signal
+        });
       } finally {
         process.off("SIGINT", interrupt);
         await connection.close();
       }
     }
     if (!io.stdout.isTTY) throw new UsageError("stdout is not a terminal. Use -p <prompt> for one reply or `oxbit-agent acp` for ACP");
-    const [tui, memory] = await Promise.all([import("./assets/index-DU-a4mnM.js"), import("./assets/memory-Bdy8hvTl.js")]);
-    const label = () => ({ provider: provider2.runtime.label, usingChatGPTPlan: provider2.runtime.method === "chatgpt" });
+    const [tui, memory] = await Promise.all([import("./assets/index-Crr8fCGQ.js"), import("./assets/memory-C3ixKimB.js")]);
+    const label = () => isClaude(provider2) ? { provider: CLAUDE_PLAN.inUse } : { provider: provider2.runtime.label, usingChatGPTPlan: provider2.runtime.method === "chatgpt" };
+    const claudeOptions = () => isClaude(provider2) ? { modes: CLAUDE_MODES, model: provider2.model } : {};
     const panels = createSettingsManager({ ...deps, rebuild: async (id2) => {
       await config.reload();
-      const next = await selectProvider({ ...input2, settings: config.settings, provider: id2, model: id2 === provider2.id ? provider2.model : void 0 });
-      const connection = await MemoryConnection.open(agentFactory({ ...setup(true, true), provider: next }));
+      const next = await activeProvider({ ...input2, settings: config.settings, provider: id2, model: id2 === provider2.id ? provider2.model : void 0 });
+      const connection = await open2(next, true, true);
       provider2 = next;
-      await adapter.replace(connection, label());
+      await adapter.replace(connection, label(), claudeOptions());
     } });
-    const adapter = memory.memoryTuiConnection(await MemoryConnection.open(agentFactory(setup(true, true))), { ...label(), mode, settings: panels });
+    const first = await open2(provider2, true, true);
+    const adapter = memory.memoryTuiConnection(first, { ...label(), ...claudeOptions(), mode, settings: panels });
     try {
+      const sessionId = await session(first);
       const { sessionId: last } = await tui.run(adapter, {
         cwd: io.cwd,
         sessionId,
@@ -6932,6 +7179,25 @@ ${USAGE}`);
     return error instanceof UsageError ? 2 : 1;
   }
 }
+async function claudeResume(connection, values, cwd) {
+  if (values.continue && values.resume) throw new UsageError("Use --continue or --resume, not both");
+  if (!values.continue) return values.resume;
+  const [latest] = (await connection.listSessions(cwd)).sessions.filter((item) => item.cwd === cwd).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+  if (!latest) throw new Error(`No saved session for ${cwd}`);
+  return latest.sessionId;
+}
+function relay(agent, io) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(agent.command, agent.args, { cwd: io.cwd, env: agent.env, stdio: ["pipe", "pipe", "pipe"] });
+    child.once("error", (error) => reject(new Error(`Could not start ${agent.command}: ${error.message}`)));
+    child.stdin.on("error", () => {
+    });
+    io.stdin.pipe(child.stdin);
+    child.stdout.on("data", (chunk) => io.stdout.write(chunk));
+    child.stderr.on("data", (chunk) => io.stderr.write(chunk));
+    child.once("close", (code) => resolve2(code ?? 1));
+  });
+}
 async function resumeId(config, values, cwd) {
   if (values.continue && values.resume) throw new UsageError("Use --continue or --resume, not both");
   const store = new JsonlSessionStore(config.paths.sessions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxbit/cli",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "description": "The oxbit command: runs the Oxbit runtime and opens the editor in a browser",
   "type": "module",
   "bin": {