@khalilgharbaoui/opencode-claude-code-plugin 0.10.0 → 0.11.1

package/README.md

@@ -531,6 +531,47 @@ Boolean env vars accept `1/true/on/yes` for on and `0/false/no/off` for
 off; empty / unset falls through to config. Invalid `level` values fall
 through to config.
 
+### Startup diagnostics
+
+Once per process, right after the provider(s) register, the plugin logs a
+single `NOTICE: claude-code plugin ready` line summarizing everything worth
+knowing before you start debugging anything else:
+
+```bash
+OPENCODE_CLAUDE_CODE_LOG_FILE=1 opencode
+grep "plugin ready" ~/.local/share/opencode-claude-code/plugin.log
+```
+
+```json
+{
+  "plugin": "0.11.1",
+  "opencode": "1.18.5",
+  "cwd": { "resolved": "/Users/you/code/app", "source": "process" },
+  "providers": ["claude-code-default", "claude-code-work"],
+  "accounts": ["default", "work"],
+  "proxyTools": ["Bash", "Edit", "Write", "WebFetch", "Task"],
+  "mcpServers": ["github", "slack"],
+  "interactiveTransport": false,
+  "anthropicApiKeyInEnv": false,
+  "claudeCli": { "path": "claude", "version": "2.1.211 (Claude Code)" }
+}
+```
+
+Reading it:
+
+- **`cwd.source`** is which rule picked the working directory Claude will be
+  spawned in — `configured` (you pinned `options.cwd`), `process` (normal),
+  `captured` (`process.cwd()` was unusable and opencode's project directory
+  rescued it, the macOS GUI-launch case), or `unresolved` (neither worked).
+- **`claudeCli.version`** reading `not detected` means the `claude` binary at
+  that path didn't answer `--version`, which also disables version-gated
+  flags like `--thinking-display`.
+- **`mcpServers`** is the on-disk merge, before opencode's runtime toggles
+  are applied (those aren't settled yet at startup).
+- **`opencode`** is read from the running opencode binary (`--version`), since
+  opencode still does not hand its version to plugins. It reads `unknown` when
+  opencode is run from source rather than as the packaged binary.
+
 ### Default behavior (no config, no env)
 
 Nothing persists; only WARN and ERROR bubble in the TUI. The plugin

package/dist/index.d.ts

@@ -467,6 +467,11 @@ interface ClaudeStreamMessage {
     index?: number;
 }
 
+interface DiagnosticsProviderEntry {
+    name?: string;
+    options?: Record<string, unknown>;
+}
+
 declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     readonly specificationVersion = "v3";
     readonly modelId: string;
@@ -598,9 +603,15 @@ declare function createClaudeCode(settings?: ClaudeCodeProviderSettings): Claude
  * so the config-path provider loader parses them correctly.
  */
 declare function configModelsForProvider(providerModels: OpenCodeProvider["models"], providerID: string, modelSuffix?: string): Record<string, Record<string, unknown>>;
+/**
+ * Narrow opencode's full provider map down to the ones this plugin owns
+ * (`claude-code` plus every `claude-code-<account>` expansion) so startup
+ * diagnostics never report another provider's options.
+ */
+declare function claudeCodeProviders(providers: Record<string, DiagnosticsProviderEntry> | undefined): Record<string, DiagnosticsProviderEntry>;
 declare const _default: {
     id: string;
     server: OpenCodePlugin;
 };
 
-export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, configModelsForProvider, createClaudeCode, _default as default, defaultModels };
+export { type ClaudeCodeConfig, ClaudeCodeLanguageModel, type ClaudeCodeProvider, type ClaudeCodeProviderSettings, type ClaudeStreamMessage, type OpenCodeHooks, type OpenCodeModel, type OpenCodePlugin, bridgeOpencodeMcp, claudeCodeProviders, configModelsForProvider, createClaudeCode, _default as default, defaultModels };

package/dist/index.js

@@ -974,6 +974,31 @@ function mergeMcp(target, source) {
   return out;
 }
 function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
+  const {
+    servers: merged,
+    enabledServerNames: allEnabledServerNames,
+    hash
+  } = mergeOpencodeMcp(cwd, runtimeStatus);
+  const servers = {};
+  const bridgedServerNames = [];
+  for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
+    if (excludeServers?.has(name)) continue;
+    const translated = translateServer(name, spec);
+    if (translated) {
+      servers[name] = translated;
+      bridgedServerNames.push(name);
+    }
+  }
+  return finishBridge({
+    servers,
+    bridgedServerNames,
+    allEnabledServerNames,
+    hash,
+    excludeServers
+  });
+}
+function mergeOpencodeMcp(cwd, runtimeStatus) {
   const worktree = detectWorktree(cwd);
   let merged = {};
   merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
@@ -1012,26 +1037,19 @@ function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
       merged[name] = { ...base, enabled: status === "connected" };
     }
   }
