@withtruing/companion 0.0.0-stage → 0.13.0

package/dist/api-key-caller.js

@@ -0,0 +1,388 @@
+/**
+ * The 3b backend (see the local-companion plan's Section 3) — no CLI dependency, calls the
+ * model directly with a locally-configured API key. Structurally mirrors server/drift.ts's
+ * verifyModuleAgainstCode almost exactly (same two-pass shape: pick candidate files, then judge
+ * against their contents) — the two things that actually change are which machine runs it and
+ * that file reads go through node:fs against the local checkout instead of the GitHub API, so
+ * nothing here truncates a file's contents the way MAX_FILE_CHARS does server-side.
+ *
+ * fileSelectSchema below is a deliberate duplicate of server/drift.ts's own (not imported —
+ * this package is meant to be independently publishable, see types.ts's own comment). Keep the
+ * two in sync by hand if either changes.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildLocalDesignContext } from './design-context.js';
+import { buildLocalRepoContext, listRepoFiles } from './local-scan.js';
+import { appendDiffToVolatile, prepareShipmentAnalysis } from './shipment.js';
+import { replyText, streamWithFallback } from './text-model.js';
+const MAX_CANDIDATE_FILES = 8;
+/** A skip threshold, not a truncation — a file over this is left OUT of what's read entirely
+ *  (with a note in the log), rather than read and cut off partway through. The whole point of
+ *  this backend is that what IS read is never truncated; this only guards against an
+ *  accidentally-selected generated/binary/data file blowing up the prompt. */
+const MAX_FILE_BYTES = 512 * 1024;
+/** Structured model-only call used by the investigation reader. The reader, not this call and
+ * not the model, owns every repository read and evidence id. */
+export async function runStructuredModelCall(client, request) {
+    const stream = streamWithFallback(client, {
+        model: request.model,
+        max_tokens: request.maxTokens,
+        thinking: { type: 'adaptive' },
+        output_config: {
+            effort: request.effort,
+            format: { type: 'json_schema', schema: request.schema },
+        },
+        system: request.system,
+        messages: [{ role: 'user', content: request.prompt }],
+    });
+    let message;
+    try {
+        message = await stream.finalMessage();
+    }
+    catch (error) {
+        if (error instanceof Anthropic.RateLimitError) {
+            throw new Error('budget_exhausted: Anthropic API rate limit (HTTP 429).', { cause: error });
+        }
+        throw error;
+    }
+    if (message.stop_reason === 'max_tokens')
+        throw new Error('budget_exhausted: the structured investigation call reached its output-token limit.');
+    const text = replyText(message, 'The model declined the structured investigation call.');
+    if (!text)
+        throw new Error('The structured investigation call returned no text.');
+    return JSON.parse(text);
+}
+export const fileSelectSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['paths'],
+    properties: {
+        paths: {
+            type: 'array',
+            items: { type: 'string' },
+            description: `Up to ${MAX_CANDIDATE_FILES} repo file paths (verbatim from the tree) most likely to implement this module. Prefer source over tests/config. Empty if nothing in the tree plausibly implements it.`,
+        },
+    },
+};
+async function readLocalFile(repoPath, relPath) {
+    try {
+        const buf = await readFile(join(repoPath, relPath));
+        if (buf.byteLength > MAX_FILE_BYTES) {
+            console.warn(`  [skip] ${relPath} is ${Math.round(buf.byteLength / 1024)}KB — over the ${MAX_FILE_BYTES / 1024}KB safety threshold, leaving it out rather than truncating it`);
+            return null;
+        }
+        return buf.toString('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/** Runs the whole verify_module task locally and returns exactly what
+ * POST /api/companion/tasks/:id/result expects — `result` validated server-side against the
+ * exact schema the task shipped with (task.payload.spec.schema), `filesRead` for the UI's
+ * provenance note. Throws on anything that should surface as a task error (caller reports it
+ * via POST .../error). */
+export async function runVerifyModuleTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    const spec = payload.spec;
+    const allFiles = await listRepoFiles(repoPath);
+    console.log(`  scanning ${allFiles.length} files in ${repoPath}…`);
+    // Pass 1: which files implement this module? Reuses the module-spec text the server already
+    // wrote into spec.volatileText (buildVerifyModuleTaskSpec) as context — it already contains
+    // the full spec, so this doesn't need to re-derive it.
+    const selectPrompt = `${spec.volatileText}
+
+# The repository file tree (${allFiles.length} files)
+
+${allFiles.join('\n')}
+
+# Before judging
+
+First, list the file paths (verbatim from the tree above, up to ${MAX_CANDIDATE_FILES}) most
+likely to implement this module's behaviour. Prefer application source over tests, config, and
+generated files. Empty list if nothing plausibly implements it.`;
+    const selectMsg = await callModel({
+        purpose: 'verify_module:file_select',
+        model: spec.model,
+        maxTokens: 2000,
+        effort: 'low',
+        system: spec.system,
+        stableText: '',
+        text: selectPrompt,
+        schema: fileSelectSchema,
+    });
+    const known = new Set(allFiles);
+    const chosen = JSON.parse(selectMsg.text).paths.filter((p) => known.has(p)).slice(0, MAX_CANDIDATE_FILES);
+    if (chosen.length === 0) {
+        return {
+            filesRead: [],
+            result: {
+                verdict: 'differs',
+                specSaid: 'See the module spec above.',
+                codeDid: 'No file in the local checkout appears to implement this module.',
+                differences: ['Nothing in the local checkout plausibly implements this spec — it may be unbuilt, or the code lives outside this checkout.'],
+            },
+        };
+    }
+    const files = (await Promise.all(chosen.map(async (p) => {
+        const content = await readLocalFile(repoPath, p);
+        return content !== null ? { path: p, content } : null;
+    }))).filter((f) => f !== null);
+    console.log(`  reading ${files.map((f) => f.path).join(', ') || '(nothing readable)'}`);
+    // Pass 2: does the code satisfy the spec? spec.system/spec.volatileText/spec.schema are sent
+    // by the server unchanged — this is the exact same prompt+schema the server-execution path
+    // would use, just pointed at unbounded local file contents instead of truncated GitHub reads.
+    const verdictMsg = await callModel({
+        purpose: 'verify_module:judge',
+        model: spec.model,
+        maxTokens: spec.maxTokens,
+        effort: spec.effort,
+        system: spec.system,
+        stableText: spec.stableText,
+        text: `${spec.volatileText}\n\n# The actual code, as it currently stands locally\n\n${files.map((f) => `## ${f.path}\n\n\`\`\`\n${f.content}\n\`\`\``).join('\n\n')}`,
+        schema: spec.schema,
+    });
+    return { result: JSON.parse(verdictMsg.text), filesRead: files.map((f) => f.path) };
+}
+/* ------------------------------------------------------------------ generate_spec_batch */
+/** Matches verify_module's own MAX_CANDIDATE_FILES — tried lower (4) first on the theory that a
+ *  batch multiplies by however many modules it holds, but a real end-to-end test caught it
+ *  under-reading: a module genuinely spread across companion/, server/, and src/ (this repo's
+ *  own "Local Companion Agent" module, dogfooded during Phase 3 development) got 4 real files
+ *  read and produced an accurate spec for what it saw, but never even considered
+ *  server/companion.ts or src/CompanionModal.tsx — half the actual implementation. Comfortably
+ *  beats the server path's own FILES_PER_MODULE=2 (bootstrap.ts) either way; this raises the
+ *  ceiling for the genuinely multi-file case rather than assuming it wouldn't come up. */
+const MAX_FILES_PER_MODULE_IN_BATCH = 8;
+export const batchFileSelectSchema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['selections'],
+    properties: {
+        selections: {
+            type: 'array',
+            description: 'One entry per module in the batch, in the same order.',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['moduleId', 'paths'],
+                properties: {
+                    moduleId: { type: 'string' },
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: `Up to ${MAX_FILES_PER_MODULE_IN_BATCH} repo file paths (verbatim from the tree) most likely to implement this module. Empty if nothing plausibly does.`,
+                    },
+                },
+            },
+        },
+    },
+};
+/** Runs a whole generate_spec_batch task locally — writes full specs for every module in the
+ *  batch (up to server/bootstrap.ts's BATCH_SIZE, currently 5) in one task. Same two-pass shape
+ *  as runVerifyModuleTask (pick files, then use them), just per-module in pass 1 and producing
+ *  the whole specs array in pass 2. `spec.volatileText` already carries the per-module id/lane/
+ *  purpose breakdown and the "find files yourself" instruction (buildSpecBatchVolatile,
+ *  server/bootstrap.ts) — this only adds the file tree and, in pass 2, what was actually read. */
+export async function runGenerateSpecBatchTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    const spec = payload.spec;
+    const moduleIds = payload.moduleIds;
+    if (payload.connectionless) {
+        // The PRD is already in spec.stableText (stableTextForLocalDispatch); there is nothing local to read.
+        const writeMsg = await callModel({
+            purpose: 'generate_spec_batch:write',
+            model: spec.model,
+            maxTokens: spec.maxTokens,
+            effort: spec.effort,
+            system: spec.system,
+            stableText: spec.stableText,
+            text: spec.volatileText,
+            schema: spec.schema,
+        });
+        return { result: JSON.parse(writeMsg.text), filesRead: [] };
+    }
+    const allFiles = await listRepoFiles(repoPath);
+    console.log(`  scanning ${allFiles.length} files in ${repoPath} for ${moduleIds.length} module(s)…`);
+    // Pass 1: which files relate to each module in this batch?
+    const selectPrompt = `${spec.volatileText}
+
+# The repository file tree (${allFiles.length} files)
+
+${allFiles.join('\n')}
+
+# Before writing specs
+
+For EACH module above (by id: ${moduleIds.join(', ')}), list up to ${MAX_FILES_PER_MODULE_IN_BATCH}
+file paths (verbatim from the tree above) most likely to implement it. One entry per module id,
+in the same order as given.`;
+    const selectMsg = await callModel({
+        purpose: 'generate_spec_batch:file_select',
+        model: spec.model,
+        maxTokens: 3000,
+        effort: 'low',
+        system: spec.system,
+        stableText: '',
+        text: selectPrompt,
+        schema: batchFileSelectSchema,
+    });
+    const known = new Set(allFiles);
+    const selections = JSON.parse(selectMsg.text).selections;
+    const uniquePaths = [...new Set(selections.flatMap((s) => s.paths.filter((p) => known.has(p)).slice(0, MAX_FILES_PER_MODULE_IN_BATCH)))];
+    const fileMap = new Map();
+    await Promise.all(uniquePaths.map(async (p) => {
+        const content = await readLocalFile(repoPath, p);
+        if (content !== null)
+            fileMap.set(p, content);
+    }));
+    console.log(`  reading ${[...fileMap.keys()].join(', ') || '(nothing readable)'}`);
+    // Pass 2: write the actual specs, grounded in what was read.
+    const filesSection = selections
+        .map((s) => {
+        const found = s.paths.filter((p) => fileMap.has(p));
+        return `## Files read for ${s.moduleId}\n\n${found.length ? found.map((p) => `### ${p}\n\`\`\`\n${fileMap.get(p)}\n\`\`\``).join('\n\n') : '(nothing readable found for this module)'}`;
+    })
+        .join('\n\n');
+    const writeMsg = await callModel({
+        purpose: 'generate_spec_batch:write',
+        model: spec.model,
+        maxTokens: spec.maxTokens,
+        effort: spec.effort,
+        system: spec.system,
+        stableText: spec.stableText,
+        text: `${spec.volatileText}\n\n# Related files, as found in the local checkout\n\n${filesSection}`,
+        schema: spec.schema,
+    });
+    return { result: JSON.parse(writeMsg.text), filesRead: [...fileMap.keys()] };
+}
+/* ---------------------------------------------------- propose_skeleton / propose_new_capabilities */
+/**
+ * Both propose_skeleton and propose_new_capabilities are "shallow whole-repo" tasks — server
+ * sends stableText/volatileText built with NO repo content at all (see bootstrap.ts's
+ * stableTextForLocalDispatch / buildCapabilityScanVolatile's repoCtx-null branch), because
+ * there's nothing GitHub-sourced to send: the whole point of dispatching is that the companion
+ * reads the repo itself. Unlike verify_module/generate_spec_batch, there's no per-module drilling
+ * here — just one shallow local scan (file tree + README/CHANGELOG/package.json, mirroring
+ * server/bootstrap.ts's own RepoContext shape) appended after spec.volatileText, then one model
+ * call. filesRead is always empty for these two: neither result shape uses it (check
+ * server/index.ts's completeAiJob payloads for /api/setup/skeleton and
+ * /api/module-suggestions/scan — neither includes it), so there's nothing meaningful to report.
+ */
+async function runShallowRepoTask(callModel, purpose, spec, repoPath, connectionless = false) {
+    let repoSection = '';
+    if (!connectionless) {
+        const repoCtx = await buildLocalRepoContext(repoPath);
+        console.log(`  scanning ${repoCtx.fileList.length} files, README ${repoCtx.readme ? 'found' : 'not found'}, CHANGELOG ${repoCtx.changelog ? 'found' : 'not found'}, package.json ${repoCtx.packageJson ? 'found' : 'not found'}`);
+        repoSection = `
+# Repository context (your local checkout)
+
+## File tree (${repoCtx.fileList.length} files)
+${repoCtx.fileList.join('\n')}
+
+## README
+${repoCtx.readme ?? '(none found)'}
+
+## CHANGELOG
+${repoCtx.changelog ?? '(none found)'}
+
+## package.json
+${repoCtx.packageJson ?? '(none found)'}
+`.trim();
+    }
+    const message = await callModel({
+        purpose,
+        model: spec.model,
+        maxTokens: spec.maxTokens,
+        effort: spec.effort,
+        system: spec.system,
+        stableText: spec.stableText,
+        text: connectionless ? spec.volatileText : `${spec.volatileText}\n\n${repoSection}`,
+        schema: spec.schema,
+        documentBase64: spec.stableDocumentBase64,
+    });
+    return { result: spec.schema ? JSON.parse(message.text) : message.text, filesRead: [] };
+}
+/** Forward-compatible fallback for server-created graph/spec reasoning tasks. The server sends
+ *  the complete self-describing spec, so these calls never need or receive filesystem context. */
+export async function runGenericTask(callModel, task, repoPath) {
+    const spec = task.payload?.spec;
+    if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {
+        throw new Error(`Cannot run task kind "${task.kind}": payload.spec is missing or not an object.`);
+    }
+    return runShallowRepoTask(callModel, 'generic', spec, repoPath, true);
+}
+export async function runProposeSkeletonTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    return runShallowRepoTask(callModel, 'propose_skeleton', payload.spec, repoPath, payload.connectionless);
+}
+export async function runProposeNewCapabilitiesTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    return runShallowRepoTask(callModel, 'propose_new_capabilities', payload.spec, repoPath);
+}
+/* --------------------------------------------------------------------- design_prompt */
+/**
+ * The one task kind with no schema — spec.schema is undefined, so the model's raw text answer
+ * IS the result, never JSON.parse'd (unlike every other task kind here). Looks for local design
+ * signal (findDesignFiles, copied verbatim from server/design-context.ts — see design-context.ts's
+ * own comment) and appends it if found; spec.volatileText already carries the right instructions
+ * for both the "honor what you find" and "propose from scratch" cases (see export.ts's
+ * generateDesignPrompt — the local-dispatch branch decides which wording to send based on the
+ * same `direction` the server path already respects, before this ever reaches the companion).
+ */
+export async function runDesignPromptTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    const spec = payload.spec;
+    const designContext = await buildLocalDesignContext(repoPath);
+    console.log(`  design signal: ${designContext ? 'found' : 'none found'}`);
+    const message = await callModel({
+        purpose: 'design_prompt',
+        model: spec.model,
+        maxTokens: spec.maxTokens,
+        effort: spec.effort,
+        system: spec.system,
+        stableText: spec.stableText,
+        text: designContext ? `${spec.volatileText}\n\n# Design signal found in your local checkout\n\n${designContext}` : spec.volatileText,
+        schema: spec.schema,
+    });
+    return { result: message.text, filesRead: [] }; // filesRead unused for this kind — see propose_skeleton/propose_new_capabilities's own comment
+}
+/* --------------------------------------------------------------------- analyse_shipment */
+/**
+ * Runs a whole analyse_shipment task locally. Unlike every other task kind above, this one's
+ * "find the relevant content" step is git-level, not file-level (prepareShipmentAnalysis, see
+ * shipment.ts), and can conclude the task WITHOUT ever calling the model at all — a commit the
+ * companion's own local looksTrivial filter rejects is reported straight back as an empty
+ * result ({touched: [], possibleNewModules: []}), exactly the shape driftSchema already treats
+ * as a valid "nothing plausible here" answer, so there's no separate result shape to teach the
+ * server about. sha_not_local throws — the caller (cli.ts's runOneTask) reports it as a task
+ * error via POST .../error, which surfaces to checkConnection as one caught, per-commit failure
+ * (see server/poller.ts's own comment), not a crash that would wedge the rest of that check.
+ */
+export async function runAnalyseShipmentTask(callModel, task, repoPath) {
+    const payload = task.payload;
+    const prep = await prepareShipmentAnalysis(repoPath, payload.sha);
+    if (prep.outcome === 'sha_not_local') {
+        throw new Error(`sha_not_local: commit ${payload.sha} was not found in the local checkout at ${repoPath}, even after a git fetch.`);
+    }
+    if (prep.outcome === 'trivial') {
+        console.log(`  ${payload.sha.slice(0, 7)} looks trivial (lockfile/CI-config/build-output only) — skipping the AI call`);
+        return { result: { touched: [], possibleNewModules: [] }, filesRead: [] };
+    }
+    console.log(`  read ${payload.sha.slice(0, 7)}'s diff locally (${prep.diffText.length} chars, ${prep.changedPaths.length} file(s) changed)`);
+    const spec = appendDiffToVolatile(payload.spec, prep.diffText, prep.changedPaths);
+    const message = await callModel({
+        purpose: 'analyse_shipment',
+        model: spec.model,
+        maxTokens: spec.maxTokens,
+        effort: spec.effort,
+        system: spec.system,
+        stableText: spec.stableText,
+        text: spec.volatileText,
+        schema: spec.schema,
+    });
+    // filesRead unused for this kind, same as propose_skeleton/propose_new_capabilities above —
+    // dispatchAndAwaitLocalTask's caller (poller.ts) only consumes the parsed result, not filesRead.
+    return { result: JSON.parse(message.text), filesRead: [] };
+}

package/dist/claude-binary.js

@@ -0,0 +1,122 @@
+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(`[truing] ${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()) {
+    const hiddenOptions = { ...options, windowsHide: true };
+    if (resolution.viaShell) {
+        assertClaudeArgumentsSafeForFallback(args);
+        return crossSpawn(resolution.command, args, hiddenOptions);
+    }
+    return nodeSpawn(resolution.command, args, hiddenOptions);
+}