@seawork/server 1.0.4 → 1.0.10-rc.4

package/dist/server/server/agent/providers/claude-agent.js

@@ -1,21 +1,20 @@
 import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
-import fs from "node:fs";
-import { promises } from "node:fs";
+import fs, { promises } from "node:fs";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
-import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { spawnProcess } from "../../../utils/spawn.js";
+import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
+import { applyProviderEnv } from "../provider-launch-config.js";
 import { getClaudeModels, normalizeClaudeRuntimeModelId } from "./claude/claude-models.js";
 import { parsePartialJsonObject } from "./claude/partial-json.js";
 import { ClaudeSidechainTracker } from "./claude/sidechain-tracker.js";
+import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
+import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
-import { applyProviderEnv } from "../provider-launch-config.js";
-import { findExecutable } from "../../../utils/executable.js";
-import { spawnProcess } from "../../../utils/spawn.js";
-import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
 const fsPromises = promises;
 const execFileAsync = promisify(execFile);
 const CLAUDE_SETTING_SOURCES = ["user", "project"];
@@ -60,6 +59,53 @@ const INTERRUPT_TOOL_USE_PLACEHOLDER = "[Request interrupted by user for tool us
 const INTERRUPT_PLACEHOLDER_PATTERN = /^\[Request interrupted by user(?:[^\]]*)\]$/;
 const NO_RESPONSE_REQUESTED_PLACEHOLDER = "No response requested.";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/**
+ * Resolve the Electron Helper binary path. The Helper has LSUIElement=true in
+ * its Info.plist, so spawning via it won't create macOS Dock icons.
+ */
+function resolveElectronHelperPath() {
+    if (process.platform !== "darwin" || !process.versions["electron"]) {
+        return null;
+    }
+    // process.execPath = .../Electron.app/Contents/MacOS/Electron (or Seawork)
+    // Helper lives at .../Electron.app/Contents/Frameworks/Electron Helper.app/Contents/MacOS/Electron Helper
+    const contentsDir = path.dirname(path.dirname(process.execPath));
+    const appName = path.basename(process.execPath);
+    const helperPath = path.join(contentsDir, "Frameworks", `${appName} Helper.app`, "Contents", "MacOS", `${appName} Helper`);
+    return fs.existsSync(helperPath) ? helperPath : null;
+}
+/**
+ * Resolve the absolute path to the Claude Agent SDK's `cli.js`. The SDK would
+ * otherwise derive this from `import.meta.url`, which inside a packaged
+ * Electron app resolves to a virtual `app.asar` path that child processes
+ * cannot read — `cli.js` physically lives in `app.asar.unpacked`. Passing the
+ * rewritten path via `pathToClaudeCodeExecutable` also makes the SDK's
+ * ENOENT error messages reference a real on-disk location instead of the
+ * misleading asar path.
+ */
+let cachedClaudeCliPath;
+export function resolveClaudeCliExecutable() {
+    if (cachedClaudeCliPath !== undefined) {
+        return cachedClaudeCliPath;
+    }
+    try {
+        const sdkRequire = createRequire(import.meta.url);
+        // The SDK's package.json doesn't expose "./package.json" via exports, so
+        // resolve the main entry (sdk.mjs) and derive the package root from it.
+        const mainPath = sdkRequire.resolve("@anthropic-ai/claude-agent-sdk");
+        let cliPath = path.join(path.dirname(mainPath), "cli.js");
+        const asarSeg = `app.asar${path.sep}`;
+        const unpackedSeg = `app.asar.unpacked${path.sep}`;
+        if (cliPath.includes(asarSeg) && !cliPath.includes(unpackedSeg)) {
+            cliPath = cliPath.replace(asarSeg, unpackedSeg);
+        }
+        cachedClaudeCliPath = fs.existsSync(cliPath) ? cliPath : null;
+    }
+    catch {
+        cachedClaudeCliPath = null;
+    }
+    return cachedClaudeCliPath;
+}
 function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
     const commandConfig = runtimeSettings?.command;
     if (!commandConfig || commandConfig.mode === "default") {
@@ -79,24 +125,94 @@ function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
         args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
     };
 }
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
+function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv, logger) {
     return {
         ...options,
         spawnClaudeCodeProcess: (spawnOptions) => {
             const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
-            // When the SDK passes a default JS runtime ("node"/"bun"), replace it with
-            // process.execPath — the actual node binary running the daemon. This avoids
-            // PATH lookup failures in the managed runtime bundle.
-            // When the SDK passes a native binary path (from pathToClaudeCodeExecutable)
-            // or the user overrides the command via runtime settings, use that directly.
             const isDefaultRuntime = resolved.command === "node" || resolved.command === "bun";
-            const command = isDefaultRuntime ? process.execPath : resolved.command;
+            // Prefer system node/bun. In packaged Electron apps where those are
+            // unavailable, fall back to the Electron Helper binary (which has
+            // LSUIElement=true in its Info.plist, so it won't create Dock icons).
+            let command;
+            const spawnEnv = {
+                ...applyProviderEnv(spawnOptions.env, runtimeSettings),
+                ...(launchEnv ?? {}),
+                // Skip OAuth/keychain auth check against api.anthropic.com so
+                // claude CLI authenticates purely via ANTHROPIC_API_KEY env var.
+                CLAUDE_CODE_SIMPLE: "1",
+                // Strip conflicting Anthropic/Bedrock/Vertex auth vars inherited from
+                // the user's shell. If these are set, claude CLI picks one of the
+                // non-API-key code paths (Bedrock/Vertex/OAuth) and ignores our
+                // ANTHROPIC_API_KEY, causing 403 invalid_api_key errors.
+                ANTHROPIC_AUTH_TOKEN: undefined,
+                ANTHROPIC_MODEL: undefined,
+                ANTHROPIC_SMALL_FAST_MODEL: undefined,
+                CLAUDE_CODE_USE_BEDROCK: undefined,
+                CLAUDE_CODE_USE_VERTEX: undefined,
+                AWS_BEARER_TOKEN_BEDROCK: undefined,
+            };
+            if (!isDefaultRuntime) {
+                command = resolved.command;
+            }
+            else if (process.versions["electron"] != null) {
+                // Running inside Electron — use Helper binary (LSUIElement=true, no Dock icon).
+                command = resolveElectronHelperPath() ?? process.execPath;
+                spawnEnv.ELECTRON_RUN_AS_NODE = "1";
+                // ELECTRON_RUN_AS_NODE disables asar support, so rewrite any
+                // app.asar paths in args to app.asar.unpacked so Node can find them.
+                for (let i = 0; i < resolved.args.length; i++) {
+                    if (resolved.args[i].includes("app.asar" + path.sep)) {
+                        resolved.args[i] = resolved.args[i].replace("app.asar" + path.sep, "app.asar.unpacked" + path.sep);
+                    }
+                }
+            }
+            else {
+                command = resolved.command;
+            }
+            const runtimeKind = !isDefaultRuntime
+                ? "custom"
+                : command === resolved.command
+                    ? resolved.command
+                    : command.includes("Helper")
+                        ? "electron-helper"
+                        : "electron";
+            logger?.debug({
+                runtimeKind,
+                command,
+                sdkCommand: resolved.command,
+                args: resolved.args,
+                cwd: spawnOptions.cwd,
+                isElectron: process.versions["electron"] != null,
+                hasAnthropicKey: !!spawnEnv.ANTHROPIC_API_KEY,
+                anthropicKeyPrefix: spawnEnv.ANTHROPIC_API_KEY?.slice(0, 10) ?? null,
+                anthropicBaseUrl: spawnEnv.ANTHROPIC_BASE_URL ?? null,
+                launchEnvKeys: Object.keys(launchEnv ?? {}),
+            }, "claude_spawn");
+            // Pre-flight diagnostics. The SDK reports every ENOENT from spawn as
+            // "Claude Code executable not found", which is misleading when the true
+            // cause is the cwd, the Node host, or the cli.js script. Surface the
+            // actual culprit in the daemon log before spawn returns.
+            const cwdForSpawn = typeof spawnOptions.cwd === "string" ? spawnOptions.cwd : null;
+            const scriptArg = resolved.args[0];
+            // Bare command names (e.g. "node", "bun") are resolved via PATH at spawn
+            // time, not as filesystem paths — fs.existsSync would always return false
+            // for them and trigger spurious preflight_failed logs. Only probe the
+            // filesystem when the command actually contains a path separator.
+            const commandLooksLikePath = command.includes("/") || command.includes("\\");
+            const preflight = {
+                cwdExists: cwdForSpawn ? fs.existsSync(cwdForSpawn) : null,
+                commandExists: commandLooksLikePath ? fs.existsSync(command) : null,
+                scriptExists: typeof scriptArg === "string" ? fs.existsSync(scriptArg) : null,
+            };
+            if (preflight.cwdExists === false ||
+                preflight.commandExists === false ||
+                preflight.scriptExists === false) {
+                logger?.error({ ...preflight, cwd: cwdForSpawn, command, scriptArg }, "claude_spawn_preflight_failed");
+            }
             const child = spawnProcess(command, resolved.args, {
                 cwd: spawnOptions.cwd,
-                env: {
-                    ...applyProviderEnv(spawnOptions.env, runtimeSettings),
-                    ...(launchEnv ?? {}),
-                },
+                env: spawnEnv,
                 signal: spawnOptions.signal,
                 stdio: ["pipe", "pipe", "pipe"],
                 // Bypass cmd.exe on Windows: the SDK passes --mcp-config with inline JSON
@@ -109,6 +225,18 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv
                     options.stderr?.(chunk.toString());
                 });
             }
+            child.on("error", (err) => {
+                logger?.error({
+                    code: err.code,
+                    errno: err.errno,
+                    syscall: err.syscall,
+                    path: err.path,
+                    ...preflight,
+                    cwd: cwdForSpawn,
+                    command,
+                    scriptArg,
+                }, "claude_spawn_child_error");
+            });
             return child;
         },
     };