-  const allEnabledServerNames = [];
+  const enabledServerNames = [];
   for (const [name, spec] of Object.entries(merged)) {
     if (!spec || typeof spec !== "object") continue;
     const enabled = spec.enabled;
     if (enabled === false) continue;
-    allEnabledServerNames.push(name);
-  }
-  const servers = {};
-  const bridgedServerNames = [];
-  for (const [name, spec] of Object.entries(merged)) {
-    if (!spec || typeof spec !== "object") continue;
-    if (excludeServers?.has(name)) continue;
-    const translated = translateServer(name, spec);
-    if (translated) {
-      servers[name] = translated;
-      bridgedServerNames.push(name);
-    }
+    enabledServerNames.push(name);
   }
   const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
   const hash = crypto.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  return { servers: merged, enabledServerNames, hash };
+}
+function finishBridge(input) {
+  const { servers, bridgedServerNames, allEnabledServerNames, hash, excludeServers } = input;
   if (Object.keys(servers).length === 0) {
     const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
     if (!allEnabledServersExcluded) return null;
@@ -1082,6 +1100,9 @@ var opencodeProjectDirectory;
 function setOpencodeProjectDirectory(dir) {
   opencodeProjectDirectory = dir;
 }
+function getOpencodeProjectDirectory() {
+  return opencodeProjectDirectory;
+}
 function isUsableDirectory(d) {
   return typeof d === "string" && d.length > 1 && d !== "/";
 }
@@ -2832,9 +2853,9 @@ function makeAutoContinueMessage() {
     }
   });
 }
