@sna-sdk/core 0.9.9 → 0.9.11

package/dist/core/providers/claude-code.d.ts

@@ -1,9 +1,40 @@
 import { AgentProvider, SpawnOptions, AgentProcess } from './types.js';
 
+/**
+ * Parse `command -v claude` output to extract the executable path.
+ * Handles: direct paths, alias with/without quotes, bare command names.
+ * @internal Exported for testing only.
+ */
+declare function parseCommandVOutput(raw: string): string;
+/**
+ * Validate a Claude CLI path by running `<path> --version`.
+ * Adds the binary's directory to PATH so shebang resolution works (nvm/fnm).
+ */
+declare function validateClaudePath(claudePath: string): {
+    ok: boolean;
+    version?: string;
+};
+/**
+ * Save a validated Claude path to cache for faster startup next time.
+ */
+declare function cacheClaudePath(claudePath: string, cacheDir?: string): void;
+interface ResolveResult {
+    path: string;
+    version?: string;
+    source: "env" | "cache" | "static" | "shell" | "fallback";
+}
+/**
+ * Resolve Claude CLI path. Tries: env override → cache → static paths → shell detection.
+ * All candidates are validated with `--version` before returning.
+ * Consumer apps should call this and handle the `fallback` source (= not found).
+ */
+declare function resolveClaudeCli(opts?: {
+    cacheDir?: string;
+}): ResolveResult;
 declare class ClaudeCodeProvider implements AgentProvider {
     readonly name = "claude-code";
     isAvailable(): Promise<boolean>;
     spawn(options: SpawnOptions): AgentProcess;
 }
 
-export { ClaudeCodeProvider };
+export { ClaudeCodeProvider, type ResolveResult, cacheClaudePath, parseCommandVOutput, resolveClaudeCli, validateClaudePath };

package/dist/core/providers/claude-code.js

@@ -6,38 +6,80 @@ import { fileURLToPath } from "url";
 import { writeHistoryJsonl, buildRecalledConversation } from "./cc-history-adapter.js";
 import { logger } from "../../lib/logger.js";
 const SHELL = process.env.SHELL || "/bin/zsh";
-function resolveClaudePath(cwd) {
-  if (process.env.SNA_CLAUDE_COMMAND) return process.env.SNA_CLAUDE_COMMAND;
-  const cached = path.join(cwd, ".sna/claude-path");
-  if (fs.existsSync(cached)) {
-    const p = fs.readFileSync(cached, "utf8").trim();
-    if (p) {
-      try {
-        execSync(`test -x "${p}"`, { stdio: "pipe" });
-        return p;
-      } catch {
-      }
+function parseCommandVOutput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return "claude";
+  const aliasMatch = trimmed.match(/=\s*['"]?([^'"]+?)['"]?\s*$/);
+  if (aliasMatch) return aliasMatch[1];
+  const pathMatch = trimmed.match(/^(\/\S+)/m);
+  if (pathMatch) return pathMatch[1];
+  return trimmed;
+}
+function validateClaudePath(claudePath) {
+  try {
+    const claudeDir = path.dirname(claudePath);
+    const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
+    const out = execSync(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
+    return { ok: true, version: out.split("\n")[0].slice(0, 30) };
+  } catch {
+    return { ok: false };
+  }
+}
+function cacheClaudePath(claudePath, cacheDir) {
+  const dir = cacheDir ?? path.join(process.cwd(), ".sna");
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, "claude-path"), claudePath);
+  } catch {
+  }
+}
+function resolveClaudeCli(opts) {
+  const cacheDir = opts?.cacheDir;
+  if (process.env.SNA_CLAUDE_COMMAND) {
+    const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
+    return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
+  }
+  const cacheFile = cacheDir ? path.join(cacheDir, "claude-path") : path.join(process.cwd(), ".sna/claude-path");
+  try {
+    const cached = fs.readFileSync(cacheFile, "utf8").trim();
+    if (cached) {
+      const v = validateClaudePath(cached);
+      if (v.ok) return { path: cached, version: v.version, source: "cache" };
     }
+  } catch {
   }
-  for (const p of [
+  const staticPaths = [
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     `${process.env.HOME}/.local/bin/claude`,
-    `${process.env.HOME}/.claude/bin/claude`
-  ]) {
-    try {
-      execSync(`test -x "${p}"`, { stdio: "pipe" });
-      return p;
-    } catch {
+    `${process.env.HOME}/.claude/bin/claude`,
+    `${process.env.HOME}/.volta/bin/claude`
+  ];
+  for (const p of staticPaths) {
+    const v = validateClaudePath(p);
+    if (v.ok) {
+      cacheClaudePath(p, cacheDir);
+      return { path: p, version: v.version, source: "static" };
     }
   }
   try {
     const raw = execSync(`${SHELL} -i -l -c "command -v claude" 2>/dev/null`, { encoding: "utf8", timeout: 5e3 }).trim();
-    const match = raw.match(/=(.+)/) ?? raw.match(/^(\/\S+)/m);
-    return match ? match[1] : raw;
+    const resolved = parseCommandVOutput(raw);
+    if (resolved && resolved !== "claude") {
+      const v = validateClaudePath(resolved);
+      if (v.ok) {
+        cacheClaudePath(resolved, cacheDir);
+        return { path: resolved, version: v.version, source: "shell" };
+      }
+    }
   } catch {
-    return "claude";
   }
+  return { path: "claude", source: "fallback" };
+}
+function resolveClaudePath(cwd) {
+  const result = resolveClaudeCli({ cacheDir: path.join(cwd, ".sna") });
+  logger.log("agent", `claude path: ${result.source}=${result.path}${result.version ? ` (${result.version})` : ""}`);
+  return result.path;
 }
 const _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
@@ -473,6 +515,10 @@ class ClaudeCodeProvider {
     delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
     delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
     delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const claudeDir = path.dirname(claudePath);
+    if (claudeDir && claudeDir !== ".") {
+      cleanEnv.PATH = `${claudeDir}:${cleanEnv.PATH ?? ""}`;
+    }
     const proc = spawn(claudePath, [...claudePrefix, ...args], {
       cwd: options.cwd,
       env: cleanEnv,
@@ -483,5 +529,9 @@ class ClaudeCodeProvider {
   }
 }
 export {
-  ClaudeCodeProvider
+  ClaudeCodeProvider,
+  cacheClaudePath,
+  parseCommandVOutput,
+  resolveClaudeCli,
+  validateClaudePath
 };