@meistrari/tela-cli 0.7.29 → 0.7.31

package/dist/index.js

@@ -910,11 +910,16 @@ var require_process = __commonJS({
     exports2.runCommand = runCommand;
     exports2.runShell = runShell;
     exports2.commandExists = commandExists;
+    exports2.resolveExecutable = resolveExecutable;
     exports2.runInteractiveCommand = runInteractiveCommand;
     exports2.runStreamingCommand = runStreamingCommand;
     exports2.spawnStreamingCommand = spawnStreamingCommand;
     var node_child_process_1 = require("node:child_process");
     var node_events_1 = require("node:events");
+    var node_fs_1 = require("node:fs");
+    var promises_1 = require("node:fs/promises");
+    var node_os_1 = require("node:os");
+    var node_path_1 = require("node:path");
     var CommandError = class extends Error {
       result;
       constructor(message, result) {
@@ -981,8 +986,89 @@ var require_process = __commonJS({
       } catch {
       }
     }
+    function hasPathSeparator(command) {
+      return command.includes("/") || command.includes("\\");
+    }
+    function pathDelimiterForPlatform(platform) {
+      return platform === "win32" ? ";" : ":";
+    }
+    function shellSingleQuote(value) {
+      return `'${String(value).replace(/'/g, "'\\''")}'`;
+    }
+    function isSafeExecutableName(command) {
+      return /^[A-Za-z0-9._+-]+$/.test(command);
+    }
+    function getWindowsExecutableSuffixes(command, env) {
+      if (/\.[^\\/]+$/.test(command)) {
+        return [""];
+      }
+      const pathExt = env.PATHEXT || ".COM;.EXE;.BAT;.CMD";
+      return pathExt.split(";").map((item) => item.trim()).filter(Boolean);
+    }
+    function getPathExecutableCandidates(command, env, platform) {
+      if (hasPathSeparator(command)) {
+        return [command];
+      }
+      const suffixes = platform === "win32" ? getWindowsExecutableSuffixes(command, env) : [""];
+      return (env.PATH || "").split(pathDelimiterForPlatform(platform)).map((item) => item.trim()).filter(Boolean).flatMap((directory) => suffixes.map((suffix) => (0, node_path_1.join)(directory, `${command}${suffix}`)));
+    }
+    function getKnownExecutableCandidates(command, homeDir, platform) {
+      if (platform === "win32" || hasPathSeparator(command)) {
+        return [];
+      }
+      return [
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        (0, node_path_1.join)(homeDir, ".claude", "local"),
+        (0, node_path_1.join)(homeDir, ".claude", "local", "bin"),
+        (0, node_path_1.join)(homeDir, ".bun", "bin"),
+        (0, node_path_1.join)(homeDir, ".npm-global", "bin"),
+        (0, node_path_1.join)(homeDir, ".local", "bin")
+      ].map((directory) => (0, node_path_1.join)(directory, command));
+    }
+    async function findFirstExecutable(candidates, accessFn) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const candidate of candidates) {
+        if (!candidate || seen.has(candidate)) {
+          continue;
+        }
+        seen.add(candidate);
+        try {
+          await accessFn(candidate, node_fs_1.constants.X_OK);
+          return candidate;
+        } catch {
+        }
+      }
+      return null;
+    }
+    async function resolveExecutableFromShell(command, options) {
+      if (hasPathSeparator(command) || !isSafeExecutableName(command)) {
+        return null;
+      }
+      const lookupCommand = options.platform === "win32" ? ["where", command] : [
+        options.shell || (options.platform === "darwin" ? "/bin/zsh" : options.env.SHELL || process.env.SHELL || "/bin/sh"),
+        "-lc",
+        `command -v ${shellSingleQuote(command)}`
+      ];
+      try {
+        const result = await options.runCommandFn(lookupCommand, {
+          env: options.env,
+          allowFailure: true,
+          timeoutMs: options.timeoutMs
+        });
+        if (result.exitCode !== 0) {
+          return null;
+        }
+        const candidates = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+        return await findFirstExecutable(candidates, options.accessFn);
+      } catch {
+        return null;
+      }
+    }
     async function runCommand(command, options = {}) {
       assertCommand(command);
+      let timedOut = false;
+      let timeout;
       const child = (0, node_child_process_1.spawn)(command[0], command.slice(1), {
         cwd: options.cwd,
         env: buildEnv(options.env),
@@ -992,6 +1078,13 @@ var require_process = __commonJS({
           "pipe"
         ]
       });
+      if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          signalProcessGroup(child, "SIGTERM");
+        }, options.timeoutMs);
+        timeout.unref?.();
+      }
       if (options.input !== void 0) {
         child.stdin?.end(options.input);
       }
@@ -1000,12 +1093,15 @@ var require_process = __commonJS({
         readStream(child.stderr),
         (0, node_events_1.once)(child, "close")
       ]);
+      if (timeout) {
+        clearTimeout(timeout);
+      }
       const [code] = closeResult;
       const result = {
         command,
         exitCode: code ?? 1,
         stdout,
-        stderr
+        stderr: timedOut ? `${stderr}${stderr ? "\n" : ""}Command timed out after ${options.timeoutMs}ms.` : stderr
       };
       if (result.exitCode !== 0 && !options.allowFailure) {
         throw new CommandError(`Command failed (${result.exitCode}): ${command.join(" ")}`, result);
@@ -1016,8 +1112,31 @@ var require_process = __commonJS({
       return await runCommand([process.env.SHELL ?? "/bin/sh", "-c", script], options);
     }
     async function commandExists(command) {
-      const result = await runCommand(["which", command], { allowFailure: true });
-      return result.exitCode === 0;
+      return await resolveExecutable(command) !== null;
+    }
+    async function resolveExecutable(command, options = {}) {
+      const platform = options.platform ?? process.platform;
+      const env = options.env ?? process.env;
+      const accessFn = options.accessFn ?? promises_1.access;
+      const runCommandFn = options.runCommandFn ?? runCommand;
+      const timeoutMs = options.timeoutMs ?? 5e3;
+      const homeDir = options.homeDir ?? (0, node_os_1.homedir)();
+      const pathCandidate = await findFirstExecutable(getPathExecutableCandidates(command, env, platform), accessFn);
+      if (pathCandidate) {
+        return pathCandidate;
+      }
+      const shellCandidate = await resolveExecutableFromShell(command, {
+        env,
+        runCommandFn,
+        accessFn,
+        platform,
+        shell: options.shell,
+        timeoutMs
+      });
+      if (shellCandidate) {
+        return shellCandidate;
+      }
+      return await findFirstExecutable(getKnownExecutableCandidates(command, homeDir, platform), accessFn);
     }
     async function runInteractiveCommand(command, options = {}) {
       assertCommand(command);
@@ -1906,7 +2025,7 @@ var require_claude = __commonJS({
       }
       return tools;
     }
-    async function prepareProjectScopedClaudeLaunch(repoRoot) {
+    async function prepareProjectScopedClaudeLaunch(repoRoot, options = {}) {
       const settingsPath = (0, node_path_1.join)(repoRoot, ".claude", "settings.json");
       let settingsContent;
       try {
@@ -1932,12 +2051,13 @@ var require_claude = __commonJS({
         settingsPath,
         allowedTools,
         mcpConfig: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : EMPTY_MCP_CONFIG,
-        mcpConfigPath: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : void 0
+        mcpConfigPath: (0, node_fs_1.existsSync)(mcpConfigPath) ? mcpConfigPath : void 0,
+        claudeExecutablePath: options.claudeExecutablePath
       };
     }
     function buildProjectScopedClaudeCommand(launch, options = {}) {
       const command = [
-        "claude",
+        launch.claudeExecutablePath ?? "claude",
         "--setting-sources",
         "project",
         "--permission-mode",
@@ -1999,9 +2119,10 @@ var require_claude = __commonJS({
       };
     }
     async function inspectClaudeCli(options = {}) {
-      const commandExistsFn = options.commandExistsFn ?? process_1.commandExists;
+      const resolveExecutableFn = options.resolveExecutableFn ?? process_1.resolveExecutable;
       const runCommandFn = options.runCommandFn ?? process_1.runCommand;
-      if (!await commandExistsFn("claude")) {
+      const executablePath = options.commandExistsFn ? await options.commandExistsFn("claude") ? "claude" : null : await resolveExecutableFn("claude");
+      if (!executablePath) {
         return {
           available: false,
           supportsProjectScopedRun: false,
@@ -2009,13 +2130,14 @@ var require_claude = __commonJS({
           detail: "`claude` is not available on PATH."
         };
       }
-      const result = await runCommandFn(["claude", "--version"], { allowFailure: true });
+      const result = await runCommandFn([executablePath, "--version"], { allowFailure: true });
       const output = `${result.stdout}
 ${result.stderr}`.trim();
       const parsedVersion = parseClaudeCliVersion(output);
       if (!parsedVersion) {
         return {
           available: true,
+          executablePath,
           supportsProjectScopedRun: false,
           problem: "unparseable",
           detail: output || "Claude CLI version output was empty."
@@ -2025,6 +2147,7 @@ ${result.stderr}`.trim();
       if (compareClaudeCliVersions(parsedVersion, exports2.MIN_CLAUDE_VERSION_FOR_PROJECT_SCOPED_RUN) < 0) {
         return {
           available: true,
+          executablePath,
           version,
           parsedVersion,
           supportsProjectScopedRun: false,
@@ -2034,6 +2157,7 @@ ${result.stderr}`.trim();
       }
       return {
         available: true,
+        executablePath,
         version,
         parsedVersion,
         supportsProjectScopedRun: true,
@@ -2869,7 +2993,9 @@ var require_feedback = __commonJS({
     }
     async function launchFeedbackClaude(options) {
       const runInteractiveCommandFn = options.runInteractiveCommand ?? process_1.runInteractiveCommand;
-      const launch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(options.repoRoot);
+      const launch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(options.repoRoot, {
+        claudeExecutablePath: options.claudeExecutablePath
+      });
       const command = (0, claude_1.buildProjectScopedClaudeCommand)(launch, {
         prompt: options.prompt
       });
@@ -2907,7 +3033,10 @@ var require_feedback = __commonJS({
       const getOriginUrlFn = options.getOriginUrl ?? git_1.getOriginUrl;
       const getHeadCommitHashFn = options.getHeadCommitHash ?? git_1.getHeadCommitHash;
       const getDiffStatAgainstHeadFn = options.getDiffStatAgainstHead ?? git_1.getDiffStatAgainstHead;
-      const commandExistsFn = options.commandExists ?? process_1.commandExists;
+      const inspectClaudeCliFn = options.inspectClaudeCli ?? (async () => await (0, claude_1.inspectClaudeCli)({
+        commandExistsFn: options.commandExists,
+        runCommandFn: options.runCommand
+      }));
       const runInteractiveCommandFn = options.runInteractiveCommand ?? process_1.runInteractiveCommand;
       const selectionMode = getFeedbackSelectionMode(options);
       const config = await ensureConfig();
@@ -2931,13 +3060,27 @@ var require_feedback = __commonJS({
           launchedClaude: false
         });
       }
-      if (!await commandExistsFn("claude")) {
+      let claudeExecutablePath;
+      const claudeInspection = await inspectClaudeCliFn();
+      if (!claudeInspection.available) {
         throw (0, errors_1.createUserFacingError)({
           code: "feedback_claude_missing",
           summary: "Claude CLI is not available on PATH.",
           fixes: ["Install the Claude CLI before using `tela feedback --apply ...`."]
         });
       }
+      if (!claudeInspection.supportsProjectScopedRun) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "feedback_claude_version_unsupported",
+          summary: "Claude CLI version does not support project-scoped feedback runs.",
+          details: claudeInspection.detail,
+          fixes: [
+            "Update Claude CLI before using `tela feedback --apply ...`.",
+            "Run `claude --version` to confirm the installed version."
+          ]
+        });
+      }
+      claudeExecutablePath = claudeInspection.executablePath;
       let selectedFeedbacks = selectionMode === "select" ? [] : actionableFeedbacks;
       if (selectionMode === "select" && options.feedbackIds?.length) {
         selectedFeedbacks = selectFeedbackEntriesById(feedbackEntries, options.feedbackIds);
@@ -3033,6 +3176,7 @@ var require_feedback = __commonJS({
       await launchFeedbackClaude({
         repoRoot: data.repoRoot,
         prompt,
+        claudeExecutablePath,
         runInteractiveCommand: runInteractiveCommandFn
       });
       const diffStat = await getDiffStatAgainstHeadFn(repoRoot) || "<no local diff detected>";
@@ -3067,7 +3211,8 @@ var require_commit_message = __commonJS({
       return input.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? "";
     }
     async function generateCommitMessageWithClaude(context) {
-      if (!await (0, process_1.commandExists)("claude")) {
+      const claudePath = await (0, process_1.resolveExecutable)("claude");
+      if (!claudePath) {
         throw new Error("Claude CLI is not available");
       }
       const prompt = `You are writing a git commit message for already staged changes.
@@ -3087,7 +3232,7 @@ Write exactly one short natural-language git commit message.
 - Keep it concise
 - Return only the commit message text`;
       const result = await (0, process_1.runCommand)([
-        "claude",
+        claudePath,
         "-p",
         prompt,
         "--output-format",
@@ -4497,7 +4642,9 @@ ${detail.errors.join("\n")}` : summary);
       const outputFormat = parseJsonObjectFile("output-format.json", outputFormatContent, "output-format.json must be a valid JSON object.");
       const config = parseAgentConfig("agent.config.json", agentConfigContent);
       const resultKind = Object.keys(outputFormat).length > 0 ? "json" : "markdown";
-      const claudeLaunch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(repoRoot);
+      const claudeLaunch = await (0, claude_1.prepareProjectScopedClaudeLaunch)(repoRoot, {
+        claudeExecutablePath: claudeInspection.executablePath
+      });
       return {
         repoRoot,
         config,
@@ -5902,6 +6049,7 @@ var require_cli = __commonJS({
     var sync_1 = require_sync();
     var config_1 = require_config2();
     var errors_1 = require_errors();
+    var claude_1 = require_claude();
     var git_1 = require_git();
     var process_1 = require_process();
     var setup_1 = require_setup();
@@ -6580,15 +6728,28 @@ var require_cli = __commonJS({
           write(io.stdout, renderFeedbackResult(result2));
         return 0;
       }
-      if (!await (0, process_1.commandExists)("claude")) {
+      const claudeInspection = await (0, claude_1.inspectClaudeCli)();
+      if (!claudeInspection.available) {
         throw (0, errors_1.createUserFacingError)({
           code: "feedback_claude_missing",
           summary: "Claude CLI is not available on PATH."
         });
       }
+      if (!claudeInspection.supportsProjectScopedRun) {
+        throw (0, errors_1.createUserFacingError)({
+          code: "feedback_claude_version_unsupported",
+          summary: "Claude CLI version does not support project-scoped feedback runs.",
+          details: claudeInspection.detail,
+          fixes: [
+            "Update Claude CLI before using `tela agent feedback`.",
+            "Run `claude --version` to confirm the installed version."
+          ]
+        });
+      }
       const selectedFeedbacks = data.actionableEntries;
       await (0, feedback_1.launchFeedbackClaude)({
         repoRoot: data.repoRoot,
+        claudeExecutablePath: claudeInspection.executablePath,
         prompt: (0, feedback_1.buildClaudeFeedbackPrompt)({
           repoRoot: data.repoRoot,
           organizationName: data.organizationName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/tela-cli",
-  "version": "0.7.29",
+  "version": "0.7.31",
   "description": "Tela command line tools for local state and agent workflows.",
   "license": "UNLICENSED",
   "repository": {