-function readPromptFileIfPresent(path6) {
+function readPromptFileIfPresent(path7) {
   try {
-    const content = readFileSync3(path6, "utf8").trim();
+    const content = readFileSync3(path7, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -2903,10 +2924,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 path6 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID3()}.md`);
+  const path7 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID3()}.md`);
   try {
-    writeFileSync3(path6, content, "utf8");
-    return path6;
+    writeFileSync3(path7, content, "utf8");
+    return path7;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -5515,6 +5536,130 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
+// src/startup-diagnostics.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs5 from "fs";
+import * as path6 from "path";
+import { promisify as promisify2 } from "util";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cachedPluginVersion;
+function pluginVersion() {
+  if (cachedPluginVersion) return cachedPluginVersion;
+  try {
+    const here = path6.dirname(fileURLToPath2(import.meta.url));
+    const raw = fs5.readFileSync(path6.join(here, "..", "package.json"), "utf8");
+    const version = JSON.parse(raw).version;
+    cachedPluginVersion = typeof version === "string" ? version : "unknown";
+  } catch {
+    cachedPluginVersion = "unknown";
+  }
+  return cachedPluginVersion;
+}
+function pickOpencodeVersion(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const app = input.app;
+  if (app && typeof app === "object") {
+    const version = app.version;
+    if (typeof version === "string" && version.length > 0) return version;
+  }
+  const direct = input.version;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  return void 0;
+}
+var execFileAsync2 = promisify2(execFile2);
+var opencodeVersionProbe;
+function detectOpencodeVersion(execPath = process.execPath) {
+  if (opencodeVersionProbe) return opencodeVersionProbe;
+  opencodeVersionProbe = (async () => {
+    if (!path6.basename(execPath).toLowerCase().includes("opencode")) {
+      log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
+      return void 0;
+    }
+    try {
+      const { stdout } = await execFileAsync2(execPath, ["--version"], { timeout: 5e3 });
+      const match = /\d+\.\d+\.\d+\S*/.exec(stdout.trim());
+      return match ? match[0] : void 0;
+    } catch (err) {
+      log.debug("opencode version probe failed", {
+        execPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return void 0;
+    }
+  })();
+  return opencodeVersionProbe;
+}
+function describeSpawnCwd(configured, live = process.cwd(), captured = getOpencodeProjectDirectory()) {
+  if (typeof configured === "string" && configured.length > 0) {
+    return { resolved: configured, source: "configured" };
+  }
+  if (isUsableDirectory(live)) return { resolved: live, source: "process" };
+  if (isUsableDirectory(captured)) return { resolved: captured, source: "captured" };
+  return { resolved: live, source: "unresolved" };
+}
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function firstOption(providers, key) {
+  for (const entry of Object.values(providers)) {
+    const value = entry?.options?.[key];
+    if (value !== void 0) return value;
+  }
+  return void 0;
+}
+function collectStartupDiagnostics(providers, opencodeVersion) {
+  const accounts = [];
+  for (const entry of Object.values(providers)) {
+    const account = entry?.options?.account;
+    if (typeof account === "string" && account.length > 0) accounts.push(account);
+  }
+  const cwd = describeSpawnCwd(firstOption(providers, "cwd"));
+  let mcpServers = [];
+  try {
+    mcpServers = mergeOpencodeMcp(cwd.resolved).enabledServerNames;
+  } catch (err) {
+    log.debug("startup diagnostics could not read MCP config", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return {
+    plugin: pluginVersion(),
+    opencode: opencodeVersion ?? process.env.OPENCODE_VERSION ?? "unknown",
+    claudeCliPath: String(firstOption(providers, "cliPath") ?? "claude"),
+    cwd,
+    providers: Object.keys(providers),
+    accounts,
+    proxyTools: stringList(firstOption(providers, "proxyTools")),
+    mcpServers,
+    interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
+    anthropicApiKeyInEnv: Boolean(
+      process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
+    )
+  };
+}
+var logged = false;
+function logStartupDiagnostics(providers, opencodeVersion) {
+  if (logged) return;
+  logged = true;
+  void (async () => {
+    try {
+      const version = opencodeVersion ?? process.env.OPENCODE_VERSION ?? await detectOpencodeVersion();
+      const { claudeCliPath, ...rest } = collectStartupDiagnostics(providers, version);
+      const cli = await detectCliVersion(claudeCliPath);
+      const diagnostics = {
+        ...rest,
+        claudeCli: { path: claudeCliPath, version: cli?.raw ?? "not detected" }
+      };
+      log.notice("claude-code plugin ready", { ...diagnostics });
+    } catch (err) {
+      log.debug("startup diagnostics failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  })();
+}
+
 // src/index.ts
 function pickOpencodeDirectory(input) {
   if (!input || typeof input !== "object") return void 0;
@@ -5690,6 +5835,13 @@ async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefault
     // opencode's config-path loader parses (and merges user variants).
   };
 }
+function claudeCodeProviders(providers) {
+  const out = {};
+  for (const [id, entry] of Object.entries(providers ?? {})) {
+    if (id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)) out[id] = entry;
+  }
+  return out;
+}
 async function expandAccountProviders(config) {
   const seed = config.provider?.[PROVIDER_ID2];
   const accounts = resolveAccounts(seed?.options?.accounts);
@@ -5735,6 +5887,7 @@ async function expandAccountProviders(config) {
 }
 var server = async (input) => {
   cleanupStaleUnscopedInstall();
+  const opencodeVersion = pickOpencodeVersion(input);
   if (input && typeof input === "object" && "client" in input) {
     setOpencodeClient(input.client);
   }
@@ -5744,12 +5897,10 @@ var server = async (input) => {
       config.provider ??= {};
       const expanded = await expandAccountProviders(config);
       if (expanded) {
-        const registered2 = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({
-          id,
-          name: p?.name ?? id,
-          cwd: p?.options?.cwd
-        }));
-        log.notice("registered claude-code providers", { providers: registered2 });
+        logStartupDiagnostics(
+          claudeCodeProviders(config.provider),
+          opencodeVersion
+        );
         return;
       }
       const existing = config.provider[PROVIDER_ID2];
@@ -5761,11 +5912,10 @@ var server = async (input) => {
           PROVIDER_ID2
         )
       };
-      log.notice("registered claude-code provider", {
-        id: PROVIDER_ID2,
-        name: config.provider[PROVIDER_ID2]?.name ?? PROVIDER_ID2,
-        cwd: config.provider[PROVIDER_ID2]?.options?.cwd
-      });
+      logStartupDiagnostics(
+        claudeCodeProviders(config.provider),
+        opencodeVersion
+      );
     },
     // No `event` hook: MCP config drift is detected at turn start by the
     // hot-reload check in `claude-code-language-model.ts`, which respawns
@@ -5810,6 +5960,7 @@ var index_default = {
 export {
   ClaudeCodeLanguageModel,
   bridgeOpencodeMcp,
+  claudeCodeProviders,
   configModelsForProvider,
   createClaudeCode,
   index_default as default,