langflower 0.0.6 → 0.0.7

package/vendor/common-nodes/dist/ai/llm-loop/run-llm-loop.js

@@ -407,19 +407,42 @@ const invokeTool = (state, call, options, cancelSignal) => {
             ? `Error: Sub-Agent ${payload.callId} timed out after ${options.recovery.subagentTimeoutMs}ms.`
             : `Error: ${classifyLlmFailure(error).message}`)), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
     }
-    const invocation$ = defer(() => invokeInventoryTool(options.harness, options.inventoryTools, call, options.toolCtx, options.policy.toolNotAllowedText === undefined
-        ? undefined
-        : {
-            notInAllowlistText: options.policy.toolNotAllowedText,
-        }));
+    const toolAbort = new AbortController();
+    const abortTool = () => {
+        toolAbort.abort();
+    };
+    cancelSignal.addEventListener('abort', abortTool);
+    const invokeOptions = {
+        ...(options.policy.toolNotAllowedText === undefined
+            ? {}
+            : {
+                notInAllowlistText: options.policy.toolNotAllowedText,
+            }),
+        signal: toolAbort.signal,
+    };
+    const invocation$ = defer(() => invokeInventoryTool(options.harness, options.inventoryTools, call, options.toolCtx, invokeOptions).catch((error) => {
+        // Avoid unhandled rejection when timeout/cancel aborts in-flight work.
+        if (toolAbort.signal.aborted) {
+            return {
+                ok: false,
+                text: 'Tool aborted.',
+            };
+        }
+        throw error;
+    })).pipe(finalize(() => {
+        cancelSignal.removeEventListener('abort', abortTool);
+    }));
     const boundedInvocation$ = options.recovery.toolTimeoutMs > 0
         ? invocation$.pipe(timeout({
             first: options.recovery.toolTimeoutMs,
         }))
         : invocation$;