@@ -818,7 +946,6 @@ export class ClaudeAgentClient {
     }
     async getDiagnostic() {
         try {
-            const resolvedBinary = (await findExecutable("claude")) ?? "not found";
             const available = await this.isAvailable();
             const version = await resolveClaudeVersion(this.runtimeSettings);
             let modelsValue = "Not checked";
@@ -838,7 +965,7 @@ export class ClaudeAgentClient {
             }
             return {
                 diagnostic: formatProviderDiagnostic("Claude Code", [
-                    { label: "Binary", value: resolvedBinary },
+                    { label: "Binary", value: "Built-in (SDK)" },
                     ...(version ? [{ label: "Version", value: version }] : []),
                     { label: "Models", value: modelsValue },
                     { label: "Status", value: status },
@@ -869,16 +996,8 @@ async function resolveClaudeVersion(runtimeSettings) {
             });
             return stdout.trim() || null;
         }
-        const executable = await findExecutable("claude");
-        if (!executable) {
-            return null;
-        }
-        const { stdout } = await execFileAsync(executable, ["--version"], {
-            encoding: "utf8",
-            timeout: 5000,
-            windowsHide: true,
-        });
-        return stdout.trim() || null;
+        // Using SDK built-in CLI — version not directly queryable without running it
+        return null;
     }
     catch {
         return null;
@@ -1694,20 +1813,25 @@ class ClaudeAgentSession {
         ]
             .filter((entry) => typeof entry === "string" && entry.length > 0)
             .join("\n\n");
-        const claudeBinary = await findExecutable("claude");
-        this.logger.debug({
-            claudeBinary,
-            pathEnvKey: process.env["Path"] !== undefined
-                ? "Path"
-                : process.env["PATH"] !== undefined
-                    ? "PATH"
-                    : null,
-            pathIncludesClaudeLocalBin: (process.env["Path"] ?? process.env["PATH"] ?? "")
-                .toLowerCase()
-                .includes("\\.local\\bin"),
-        }, "Resolved Claude executable");
+        // Point to the Seawork-managed settings file (written at daemon startup in
+        // server/index.ts) so the spawned claude CLI uses our gateway auth.
+        // The SDK `settings` option (flag settings layer) has the highest priority.
+        const seaworkHome = process.env.SEAWORK_HOME ?? path.join(os.homedir(), ".seawork");
+        const seaworkSettingsPath = path.join(seaworkHome, "claude-settings.json");
+        const hasSeaworkSettings = fs.existsSync(seaworkSettingsPath);
+        // Windows' CreateProcess returns ENOENT when the spawn cwd does not exist,
+        // and the SDK mislabels that ENOENT as "Claude Code executable not found".
+        // Fail early with a clear message instead.
+        if (this.config.cwd && !fs.existsSync(this.config.cwd)) {
+            throw new Error(`Agent working directory does not exist: ${this.config.cwd}`);
+        }
+        // Pre-resolve cli.js and pin it via pathToClaudeCodeExecutable. The SDK's
+        // default resolution uses `import.meta.url`, which in packaged Electron
+        // apps produces a virtual app.asar path that spawned children can't read.
+        const cliExecutable = resolveClaudeCliExecutable();
         const base = {
             cwd: this.config.cwd,
+            ...(cliExecutable ? { pathToClaudeCodeExecutable: cliExecutable } : {}),
             includePartialMessages: true,
             permissionMode: this.currentMode,
             // Dynamic mode switching can recreate the underlying Claude query. Keep the
@@ -1716,7 +1840,6 @@ class ClaudeAgentSession {
             allowDangerouslySkipPermissions: true,
             agents: this.defaults?.agents,
             canUseTool: this.handlePermissionRequest,
-            ...(claudeBinary ? { pathToClaudeCodeExecutable: claudeBinary } : {}),
             // Use Claude Code preset system prompt and load CLAUDE.md files
             // Append provider-agnostic system prompt and orchestrator instructions for agents.
             systemPrompt: {
@@ -1725,12 +1848,18 @@ class ClaudeAgentSession {
                 append: appendedSystemPrompt,
             },
             settingSources: CLAUDE_SETTING_SOURCES,
+            ...(hasSeaworkSettings ? { settings: seaworkSettingsPath } : {}),
             stderr: (data) => {
                 this.captureStderr(data);
                 this.logger.error({ stderr: data.trim() }, "Claude Agent SDK stderr");
             },
             env: {
                 ...process.env,
+                // Clear proxy env vars to prevent interference with gateway requests.
+                http_proxy: "",
+                https_proxy: "",
+                HTTP_PROXY: "",
+                HTTPS_PROXY: "",
                 // Increase MCP timeouts for long-running tool calls (10 minutes)
                 MCP_TIMEOUT: "600000",
                 MCP_TOOL_TIMEOUT: "600000",
@@ -1758,7 +1887,7 @@ class ClaudeAgentSession {
         return this.applyRuntimeSettings(base);
     }
     applyRuntimeSettings(options) {
-        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings, this.launchEnv);
+        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings, this.launchEnv, this.logger);
     }
     normalizeMcpServers(servers) {
         const result = {};