@meetopenbot/claude-code 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,3 +1,7 @@
+// runtime.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2, readlinkSync as readlinkSync2, statSync as statSync2 } from "node:fs";
+
 // node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as $S } from "node:module";
 import { execFile as E6$ } from "child_process";
@@ -19425,6 +19429,131 @@ var buildApiKeyWidget = (agentId, threadId, reason) => uiWidget({
 var toolCallWidgetId = (toolUseId) => `claude_code_tool_${toolUseId}`;
 var truncate = (s2, max) => s2.length > max ? `${s2.slice(0, max)}
 \u2026` : s2;
+var MAX_STDERR_CHARS = 4e3;
+var MAX_ERROR_CHARS = 12e3;
+var asSystemError = (value) => value && typeof value === "object" ? value : void 0;
+var spawnFailureHint = (code, executablePath) => {
+  switch (code) {
+    case "EACCES":
+      return executablePath ? `Permission denied executing "${executablePath}". Check chmod +x and macOS quarantine (xattr -d com.apple.quarantine "${executablePath}").` : "Permission denied executing the Claude Code binary.";
+    case "EPERM":
+      return "Operation not permitted when launching Claude Code. Common under sandboxed runtimes or restricted security policies.";
+    case "ENOENT":
+      return executablePath ? `No such file at "${executablePath}", or a required runtime/interpreter is missing.` : "Claude Code executable or required runtime not found.";
+    case "ENOTDIR":
+    case "ELOOP":
+      return "Invalid executable path \u2014 a path component is not a directory or is a symlink loop.";
+    default:
+      return void 0;
+  }
+};
+var describePathAccess = (label, path) => {
+  try {
+    if (!existsSync2(path)) return `${label}: missing (${path})`;
+    const st = statSync2(path);
+    const lines = [
+      `${label}: ${path}`,
+      `exists: yes`,
+      `type: ${st.isDirectory() ? "directory" : st.isFile() ? "file" : "other"}`
+    ];
+    if (st.isFile()) {
+      lines.push(`size: ${st.size} bytes`);
+      lines.push(`mode: ${(st.mode & 511).toString(8)}`);
+      lines.push(`executable bit: ${(st.mode & 73) !== 0 ? "yes" : "no"}`);
+    }
+    try {
+      const target = readlinkSync2(path);
+      lines.push(`symlink target: ${target}`);
+      lines.push(`target exists: ${existsSync2(target) ? "yes" : "no"}`);
+    } catch {
+    }
+    return lines.join("\n");
+  } catch (inspectError) {
+    return `${label}: could not inspect (${path}): ${inspectError instanceof Error ? inspectError.message : String(inspectError)}`;
+  }
+};
+var launchFailureHintsFromInspection = (executableDetails, workingDirDetails, executablePath) => {
+  const hints = [];
+  if (workingDirDetails?.includes("missing")) {
+    hints.push("Working directory does not exist. Create it or remove the cwd override from config.");
+  }
+  if (executableDetails?.includes("executable bit: no")) {
+    const hint = spawnFailureHint("EACCES", executablePath);
+    if (hint) hints.push(hint);
+  }
+  if (executableDetails?.includes("target exists: no")) {
+    hints.push("Executable symlink target is missing. Reinstall Claude Code or point executablePath at a valid binary.");
+  }
+  if (executableDetails?.includes("missing")) {
+    const hint = spawnFailureHint("ENOENT", executablePath);
+    if (hint) hints.push(hint);
+  }
+  if (hints.length === 0) {
+    hints.push(
+      "The Claude Code process could not be started. Verify executablePath, working directory permissions, and that OpenBot can spawn child processes in this environment."
+    );
+  }
+  return hints;
+};
+var formatClaudeCodeError = (error, context, stderrChunks) => {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const parts = [err.message];
+  const causeLines = [];
+  let current = err.cause;
+  while (current) {
+    if (current instanceof Error) {
+      causeLines.push(current.message);
+      const sys2 = asSystemError(current);
+      if (sys2?.code) causeLines.push(`  code: ${sys2.code}`);
+      if (sys2?.errno !== void 0) causeLines.push(`  errno: ${sys2.errno}`);
+      if (sys2?.syscall) causeLines.push(`  syscall: ${sys2.syscall}`);
+      if (sys2?.path) causeLines.push(`  path: ${sys2.path}`);
+      current = current.cause;
+    } else {
+      causeLines.push(String(current));
+      break;
+    }
+  }
+  if (causeLines.length > 0) parts.push(`Cause:
+${causeLines.join("\n")}`);
+  const sys = asSystemError(err.cause) ?? asSystemError(err);
+  const hint = spawnFailureHint(sys?.code, context.executablePath);
+  if (hint) parts.push(hint);
+  const isLaunchFailure = err.message.includes("failed to launch") || err.message.includes("not found") || err.message.includes("Failed to spawn") || err.message.includes("exited with code") || err.message.includes("terminated by signal");
+  if (isLaunchFailure) {
+    const executableDetails = context.executablePath ? describePathAccess("Executable", context.executablePath) : "Executable: using SDK bundled binary (no executablePath override).";
+    const workingDirDetails = context.workingDir ? describePathAccess("Working directory", context.workingDir) : void 0;
+    parts.push(`Launch diagnostics:
+${executableDetails}`);
+    if (workingDirDetails) parts.push(workingDirDetails);
+    if (err.message.includes("failed to launch")) {
+      for (const launchHint of launchFailureHintsFromInspection(
+        executableDetails,
+        workingDirDetails,
+        context.executablePath
+      )) {
+        parts.push(launchHint);
+      }
+    }
+  }
+  const stderr = stderrChunks.join("").trim();
+  if (stderr) parts.push(`Process stderr:
+${truncate(stderr, MAX_STDERR_CHARS)}`);
+  return truncate(parts.join("\n\n"), MAX_ERROR_CHARS);
+};
+var formatResultError = (message) => {
+  if (message.type !== "result" || message.subtype === "success") return "";
+  const record = asRecord(message);
+  const parts = [`subtype: ${message.subtype}`];
+  const result = record.result;
+  if (typeof result === "string" && result) parts.push(`result: ${result}`);
+  const errors = record.errors;
+  if (Array.isArray(errors) && errors.length > 0) {
+    parts.push(`errors:
+${errors.map((entry) => `- ${String(entry)}`).join("\n")}`);
+  }
+  return parts.join("\n");
+};
 var formatJsonForWidget = (value, maxLen) => {
   try {
     return truncate(JSON.stringify(value, null, 2), maxLen);
@@ -19432,6 +19561,15 @@ var formatJsonForWidget = (value, maxLen) => {
     return truncate(String(value), maxLen);
   }
 };
+var formatToolInputBody = (input, maxLen = 8e3) => `Input:
+${formatJsonForWidget(input, maxLen)}`;
+var formatToolResultBody = (input, output) => {
+  const inputSection = formatJsonForWidget(input, 4e3);
+  const parts = [`Input:
+${inputSection}`, `Output:
+${output}`];
+  return parts.join("\n\n");
+};
 var formatToolResultPayload = (content, isError) => {
   let body;
   if (typeof content === "string") {
@@ -19481,15 +19619,28 @@ var parseToolResultBlock = (block) => {
   }
   return null;
 };
+var findClaudeExecutable = () => {
+  try {
+    const command = process.platform === "win32" ? "where claude" : "which claude";
+    const path = execSync(command, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (path && existsSync2(path)) {
+      return path;
+    }
+  } catch {
+  }
+  return void 0;
+};
 var claudeCodeRuntime = (options = {}) => (builder) => {
   const {
     model = "sonnet",
     system,
     permissionMode = "default",
     cwd,
+    executablePath: executablePathOverride,
     allowedTools,
     storage
   } = options;
+  const executablePath = executablePathOverride || findClaudeExecutable();
   builder.on("agent:invoke", async function* (event, context) {
     if (!shouldHandleInvoke(event, context.state.agentId)) {
       return;
@@ -19499,12 +19650,21 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
     const threadId = event.meta?.threadId || context.state.threadId;
     const resumeId = readPersistedSessionId(context.state);
     const workingDir = cwd ?? context.state.channelDetails?.cwd;
+    const stderrChunks = [];
+    const launchContext = {
+      executablePath,
+      workingDir
+    };
     const sdkOptions = {
       model,
       permissionMode,
+      stderr: (data) => {
+        stderrChunks.push(data);
+      },
       ...system ? { systemPrompt: { type: "preset", preset: "claude_code", append: system } } : {},
       ...resumeId ? { resume: resumeId } : {},
       ...workingDir ? { cwd: workingDir } : {},
+      ...executablePath ? { pathToClaudeCodeExecutable: executablePath } : {},
       ...allowedTools ? { allowedTools } : {}
     };
     try {
@@ -19550,8 +19710,8 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
                       kind: "message",
                       widgetId: toolCallWidgetId(tool.toolUseId),
                       title: toolTitleByUseId.get(tool.toolUseId)?.title ?? "",
-                      description: JSON.stringify(toolTitleByUseId.get(tool.toolUseId)?.input ?? {}),
-                      body: formatJsonForWidget(tool.input, 8e3),
+                      description: "",
+                      body: formatToolInputBody(tool.input),
                       display: "collapsed",
                       metadata: {
                         type: "claude_tool",
@@ -19597,8 +19757,11 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
                   kind: "message",
                   widgetId: toolCallWidgetId(res.toolUseId),
                   title: toolTitleByUseId.get(res.toolUseId)?.title ?? "",
-                  description: JSON.stringify(toolTitleByUseId.get(res.toolUseId)?.input ?? {}),
-                  body,
+                  description: "",
+                  body: formatToolResultBody(
+                    toolTitleByUseId.get(res.toolUseId)?.input,
+                    body
+                  ),
                   display: "collapsed",
                   ...state ? { state } : {},
                   metadata: {
@@ -19620,10 +19783,12 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
             yield buildApiKeyWidget(context.state.agentId, threadId, subtype);
             return;
           }
+          const details = formatResultError(message);
           yield agentOutput({
             agentId: context.state.agentId,
             threadId,
-            content: `[claude-code] run ended with error: ${subtype}`
+            content: details ? `[claude-code] run ended with error:
+${details}` : `[claude-code] run ended with error: ${subtype}`
           });
         }
       }
@@ -19631,7 +19796,7 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
         await persistSessionId(context.state, storage, lastSessionId);
       }
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorMessage = formatClaudeCodeError(error, launchContext, stderrChunks);
       if (isAuthErrorMessage(errorMessage)) {
         yield buildApiKeyWidget(context.state.agentId, threadId, errorMessage);
         return;
@@ -19639,7 +19804,8 @@ var claudeCodeRuntime = (options = {}) => (builder) => {
       yield agentOutput({
         agentId: context.state.agentId,
         threadId,
-        content: `[claude-code] error: ${errorMessage}`
+        content: `[claude-code] error:
+${errorMessage}`
       });
     }
   });
@@ -19708,17 +19874,23 @@ var claudeCodePlugin = {
       permissionMode: {
         type: "string",
         description: "How the SDK handles tool permission prompts: default | acceptEdits | bypassPermissions | plan | dontAsk | auto.",
-        default: "default",
+        default: "bypassPermissions",
         enum: ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]
+      },
+      executablePath: {
+        type: "string",
+        description: "Path to the Claude Code CLI executable. When unset, the plugin attempts to find it in your PATH, falling back to the SDK bundled binary."
       }
     }
   },
   factory: ({ agentDetails, config, storage }) => {
     const model = typeof config.model === "string" && config.model ? config.model : "sonnet";
-    const permissionMode = typeof config.permissionMode === "string" && config.permissionMode ? config.permissionMode : "default";
+    const permissionMode = typeof config.permissionMode === "string" && config.permissionMode ? config.permissionMode : "bypassPermissions";
+    const executablePath = typeof config.executablePath === "string" && config.executablePath ? config.executablePath : void 0;
     return claudeCodeRuntime({
       model,
       permissionMode,
+      executablePath,
       system: agentDetails.instructions || CLAUDE_CODE_SYSTEM_PROMPT,
       storage
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/claude-code",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "Claude Code plugin for OpenBot",
   "main": "./dist/index.js",