fix: harden Claude SDK CLI path resolution

Co-authored-by: Codex <codex@openai.com>

Author: OpenSource03

electron/src/ipc/claude-sessions.ts

@@ -214,6 +214,14 @@ function buildThinkingConfig(thinkingEnabled?: boolean): { type: "adaptive" } |
     : { type: "adaptive" };
 }
 
+function logSdkCliPath(context: string, cliPath?: string): void {
+  if (cliPath) {
+    log("SDK_CLI_PATH", `${context} path=${cliPath}`);
+    return;
+  }
+  log("SDK_CLI_PATH", `${context} unresolved; relying on SDK fallback`);
+}
+
 let modelsRevalidationPromise: Promise<{ models: Array<Record<string, unknown>>; updatedAt?: number; error?: string }> | null = null;
 
 async function revalidateClaudeModelsCache(cwd?: string): Promise<{ models: Array<Record<string, unknown>>; updatedAt?: number; error?: string }> {
@@ -226,12 +234,14 @@ async function revalidateClaudeModelsCache(cwd?: string): Promise<{ models: Arra
 
     try {
       const query = await getSDK();
+      const cliPath = getCliPath();
+      logSdkCliPath("models-revalidate", cliPath);
       const queryOptions: Record<string, unknown> = {
         cwd: cwd?.trim() || os.homedir(),
         includePartialMessages: true,
         thinking: buildThinkingConfig(true),
         settingSources: ["user", "project"],
-        pathToClaudeCodeExecutable: getCliPath(),
+        pathToClaudeCodeExecutable: cliPath,
         ...fileCheckpointOptions(),
       };
 
@@ -319,6 +329,8 @@ async function restartSession(
   const mcpServers = mcpServersOverride ?? opts.mcpServers;
   const query = await getSDK();
   const newChannel = new AsyncChannel<unknown>();
+  const cliPath = getCliPath();
+  logSdkCliPath(`restart session=${sessionId.slice(0, 8)}`, cliPath);
 
   const newSession: SessionEntry = {
     channel: newChannel,
@@ -350,7 +362,7 @@ async function restartSession(
     thinking: buildThinkingConfig(opts.thinkingEnabled),
     canUseTool,
     settingSources: ["user", "project"],
-    pathToClaudeCodeExecutable: getCliPath(),
+    pathToClaudeCodeExecutable: cliPath,
     ...fileCheckpointOptions(),
     resume: sessionId,
     stderr: (data: string) => {
@@ -439,13 +451,15 @@ export function register(getMainWindow: () => BrowserWindow | null): void {
         });
       };
 
+      const cliPath = getCliPath();
+      logSdkCliPath(`start session=${sessionId.slice(0, 8)}`, cliPath);
       const queryOptions: Record<string, unknown> = {
         cwd: options.cwd || process.cwd(),
         includePartialMessages: true,
         thinking: buildThinkingConfig(options.thinkingEnabled),
         canUseTool,
         settingSources: ["user", "project"],
-        pathToClaudeCodeExecutable: getCliPath(),
+        pathToClaudeCodeExecutable: cliPath,
         ...fileCheckpointOptions(),
         stderr: (data: string) => {
           const trimmed = data.trim();

electron/src/ipc/title-gen.ts

@@ -32,6 +32,12 @@ async function oneShotSdkQuery(
 
   try {
     const query = await getSDK();
+    const cliPath = getCliPath();
+    if (cliPath) {
+      log("SDK_CLI_PATH", `${logLabel} path=${cliPath}`);
+    } else {
+      log("SDK_CLI_PATH", `${logLabel} unresolved; relying on SDK fallback`);
+    }
     let eventCount = 0;
     let lastEventType = "none";
     let lastResultSubtype = "none";
@@ -49,7 +55,7 @@ async function oneShotSdkQuery(
         permissionMode: "bypassPermissions",
         allowDangerouslySkipPermissions: true,
         persistSession: false,
-        pathToClaudeCodeExecutable: getCliPath(),
+        pathToClaudeCodeExecutable: cliPath,
         env: { ...process.env, ...clientAppEnv() },
         stderr: (data: string) => {
           const trimmed = data.trim();

electron/src/lib/__tests__/sdk.test.ts

@@ -0,0 +1,130 @@
+import path from "path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockApp,
+  mockGetAppSetting,
+  mockExistsSync,
+  mockLog,
+} = vi.hoisted(() => ({
+  mockApp: {
+    isPackaged: false,
+    getVersion: vi.fn(() => "0.16.0"),
+    getAppPath: vi.fn(() => "/Applications/Harnss.app/Contents/Resources/app.asar"),
+  },
+  mockGetAppSetting: vi.fn(() => "Harnss"),
+  mockExistsSync: vi.fn(() => false),
+  mockLog: vi.fn(),
+}));
+
+vi.mock("electron", () => ({
+  app: mockApp,
+}));
+
+vi.mock("fs", () => ({
+  default: {
+    existsSync: mockExistsSync,
+  },
+}));
+
+vi.mock("../app-settings", () => ({
+  getAppSetting: mockGetAppSetting,
+}));
+
+vi.mock("../logger", () => ({
+  log: mockLog,
+}));
+
+async function loadSdkModule() {
+  vi.resetModules();
+  return import("../sdk");
+}
+
+describe("sdk path resolution", () => {
+  beforeEach(() => {
+    mockApp.isPackaged = false;
+    mockApp.getAppPath.mockReset();
+    mockApp.getAppPath.mockReturnValue("/Applications/Harnss.app/Contents/Resources/app.asar");
+    mockGetAppSetting.mockReset();
+    mockGetAppSetting.mockReturnValue("Harnss");
+    mockExistsSync.mockReset();
+    mockExistsSync.mockReturnValue(false);
+    mockLog.mockReset();
+  });
+
+  it("derives cli.js from an exported SDK entrypoint in dev", async () => {
+    const mod = await loadSdkModule();
+
+    expect(
+      mod.resolveCliPathFromEntry("/x/node_modules/@anthropic-ai/claude-agent-sdk/embed.js", false),
+    ).toBe("/x/node_modules/@anthropic-ai/claude-agent-sdk/cli.js");
+  });
+
+  it("maps packaged app paths to app.asar.unpacked", async () => {
+    const mod = await loadSdkModule();
+
+    expect(
+      mod.resolveCliPathFromEntry(
+        "/Applications/Harnss.app/Contents/Resources/app.asar/node_modules/@anthropic-ai/claude-agent-sdk/embed.js",
+        true,
+      ),
+    ).toBe(
+      "/Applications/Harnss.app/Contents/Resources/app.asar.unpacked/node_modules/@anthropic-ai/claude-agent-sdk/cli.js",
+    );
+  });
+
+  it("prefers embed resolution when the candidate exists", async () => {
+    const embedEntry = require.resolve("@anthropic-ai/claude-agent-sdk/embed");
+    const embedCliPath = path.join(path.dirname(embedEntry), "cli.js");
+    mockExistsSync.mockImplementation((candidate) => candidate === embedCliPath);
+
+    const mod = await loadSdkModule();
+
+    expect(mod.getCliPath()).toBe(embedCliPath);
+    expect(mockLog).toHaveBeenCalledWith("CLI_PATH_SELECTED", `strategy=embed path=${embedCliPath}`);
+  });
+
+  it("falls back to package entry resolution when embed resolution is unavailable", async () => {
+    const packageEntry = require.resolve("@anthropic-ai/claude-agent-sdk");
+    const packageCliPath = path.join(path.dirname(packageEntry), "cli.js");
+    mockExistsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+
+    const mod = await loadSdkModule();
+
+    expect(mod.getCliPath()).toBe(packageCliPath);
+    expect(mockLog).toHaveBeenCalledWith("CLI_PATH_SELECTED", `strategy=package path=${packageCliPath}`);
+  });
+
+  it("falls back to the packaged app path only after SDK-based strategies fail", async () => {
+    mockApp.isPackaged = true;
+    const packagedCliPath = "/Applications/Harnss.app/Contents/Resources/app.asar.unpacked/node_modules/@anthropic-ai/claude-agent-sdk/cli.js";
+    mockExistsSync.mockReturnValueOnce(false).mockReturnValueOnce(false).mockReturnValueOnce(true);
+
+    const mod = await loadSdkModule();
+
+    expect(mod.getCliPath()).toBe(packagedCliPath);
+    expect(mockLog).toHaveBeenCalledWith("CLI_PATH_SELECTED", `strategy=app-path path=${packagedCliPath}`);
+  });
+
+  it("returns undefined when no candidate exists", async () => {
+    mockApp.isPackaged = true;
+    mockExistsSync.mockReturnValue(false);
+
+    const mod = await loadSdkModule();
+
+    expect(mod.getCliPath()).toBeUndefined();
+    expect(mockLog).toHaveBeenCalledWith(
+      "CLI_PATH_MISSING",
+      "No valid Claude CLI path resolved; SDK fallback may fail in packaged apps",
+    );
+  });
+
+  it("formats the Claude client app header from settings and app version", async () => {
+    mockGetAppSetting.mockReturnValue("Codex Desktop");
+    const mod = await loadSdkModule();
+
+    expect(mod.clientAppEnv()).toEqual({
+      CLAUDE_AGENT_SDK_CLIENT_APP: "Codex Desktop/0.16.0",
+    });
+  });
+});

electron/src/lib/sdk.ts

@@ -1,5 +1,8 @@
+import path from "path";
+import fs from "fs";
 import { app } from "electron";
 import { getAppSetting } from "./app-settings";
+import { log } from "./logger";
 
 // Import the SDK's own types — Query is the return type of sdk.query()
 import type { Query, query as sdkQueryFn } from "@anthropic-ai/claude-agent-sdk";
@@ -40,20 +43,84 @@ export function clientAppEnv(): Record<string, string> {
   return { CLAUDE_AGENT_SDK_CLIENT_APP: `${clientName}/${app.getVersion()}` };
 }
 
+const SDK_PACKAGE = ["@anthropic-ai", "claude-agent-sdk"].join("/");
+const SDK_EMBED_EXPORT = [SDK_PACKAGE, "embed"].join("/");
+
 /**
  * Resolve the SDK's cli.js path for child process spawning.
- * In production ASAR builds, the SDK resolves cli.js inside app.asar via import.meta.url,
- * but the spawned Node child process has no ASAR patching and can't read it.
- * We translate app.asar → app.asar.unpacked so the child process finds the real file.
+ * In production ASAR builds, the SDK may resolve cli.js inside app.asar, but the
+ * spawned Node child process has no ASAR patching and can't read it. We derive
+ * cli.js from the package entrypoint and prefer app.asar.unpacked when packaged.
  */
-export function getCliPath(): string | undefined {
+export function resolveCliPathFromEntry(entryPath: string, isPackaged: boolean): string {
+  const cliPath = path.join(path.dirname(entryPath), "cli.js");
+  if (!isPackaged) return cliPath;
+
+  const unpackedCliPath = cliPath.replace(/app\.asar([/\\])/, "app.asar.unpacked$1");
+  return unpackedCliPath;
+}
+
+/** Cached CLI path — resolved once then reused. */
+let _cachedCliPath: string | undefined;
+
+interface CliPathResolution {
+  strategy: "embed" | "package" | "app-path";
+  path: string;
+}
+
+function candidateExists(filePath: string): boolean {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const cliPath = require.resolve("@anthropic-ai/claude-agent-sdk/cli.js");
-    if (!app.isPackaged) return cliPath;
-    // asarUnpack puts cli.js in app.asar.unpacked/ — translate for child processes
-    return cliPath.replace(/app\.asar([/\\])/, "app.asar.unpacked$1");
+    return fs.existsSync(filePath);
   } catch {
+    return false;
+  }
+}
+
+function tryResolveFromEntry(specifier: string, strategy: CliPathResolution["strategy"]): CliPathResolution | undefined {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const entryPath = require.resolve(specifier);
+    const candidatePath = resolveCliPathFromEntry(entryPath, app.isPackaged);
+    const exists = candidateExists(candidatePath);
+    log("CLI_PATH_RESOLVE", `strategy=${strategy} entry=${entryPath} candidate=${candidatePath} exists=${exists}`);
+    if (!exists) return undefined;
+    return { strategy, path: candidatePath };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log("CLI_PATH_RESOLVE_ERR", `strategy=${strategy} specifier=${specifier} ${message}`);
     return undefined;
   }
 }
+
+function resolveFromEmbedEntry(): CliPathResolution | undefined {
+  return tryResolveFromEntry(SDK_EMBED_EXPORT, "embed");
+}
+
+function resolveFromPackageEntry(): CliPathResolution | undefined {
+  return tryResolveFromEntry(SDK_PACKAGE, "package");
+}
+
+function resolveFromAppPath(): CliPathResolution | undefined {
+  if (!app.isPackaged) return undefined;
+
+  const unpackedBase = app.getAppPath().replace(/app\.asar$/, "app.asar.unpacked");
+  const candidatePath = path.join(unpackedBase, "node_modules", "@anthropic-ai", "claude-agent-sdk", "cli.js");
+  const exists = candidateExists(candidatePath);
+  log("CLI_PATH_RESOLVE", `strategy=app-path candidate=${candidatePath} exists=${exists}`);
+  if (!exists) return undefined;
+  return { strategy: "app-path", path: candidatePath };
+}
+
+export function getCliPath(): string | undefined {
+  if (_cachedCliPath) return _cachedCliPath;
+
+  const resolution = resolveFromEmbedEntry() ?? resolveFromPackageEntry() ?? resolveFromAppPath();
+  if (resolution) {
+    _cachedCliPath = resolution.path;
+    log("CLI_PATH_SELECTED", `strategy=${resolution.strategy} path=${resolution.path}`);
+    return resolution.path;
+  }
+
+  log("CLI_PATH_MISSING", "No valid Claude CLI path resolved; SDK fallback may fail in packaged apps");
+  return undefined;
+}