@khalilgharbaoui/opencode-claude-code-plugin 0.8.1 → 0.9.0

package/dist/index.js

@@ -1282,6 +1282,9 @@ function getActiveProcess(key) {
   if (ap) touch(key);
   return ap;
 }
+function setActiveProcess(key, ap) {
+  activeProcesses.set(key, ap);
+}
 function deleteActiveProcess(key) {
   const ap = activeProcesses.get(key);
   if (ap) {
@@ -1425,12 +1428,561 @@ function sessionKey(cwd, modelId) {
   return `${cwd}::${modelId}`;
 }
 
-// src/proxy-mcp.ts
-import { createServer } from "http";
+// src/claude-session-wrapper.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { unlink as unlink2 } from "fs/promises";
+
+// src/claude-session-bun.ts
+import * as os3 from "os";
 import * as fs3 from "fs";
 import * as path3 from "path";
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+function resolveClaude(cmd = "claude") {
+  if (path3.isAbsolute(cmd) && fs3.existsSync(cmd)) return cmd;
+  const viaBun = Bun.which(cmd);
+  if (viaBun) return viaBun;
+  const isWin = os3.platform() === "win32";
+  try {
+    const out = execFileSync(isWin ? "where" : "which", [cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs3.existsSync(p));
+    if (first) return first;
+  } catch {
+  }
+  throw new Error(`Could not resolve command on PATH: ${cmd}`);
+}
+function encodeCwd(cwd) {
+  return path3.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+}
+var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveConfigDir(configDir) {
+  const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
+  if (!value) return path3.join(os3.homedir(), ".claude");
+  if (value === "~") return os3.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path3.join(os3.homedir(), value.slice(2));
+  }
+  return path3.resolve(value);
+}
+var ClaudeSession = class {
+  sessionId;
+  cwd;
+  configDir;
+  jsonlPath;
+  raw = "";
+  proc = null;
+  cursor = 0;
+  // index into transcript split('\n')
+  lastDataAt = 0;
+  exited = false;
+  exitCode = null;
+  aborted = false;
+  signal;
+  o;
+  constructor(opts = {}) {
+    this.cwd = path3.resolve(opts.cwd ?? process.cwd());
+    this.configDir = resolveConfigDir(opts.configDir);
+    this.signal = opts.signal;
+    this.sessionId = randomUUID();
+    this.jsonlPath = path3.join(
+      this.configDir,
+      "projects",
+      encodeCwd(this.cwd),
+      `${this.sessionId}.jsonl`
+    );
+    this.o = {
+      cwd: this.cwd,
+      cliPath: opts.cliPath,
+      configDir: this.configDir,
+      model: opts.model,
+      settingSources: opts.settingSources,
+      extraArgs: opts.extraArgs ?? [],
+      cols: opts.cols ?? 200,
+      rows: opts.rows ?? 50,
+      bootMinMs: opts.bootMinMs ?? 3e3,
+      bootQuietMs: opts.bootQuietMs ?? 1500,
+      bootMaxMs: opts.bootMaxMs ?? 25e3,
+      pollMs: opts.pollMs ?? 250,
+      // Agentic turns (tool loops) routinely run for many minutes; a short
+      // cap would surface as a mid-task error result. 30 min mirrors the
+      // proxy-tool ceiling rather than a chat-reply expectation.
+      turnTimeoutMs: opts.turnTimeoutMs ?? 18e5,
+      bracketedPaste: opts.bracketedPaste ?? true,
+      submitMinMs: opts.submitMinMs ?? 200,
+      submitConfirmMs: opts.submitConfirmMs ?? 1500,
+      submitMaxRetries: opts.submitMaxRetries ?? 8,
+      debug: opts.debug ?? false
+    };
+  }
+  async start() {
+    if (this.signal?.aborted) throw new Error("aborted before start");
+    this.signal?.addEventListener(
+      "abort",
+      () => {
+        this.aborted = true;
+        this.dispose();
+      },
+      { once: true }
+    );
+    const claude = resolveClaude(this.o.cliPath ?? "claude");
+    const args = ["--session-id", this.sessionId];
+    if (this.o.model) args.push("--model", this.o.model);
+    if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
+      args.push("--setting-sources", this.o.settingSources);
+    }
+    if (this.o.extraArgs && this.o.extraArgs.length) args.push(...this.o.extraArgs);
+    if (this.o.debug)
+      process.stderr.write(`[session] spawn: ${claude} ${args.join(" ")}
+`);
+    this.lastDataAt = Date.now();
+    this.proc = Bun.spawn([claude, ...args], {
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: this.o.configDir,
+        TERM: "xterm-256color"
+      },
+      terminal: {
+        cols: this.o.cols,
+        rows: this.o.rows,
+        data: (_term, d) => {
+          this.lastDataAt = Date.now();
+          const chunk = Buffer.from(d).toString("utf8");
+          this.raw += chunk;
+          if (this.o.debug) process.stdout.write(chunk);
+        }
+      }
+    });
+    this.proc.exited.then((code) => {
+      this.exitCode = typeof code === "number" ? code : null;
+      this.exited = true;
+      this.proc = null;
+    }).catch(() => {
+      this.exited = true;
+      this.proc = null;
+    });
+    await this.waitForBoot();
+    this.cursor = this.lineCount();
+  }
+  /** Wait until the TUI has been quiet for bootQuietMs (Ink ready), bounded by
+   *  bootMinMs..bootMaxMs. */
+  async waitForBoot() {
+    const start = Date.now();
+    while (Date.now() - start < this.o.bootMaxMs) {
+      await delay(150);
+      if (this.aborted) throw new Error("aborted during boot");
+      if (this.exited) {
+        throw new Error(this.failureMessage("claude exited during boot", true));
+      }
+      const elapsed = Date.now() - start;
+      const sinceData = Date.now() - this.lastDataAt;
+      if (elapsed >= this.o.bootMinMs && sinceData >= this.o.bootQuietMs) return;
+    }
+  }
+  /** Submit the freshly-injected prompt and confirm the turn was actually
+   *  accepted. A large bracketed paste collapses into a "[Pasted text]"
+   *  placeholder; an Enter sent while claude is still ingesting the paste is
+   *  silently dropped, so a single fixed-delay Enter races the paste and can
+   *  leave the prompt sitting unsubmitted (→ hang until turnTimeoutMs). Send
+   *  Enter, then poll for transcript growth past the cursor (the turn's records
+   *  are written on acceptance); resend Enter until accepted or the retry
+   *  budget is spent. Polling growth (not a blind delay) also stops us from
+   *  sending a stray Enter once the turn is in flight. */
+  async submitTurn() {
+    await delay(this.o.submitMinMs);
+    for (let attempt = 0; attempt < this.o.submitMaxRetries; attempt++) {
+      if (this.aborted || this.exited || !this.proc) return;
+      this.proc.terminal.write("\r");
+      const until = Date.now() + this.o.submitConfirmMs;
+      while (Date.now() < until) {
+        await delay(80);
+        if (this.aborted || this.exited) return;
+        if (this.lineCount() > this.cursor) return;
+      }
+    }
+  }
+  readRawLines() {
+    try {
+      return fs3.readFileSync(this.jsonlPath, "utf8").split("\n");
+    } catch {
+      return [];
+    }
+  }
+  /** Count of complete lines (split('\n') minus the trailing/partial element). */
+  lineCount() {
+    const lines = this.readRawLines();
+    return lines.length > 0 ? lines.length - 1 : 0;
+  }
+  rawTail(max = 600) {
+    const clean = this.raw.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\s+/g, " ").trim();
+    return clean.length > max ? clean.slice(-max) : clean;
+  }
+  failureMessage(reason, includeRaw = false) {
+    const parts = [
+      `${reason} (sessionId=${this.sessionId}, jsonlPath=${this.jsonlPath}, exitCode=${this.exitCode ?? "unknown"})`
+    ];
+    if (includeRaw) {
+      const tail = this.rawTail();
+      if (tail) parts.push(`terminalTail=${JSON.stringify(tail)}`);
+    }
+    return parts.join("; ");
+  }
+  /**
+   * Inject a turn into the live session and return the assistant reply once a
+   * terminal stop_reason is observed in the transcript.
+   */
+  async ask(prompt, perTurnTimeoutMs) {
+    if (this.aborted) throw new Error("aborted");
+    if (!this.proc || this.exited)
+      throw new Error("session not started or already exited");
+    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
+    const t0 = Date.now();
+    if (this.o.bracketedPaste) {
+      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
+    } else {
+      this.proc.terminal.write(prompt);
+    }
+    await this.submitTurn();
+    const collected = [];
+    let lastUsage = null;
+    let stopReason = null;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      await delay(this.o.pollMs);
+      if (this.aborted) throw new Error("aborted mid-turn");
+      const lines = this.readRawLines();
+      const lastComplete = lines.length - 1;
+      if (lastComplete <= this.cursor) {
+        if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
+        continue;
+      }
+      for (let i = this.cursor; i < lastComplete; i++) {
+        const s = lines[i];
+        if (!s || !s.trim()) continue;
+        let rec;
+        try {
+          rec = JSON.parse(s);
+        } catch {
+          continue;
+        }
+        if (rec.type === "assistant" && rec.message) {
+          for (const b of rec.message.content ?? []) {
+            if (b?.type === "text" && typeof b.text === "string")
+              collected.push(b.text);
+          }
+          if (rec.message.usage) lastUsage = rec.message.usage;
+          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
+            stopReason = rec.message.stop_reason;
+          }
+        }
+      }
+      this.cursor = lastComplete;
+      if (stopReason) break;
+    }
+    if (!stopReason) {
+      throw new Error(
+        this.failureMessage(
+          `turn timed out after ${timeout}ms (no terminal assistant record; collected ${collected.length} text block(s))`
+        )
+      );
+    }
+    const u = lastUsage ?? {};
+    return {
+      text: collected.join("\n").trim(),
+      stopReason,
+      usage: lastUsage,
+      cacheReadTokens: u.cache_read_input_tokens ?? 0,
+      cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+      ephemeral1hTokens: u.cache_creation?.ephemeral_1h_input_tokens ?? 0,
+      ephemeral5mTokens: u.cache_creation?.ephemeral_5m_input_tokens ?? 0,
+      inputTokens: u.input_tokens ?? 0,
+      outputTokens: u.output_tokens ?? 0,
+      elapsedMs: Date.now() - t0
+    };
+  }
+  /**
+   * Like ask(), but instead of collecting the reply text it re-emits each NEW
+   * raw JSONL transcript line via onLine (verbatim) until a terminal
+   * stop_reason. Returns the terminal stop_reason + the last assistant usage.
+   * Used by the opencode plugin transport shim, which feeds these raw lines
+   * into the existing stream-json line handler unchanged.
+   */
+  async tailTurn(prompt, onLine, perTurnTimeoutMs) {
+    if (this.aborted) throw new Error("aborted");
+    if (!this.proc || this.exited)
+      throw new Error("session not started or already exited");
+    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
+    if (this.o.bracketedPaste) {
+      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
+    } else {
+      this.proc.terminal.write(prompt);
+    }
+    await this.submitTurn();
+    let lastUsage = null;
+    let totalOutput = 0;
+    let stopReason = null;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      await delay(this.o.pollMs);
+      if (this.aborted) throw new Error("aborted mid-turn");
+      const lines = this.readRawLines();
+      const lastComplete = lines.length - 1;
+      if (lastComplete <= this.cursor) {
+        if (this.exited) {
+          throw new Error(this.failureMessage("claude exited mid-turn", true));
+        }
+        continue;
+      }
+      for (let i = this.cursor; i < lastComplete; i++) {
+        const s = lines[i];
+        if (!s || !s.trim()) continue;
+        onLine(s);
+        let rec;
+        try {
+          rec = JSON.parse(s);
+        } catch {
+          continue;
+        }
+        if (rec.type === "assistant" && rec.message) {
+          if (rec.message.usage) {
+            lastUsage = rec.message.usage;
+            totalOutput += rec.message.usage.output_tokens ?? 0;
+          }
+          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
+            stopReason = rec.message.stop_reason;
+          }
+        }
+      }
+      this.cursor = lastComplete;
+      if (stopReason) break;
+    }
+    let usage = lastUsage;
+    if (lastUsage) {
+      usage = { ...lastUsage, output_tokens: totalOutput };
+      if (Array.isArray(lastUsage.iterations) && lastUsage.iterations.length > 0) {
+        const iters = lastUsage.iterations.map((it) => ({ ...it }));
+        iters[iters.length - 1] = {
+          ...iters[iters.length - 1],
+          output_tokens: totalOutput
+        };
+        usage.iterations = iters;
+      }
+    }
+    if (!stopReason) {
+      throw new Error(
+        this.failureMessage(
+          `turn timed out after ${timeout}ms (no terminal assistant record)`
+        )
+      );
+    }
+    return { stopReason, usage };
+  }
+  dispose() {
+    if (this.proc) {
+      try {
+        this.proc.terminal.write("");
+      } catch {
+      }
+      try {
+        this.proc.kill();
+      } catch {
+      }
+      try {
+        this.proc.terminal.close();
+      } catch {
+      }
+    }
+    this.proc = null;
+  }
+};
+
+// src/claude-session-wrapper.ts
+function decodeUserEnvelope(chunk) {
+  let parsed;
+  try {
+    parsed = JSON.parse(chunk);
+  } catch {
+    return chunk;
+  }
+  if (!parsed || parsed.type !== "user" || !parsed.message) return chunk;
+  const content = parsed.message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return chunk;
+  const parts = [];
+  let dropped = 0;
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block?.type === "tool_result") {
+      const v = block.content;
+      const text = typeof v === "string" ? v : Array.isArray(v) ? v.map((i) => i?.type === "text" ? i.text : "").filter(Boolean).join("\n") : "";
+      parts.push(
+        `[Tool result${block.tool_use_id ? ` ${block.tool_use_id}` : ""}]
+${text}`
+      );
+    } else {
+      dropped++;
+    }
+  }
+  if (dropped > 0) {
+    log.warn("interactive transport dropped non-text content blocks", {
+      dropped
+    });
+  }
+  return parts.join("\n\n");
+}
+function spawnInteractiveProcess(opts) {
+  const extraArgs = [];
+  if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
+    extraArgs.push(
+      "--mcp-config",
+      ...opts.mcpConfigPaths,
+      "--strict-mcp-config"
+    );
+  }
+  if (opts.permissionsAllow && opts.permissionsAllow.length > 0) {
+    extraArgs.push(
+      "--settings",
+      JSON.stringify({ permissions: { allow: opts.permissionsAllow } })
+    );
+  }
+  if (opts.permissionMode === "bypassPermissions") {
+    log.warn(
+      "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI"
+    );
+  } else if (opts.permissionMode) {
+    extraArgs.push("--permission-mode", opts.permissionMode);
+  }
+  if (opts.systemPromptFile) {
+    extraArgs.push("--append-system-prompt-file", opts.systemPromptFile);
+  }
+  const session = new ClaudeSession({
+    cwd: opts.cwd,
+    cliPath: opts.cliPath,
+    configDir: opts.configDir,
+    model: opts.model,
+    // Default null = normal CLAUDE.md + settings load, matching what the
+    // headless spawn does. "" (skip everything) is for fast e2e runs only.
+    settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
+    extraArgs
+  });
+  log.info("prepared interactive claude session", {
+    cwd: opts.cwd,
+    cliPath: opts.cliPath ?? "claude",
+    configDir: session.configDir,
+    model: opts.model,
+    sessionId: session.sessionId,
+    jsonlPath: session.jsonlPath
+  });
+  const lineEmitter = new EventEmitter2();
+  const errorHandlers = /* @__PURE__ */ new Set();
+  let startPromise = null;
+  const ensureStarted = () => {
+    if (!startPromise) startPromise = session.start();
+    return startPromise;
+  };
+  const emitResult = (subtype, isError, result, usage) => {
+    lineEmitter.emit(
+      "line",
+      JSON.stringify({
+        type: "result",
+        subtype,
+        is_error: isError,
+        result,
+        session_id: session.sessionId,
+        usage: usage ?? {},
+        total_cost_usd: null,
+        duration_ms: 0
+      })
+    );
+  };
+  const runTurn = (userMsg) => {
+    void (async () => {
+      try {
+        await ensureStarted();
+        const { stopReason, usage } = await session.tailTurn(userMsg, (raw) => {
+          lineEmitter.emit("line", raw);
+        });
+        const timedOut = !stopReason;
+        emitResult(
+          timedOut ? "error_during_execution" : stopReason,
+          timedOut,
+          timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
+          usage
+        );
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        log.error("interactive turn failed", { error: e.message });
+        emitResult(
+          "error_during_execution",
+          true,
+          `Interactive transport failed: ${e.message}`
+        );
+        if (errorHandlers.size > 0) {
+          for (const h of errorHandlers) h(e);
+        } else {
+          lineEmitter.emit("close");
+        }
+      }
+    })();
+  };
+  const proc = {
+    stdin: {
+      write(chunk) {
+        const raw = typeof chunk === "string" && chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
+        runTurn(decodeUserEnvelope(raw));
+        return true;
+      },
+      end() {
+      }
+    },
+    stdout: null,
+    stderr: null,
+    pid: -1,
+    killed: false,
+    on(event, fn) {
+      if (event === "error") errorHandlers.add(fn);
+      return proc;
+    },
+    once() {
+      return proc;
+    },
+    off(event, fn) {
+      if (event === "error") errorHandlers.delete(fn);
+      return proc;
+    },
+    kill() {
+      try {
+        session.dispose();
+      } catch {
+      }
+      if (opts.systemPromptFile) {
+        void unlink2(opts.systemPromptFile).catch(() => {
+        });
+      }
+      proc.killed = true;
+      return true;
+    }
+  };
+  return {
+    proc,
+    lineEmitter,
+    proxyServer: null,
+    mcpHash: void 0,
+    systemPromptFile: opts.systemPromptFile
+  };
+}
+
+// src/proxy-mcp.ts
+import { createServer } from "http";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as crypto2 from "crypto";
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
@@ -1557,7 +2109,7 @@ var DEFAULT_PROXY_TOOLS = [
   }
 ];
 async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
