fix: resolve Claude Code executable outside asar for Electron

In packaged Electron, the SDK's bundled cli.js lives inside app.asar.
child_process.spawn('node', ['...app.asar/.../cli.js']) fails with
exit code 1 because the child node process has no asar support.

Three-part fix:
1. electron-builder.yml: asarUnpack claude-agent-sdk so cli.js is on disk
2. provider.ts: resolveClaudeCodePath() finds unpacked cli.js or global
   claude binary, passes pathToClaudeCodeExecutable to SDK options
3. electron/main.ts: fixElectronPath() resolves user's full shell PATH
   (fixes 'spawn node ENOENT' in Electron launched from Dock/Finder)

Also adds stderr capture from SDK for better error diagnostics.

Author: acedatacloud-dev

electron-builder.yml

@@ -11,6 +11,11 @@ files:
   - node_modules/**
   - package.json
 
+# The claude-agent-sdk spawns cli.js via child_process.spawn().
+# child processes can't read files inside asar, so unpack it.
+asarUnpack:
+  - node_modules/@anthropic-ai/claude-agent-sdk/**
+
 # Do NOT include the CLI dist/ or src/ in the Electron app
 extraFiles: []
 

electron/main.ts

@@ -17,6 +17,7 @@ import {
   Notification,
   shell
 } from 'electron';
+import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -136,6 +137,44 @@ function pushRecentMessage(entry: {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Fix PATH for macOS/Linux — Electron GUI apps inherit a minimal PATH that
+// doesn't include user-installed node (nvm, volta, homebrew, fnm, etc.).
+// We resolve the real PATH from the user's login shell before anything runs.
+// ---------------------------------------------------------------------------
+
+function fixElectronPath(): void {
+  if (process.platform !== 'darwin' && process.platform !== 'linux') return;
+
+  try {
+    const shell = process.env.SHELL || '/bin/zsh';
+    const result = execFileSync(shell, ['-ilc', 'echo -n "$PATH"'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+    if (result) {
+      process.env.PATH = result;
+      logger.info('Resolved shell PATH for Electron', { pathLength: result.length });
+    }
+  } catch {
+    // Fallback: prepend common node binary directories
+    const home = homedir();
+    const fallbackPaths = [
+      '/opt/homebrew/bin',
+      '/usr/local/bin',
+      `${home}/.volta/bin`,
+      `${home}/.fnm/aliases/default/bin`
+    ].filter((p) => existsSync(p));
+    if (fallbackPaths.length) {
+      process.env.PATH = [...fallbackPaths, process.env.PATH].join(':');
+      logger.info('Applied fallback PATH entries', { added: fallbackPaths });
+    }
+  }
+}
+
+fixElectronPath();
+
 // ---------------------------------------------------------------------------
 // Single instance lock
 // ---------------------------------------------------------------------------

src/claude/provider.ts

@@ -6,9 +6,69 @@ import {
   type SDKUserMessage,
   type Options,
   type CanUseTool,
-  type PermissionResult,
-} from "@anthropic-ai/claude-agent-sdk";
-import { logger } from "../logger.js";
+  type PermissionResult
+} from '@anthropic-ai/claude-agent-sdk';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger } from '../logger.js';
+
+// ---------------------------------------------------------------------------
+// Resolve Claude Code executable for packaged Electron
+// ---------------------------------------------------------------------------
+
+/**
+ * In a packaged Electron app the SDK's bundled cli.js lives inside the asar
+ * archive. child_process.spawn() can't read from asar, so the spawned node
+ * process fails with exit code 1.
+ *
+ * Resolution order:
+ * 1. asar-unpacked cli.js (electron-builder asarUnpack extracts it)
+ * 2. Globally installed `claude` native binary (searched via PATH)
+ * 3. undefined → let the SDK use its default (works in CLI / dev mode)
+ */
+function resolveClaudeCodePath(): string | undefined {
+  const isPackagedElectron =
+    !!process.versions?.electron && !(process as unknown as { defaultApp?: boolean }).defaultApp;
+  if (!isPackagedElectron) return undefined;
+
+  // 1. Try asar-unpacked cli.js
+  const resourcesPath = (process as unknown as { resourcesPath?: string }).resourcesPath;
+  if (resourcesPath) {
+    const unpackedCli = join(
+      resourcesPath,
+      'app.asar.unpacked',
+      'node_modules',
+      '@anthropic-ai',
+      'claude-agent-sdk',
+      'cli.js'
+    );
+    if (existsSync(unpackedCli)) {
+      logger.info('Using asar-unpacked cli.js for Claude SDK', {
+        path: unpackedCli
+      });
+      return unpackedCli;
+    }
+  }
+
+  // 2. Try globally installed claude binary from PATH
+  const pathDirs = (process.env.PATH || '').split(':');
+  for (const dir of pathDirs) {
+    const candidate = join(dir, 'claude');
+    try {
+      if (existsSync(candidate)) {
+        logger.info('Using global claude binary for SDK', {
+          path: candidate
+        });
+        return candidate;
+      }
+    } catch {
+      // permission error on dir — skip
+    }
+  }
+
+  logger.warn('Packaged Electron: could not resolve Claude Code executable outside asar');
+  return undefined;
+}
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -19,15 +79,12 @@ export interface QueryOptions {
   cwd: string;
   resume?: string;
   model?: string;
-  permissionMode?: "default" | "acceptEdits" | "plan" | "bypassPermissions";
+  permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'bypassPermissions';
   images?: Array<{
-    type: "image";
-    source: { type: "base64"; media_type: string; data: string };
+    type: 'image';
+    source: { type: 'base64'; media_type: string; data: string };
   }>;
-  onPermissionRequest?: (
-    toolName: string,
-    toolInput: string,
-  ) => Promise<boolean>;
+  onPermissionRequest?: (toolName: string, toolInput: string) => Promise<boolean>;
 }
 
 export interface QueryResult {
@@ -45,18 +102,18 @@ export interface QueryResult {
  */
 function extractText(msg: SDKAssistantMessage): string {
   const content = msg.message?.content;
-  if (!Array.isArray(content)) return "";
+  if (!Array.isArray(content)) return '';
   return content
-    .filter((block: any) => block.type === "text")
-    .map((block: any) => (block.text as string) ?? "")
-    .join("");
+    .filter((block: any) => block.type === 'text')
+    .map((block: any) => (block.text as string) ?? '')
+    .join('');
 }
 
 /**
  * Extract session_id from any SDKMessage that carries one.
  */
 function getSessionId(msg: SDKMessage): string | undefined {
-  if ("session_id" in msg) {
+  if ('session_id' in msg) {
     return (msg as { session_id: string }).session_id;
   }
   return undefined;
@@ -69,28 +126,28 @@ function getSessionId(msg: SDKMessage): string | undefined {
  */
 async function* singleUserMessage(
   text: string,
-  images?: QueryOptions["images"],
+  images?: QueryOptions['images']
 ): AsyncGenerator<SDKUserMessage, void, unknown> {
   const contentBlocks: Array<{
     type: string;
     text?: string;
-    source?: { type: "base64"; media_type: string; data: string };
-  }> = [{ type: "text", text }];
+    source?: { type: 'base64'; media_type: string; data: string };
+  }> = [{ type: 'text', text }];
 
   if (images?.length) {
     for (const img of images) {
-      contentBlocks.push({ type: "image", source: img.source });
+      contentBlocks.push({ type: 'image', source: img.source });
     }
   }
 
   const msg: SDKUserMessage = {
-    type: "user",
-    session_id: "",
+    type: 'user',
+    session_id: '',
     parent_tool_use_id: null,
     message: {
-      role: "user",
-      content: contentBlocks,
-    },
+      role: 'user',
+      content: contentBlocks
+    }
   };
 
   yield msg;
@@ -101,22 +158,14 @@ async function* singleUserMessage(
 // ---------------------------------------------------------------------------
 
 export async function claudeQuery(options: QueryOptions): Promise<QueryResult> {
-  const {
-    prompt,
-    cwd,
-    resume,
-    model,
-    permissionMode,
-    images,
-    onPermissionRequest,
-  } = options;
+  const { prompt, cwd, resume, model, permissionMode, images, onPermissionRequest } = options;
 
-  logger.info("Starting Claude query", {
+  logger.info('Starting Claude query', {
     cwd,
     model,
     permissionMode,
     resume: !!resume,
-    hasImages: !!images?.length,
+    hasImages: !!images?.length
   });
 
   // When images are present we use the multi-content AsyncIterable path;
@@ -130,45 +179,53 @@ export async function claudeQuery(options: QueryOptions): Promise<QueryResult> {
   const sdkOptions: Options = {
     cwd,
     permissionMode,
-    allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
-    settingSources: ["user", "project"],
+    allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions',
+    settingSources: ['user', 'project'],
+    stderr: (msg: string) => logger.debug('Claude SDK stderr', { msg })
   };
 
+  // In packaged Electron the SDK's bundled cli.js is inside asar and
+  // can't be spawned by a child node process. Resolve an alternative.
+  const claudeCodePath = resolveClaudeCodePath();
+  if (claudeCodePath) {
+    sdkOptions.pathToClaudeCodeExecutable = claudeCodePath;
+  }
+
   if (model) sdkOptions.model = model;
   if (resume) sdkOptions.resume = resume;
 
   // Permission callback — bridges the SDK's CanUseTool to our simpler handler.
   if (onPermissionRequest) {
     const canUseTool: CanUseTool = async (
       toolName: string,
-      input: Record<string, unknown>,
+      input: Record<string, unknown>
     ): Promise<PermissionResult> => {
       const inputStr = JSON.stringify(input);
-      logger.info("Permission request from SDK", { toolName });
+      logger.info('Permission request from SDK', { toolName });
       try {
         const allowed = await onPermissionRequest(toolName, inputStr);
         if (allowed) {
-          return { behavior: "allow", updatedInput: input };
+          return { behavior: 'allow', updatedInput: input };
         }
         return {
-          behavior: "deny",
-          message: "Permission denied by user.",
-          interrupt: true,
+          behavior: 'deny',
+          message: 'Permission denied by user.',
+          interrupt: true
         };
       } catch (err) {
-        logger.error("Permission handler error", { toolName, err });
+        logger.error('Permission handler error', { toolName, err });
         return {
-          behavior: "deny",
-          message: "Permission check failed.",
-          interrupt: true,
+          behavior: 'deny',
+          message: 'Permission check failed.',
+          interrupt: true
         };
       }
     };
     sdkOptions.canUseTool = canUseTool;
   }
 
   // --- Execute query & accumulate output ---
-  let sessionId = "";
+  let sessionId = '';
   const textParts: string[] = [];
   let errorMessage: string | undefined;
 
@@ -180,31 +237,31 @@ export async function claudeQuery(options: QueryOptions): Promise<QueryResult> {
       if (sid) sessionId = sid;
 
       switch (message.type) {
-        case "assistant": {
+        case 'assistant': {
           const text = extractText(message as SDKAssistantMessage);
           if (text) textParts.push(text);
           break;
         }
-        case "result": {
+        case 'result': {
           const rm = message as SDKResultMessage;
-          if (rm.subtype === "success" && "result" in rm) {
+          if (rm.subtype === 'success' && 'result' in rm) {
             // The SDK result message carries the final result string.
             // Append only when it adds content not yet seen.
             if (rm.result) {
-              const combined = textParts.join("");
+              const combined = textParts.join('');
               if (!combined.includes(rm.result)) {
                 textParts.push(rm.result);
               }
             }
-          } else if ("errors" in rm && rm.errors.length > 0) {
-            errorMessage = rm.errors.join("; ");
-            logger.error("SDK returned error result", { errors: rm.errors });
+          } else if ('errors' in rm && rm.errors.length > 0) {
+            errorMessage = rm.errors.join('; ');
+            logger.error('SDK returned error result', { errors: rm.errors });
           }
           break;
         }
-        case "system": {
-          logger.debug("SDK system message", {
-            subtype: (message as { subtype?: string }).subtype,
+        case 'system': {
+          logger.debug('SDK system message', {
+            subtype: (message as { subtype?: string }).subtype
           });
           break;
         }
@@ -215,24 +272,24 @@ export async function claudeQuery(options: QueryOptions): Promise<QueryResult> {
     }
   } catch (err: unknown) {
     errorMessage = err instanceof Error ? err.message : String(err);
-    logger.error("Claude query threw", { error: errorMessage });
+    logger.error('Claude query threw', { error: errorMessage });
   }
 
-  const fullText = textParts.join("\n").trim();
+  const fullText = textParts.join('\n').trim();
 
   if (!fullText && !errorMessage) {
-    errorMessage = "Claude returned an empty response.";
+    errorMessage = 'Claude returned an empty response.';
   }
 
-  logger.info("Claude query completed", {
+  logger.info('Claude query completed', {
     sessionId,
     textLength: fullText.length,
-    hasError: !!errorMessage,
+    hasError: !!errorMessage
   });
 
   return {
     text: fullText,
     sessionId,
-    error: errorMessage,
+    error: errorMessage
   };
 }