@khalilgharbaoui/opencode-claude-code-plugin 0.40.0 → 0.41.0

package/dist/index.d.ts

@@ -338,6 +338,7 @@ type OpenCodePlugin = (input: unknown, options?: Record<string, unknown>) => Pro
 type LogLevel = "debug" | "info" | "notice" | "warn" | "error";
 type LogMode = "silent" | "debug";
 
+type ClaudeCodeTransport = "auto" | "headless" | "interactive";
 interface ClaudeCodeConfig {
     provider: string;
     cliPath: string;
@@ -349,6 +350,8 @@ interface ClaudeCodeConfig {
      * so nothing process-wide may decide it.
      */
     hostApi?: "v1" | "v2";
+    /** Explicit transport selection; auto switches only on proven missing headless flags. */
+    transport?: ClaudeCodeTransport;
     /** Drive interactive claude (subscription) instead of headless --print. */
     interactive?: boolean;
     /** Deprecated/no-op with interactive: Claude Code's TUI requires manual confirmation for bypassPermissions. */
@@ -466,6 +469,8 @@ interface ClaudeCodeProviderSettings {
     cliPath?: string;
     /** Internal: set by the opencode 2 entrypoint. See `ClaudeCodeConfig.hostApi`. */
     hostApi?: "v1" | "v2";
+    /** Wins over the legacy interactive option and its environment fallback. */
+    transport?: ClaudeCodeTransport;
     /** Drive interactive claude (subscription) instead of headless --print. */
     interactive?: boolean;
     /** Deprecated/no-op with interactive: Claude Code's TUI requires manual confirmation for bypassPermissions. */

package/dist/index.js

@@ -1728,6 +1728,43 @@ function cliSupportsThinking(v) {
   return gte(v, { major: 2, minor: 0, patch: 0 });
 }
 var flagSupport = /* @__PURE__ */ new Map();
+var headlessSupport = /* @__PURE__ */ new Map();
+function detectHeadlessSupport(cliPath) {
+  const key = `${cliPath}\0headless`;
+  const cached = headlessSupport.get(key);
+  if (cached) return cached;
+  let deadlineKill = false;
+  const promise = (async () => {
+    try {
+      const execution = execFileAsync(cliPath, [
+        "--print",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--help"
+      ], { timeout: probeTimeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 });
+      execution.child.stdin?.end();
+      const { stdout } = await execution;
+      if (!/^\s*Usage:/im.test(stdout) || !/^\s*Options:/im.test(stdout)) return "unknown";
+      const flags = ["--print", "--input-format", "--output-format"];
+      if (!flags.every((flag) => new RegExp(`^\\s+(?:-[A-Za-z],\\s+)?${flag}(?:\\s|,|$)`, "m").test(stdout))) {
+        return "unsupported";
+      }
+      return stdout.includes("stream-json") ? "supported" : "unknown";
+    } catch (error) {
+      deadlineKill = killedByDeadline(error);
+      const stderr = error?.stderr;
+      if (typeof stderr === "string" && /^(?:error: )?(?:unknown|unrecognized|unsupported) option ['"]?--(?:print|input-format|output-format)(?:['"\s]|$)/im.test(stderr)) {
+        return "unsupported";
+      }
+      return "unknown";
+    }
+  })();
+  headlessSupport.set(key, promise);
+  forgetDeadlineKill(headlessSupport, key, promise, () => deadlineKill);
+  return promise;
+}
 function detectCliSupportsFlag(cliPath, flag) {
   const key = `${cliPath}\0${flag}`;
   const cached = flagSupport.get(key);
@@ -6336,6 +6373,10 @@ async function fetchPlanUsage(cliPath, options = {}) {
   const timeoutMs = options.timeoutMs ?? 2e4;
   const run = options.runImpl ?? runCli;
   try {
+    const support = options.headlessSupportImpl ?? (options.runImpl ? void 0 : detectHeadlessSupport);
+    if (support && await support(cliPath) === "unsupported") {
+      return { status: "failed", error: "Plan usage is unavailable: this Claude CLI does not support headless output. Check usage in the Claude CLI directly." };
+    }
     const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
     const stdout = await run(
       cliPath,
@@ -8055,6 +8096,9 @@ The complete prior conversation appears above. The synthesis instructions follow
 `
       });
     }
+    if (opts.compactionInstructions?.trim()) {
+      content.push({ type: "text", text: opts.compactionInstructions });
+    }
   } else if (includeHistoryContext) {
     const historyContext = compactConversationHistory(prompt);
     if (historyContext) {
@@ -9350,6 +9394,7 @@ ${text}`
 }
 function interactiveExtraArgs(opts) {
   const extraArgs = [];
+  if (opts.tools) extraArgs.push("--tools", opts.tools.join(","));
   if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
     extraArgs.push(
       "--mcp-config",
@@ -9681,6 +9726,32 @@ function spawnInteractiveProcess(opts) {
   return ap;
 }
 
+// src/transport.ts
+function requestedTransport(config, env = process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT) {
+  if (config.transport !== void 0) {
+    if (!["auto", "headless", "interactive"].includes(config.transport)) {
+      throw new Error(`Unknown Claude transport: ${config.transport}`);
+    }
+    return config.transport;
+  }
+  const enabled = config.interactive ?? (env !== void 0 && !["", "0", "false", "no", "off"].includes(env.trim().toLowerCase()));
+  return enabled ? "interactive" : "headless";
+}
+function hasInteractiveTransport() {
+  const runtime = globalThis;
+  return typeof runtime.Bun?.Terminal === "function";
+}
+async function selectTransport(requested, cliPath, available = hasInteractiveTransport()) {
+  if (requested === "headless") return "headless";
+  if (requested === "interactive") {
+    if (!available) throw new Error("Interactive Claude transport requires Bun.Terminal. Run opencode under a Bun runtime with PTY support.");
+    return "interactive";
+  }
+  if (await detectHeadlessSupport(cliPath) !== "unsupported") return "headless";
+  if (!available) throw new Error("Claude no longer supports the headless flags, and Bun.Terminal is unavailable. Run opencode under a Bun runtime with PTY support.");
+  return "interactive";
+}
+
 // src/prompts.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir8 } from "os";
@@ -12549,8 +12620,14 @@ var ClaudeCodeLanguageModel = class {
     const toFinishReason2 = this.toFinishReason.bind(this);
     const handleControlRequest2 = 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 transport = requestedTransport(this.config);
+    const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
+    const selectedTransport = doctor ? transport === "interactive" ? "interactive" : "headless" : this.config.transport === void 0 && !hasInteractiveTransport() ? "headless" : this.isTitleRequest(scope, options) && !compactionMode ? "headless" : await Promise.race([selectTransport(transport, this.config.cliPath), turnAbort.whenAborted]);
+    if (turnAbort.aborted) return abortedBeforeWork("selecting the transport");
+    const useInteractive = selectedTransport === "interactive";
+    if (useInteractive && !compactionMode && !doctor && (this.config.permissionPreset === "read-only" || this.config.permissionMode === "plan")) {
+      throw new Error("Interactive Claude transport cannot enforce the read-only preset or plan mode. Use the headless transport for this permission posture.");
+    }
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
     const modelFallbackArmed = attempt?.armed === true && !compactionMode && !useInteractive;
     const sourceAccount = normalizeAccountName(
@@ -12566,7 +12643,6 @@ var ClaudeCodeLanguageModel = class {
     let cliPath = failover.cliPath;
     if (turnAbort.aborted) return abortedBeforeWork("resolving the spawn cwd and account");
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
-    const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
     if (doctor) {
       const doctorOptions = {
         cliPath,
@@ -12686,7 +12762,7 @@ var ClaudeCodeLanguageModel = class {
         request: { body: { text: "" } }
       };
     }
-    if (!hasNewUserContent(options.prompt)) {
+    if (!compactionMode && !hasNewUserContent(options.prompt)) {
       log.info("doStream short-circuit: no new user content");
       const stream2 = new ReadableStream({
         start(controller) {
@@ -12859,6 +12935,7 @@ var ClaudeCodeLanguageModel = class {
     const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(options.prompt, failoverAnswer.target) : options.prompt;
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(effectivePrompt, includeHistoryContext, {
       compactionMode,
+      compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
       cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
       stripContextReminders: this.stripContextRemindersEnabled()
     });
@@ -13222,7 +13299,21 @@ var ClaudeCodeLanguageModel = class {
               allDisallowed
             };
           };
-          if (useInteractive && !compactionMode) {
+          if (useInteractive && compactionMode) {
+            const ap = spawnInteractiveProcess({
+              cwd,
+              cliPath,
+              configDir: self.config.configDir,
+              model: spawnModelId,
+              fastMode,
+              tools: [],
+              mcpConfigPaths: ['{"mcpServers":{}}'],
+              env: claudeSpawnEnv({ ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey })
+            });
+            state.proc = ap.proc;
+            state.lineEmitter = ap.lineEmitter;
+            state.activeProcess = ap;
+          } else if (useInteractive) {
             if (state.activeProcess) {
               state.proc = state.activeProcess.proc;
               state.lineEmitter = state.activeProcess.lineEmitter;
@@ -13706,6 +13797,7 @@ var ClaudeCodeLanguageModel = class {
             state.asideSinkUnregister?.();
             state.asideSinkUnregister = null;
             state.proc.off("error", procErrorHandler);
+            if (compactionMode && useInteractive) state.proc.kill();
           };
           const procErrorHandler = (err) => {
             log.error("process error", { error: err.message });
@@ -14719,6 +14811,7 @@ function createClaudeCode(settings = {}) {
       turnStats: settings.turnStats === true,
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
+      transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
       interactiveAllowTools: settings.interactiveAllowTools,