-  const calls = new EventEmitter2();
+  const calls = new EventEmitter3();
   const pending = /* @__PURE__ */ new Map();
   const server2 = createServer(async (req, res) => {
     if (req.method !== "POST" || !req.url?.startsWith("/mcp")) {
@@ -1637,12 +2189,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         });
         let timer = null;
         const result = await new Promise(
-          (resolve3, reject) => {
+          (resolve4, reject) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve3,
+              resolve: resolve4,
               reject
             };
             pending.set(callId, entry);
@@ -1717,11 +2269,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       }
     }
   });
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve4, reject) => {
     server2.once("error", reject);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject);
-      resolve3();
+      resolve4();
     });
   });
   const addr = server2.address();
@@ -1755,11 +2307,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         2
       );
       const hash = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path3.join(
+      const outPath = path4.join(
         pluginTmpDir(),
         `proxy-${hash}.json`
       );
-      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs4.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
       configFilePath = outPath;
       return outPath;
     },
@@ -1768,12 +2320,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         entry.reject(new Error("proxy MCP server closed"));
       }
       pending.clear();
-      await new Promise((resolve3) => {
-        server2.close(() => resolve3());
+      await new Promise((resolve4) => {
+        server2.close(() => resolve4());
       });
       if (configFilePath) {
         try {
-          fs3.unlinkSync(configFilePath);
+          fs4.unlinkSync(configFilePath);
         } catch {
         }
         configFilePath = null;
@@ -1807,10 +2359,10 @@ function disallowedToolFlags(tools) {
   return out;
 }
 function readBody(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -1823,10 +2375,10 @@ function writeJson(res, body) {
 }
 
 // src/proxy-broker.ts
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 var pendingByCallId = /* @__PURE__ */ new Map();
 var callIdsBySession = /* @__PURE__ */ new Map();
-var emitter = new EventEmitter3();
+var emitter = new EventEmitter4();
 var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
@@ -1948,11 +2500,11 @@ function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
 }
 
 // src/claude-code-language-model.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
-import { unlink as unlink2 } from "fs/promises";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname3, join as join5 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { unlink as unlink3 } from "fs/promises";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname3, join as join6 } from "path";
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
   const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
@@ -2141,9 +2693,9 @@ function makeAutoContinueMessage() {
     }
   });
 }
