daemon: fix spawn ENOTDIR for bundled claude in packaged app

In the packaged .app the SDK resolves its `claude` SEA binary via
createRequire relative to sdk.mjs — which lives INSIDE app.asar. The
resolved path runs THROUGH app.asar (a file), so child_process.spawn
of it throws `spawn ENOTDIR`. electron-builder asarUnpacks the binary
to Resources/app.asar.unpacked/, but the SDK doesn't know to look
there. Surfaced now because this was the first packaged build to
exercise sendPrompt → spawn end-to-end (dev has no asar; node-datachannel
dodges it because .node dlopen goes through Electron's patched fs).

Fix keeps packaging knowledge in the Electron layer where it belongs:
the menubar computes the asar.unpacked binary path (it owns the
asarUnpack glob + knows app.isPackaged) and passes it via
DaemonOptions.claudeExecutablePath → RouterDeps → SessionLoopOptions →
pathToClaudeCodeExecutable. The daemon stays electron-agnostic and just
forwards it; dev/tests pass undefined → the SDK resolves its platform
package itself (no asar, real path).

Needs a menubar .dmg re-release (daemon code, not OTA).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: yyq1025

packages/daemon/src/index.ts

@@ -35,6 +35,16 @@ export interface DaemonOptions {
   /** Override signaling host (for `wrangler dev`). */
   signalingHost?: string;
   signalingScheme?: "ws" | "wss";
+  /**
+   * Absolute path to the bundled `claude` SEA binary to spawn. The Electron
+   * host (menubar) computes this because it owns packaging: in the packaged
+   * .app the binary is `asarUnpack`'d to a fixed `Resources/app.asar.unpacked/`
+   * location, and the SDK's own resolution would otherwise point INSIDE
+   * `app.asar` (a file) → `spawn ENOTDIR`. Omit in dev: the SDK resolves its
+   * platform package from node_modules itself (no asar). The daemon stays
+   * electron-agnostic and just forwards this into every claude spawn.
+   */
+  claudeExecutablePath?: string;
 }
 
 export type {
@@ -205,7 +215,11 @@ export async function start(options: DaemonOptions = {}): Promise<Daemon> {
         // gets it via env. A creds failure surfaces as turn_failed (forwarded
         // to claude.ai by the bridge mirror) rather than a silent drop.
         const oauthToken = await oauth.ensureFresh();
-        ensureSessionLoop(runtime, { mode: "resume", oauthToken });
+        ensureSessionLoop(runtime, {
+          mode: "resume",
+          oauthToken,
+          claudeExecutablePath: options.claudeExecutablePath,
+        });
         pushPrompt(runtime, prompt.text, prompt.images, prompt.uuid);
       } catch (err) {
         runtime.addEvent({
@@ -344,6 +358,8 @@ export async function start(options: DaemonOptions = {}): Promise<Daemon> {
     // Per-spawn OAuth token for the bundled binary — same shared keychain
     // manager the CCR bridge uses (one keeper per process).
     ensureFreshToken: () => oauth.ensureFresh(),
+    // Host-computed binary path (packaged app) — forwarded into every spawn.
+    claudeExecutablePath: options.claudeExecutablePath,
     gitWatchers,
     epoch,
   });

packages/daemon/src/router.ts

@@ -116,6 +116,13 @@ export interface RouterDeps {
    * (`queryFactory` set), which spawns no real binary.
    */
   ensureFreshToken?: () => Promise<string>;
+  /**
+   * Absolute path to the bundled `claude` binary to spawn, computed by the
+   * Electron host (see SessionLoopOptions.claudeExecutablePath — needed so the
+   * spawn survives asar packaging). Forwarded verbatim into each spawn.
+   * Undefined in dev / tests → the SDK resolves its platform package itself.
+   */
+  claudeExecutablePath?: string;
   /**
    * Per-daemon registry of `GitWatcher`s keyed by `cwd`. Shared across
    * connections so two iOS clients on the same project re-use one watch
@@ -785,6 +792,7 @@ export function createCommandHandler(deps: RouterDeps): CommandHandler {
             cwd: cmd.cwd,
             model: cmd.model,
             oauthToken,
+            claudeExecutablePath: deps.claudeExecutablePath,
             queryFactory: deps.queryFactory,
           });
           // pushPrompt emits turn_started synchronously before the SDK

packages/daemon/src/runtime/run-query.ts

@@ -204,6 +204,17 @@ export interface SessionLoopOptions {
    * (`queryFactory` set), which never spawns a real binary.
    */
   oauthToken?: string;
+  /**
+   * Absolute path to the bundled `claude` SEA binary to spawn
+   * (`pathToClaudeCodeExecutable`). Computed by the Electron layer (menubar),
+   * which owns packaging: inside the packaged .app the binary is `asarUnpack`'d
+   * to a fixed `Resources/app.asar.unpacked/...` location, and the SDK's own
+   * resolution would otherwise point INSIDE `app.asar` (a file) and spawn with
+   * `ENOTDIR`. Undefined in dev / tests → the SDK resolves its platform package
+   * from node_modules itself (no asar, so that path is real). The daemon stays
+   * electron-agnostic: it just forwards whatever the host computed.
+   */
+  claudeExecutablePath?: string;
   /** Test seam: override the SDK's `query()` factory. */
   queryFactory?: typeof query;
 }
@@ -254,6 +265,13 @@ export function ensureSessionLoop(
       : undefined;
   const envOption = spawnEnv ? { env: spawnEnv } : {};
 
+  // Spawn the host-supplied binary path when present (packaged app, where the
+  // SDK's own resolution would hit `app.asar` → ENOTDIR). Absent in dev/tests,
+  // where the SDK resolves its platform package itself. See SessionLoopOptions.
+  const execOption = options.claudeExecutablePath
+    ? { pathToClaudeCodeExecutable: options.claudeExecutablePath }
+    : {};
+
   const channel = createAsyncMessageInput<SDKUserMessage>();
   runtime.inputChannel = channel;
 
@@ -298,6 +316,7 @@ export function ensureSessionLoop(
           includePartialMessages: true as const,
           cwd: options.cwd,
           ...envOption,
+          ...execOption,
         }
       : {
           ...bypassFlags,
@@ -307,6 +326,7 @@ export function ensureSessionLoop(
           includePartialMessages: true as const,
           cwd: options.cwd,
           ...envOption,
+          ...execOption,
         };
   const q: Query = factory({
     prompt: channel.iterable,

packages/menubar/electron/main.ts

@@ -29,6 +29,28 @@ let isQuitting = false;
 let daemon: Daemon | null = null;
 let keepAwakeId: number | null = null;
 
+// Absolute path to the SDK's bundled `claude` SEA binary, handed to the daemon
+// so its spawn survives asar packaging. This lives HERE (the Electron layer)
+// because packaging is our concern, not the daemon's: electron-builder.cjs
+// `asarUnpack`s the SDK platform package to `Resources/app.asar.unpacked/...`,
+// a fixed location we can name directly. If we let the SDK resolve the binary
+// itself, it would point INSIDE `app.asar` (sdk.mjs lives there) — and since
+// app.asar is a file, `child_process.spawn` of a path through it throws
+// `spawn ENOTDIR`. Dev (unpackaged) returns undefined → the SDK resolves its
+// platform package from node_modules itself (no asar, real path).
+//
+// Keep the `asarUnpack` glob in electron-builder.cjs and this layout in sync.
+function bundledClaudePath(): string | undefined {
+  if (!app.isPackaged) return undefined;
+  return path.join(
+    process.resourcesPath,
+    "app.asar.unpacked",
+    "node_modules",
+    `@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}`,
+    "claude",
+  );
+}
+
 // --- Plan usage (daemon-fetched, menu-cached) ---
 //
 // Last fetch result, rendered by buildMenu. macOS doesn't repaint an open
@@ -323,7 +345,7 @@ app.whenReady().then(async () => {
   );
 
   console.log("[main] starting daemon...");
-  daemon = await startDaemon();
+  daemon = await startDaemon({ claudeExecutablePath: bundledClaudePath() });
   console.log(
     `[main] daemon ready (fingerprint ${daemon.fingerprint}, ${daemon.pairedClientCount()} paired clients)`,
   );