-    return concat(of(callLog), boundedInvocation$.pipe(map((result) => result.ok ? result.text : `Error: ${result.text}`), catchError((error) => of(error instanceof TimeoutError
-        ? `Error: Tool ${call.name} timed out after ${options.recovery.toolTimeoutMs}ms.`
-        : `Error: ${classifyLlmFailure(error).message}`)), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
+    return concat(of(callLog), boundedInvocation$.pipe(map((result) => result.ok ? result.text : `Error: ${result.text}`), catchError((error) => {
+        abortTool();
+        return of(error instanceof TimeoutError
+            ? `Error: Tool ${call.name} timed out after ${options.recovery.toolTimeoutMs}ms.`
+            : `Error: ${classifyLlmFailure(error).message}`);
+    }), mergeMap((result) => toolResultPackets(state, call, result, options, []))));
 };
 const toolResultPackets = (state, call, result, options, prefix) => {
     const normalized = normalizeToolResult(result, options.recovery.maxToolResultChars);

package/vendor/common-nodes/dist/tools/inventory-tool-round.d.ts

@@ -15,6 +15,7 @@ export declare const parseToolArgs: (raw: string) => Readonly<Record<string, unk
  */
 export declare const invokeInventoryTool: (harness: Harness | undefined, tools: readonly ToolHandle[], call: ChatCompletionToolCall, toolCtx: ToolHandlerContext | undefined, options?: {
     readonly notInAllowlistText?: (toolName: string) => string;
+    readonly signal?: AbortSignal;
 }) => Promise<{
     readonly ok: boolean;
     readonly text: string;

package/vendor/common-nodes/dist/tools/inventory-tool-round.js

@@ -60,8 +60,11 @@ export const invokeInventoryTool = async (harness, tools, call, toolCtx, options
     }
     const args = parseToolArgs(call.arguments);
     const toolId = handle.toolId.length > 0 ? handle.toolId : handle.name;
+    const ctx = options?.signal === undefined
+        ? toolCtx
+        : { ...toolCtx, signal: options.signal };
     if (isBuiltinToolId(toolId)) {
-        const authorize = toolCtx.authorize ?? harness?.authorize;
+        const authorize = ctx.authorize ?? harness?.authorize;
         if (authorize === undefined) {
             return {
                 ok: false,
@@ -77,7 +80,7 @@ export const invokeInventoryTool = async (harness, tools, call, toolCtx, options
         }
     }
     try {
-        const text = await handle.invoke(args, toolCtx);
+        const text = await handle.invoke(args, ctx);
         return { ok: true, text };
     }
     catch (error) {

package/vendor/server/dist/bridge/wrap-builtin-tool-handles.js

@@ -23,10 +23,15 @@ export const wrapBuiltinToolHandles = (harness, enabledToolIds, permission) => {
         name: reg.name,
         description: reg.description,
         inputSchema: reg.inputSchema,
-        invoke: async (args) => {
+        invoke: async (args, toolCtx) => {
+            // Shell passes tools host bag (optional signal); SDK type stays identity-only.
+            const hostCtx = toolCtx;
             const result = await harness.invoke({
                 toolId: reg.toolId,
                 args,
+                ...(hostCtx?.signal !== undefined
+                    ? { signal: hostCtx.signal }
+                    : {}),
             });
             if (!result.ok) {
                 throw new Error(result.text);

package/vendor/tools/dist/builtins/catalog.d.ts

@@ -75,13 +75,13 @@ export declare const BUILTIN_TOOLS: readonly [{
     readonly registration: {
         readonly toolId: "grep";
         readonly name: "grep";
-        readonly description: "Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.";
+        readonly description: "Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.";
         readonly inputSchema: {
             readonly type: "object";
             readonly properties: {
                 readonly pattern: {
                     readonly type: "string";
-                    readonly description: "JavaScript RegExp source";
+                    readonly description: "Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)";
                 };
                 readonly path: {
                     readonly type: "string";

package/vendor/tools/dist/builtins/command-exists.d.ts

@@ -0,0 +1,5 @@
+/**
+ * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
+ * Result is cached per process.
+ */
+export declare const commandExists: (cmd: string) => Promise<boolean>;

package/vendor/tools/dist/builtins/command-exists.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process';
+const cache = new Map();
+/**
+ * True when `cmd` resolves on PATH (`where` on Windows, `which` elsewhere).
+ * Result is cached per process.
+ */
+export const commandExists = async (cmd) => {
+    const cached = cache.get(cmd);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const checkCmd = process.platform === 'win32' ? 'where' : 'which';
+    const exists = await new Promise((resolve) => {
+        const child = spawn(checkCmd, [cmd], {
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.on('error', () => {
+            resolve(false);
+        });
+        child.on('close', (code) => {
+            resolve(code === 0);
+        });
+    });
+    cache.set(cmd, exists);
+    return exists;
+};

package/vendor/tools/dist/builtins/grep/search.d.ts

@@ -0,0 +1,43 @@
+import { type SpawnCaptureOptions, type SpawnCaptureResult } from '../spawn-capture.js';
+export declare const MAX_GREP_MATCHES = 100;
+type GrepHit = {
+    readonly file: string;
+    readonly line: number;
+    readonly text: string;
+};
+export type GrepSearchInput = {
+    readonly pattern: string;
+    readonly caseInsensitive: boolean;
+    readonly respectGitignore: boolean;
+    /** Absolute search file or directory (already fenced). */
+    readonly searchAbsolute: string;
+    /** Fence root for relative display paths. */
+    readonly fenceRoot: string;
+    readonly displayPath: (absolute: string) => string;
+    readonly signal?: AbortSignal;
+};
+export type GrepSearchDeps = {
+    readonly commandExists?: (cmd: string) => Promise<boolean>;
+    readonly spawnCapture?: (command: string, args: readonly string[], options?: SpawnCaptureOptions) => Promise<SpawnCaptureResult>;
+};
+type GrepSearchOutcome = {
+    readonly ok: true;
+    readonly hits: readonly GrepHit[];
+    readonly truncated: boolean;
+    readonly backend: 'rg' | 'grep' | 'node';
+} | {
+    readonly ok: false;
+    readonly reason: 'unavailable' | 'error';
+    readonly message: string;
+};
+export declare const searchWithNodeWalk: (input: GrepSearchInput) => Promise<GrepSearchOutcome>;
+/**
+ * ts-scan-style cascade: rg → grep → bounded Node walk.
+ * Soft-falls through when a CLI binary is missing or fails to spawn;
+ * Node tier surfaces invalid JS RegExp errors.
+ */
+export declare const runGrepCascade: (input: GrepSearchInput, deps?: GrepSearchDeps) => Promise<{
+    readonly body: string;
+    readonly backend: "rg" | "grep" | "node";
+}>;
+export {};

package/vendor/tools/dist/builtins/grep/search.js

@@ -0,0 +1,315 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { commandExists } from '../command-exists.js';
+import { spawnCapture, } from '../spawn-capture.js';
+import { WALK_EXCLUDE_DIR_NAMES, walkFiles } from '../walk-files.js';
+export const MAX_GREP_MATCHES = 100;
+const MAX_GREP_FILES_SCANNED = 5_000;
+const MAX_GREP_FILE_BYTES = 1_048_576;
+const MAX_GREP_LINE_CHARS = 8_000;
+const SEARCH_EXCLUDE_GLOBS = [
+    '!**/node_modules/**',
+    '!**/dist/**',
+    '!**/build/**',
+    '!**/.git/**',
+];
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw new Error('aborted');
+    }
+};
+const formatHits = (hits, truncated) => {
+    if (hits.length === 0) {
+        return '(no matches)';
+    }
+    const body = hits
+        .map((hit) => `${hit.file}:${hit.line}:${hit.text}`)
+        .join('\n');
+    return truncated
+        ? `${body}\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
+        : body;
+};
+const formatGrepBody = (hits, truncated) => formatHits(hits, truncated);
+const parseLineHits = (stdout, displayPath, fenceRoot, maxHits) => {
+    const hits = [];
+    const lines = stdout.split(/\r?\n/);
+    for (const raw of lines) {
+        if (raw.length === 0) {
+            continue;
+        }
+        const match = /^(.+?):(\d+):(.*)$/.exec(raw);
+        if (match === null) {
+            continue;
+        }
+        const fileAbs = path.isAbsolute(match[1] ?? '')
+            ? (match[1] ?? '')
+            : path.join(fenceRoot, match[1] ?? '');
+        const line = Number(match[2]);
+        const text = match[3] ?? '';
+        if (!Number.isFinite(line)) {
+            continue;
+        }
+        hits.push({
+            file: displayPath(fileAbs),
+            line,
+            text: text.length > MAX_GREP_LINE_CHARS
+                ? `${text.slice(0, MAX_GREP_LINE_CHARS)}…`
+                : text,
+        });
+        if (hits.length >= maxHits) {
+            return { hits, truncated: true };
+        }
+    }
+    return { hits, truncated: false };
+};
+const isBinaryAbortError = (error) => error instanceof Error &&
+    (error.name === 'AbortError' || error.message === 'aborted');
+const searchWithRipgrep = async (input, deps = {}) => {
+    const exists = deps.commandExists ?? commandExists;
+    const run = deps.spawnCapture ?? spawnCapture;
+    if (!(await exists('rg'))) {
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: 'ripgrep (rg) is not available on this system',
+        };
+    }
+    throwIfAborted(input.signal);
+    const args = [
+        '-n',
+        '--color',
+        'never',
+        '--max-filesize',
+        `${MAX_GREP_FILE_BYTES}`,
+        ...(input.respectGitignore ? [] : ['--no-ignore']),
+        ...SEARCH_EXCLUDE_GLOBS.flatMap((glob) => ['--glob', glob]),
+        ...(input.caseInsensitive ? ['-i'] : []),
+        '-e',
+        input.pattern,
+        input.searchAbsolute,
+    ];
+    try {
+        const result = await run('rg', args, {
+            cwd: input.fenceRoot,
+            ...(input.signal !== undefined ? { signal: input.signal } : {}),
+        });
+        // rg: 0 = matches, 1 = no matches, 2 = error
+        if (result.code !== null && result.code >= 2) {
+            const detail = result.stderr.trim();
+            return {
+                ok: false,
+                reason: 'error',
+                message: detail.length > 0
+                    ? `ripgrep failed: ${detail}`
+                    : 'ripgrep failed',
+            };
+        }
+        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
+        return {
+            ok: true,
+            hits: parsed.hits,
+            truncated: parsed.truncated,
+            backend: 'rg',
+        };
+    }
+    catch (error) {
+        if (isBinaryAbortError(error)) {
+            throw new Error('aborted');
+        }
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: error instanceof Error
+                ? error.message
+                : 'Error executing ripgrep',
+        };
+    }
+};
+const searchWithGrep = async (input, deps = {}) => {
+    const exists = deps.commandExists ?? commandExists;
+    const run = deps.spawnCapture ?? spawnCapture;
+    if (!(await exists('grep'))) {
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: 'grep is not available on this system',
+        };
+    }
+    throwIfAborted(input.signal);
+    const args = [
+        '-r',
+        '-n',
+        '-E',
+        '-I',
+        ...(input.caseInsensitive ? ['-i'] : []),
+        ...WALK_EXCLUDE_DIR_NAMES.flatMap((name) => ['--exclude-dir', name]),
+        '-e',
+        input.pattern,
+        input.searchAbsolute,
+    ];
+    try {
+        const result = await run('grep', args, {
+            cwd: input.fenceRoot,
+            ...(input.signal !== undefined ? { signal: input.signal } : {}),
+        });
+        // grep: 0 = matches, 1 = no matches, ≥2 = error
+        if (result.code !== null && result.code >= 2) {
+            const detail = result.stderr.trim();
+            return {
+                ok: false,
+                reason: 'error',
+                message: detail.length > 0
+                    ? `grep failed: ${detail}`
+                    : 'grep failed',
+            };
+        }
+        const parsed = parseLineHits(result.stdout, input.displayPath, input.fenceRoot, MAX_GREP_MATCHES);
+        return {
+            ok: true,
+            hits: parsed.hits,
+            truncated: parsed.truncated,
+            backend: 'grep',
+        };
+    }
+    catch (error) {
+        if (isBinaryAbortError(error)) {
+            throw new Error('aborted');
+        }
+        return {
+            ok: false,
+            reason: 'unavailable',
+            message: error instanceof Error ? error.message : 'Error executing grep',
+        };
+    }
+};
+const looksBinary = (buf) => {
+    const sample = buf.subarray(0, Math.min(buf.length, 8_192));
+    return sample.includes(0);
+};
+const yieldEventLoop = () => new Promise((resolve) => {
+    setImmediate(resolve);
+});
+export const searchWithNodeWalk = async (input) => {
+    throwIfAborted(input.signal);
+    let regex;
+    try {
+        regex = new RegExp(input.pattern, input.caseInsensitive ? 'i' : '');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            reason: 'error',
+            message: `Invalid regex «${input.pattern}»: ${message}. Escape special characters or simplify the pattern.`,
+        };
+    }
+    const stat = await fs.stat(input.searchAbsolute).catch(() => null);
+    if (stat === null) {
+        return {
+            ok: false,
+            reason: 'error',
+            message: `Path not found: ${input.searchAbsolute}`,
+        };
+    }
+    const files = stat.isFile()
+        ? [input.searchAbsolute]
+        : (await walkFiles(input.fenceRoot, input.searchAbsolute, {
+            respectGitignore: input.respectGitignore,
+            ...(input.signal !== undefined
+                ? { signal: input.signal }
+                : {}),
+            maxFiles: MAX_GREP_FILES_SCANNED,
+        })).map((relative) => path.join(input.fenceRoot, relative));
+    const hits = [];
+    let matchCapHit = false;
+    let scanned = 0;
+    for (const fileAbs of files) {
+        throwIfAborted(input.signal);
+        scanned += 1;
+        if (scanned % 16 === 0) {
+            await yieldEventLoop();
+            throwIfAborted(input.signal);
+        }
+        if (hits.length >= MAX_GREP_MATCHES) {
+            matchCapHit = true;
+            break;
+        }
+        let buf;
+        try {
+            const handle = await fs.open(fileAbs, 'r');
+            try {
+                const st = await handle.stat();
+                if (st.size > MAX_GREP_FILE_BYTES) {
+                    continue;
+                }
+                buf = Buffer.alloc(Number(st.size));
+                await handle.read(buf, 0, buf.length, 0);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            continue;
+        }
+        if (looksBinary(buf)) {
+            continue;
+        }
+        const text = buf.toString('utf8');
+        const lines = text.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            let line = lines[i] ?? '';
+            if (line.length > MAX_GREP_LINE_CHARS) {
+                line = line.slice(0, MAX_GREP_LINE_CHARS);
+            }
+            if (regex.test(line)) {
+                hits.push({
+                    file: input.displayPath(fileAbs),
+                    line: i + 1,
+                    text: line,
+                });
+                if (hits.length >= MAX_GREP_MATCHES) {
+                    matchCapHit = true;
+                    break;
+                }
+            }
+        }
+    }
+    const fileCapHit = !stat.isFile() && files.length >= MAX_GREP_FILES_SCANNED;
+    return {
+        ok: true,
+        hits,
+        truncated: matchCapHit || fileCapHit,
+        backend: 'node',
+    };
+};
+/**
+ * ts-scan-style cascade: rg → grep → bounded Node walk.
+ * Soft-falls through when a CLI binary is missing or fails to spawn;
+ * Node tier surfaces invalid JS RegExp errors.
+ */
+export const runGrepCascade = async (input, deps = {}) => {
+    throwIfAborted(input.signal);
+    const rg = await searchWithRipgrep(input, deps);
+    if (rg.ok) {
+        return {
+            body: formatGrepBody(rg.hits, rg.truncated),
+            backend: rg.backend,
+        };
+    }
+    const grep = await searchWithGrep(input, deps);
+    if (grep.ok) {
+        return {
+            body: formatGrepBody(grep.hits, grep.truncated),
+            backend: grep.backend,
+        };
+    }
+    const node = await searchWithNodeWalk(input);
+    if (!node.ok) {
+        throw new Error(node.message);
+    }
+    return {
+        body: formatGrepBody(node.hits, node.truncated),
+        backend: node.backend,
+    };
+};

package/vendor/tools/dist/builtins/grep/tool.d.ts

@@ -4,13 +4,13 @@ export declare const grepTool: {
     readonly registration: {
         readonly toolId: "grep";
         readonly name: "grep";
-        readonly description: "Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.";
+        readonly description: "Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.";
         readonly inputSchema: {
             readonly type: "object";
             readonly properties: {
                 readonly pattern: {
                     readonly type: "string";
-                    readonly description: "JavaScript RegExp source";
+                    readonly description: "Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)";
                 };
                 readonly path: {
                     readonly type: "string";

package/vendor/tools/dist/builtins/grep/tool.js

@@ -4,23 +4,15 @@ import { formatNotFound, resolveFenceRoot, resolveProjectPath, } from '../../pat
 import { applyPostProcess } from '../apply-post-process.js';
 import { asBoolean, asString } from '../args.js';
 import { displayPath, fenceOptions } from '../fence.js';
-import { walkFiles } from '../walk-files.js';
-const MAX_GREP_MATCHES = 100;
+import { runGrepCascade } from './search.js';
 const invoke = async (ctx, args) => {
     const pattern = asString(args, 'pattern');
     if (pattern === undefined) {
         throw new Error('grep requires string argument «pattern».');
     }
-    let regex;
-    try {
-        regex = new RegExp(pattern, asBoolean(args, 'caseInsensitive', false) ? 'i' : '');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid regex «${pattern}»: ${message}. Escape special characters or simplify the pattern.`);
-    }
     const searchPath = asString(args, 'path') ?? '.';
     const respectGitignore = asBoolean(args, 'respectGitignore', true);
+    const caseInsensitive = asBoolean(args, 'caseInsensitive', false);
     const absolute = resolveProjectPath(ctx.projectRoot, searchPath, fenceOptions(ctx));
     const stat = await fs.stat(absolute).catch(() => null);
     if (stat === null) {
@@ -28,39 +20,15 @@ const invoke = async (ctx, args) => {
     }
     const fenceRoot = resolveFenceRoot(ctx.projectRoot, absolute, ctx.allowedRoots) ??
         path.resolve(ctx.projectRoot);
-    const files = stat.isFile()
-        ? [displayPath(ctx, absolute)]
-        : (await walkFiles(fenceRoot, absolute, respectGitignore)).map((file) => displayPath(ctx, path.join(fenceRoot, file)));
-    const hits = [];
-    for (const file of files) {
-        if (hits.length >= MAX_GREP_MATCHES) {
-            break;
-        }
-        const fileAbs = resolveProjectPath(ctx.projectRoot, file, fenceOptions(ctx));
-        let text;
-        try {
-            text = await fs.readFile(fileAbs, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const lines = text.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i += 1) {
-            const line = lines[i] ?? '';
-            if (regex.test(line)) {
-                hits.push(`${file}:${i + 1}:${line}`);
-                if (hits.length >= MAX_GREP_MATCHES) {
-                    break;
-                }
-            }
-        }
-    }
-    const body = hits.length === 0
-        ? '(no matches)'
-        : hits.join('\n') +
-            (hits.length >= MAX_GREP_MATCHES
-                ? `\n…[truncated at ${MAX_GREP_MATCHES}; refine pattern or path]`
-                : '');
+    const { body } = await runGrepCascade({
+        pattern,
+        caseInsensitive,
+        respectGitignore,
+        searchAbsolute: absolute,
+        fenceRoot,
+        displayPath: (fileAbs) => displayPath(ctx, fileAbs),
+        ...(ctx.signal !== undefined ? { signal: ctx.signal } : {}),
+    });
     return applyPostProcess(args, body);
 };
 export const grepTool = {
@@ -68,13 +36,13 @@ export const grepTool = {
     registration: {
         toolId: 'grep',
         name: 'grep',
-        description: 'Regex search across project files (gitignore-aware by default; Node walk — not ripgrep). Optional postProcess.',
+        description: 'Regex search across project files (gitignore-aware by default; ripgrep when available, else grep, else bounded Node walk). Optional postProcess.',
         inputSchema: {
             type: 'object',
             properties: {
                 pattern: {
                     type: 'string',
-                    description: 'JavaScript RegExp source',
+                    description: 'Regex pattern (ripgrep dialect when rg is available; JavaScript RegExp on Node fallback)',
                 },
                 path: {
                     type: 'string',

package/vendor/tools/dist/builtins/spawn-capture.d.ts

@@ -0,0 +1,15 @@
+export type SpawnCaptureResult = {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number | null;
+};
+export type SpawnCaptureOptions = {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+    readonly maxStdout?: number;
+};
+/**
+ * Async spawn with arg array (no shell). Honors AbortSignal via Node's
+ * spawn `signal` (kills the child). Caps captured stdout.
+ */
+export declare const spawnCapture: (command: string, args: readonly string[], options?: SpawnCaptureOptions) => Promise<SpawnCaptureResult>;

package/vendor/tools/dist/builtins/spawn-capture.js

@@ -0,0 +1,42 @@
+import { spawn } from 'node:child_process';
+/**
+ * Async spawn with arg array (no shell). Honors AbortSignal via Node's
+ * spawn `signal` (kills the child). Caps captured stdout.
+ */
+export const spawnCapture = (command, args, options = {}) => {
+    const maxStdout = options.maxStdout ?? 2_000_000;
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            reject(new Error('aborted'));
+            return;
+        }
+        const child = spawn(command, [...args], {
+            cwd: options.cwd,
+            windowsHide: true,
+            shell: false,
+            ...(options.signal !== undefined ? { signal: options.signal } : {}),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            if (stdout.length < maxStdout) {
+                stdout += String(chunk);
+                if (stdout.length > maxStdout) {
+                    stdout = stdout.slice(0, maxStdout);
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+            if (stderr.length > 64_000) {
+                stderr = stderr.slice(0, 64_000);
+            }
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve({ stdout, stderr, code });
+        });
+    });
+};