-function readPromptFileIfPresent(path5) {
+function readPromptFileIfPresent(path6) {
   try {
-    const content = readFileSync2(path5, "utf8").trim();
+    const content = readFileSync3(path6, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -2152,7 +2704,7 @@ function readPromptFileIfPresent(path5) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join5(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join6(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname3(dir);
     if (parent === dir) return void 0;
@@ -2203,8 +2755,8 @@ function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystem
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config");
-  const globalAgents = readPromptFileIfPresent(join5(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join6(homedir4(), ".config");
+  const globalAgents = readPromptFileIfPresent(join6(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   if (globalAgents) parts.push(globalAgents);
   if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
@@ -2212,10 +2764,10 @@ function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystem
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path5 = join5(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
+  const path6 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID3()}.md`);
   try {
-    writeFileSync3(path5, content, "utf8");
-    return path5;
+    writeFileSync3(path6, content, "utf8");
+    return path6;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -2760,7 +3312,7 @@ var ClaudeCodeLanguageModel = class {
     });
     if (systemPromptFile) {
       proc.on("exit", () => {
-        void unlink2(systemPromptFile).catch(() => {
+        void unlink3(systemPromptFile).catch(() => {
         });
       });
     }
@@ -2771,7 +3323,7 @@ var ClaudeCodeLanguageModel = class {
     const toolCalls = [];
     const toolCallStreams = /* @__PURE__ */ new Map();
     let gotPartialEvents = false;
-    const result = await new Promise((resolve3, reject) => {
+    const result = await new Promise((resolve4, reject) => {
       const cleanup = () => {
         try {
           if (!proc.killed && proc.exitCode === null) proc.kill();
@@ -2879,7 +3431,7 @@ ${plan}
               usage: msg.usage
             };
             cleanup();
-            resolve3({
+            resolve4({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -2891,7 +3443,7 @@ ${plan}
       });
       rl.on("close", () => {
         cleanup();
-        resolve3({
+        resolve4({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -2996,6 +3548,10 @@ ${plan}
     const toUsage = this.toUsage.bind(this);
     const toFinishReason = this.toFinishReason.bind(this);
     const handleControlRequest = this.handleControlRequest.bind(this);
+    const flagOn = (v) => v !== void 0 && !["", "0", "false", "no", "off"].includes(v.trim().toLowerCase());
+    const interactivePref = this.config.interactive ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT);
+    const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
+    const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
     if (scope === "no-tools" && !compactionMode) {
       log.info("doStream no-tools title stub", {
         compactionMode,
@@ -3118,81 +3674,141 @@ ${plan}
           }
         }
         const setup = async () => {
-          let cliArgs;
-          let spawnSystemPromptFile;
-          let spawnProxyServer = null;
-          let spawnMcpHash = null;
-          if (compactionMode) {
-            cliArgs = buildCliArgs({
-              sessionKey: sk,
-              skipPermissions,
-              includeSessionId: false,
-              model: effectiveModelId,
-              permissionMode: self.config.permissionMode,
-              cliVersion
-            });
-          } else {
-            const discovery = self.effectiveMcpConfig(
-              cwd,
-              void 0,
-              runtimeStatus
-            );
-            const proxyMcpTools = await self.resolvedProxyMcpTools(
-              discovery.allEnabledServerNames
-            );
-            const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
-            const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
-            if (!proxyServer && combinedProxyTools) {
-              proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+          if (useInteractive && !compactionMode) {
+            const mcp = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
+            if (activeProcess) {
+              proc = activeProcess.proc;
+              lineEmitter = activeProcess.lineEmitter;
+              log.debug("reusing active interactive session", { sk });
+            } else {
+              const allow = [
+                ...mcp.allEnabledServerNames.map((n) => `mcp__${n}__*`),
+                "mcp__opencode_proxy__*",
+                ...self.config.interactiveAllowTools ?? [
+                  "Bash",
+                  "Edit",
+                  "Write",
+                  "Read",
+                  "WebFetch"
+                ]
+              ];
+              const systemPromptFile = self.config.interactiveSystemPrompt === false ? void 0 : buildAppendedSystemPrompt(
+                cwd,
+                self.config.multiStepContinuation !== false
+                // Do not forward opencode's own system prompt into the
+                // interactive TUI. Live subscription-account testing
+                // showed that large forwarded payload can trigger Claude
+                // Code's third-party-app usage gate, while our static
+                // CLI/AGENTS/continuation prompt remains safe.
+              );
+              if (self.config.interactiveSystemPrompt === false) {
+                log.warn(
+                  "interactive system prompt disabled; opencode agent prompts will not be appended"
+                );
+              }
+              if (interactiveBypassRequested) {
+                log.warn(
+                  "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI"
+                );
+              }
+              const ap = spawnInteractiveProcess({
+                cwd,
+                cliPath,
+                configDir: self.config.configDir,
+                model: effectiveModelId,
+                mcpConfigPaths: mcp.paths,
+                permissionsAllow: allow,
+                systemPromptFile
+              });
+              ap.mcpHash = mcp.bridgedHash;
+              setActiveProcess(sk, ap);
+              proc = ap.proc;
+              lineEmitter = ap.lineEmitter;
+              activeProcess = ap;
+              log.info("spawned interactive claude session", {
+                sk,
+                cliPath,
+                configDir: self.config.configDir,
+                model: effectiveModelId
+              });
             }
-            const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
-            const extraDisallowed = [];
-            if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
-            const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
-            const mcp = self.effectiveMcpConfig(
-              cwd,
-              proxyServer?.configPath(),
-              runtimeStatus,
-              excludeServers
-            );
-            const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(
-              cwd,
-              self.config.multiStepContinuation !== false,
-              extractSystemMessages(options.prompt)
-            );
-            cliArgs = buildCliArgs({
-              sessionKey: sk,
-              skipPermissions,
-              model: self.modelId,
-              permissionMode: self.config.permissionMode,
-              mcpConfig: mcp.paths,
-              strictMcpConfig: self.config.strictMcpConfig,
-              disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
-              appendSystemPromptFile: systemPromptFile,
-              ...self.thinkingCliOptions(),
-              cliVersion
-            });
-            spawnSystemPromptFile = systemPromptFile;
-            spawnProxyServer = proxyServer;
-            spawnMcpHash = mcp.bridgedHash;
-          }
-          if (activeProcess && !compactionMode) {
-            proc = activeProcess.proc;
-            lineEmitter = activeProcess.lineEmitter;
-            log.debug("reusing active process", { sk });
           } else {
-            const ap = spawnClaudeProcess(
-              cliPath,
-              cliArgs,
-              cwd,
-              sk,
-              spawnProxyServer,
-              spawnMcpHash,
-              spawnSystemPromptFile
-            );
-            proc = ap.proc;
-            lineEmitter = ap.lineEmitter;
-            activeProcess = ap;
+            let cliArgs;
+            let spawnSystemPromptFile;
+            let spawnProxyServer = null;
+            let spawnMcpHash = null;
+            if (compactionMode) {
+              cliArgs = buildCliArgs({
+                sessionKey: sk,
+                skipPermissions,
+                includeSessionId: false,
+                model: effectiveModelId,
+                permissionMode: self.config.permissionMode,
+                cliVersion
+              });
+            } else {
+              const discovery = self.effectiveMcpConfig(
+                cwd,
+                void 0,
+                runtimeStatus
+              );
+              const proxyMcpTools = await self.resolvedProxyMcpTools(
+                discovery.allEnabledServerNames
+              );
+              const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
+              const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
+              if (!proxyServer && combinedProxyTools) {
+                proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+              }
+              const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
+              const extraDisallowed = [];
+              if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
+              const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
+              const mcp = self.effectiveMcpConfig(
+                cwd,
+                proxyServer?.configPath(),
+                runtimeStatus,
+                excludeServers
+              );
+              const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(
+                cwd,
+                self.config.multiStepContinuation !== false,
+                extractSystemMessages(options.prompt)
+              );
+              cliArgs = buildCliArgs({
+                sessionKey: sk,
+                skipPermissions,
+                model: self.modelId,
+                permissionMode: self.config.permissionMode,
+                mcpConfig: mcp.paths,
+                strictMcpConfig: self.config.strictMcpConfig,
+                disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
+                appendSystemPromptFile: systemPromptFile,
+                ...self.thinkingCliOptions(),
+                cliVersion
+              });
+              spawnSystemPromptFile = systemPromptFile;
+              spawnProxyServer = proxyServer;
+              spawnMcpHash = mcp.bridgedHash;
+            }
+            if (activeProcess && !compactionMode) {
+              proc = activeProcess.proc;
+              lineEmitter = activeProcess.lineEmitter;
+              log.debug("reusing active process", { sk });
+            } else {
+              const ap = spawnClaudeProcess(
+                cliPath,
+                cliArgs,
+                cwd,
+                sk,
+                spawnProxyServer,
+                spawnMcpHash,
+                spawnSystemPromptFile
+              );
+              proc = ap.proc;
+              lineEmitter = ap.lineEmitter;
+              activeProcess = ap;
+            }
           }
           controller.enqueue({ type: "stream-start", warnings });
           let currentTextId = null;
@@ -3378,11 +3994,13 @@ ${plan}
                 }
                 if (block.type === "tool_use" && block.id && block.name) {
                   noteToolActivity();
-                  toolCallMap.set(idx, {
+                  const entry = {
                     id: block.id,
                     name: block.name,
-                    inputJson: ""
-                  });
+                    inputJson: "",
+                    started: false
+                  };
+                  toolCallMap.set(idx, entry);
                   if (block.name !== "AskUserQuestion" && block.name !== "ask_user_question" && block.name !== "ExitPlanMode" && !block.name.startsWith(PROXY_TOOL_PREFIX)) {
                     const { name: mappedName, skip, executed } = mapTool(
                       block.name,
@@ -3394,6 +4012,7 @@ ${plan}
                       }
                     );
                     if (!skip) {
+                      entry.started = true;
                       controller.enqueue({
                         type: "tool-input-start",
                         id: block.id,
@@ -3445,11 +4064,13 @@ ${plan}
                   const tc = toolCallMap.get(idx);
                   if (tc) {
                     tc.inputJson += delta.partial_json;
-                    controller.enqueue({
-                      type: "tool-input-delta",
-                      id: tc.id,
-                      delta: delta.partial_json
-                    });
+                    if (tc.started) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: tc.id,
+                        delta: delta.partial_json
+                      });
+                    }
                   }
                 }
                 if (!KNOWN_DELTA_TYPES.has(delta.type)) {
@@ -3646,11 +4267,6 @@ ${plan}
                   if (block.type === "tool_use" && block.id && block.name) {
                     noteToolActivity();
                     const parsedInput = block.input ?? {};
-                    toolCallsById.set(block.id, {
-                      id: block.id,
-                      name: block.name,
-                      input: parsedInput
-                    });
                     if (isAskUserQuestionTool(block.name)) {
                       const askId = startTextBlock();
                       controller.enqueue({
@@ -3703,6 +4319,11 @@ ${plan}
                         toolUseId: block.id
                       });
                       if (!skip) {
+                        toolCallsById.set(block.id, {
+                          id: block.id,
+                          name: block.name,
+                          input: parsedInput
+                        });
                         if (!executed) skipResultForIds.add(block.id);
                         controller.enqueue({
                           type: "tool-input-start",
@@ -3994,6 +4615,8 @@ ${plan}
           };
           const procErrorHandler = (err) => {
             log.error("process error", { error: err.message });
+            deleteActiveProcess(sk);
+            deleteClaudeSessionId(sk);
             if (controllerClosed) return;
             if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
               rejectAllPendingProxyCallsForSession(
@@ -4317,7 +4940,7 @@ var defaultModels = {
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -4355,7 +4978,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path4.join(home, value.slice(2)) : value;
+    return home ? path5.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -4378,7 +5001,7 @@ async function ensureAccountRuntime(account, baseCliPath) {
     baseCliPath,
     expandedConfigDir
   );
-  return { cliPath, configDir };
+  return { cliPath, configDir: expandedConfigDir };
 }
 async function ensureSharedCapabilities(targetRoot) {
   const sourceRoot = expandHome("~/.claude");
@@ -4387,8 +5010,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path4.join(sourceRoot, item);
-  const target = path4.join(targetRoot, item);
+  const source = path5.join(sourceRoot, item);
+  const target = path5.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -4399,8 +5022,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path4.resolve(path4.dirname(target), current);
-      const resolvedSource = path4.resolve(source);
+      const resolvedCurrent = path5.resolve(path5.dirname(target), current);
+      const resolvedSource = path5.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -4415,11 +5038,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path4.join(
+  const cacheRoot = path5.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path4.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path5.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -4459,14 +5082,14 @@ function titleizeAccount(account) {
 
 // src/cleanup-stale.ts
 import {
-  existsSync as existsSync3,
-  readFileSync as readFileSync3,
+  existsSync as existsSync4,
+  readFileSync as readFileSync4,
   realpathSync,
   rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join6, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join7, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -4474,20 +5097,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join6(xdg, "opencode") : null,
-    join6(homedir4(), ".cache", "opencode"),
-    join6(homedir4(), "Library", "Caches", "opencode")
+    xdg ? join7(xdg, "opencode") : null,
+    join7(homedir5(), ".cache", "opencode"),
+    join7(homedir5(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join6(homedir4(), ".config");
-  return join6(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join7(homedir5(), ".config");
+  return join7(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
-  if (!existsSync3(cfg)) return false;
+  if (!existsSync4(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync3(cfg, "utf8"));
+    const json = JSON.parse(readFileSync4(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -4500,7 +5123,7 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath(import.meta.url);
-    return realpathSync(resolve2(filePath, "..", ".."));
+    return realpathSync(resolve3(filePath, "..", ".."));
   } catch {
     return null;
   }
@@ -4523,20 +5146,20 @@ function cleanupStaleUnscopedInstall() {
   }
 }
 function cleanupOne(cacheRoot, ourDir) {
-  if (!existsSync3(cacheRoot)) return;
-  const stalePath = join6(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
-  if (!existsSync3(stalePath)) return;
+  if (!existsSync4(cacheRoot)) return;
+  const stalePath = join7(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync4(stalePath)) return;
   let realStalePath = stalePath;
   try {
     realStalePath = realpathSync(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join6(stalePath, "package.json");
-  if (!existsSync3(pkgJsonPath)) return;
+  const pkgJsonPath = join7(stalePath, "package.json");
+  if (!existsSync4(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync4(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -4552,10 +5175,10 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join6(cacheRoot, "package.json");
-  if (!existsSync3(cachePkgJson)) return;
+  const cachePkgJson = join7(cacheRoot, "package.json");
+  if (!existsSync4(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync3(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync4(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync4(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -4610,7 +5233,11 @@ function createClaudeCode(settings = {}) {
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
       multiStepContinuation: settings.multiStepContinuation ?? true,
       autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart",
-      compactionModel: settings.compactionModel
+      compactionModel: settings.compactionModel,
+      interactive: settings.interactive,
+      interactiveBypass: settings.interactiveBypass,
+      interactiveAllowTools: settings.interactiveAllowTools,
+      interactiveSystemPrompt: settings.interactiveSystemPrompt
     });
   };
   const provider = function(modelId) {