Files
waggle-os/packages/agent/src/tool-command.ts
Oleg Maslov b20b138fe4 moving
2026-09-02 10:14:22 +02:00

155 lines
5.3 KiB
TypeScript

import { existsSync, readFileSync } from 'node:fs';
import { execFile } from 'node:child_process';
import { win32 as pathWin32 } from 'node:path';
import { promisify } from 'node:util';
const execFileAsync = promisify(execFile);
export interface ToolCommandInvocation {
binary: string;
args: string[];
windowsVerbatimArguments?: boolean;
}
export interface ToolCommandResolutionDeps {
readTextFile?: (path: string) => string | null;
fileExists?: (path: string) => boolean;
nodeBinary?: string;
env?: NodeJS.ProcessEnv;
pathLookup?: (binary: string, env: NodeJS.ProcessEnv) => Promise<string[]>;
fallbackToWhere?: boolean;
}
function defaultReadTextFile(path: string): string | null {
try {
return readFileSync(path, 'utf8');
} catch {
return null;
}
}
function defaultFileExists(path: string): boolean {
return existsSync(path);
}
function npmCmdShimTarget(content: string): string | null {
const packageShim = content.match(/"%_prog%"\s+"%dp0%[\\/]+([^"]+)"/i);
if (packageShim?.[1]) return packageShim[1];
// npm 11's own npm.cmd/npx.cmd use NPM_CLI_JS/NPX_CLI_JS rather than
// the package-shim `_prog` template. Resolve their local JS entrypoint so
// model-supplied argv never passes through cmd.exe expansion.
const npmCli = content.match(/SET\s+"(?:NPM|NPX)_CLI_JS=%~dp0[\\/]+([^"]+)"/i);
return npmCli?.[1] ?? null;
}
export function resolveToolCommandInvocation(
binary: string,
args: string[],
platform: NodeJS.Platform = process.platform,
deps: ToolCommandResolutionDeps = {},
): ToolCommandInvocation {
if (platform === 'win32' && /\.(?:cmd|bat)$/i.test(binary)) {
const readTextFile = deps.readTextFile ?? defaultReadTextFile;
const fileExists = deps.fileExists ?? defaultFileExists;
const content = readTextFile(binary);
const shimTarget = content ? npmCmdShimTarget(content) : null;
if (shimTarget) {
const shimDir = pathWin32.dirname(binary);
const localNode = pathWin32.join(shimDir, 'node.exe');
return {
binary: fileExists(localNode) ? localNode : (deps.nodeBinary ?? 'node'),
args: [pathWin32.join(shimDir, shimTarget), ...args],
};
}
throw Object.assign(
new Error(`UNSAFE_WINDOWS_BATCH_SHIM: Refusing unrecognized Windows batch shim: ${binary}`),
{ code: 'UNSAFE_WINDOWS_BATCH_SHIM' },
);
}
return { binary, args };
}
function envValue(env: NodeJS.ProcessEnv, name: string): string | undefined {
const match = Object.entries(env).find(([key]) => key.toUpperCase() === name);
return match?.[1];
}
function windowsLookupEnv(source: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
const env: NodeJS.ProcessEnv = {};
for (const name of ['PATH', 'PATHEXT', 'SYSTEMROOT', 'WINDIR']) {
const value = envValue(source, name);
if (value !== undefined) env[name] = value;
}
return env;
}
async function defaultWindowsPathLookup(
binary: string,
env: NodeJS.ProcessEnv,
fallbackToWhere: boolean,
): Promise<string[]> {
const pathValue = envValue(env, 'PATH') ?? '';
const extension = pathWin32.extname(binary);
const extensions = extension
? ['']
: (envValue(env, 'PATHEXT') ?? '.COM;.EXE;.BAT;.CMD')
.split(';')
.filter((item) => /^\.(?:exe|com|cmd|bat)$/i.test(item));
for (const rawDir of pathValue.split(';')) {
const directory = rawDir.trim().replace(/^"(.*)"$/, '$1');
if (!directory) continue;
for (const suffix of extensions) {
const candidate = pathWin32.join(directory, `${binary}${suffix}`);
if (existsSync(candidate)) return [candidate];
}
}
if (!fallbackToWhere) return [];
// `where.exe` remains the authoritative fallback for App Execution Aliases
// and other Windows resolution cases not represented as ordinary PATH files.
const windowsRoot = envValue(env, 'SYSTEMROOT') ?? envValue(env, 'WINDIR') ?? 'C:\\Windows';
const whereBinary = pathWin32.join(windowsRoot, 'System32', 'where.exe');
const { stdout } = await execFileAsync(whereBinary, [binary], {
env,
timeout: 3_000,
windowsHide: true,
});
return stdout
.split(/\r?\n/)
.map((candidate) => candidate.trim())
.filter(Boolean);
}
/**
* Resolve a bare Windows command through PATH before applying cmd-shim
* handling. Node's shell-free spawn does not honor PATHEXT for npm/npx .cmd
* shims, so spawning the logical name directly fails with ENOENT.
*/
export async function resolveToolCommandInvocationFromPath(
binary: string,
args: string[],
platform: NodeJS.Platform = process.platform,
deps: ToolCommandResolutionDeps = {},
): Promise<ToolCommandInvocation> {
if (platform !== 'win32' || pathWin32.isAbsolute(binary) || /[\\/]/.test(binary)) {
return resolveToolCommandInvocation(binary, args, platform, deps);
}
const lookupEnv = windowsLookupEnv(deps.env ?? process.env);
let candidates: string[];
try {
candidates = deps.pathLookup
? await deps.pathLookup(binary, lookupEnv)
: await defaultWindowsPathLookup(binary, lookupEnv, deps.fallbackToWhere !== false);
} catch {
// Preserve the original spawn error when PATH lookup itself fails.
return resolveToolCommandInvocation(binary, args, platform, deps);
}
const resolved = candidates.find((candidate) => /\.(?:exe|com|cmd|bat)$/i.test(candidate));
if (resolved) return resolveToolCommandInvocation(resolved, args, platform, deps);
return resolveToolCommandInvocation(binary, args, platform, deps);
}