product-console-companion 0.7.2 → 0.7.3

package/dist/claude-binary.js

@@ -0,0 +1,121 @@
+import crossSpawn from 'cross-spawn';
+import { spawn as nodeSpawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+const CMD_UNSAFE_ARGUMENT = /[\^<>|&%!]/;
+const FALLBACK_ARGUMENT_ERROR = "claude resolves to a .cmd shim and this argument can't pass through cmd.exe intact; install Claude Code so claude.exe is reachable, or update the companion";
+const defaultFs = { existsSync, readFileSync };
+let cachedCommand = null;
+function envValue(env, name) {
+    const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key ? env[key] : undefined;
+}
+function windowsPathEntries(env) {
+    return (envValue(env, 'PATH') ?? '')
+        .split(';')
+        .map((entry) => entry.trim().replace(/^"|"$/g, ''))
+        .filter(Boolean);
+}
+function windowsExtensions(env) {
+    const pathExt = envValue(env, 'PATHEXT') || '.COM;.EXE;.BAT;.CMD';
+    return pathExt
+        .split(';')
+        .map((extension) => extension.trim().toLowerCase())
+        .filter(Boolean)
+        .map((extension) => extension.startsWith('.') ? extension : `.${extension}`);
+}
+function existingCandidate(directory, extension, fs) {
+    const lowerCaseCandidate = join(directory, `claude${extension.toLowerCase()}`);
+    if (fs.existsSync(lowerCaseCandidate))
+        return resolve(lowerCaseCandidate);
+    const originalCaseCandidate = join(directory, `claude${extension}`);
+    return fs.existsSync(originalCaseCandidate) ? resolve(originalCaseCandidate) : null;
+}
+function parsedShimExecutable(shimPath, fs) {
+    let contents;
+    try {
+        contents = fs.readFileSync(shimPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const shimDirectory = dirname(shimPath);
+    for (const match of contents.matchAll(/"([^"\r\n]*claude\.exe)"/gi)) {
+        let target = match[1].replace(/%(?:~dp0|dp0)%?/gi, shimDirectory);
+        // Tests inject win32 while running on Linux CI; normalizing both separator forms keeps the
+        // resolver testable with a real temporary filesystem and is a no-op for native Windows paths.
+        target = target.replace(/[\\/]/g, sep);
+        if (!isAbsolute(target))
+            target = resolve(shimDirectory, target);
+        if (fs.existsSync(target))
+            return resolve(target);
+    }
+    return null;
+}
+function executableForShim(shimPath, fs) {
+    const parsed = parsedShimExecutable(shimPath, fs);
+    if (parsed)
+        return parsed;
+    const conventional = join(dirname(shimPath), 'node_modules', '@anthropic-ai', 'claude-code', 'bin', 'claude.exe');
+    return fs.existsSync(conventional) ? resolve(conventional) : null;
+}
+function resolveUncached(platform, env, fs) {
+    if (platform !== 'win32') {
+        return { command: { command: 'claude', viaShell: true }, fallbackReason: null };
+    }
+    const directories = windowsPathEntries(env);
+    const extensions = windowsExtensions(env);
+    for (const directory of directories) {
+        for (const extension of extensions) {
+            if (extension !== '.cmd' && extension !== '.exe')
+                continue;
+            const candidate = existingCandidate(directory, extension, fs);
+            if (!candidate)
+                continue;
+            if (extension === '.exe') {
+                return { command: { command: candidate, viaShell: false }, fallbackReason: null };
+            }
+            const executable = executableForShim(candidate, fs);
+            if (executable) {
+                return { command: { command: executable, viaShell: false }, fallbackReason: null };
+            }
+            return {
+                command: { command: 'claude', viaShell: true },
+                fallbackReason: `Found ${candidate}, but its claude.exe target was not reachable; falling back to the .cmd shim.`,
+            };
+        }
+    }
+    return {
+        command: { command: 'claude', viaShell: true },
+        fallbackReason: 'No claude.exe or claude.cmd was found on PATH; falling back to cross-spawn command lookup.',
+    };
+}
+/** Resolve once in production. Injected dependencies bypass the cache so Linux CI can exercise
+ * the Windows lookup rules without mutating process globals or depending on Windows filesystem
+ * semantics. */
+export function resolveClaudeCommand(options = {}) {
+    const injected = options.platform !== undefined || options.env !== undefined || options.fs !== undefined;
+    if (!injected && cachedCommand)
+        return cachedCommand;
+    const result = resolveUncached(options.platform ?? process.platform, options.env ?? process.env, options.fs ?? defaultFs);
+    if (!injected) {
+        cachedCommand = result.command;
+        if (result.fallbackReason)
+            console.warn(`[product-console-companion] ${result.fallbackReason}`);
+    }
+    return result.command;
+}
+export function assertClaudeArgumentsSafeForFallback(args, platform = process.platform) {
+    if (platform === 'win32' && args.some((argument) => CMD_UNSAFE_ARGUMENT.test(argument))) {
+        throw new Error(FALLBACK_ARGUMENT_ERROR);
+    }
+}
+/** Native executables go straight through CreateProcess via Node. cross-spawn remains only for
+ * the unresolved command-name path, where it supplies the existing .cmd compatibility behavior. */
+export function spawnClaude(args, options = {}, resolution = resolveClaudeCommand()) {
+    if (resolution.viaShell) {
+        assertClaudeArgumentsSafeForFallback(args);
+        return crossSpawn(resolution.command, args, options);
+    }
+    return nodeSpawn(resolution.command, args, options);
+}

package/dist/claude-cli-caller.js

@@ -10,13 +10,13 @@
  * --max-budget-usd's exceeded-budget behavior) was confirmed with real, budgeted `claude` calls
  * during development, not guessed from --help text alone — see the Phase 2 PR description.
  */
-import spawn from 'cross-spawn';
 import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { StringDecoder } from 'node:string_decoder';
 import { assertSingleLineArguments } from './cli-arguments.js';
+import { spawnClaude } from './claude-binary.js';
 import { gitErrorMessage } from './sandbox.js';
 import { appendDiffToVolatile, prepareShipmentAnalysis } from './shipment.js';
 import { ModelRefusalError } from './text-model.js';
@@ -100,7 +100,7 @@ async function runViaCli(spec, maxBudgetUsd, repoPath, connectionless = false) {
         let firstUnparseableLineFirst = '';
         let firstUnparseableLineLast = '';
         const typeCounts = new Map();
-        const child = spawn('claude', args, { cwd: sandboxPath });
+        const child = spawnClaude(args, { cwd: sandboxPath });
         // stdout/stderr are only null when stdio is explicitly configured away from 'pipe' — the
         // default here, so both are always real streams in practice; the ! just satisfies the type.
         const stdoutDecoder = new StringDecoder('utf8');

package/dist/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import Anthropic from '@anthropic-ai/sdk';
-import spawn from 'cross-spawn';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { addConnection, configPath, enableWorkspacePolling, loadConfig } from './config.js';
@@ -8,6 +7,7 @@ import { CompanionClient, CompanionHttpError, PairingHttpError, } from './http-c
 import { assertIsRepo, checkRepositoryReadiness, currentCommit, GIT_UNAVAILABLE_MESSAGE, REMOTE_TROUBLESHOOTING_HINT, repositoryIdentity, RepositoryIdentityError, repositoryTopLevel, } from './local-scan.js';
 import { runAnalyseShipmentTask, runDesignPromptTask, runGenerateSpecBatchTask, runGenericTask, runProposeNewCapabilitiesTask, runProposeSkeletonTask, runStructuredModelCall, runVerifyModuleTask } from './api-key-caller.js';
 import { runAnalyseShipmentTaskViaCli, runDesignPromptTaskViaCli, runGenerateSpecBatchTaskViaCli, runGenericTaskViaCli, runProposeNewCapabilitiesTaskViaCli, runProposeSkeletonTaskViaCli, runStructuredModelCallViaCli, runVerifyModuleTaskViaCli } from './claude-cli-caller.js';
+import { spawnClaude } from './claude-binary.js';
 import { checkCodexLogin, CODEX_CODE_MODE_MODELS, codexTextModel, defaultCodexHome, runStructuredModelCallViaCodex } from './codex-cli-caller.js';
 import { formatInvestigationReaderDiagnostic, INVESTIGATION_MODEL, runAndReportInvestigation } from './investigation-reader.js';
 import { anthropicTextModel } from './text-model.js';
@@ -80,7 +80,7 @@ function parseFlags(argv) {
 }
 async function checkClaudeCliAvailable() {
     return new Promise((resolvePromise) => {
-        const child = spawn('claude', ['--version']);
+        const child = spawnClaude(['--version']);
         let out = '';
         child.stdout?.on('data', (chunk) => (out += chunk.toString()));
         child.on('error', () => resolvePromise(null)); // e.g. ENOENT — not installed / not on PATH

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "product-console-companion",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Local-first BYOS companion for the Fynch Product Console — reads code and runs AI calls from your own machine instead of the hosted server.",
   "type": "module",
   "license": "MIT",