@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/tools/bash/streaming-executor.js

@@ -5,6 +5,8 @@
  * as they arrive from the spawned process.
  */
 import { spawn } from 'child_process';
+import { StringDecoder } from 'node:string_decoder';
+import { BoundedOutput } from '../../utils/bounded-output.js';
 import { ConfirmationService } from '../../utils/confirmation-service.js';
 import { validateCommand as validateCommandSafety } from '../../utils/input-validator.js';
 import { validateCommand } from './command-validator.js';
@@ -149,106 +151,92 @@ export async function* executeStreaming(command, timeout = 30000, deps, signal)
     });
     const runningProcesses = deps.getRunningProcesses();
     runningProcesses.add(proc);
-    let stdout = '';
-    let stderr = '';
-    let timedOut = false;
-    let aborted = false;
-    let onAbort = () => { };
-    const timer = setTimeout(() => {
-        timedOut = true;
+    const stdout = new BoundedOutput(deps.maxOutputBytes);
+    const stderr = new BoundedOutput(deps.maxOutputBytes);
+    const pending = new BoundedOutput(deps.maxOutputBytes);
+    const outDecoder = new StringDecoder('utf8');
+    const errDecoder = new StringDecoder('utf8');
+    let done = false;
+    let failure;
+    let wake;
+    let killTimer;
+    const notify = () => { wake?.(); wake = undefined; };
+    const kill = (signal) => {
         try {
-            proc.kill('SIGTERM');
-        }
-        catch { /* ignore */ }
-    }, timeout);
-    try {
-        // Create a readable stream from stdout and stderr combined
-        const chunks = [];
-        let resolve = null;
-        let done = false;
-        const killProcess = () => {
-            try {
-                if (!isWindows && proc.pid)
-                    process.kill(-proc.pid, 'SIGTERM');
-                else
-                    proc.kill('SIGTERM');
-            }
-            catch {
-                try {
-                    proc.kill('SIGTERM');
-                }
-                catch { /* process already exited */ }
-            }
-        };
-        onAbort = () => {
-            aborted = true;
-            killProcess();
-            if (resolve) {
-                resolve();
-                resolve = null;
-            }
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
-        if (signal?.aborted)
-            onAbort();
-        const onData = (data, isStderr) => {
-            const text = data.toString();
-            if (isStderr)
-                stderr += text;
+            if (!isWindows && proc.pid)
+                process.kill(-proc.pid, signal);
             else
-                stdout += text;
-            chunks.push(text);
-            if (resolve) {
-                resolve();
-                resolve = null;
-            }
-        };
-        proc.stdout?.on('data', (data) => onData(data, false));
-        proc.stderr?.on('data', (data) => onData(data, true));
-        proc.on('close', () => { done = true; if (resolve) {
-            resolve();
-            resolve = null;
-        } });
-        while (!done) {
-            if (chunks.length > 0) {
-                while (chunks.length > 0) {
-                    yield chunks.shift();
-                }
-            }
-            else {
-                await new Promise(r => { resolve = r; });
-            }
+                proc.kill(signal);
         }
-        // Yield remaining chunks
-        while (chunks.length > 0) {
-            yield chunks.shift();
+        catch { /* The process or its group already exited. */ }
+    };
+    const stop = (reason) => {
+        if (done || failure)
+            return;
+        failure = reason;
+        kill('SIGTERM');
+        // Sending a signal is not proof of exit. Escalate even if the parent
+        // closes its pipes while a descendant still holds the process group.
+        killTimer = setTimeout(() => {
+            kill('SIGKILL');
+            done = true;
+            notify();
+        }, 250);
+        notify();
+    };
+    const timer = setTimeout(() => stop(`Command timed out after ${timeout}ms`), timeout);
+    const onAbort = () => stop('Command aborted by user');
+    const onError = (error) => {
+        failure ??= `Command failed to start: ${error.message}`;
+        done = true;
+        notify();
+    };
+    const onClose = () => {
+        if (!failure)
+            done = true;
+        notify();
+    };
+    const onData = (data, target, decoder) => {
+        const text = decoder.write(data);
+        target.append(text);
+        pending.append(text);
+        notify();
+    };
+    const onStdout = (data) => onData(data, stdout, outDecoder);
+    const onStderr = (data) => onData(data, stderr, errDecoder);
+    proc.stdout?.on('data', onStdout);
+    proc.stderr?.on('data', onStderr);
+    proc.on('error', onError);
+    proc.on('close', onClose);
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (signal?.aborted)
+        onAbort();
+    try {
+        while (!done || pending.retainedBytes > 0) {
+            if (pending.retainedBytes > 0)
+                yield pending.drain();
+            else if (!done)
+                await new Promise(resolve => { wake = resolve; });
         }
     }
     finally {
         clearTimeout(timer);
+        clearTimeout(killTimer);
         signal?.removeEventListener('abort', onAbort);
+        // Also handles a consumer calling return() before the child exits.
+        if (!done || failure)
+            kill('SIGKILL');
+        proc.stdout?.removeListener('data', onStdout);
+        proc.stderr?.removeListener('data', onStderr);
+        proc.removeListener('close', onClose);
         runningProcesses.delete(proc);
-        if (!proc.killed && proc.exitCode === null) {
-            proc.kill('SIGTERM');
-            setTimeout(() => {
-                try {
-                    if (!proc.killed)
-                        proc.kill('SIGKILL');
-                }
-                catch { /* already dead */ }
-            }, 5000);
-        }
-    }
-    if (aborted) {
-        return { success: false, error: 'Command aborted by user', output: stdout };
-    }
-    if (timedOut) {
-        return { success: false, error: `Command timed out after ${timeout}ms` };
     }
-    const exitCode = proc.exitCode ?? 0;
-    if (exitCode !== 0) {
-        return { success: false, error: stderr || `Exit code ${exitCode}`, output: stdout };
+    const output = stdout.text();
+    if (failure)
+        return { success: false, error: failure, output };
+    if (proc.exitCode !== 0) {
+        return { success: false, error: stderr.text() || `Exit code ${proc.exitCode}`, output };
     }
-    return { success: true, output: stdout };
+    return { success: true, output };
 }
 //# sourceMappingURL=streaming-executor.js.map

package/dist/tools/code-exec-preflight-runner.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Standalone isolated TypeScript preflight compiler runner.
+ *
+ * Runs inside an isolated worker/child process with:
+ * - 128MB max heap limit (--max-old-space-size=128)
+ * - Virtual in-memory file system (zero disk I/O for guest files)
+ * - Bounded diagnostics (max 20 diagnostics / 16KB formatted error size)
+ * - Full rejection of global, compiler options, environment, and guest diagnostics
+ * - Complete isolation from external module imports
+ */
+export interface PreflightWorkerPayload {
+    code: string;
+    declarations: string;
+    strict?: boolean;
+    target?: string;
+}
+export interface PreflightDiagnostic {
+    line?: number;
+    column?: number;
+    message: string;
+    code?: number;
+    category: 'error' | 'warning' | 'suggestion' | 'message';
+    file?: string;
+}
+export interface PreflightWorkerResult {
+    success: boolean;
+    diagnostics: PreflightDiagnostic[];
+    error?: string;
+    transpiledCode?: string;
+    declarations?: string;
+}
+export declare const PREFLIGHT_LIMITS: Readonly<{
+    timeoutMs: 5000;
+    maxHeapMb: 128;
+    maxDiagnostics: 20;
+    maxErrorBytes: number;
+}>;
+/**
+ * Execute isolated in-memory TypeScript compilation and diagnostic collection.
+ */
+export declare function executePreflightCompilation(payload: PreflightWorkerPayload): PreflightWorkerResult;

package/dist/tools/code-exec-preflight-runner.js

@@ -0,0 +1,254 @@
+/**
+ * Standalone isolated TypeScript preflight compiler runner.
+ *
+ * Runs inside an isolated worker/child process with:
+ * - 128MB max heap limit (--max-old-space-size=128)
+ * - Virtual in-memory file system (zero disk I/O for guest files)
+ * - Bounded diagnostics (max 20 diagnostics / 16KB formatted error size)
+ * - Full rejection of global, compiler options, environment, and guest diagnostics
+ * - Complete isolation from external module imports
+ */
+import ts from 'typescript';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+export const PREFLIGHT_LIMITS = Object.freeze({
+    timeoutMs: 5_000,
+    maxHeapMb: 128,
+    maxDiagnostics: 20,
+    maxErrorBytes: 16 * 1024,
+});
+const require = createRequire(import.meta.url);
+const tsLibDir = path.dirname(require.resolve('typescript'));
+const tsLibCache = new Map();
+function getCachedLibSourceFile(fileName, languageVersionOrOptions) {
+    const baseName = path.basename(fileName);
+    if (tsLibCache.has(baseName)) {
+        return tsLibCache.get(baseName);
+    }
+    const fullPath = path.join(tsLibDir, baseName);
+    if (ts.sys.fileExists(fullPath)) {
+        const content = ts.sys.readFile(fullPath);
+        if (content !== undefined) {
+            const sf = ts.createSourceFile(fileName, content, languageVersionOrOptions, true);
+            tsLibCache.set(baseName, sf);
+            return sf;
+        }
+    }
+    return undefined;
+}
+const defaultCompilerOptions = {
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    noImplicitAny: true,
+    strictNullChecks: true,
+    strictFunctionTypes: true,
+    strictBindCallApply: true,
+    strictPropertyInitialization: true,
+    noImplicitThis: true,
+    alwaysStrict: true,
+    noUnusedLocals: false,
+    noUnusedParameters: false,
+    exactOptionalPropertyTypes: false,
+    noEmit: true,
+    skipLibCheck: true,
+};
+/**
+ * Execute isolated in-memory TypeScript compilation and diagnostic collection.
+ */
+export function executePreflightCompilation(payload) {
+    const { code, declarations, strict, target } = payload;
+    const syntax = ts.createSourceFile('/input.ts', code, ts.ScriptTarget.ES2022, true);
+    let forbidden;
+    const inspect = (node) => {
+        if (ts.isImportDeclaration(node) || ts.isImportEqualsDeclaration(node) || ts.isImportTypeNode(node)
+            || (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword)
+            || (ts.isExportDeclaration(node) && node.moduleSpecifier)) {
+            forbidden = 'Module imports are not allowed in code_exec scripts';
+        }
+        if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name))
+            forbidden = 'Ambient module declarations are not allowed in code_exec scripts';
+        ts.forEachChild(node, inspect);
+    };
+    inspect(syntax);
+    if (syntax.referencedFiles.length || syntax.typeReferenceDirectives.length || syntax.libReferenceDirectives.length)
+        forbidden = 'TypeScript triple-slash reference directives are not allowed in code_exec scripts';
+    if (forbidden)
+        return { success: false, diagnostics: [{ message: forbidden, category: 'error' }], error: forbidden };
+    const wrappedGuestCode = `async function __codeBuddyMain() {\n${code}\n}`;
+    const virtualFiles = new Map([
+        ['/code_exec_env.d.ts', declarations],
+        ['/guest_code.ts', wrappedGuestCode],
+    ]);
+    let scriptTarget = ts.ScriptTarget.ES2022;
+    if (target) {
+        const targetUpper = target.toUpperCase();
+        if (targetUpper === 'ES2020')
+            scriptTarget = ts.ScriptTarget.ES2020;
+        else if (targetUpper === 'ES2021')
+            scriptTarget = ts.ScriptTarget.ES2021;
+        else if (targetUpper === 'ES2022')
+            scriptTarget = ts.ScriptTarget.ES2022;
+        else if (targetUpper === 'ESNEXT')
+            scriptTarget = ts.ScriptTarget.ESNext;
+    }
+    const compilerOptions = {
+        ...defaultCompilerOptions,
+        target: scriptTarget,
+        ...(strict !== undefined ? { strict } : {}),
+    };
+    const host = {
+        getSourceFile: (fileName, languageVersion) => {
+            if (virtualFiles.has(fileName)) {
+                return ts.createSourceFile(fileName, virtualFiles.get(fileName), languageVersion, true, ts.ScriptKind.TS);
+            }
+            if (fileName.includes('lib.') && fileName.endsWith('.d.ts')) {
+                return getCachedLibSourceFile(fileName, languageVersion);
+            }
+            return undefined;
+        },
+        getDefaultLibFileName: (opts) => ts.getDefaultLibFileName(opts),
+        writeFile: () => { },
+        getCurrentDirectory: () => '/',
+        getDirectories: () => [],
+        getCanonicalFileName: (fileName) => fileName,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n',
+        fileExists: (fileName) => virtualFiles.has(fileName) ||
+            (fileName.includes('lib.') &&
+                ts.sys.fileExists(path.join(tsLibDir, path.basename(fileName)))),
+        readFile: (fileName) => virtualFiles.get(fileName) ||
+            (fileName.includes('lib.')
+                ? ts.sys.readFile(path.join(tsLibDir, path.basename(fileName)))
+                : undefined),
+        resolveModuleNameLiterals: () => [],
+        resolveModuleNames: () => [],
+    };
+    const program = ts.createProgram(['/code_exec_env.d.ts', '/guest_code.ts'], compilerOptions, host);
+    // Collect all diagnostics: syntactic, global, options, semantic, declaration
+    const syntacticDiagnostics = program.getSyntacticDiagnostics();
+    const globalDiagnostics = program.getGlobalDiagnostics();
+    const optionsDiagnostics = program.getOptionsDiagnostics();
+    const semanticDiagnostics = program.getSemanticDiagnostics();
+    const declarationDiagnostics = program.getDeclarationDiagnostics();
+    const allDiagnostics = [
+        ...syntacticDiagnostics,
+        ...globalDiagnostics,
+        ...optionsDiagnostics,
+        ...semanticDiagnostics,
+        ...declarationDiagnostics,
+    ];
+    const errorDiagnostics = allDiagnostics.filter((d) => d.category === ts.DiagnosticCategory.Error);
+    if (errorDiagnostics.length === 0) {
+        let transpiledCode;
+        try {
+            const transpiled = ts.transpileModule(code, {
+                compilerOptions: {
+                    target: compilerOptions.target ?? ts.ScriptTarget.ES2022,
+                    module: ts.ModuleKind.ESNext,
+                },
+            });
+            transpiledCode = transpiled.outputText;
+        }
+        catch {
+            // Retain original code if transpilation throws
+        }
+        return {
+            success: true,
+            diagnostics: [],
+            transpiledCode,
+            declarations,
+        };
+    }
+    const formattedDiagnostics = [];
+    const errorMessages = [];
+    for (const d of errorDiagnostics) {
+        let line;
+        let column;
+        const fileName = d.file?.fileName;
+        if (d.file && d.start !== undefined) {
+            const pos = d.file.getLineAndCharacterOfPosition(d.start);
+            if (fileName === '/guest_code.ts') {
+                // Adjust line number for the async wrapper
+                line = Math.max(1, pos.line);
+            }
+            else {
+                line = pos.line + 1;
+            }
+            column = pos.character + 1;
+        }
+        const msgText = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+        const category = d.category === ts.DiagnosticCategory.Error
+            ? 'error'
+            : d.category === ts.DiagnosticCategory.Warning
+                ? 'warning'
+                : d.category === ts.DiagnosticCategory.Suggestion
+                    ? 'suggestion'
+                    : 'message';
+        formattedDiagnostics.push({
+            line,
+            column,
+            message: msgText,
+            code: d.code,
+            category,
+            file: fileName,
+        });
+        let loc = '';
+        if (fileName === '/guest_code.ts') {
+            loc = line !== undefined ? `Line ${line}${column !== undefined ? `:${column}` : ''}: ` : '';
+        }
+        else if (fileName === '/code_exec_env.d.ts') {
+            loc = `[Environment${line !== undefined ? ` Line ${line}` : ''}]: `;
+        }
+        else if (fileName) {
+            loc = `[${fileName}${line !== undefined ? ` Line ${line}` : ''}]: `;
+        }
+        else {
+            loc = '[Global/Compiler]: ';
+        }
+        errorMessages.push(`${loc}${msgText}`);
+    }
+    const boundedDiagnostics = formattedDiagnostics.slice(0, PREFLIGHT_LIMITS.maxDiagnostics);
+    const totalErrors = errorDiagnostics.length;
+    const header = totalErrors > PREFLIGHT_LIMITS.maxDiagnostics
+        ? `TypeScript preflight validation failed (${PREFLIGHT_LIMITS.maxDiagnostics} of ${totalErrors} errors shown):\n`
+        : 'TypeScript preflight validation failed:\n';
+    let summary = header + errorMessages.slice(0, PREFLIGHT_LIMITS.maxDiagnostics).map((m) => `• ${m}`).join('\n');
+    if (totalErrors > PREFLIGHT_LIMITS.maxDiagnostics) {
+        summary += `\n…[truncated ${totalErrors - PREFLIGHT_LIMITS.maxDiagnostics} diagnostic(s)]`;
+    }
+    if (summary.length > PREFLIGHT_LIMITS.maxErrorBytes) {
+        const marker = '\n…[truncated diagnostics exceeding 16KB limit]';
+        summary = summary.slice(0, Math.max(0, PREFLIGHT_LIMITS.maxErrorBytes - marker.length)) + marker;
+    }
+    return {
+        success: false,
+        diagnostics: boundedDiagnostics,
+        error: summary,
+        declarations,
+    };
+}
+// Standalone child process IPC listener
+if (typeof process.send === 'function') {
+    process.on('message', (rawMessage) => {
+        if (!rawMessage || typeof rawMessage !== 'object')
+            return;
+        const msg = rawMessage;
+        if (msg.type === 'compile' && msg.payload) {
+            try {
+                const result = executePreflightCompilation(msg.payload);
+                // Full tool catalogues can exceed the IPC pipe buffer. Exit only once
+                // Node has flushed the response, otherwise successful checks disappear.
+                process.send({ type: 'result', result }, error => process.exit(error ? 1 : 0));
+            }
+            catch (error) {
+                process.send({
+                    type: 'error',
+                    error: error instanceof Error ? error.message : String(error),
+                }, error => process.exit(error ? 1 : 0));
+            }
+        }
+    });
+}
+//# sourceMappingURL=code-exec-preflight-runner.js.map

package/dist/tools/code-exec-preflight.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TypeScript preflight validation for Code Mode (`code_exec`).
+ *
+ * Runs isolated TypeScript typechecking in a sandboxed worker/child process
+ * against declarations derived exclusively from the runtime-scoped tool catalog.
+ *
+ * Invariants:
+ * 1. Hard 5s deadline + 128MB heap isolation in a separate worker/child process.
+ * 2. Lazy loading: TypeScript is NOT imported in the parent process or when typecheck is false.
+ * 3. Bounded diagnostics: limited to 20 diagnostics and 16KB total formatted output.
+ * 4. Zero guest filesystem access: virtual files only in-memory; no guest file reads/writes.
+ * 5. No hidden tool/import exposure: declarations are generated strictly from `availableTools`.
+ * 6. Fail-closed: invalid code or compiler/global errors are rejected before child process spawn or tool dispatch.
+ */
+import type { IToolExecutionContext } from './registry/types.js';
+import { type CodeExecRuntime, type ToolCatalogEntry } from './code-exec-tool.js';
+import type { PreflightDiagnostic, PreflightWorkerResult } from './code-exec-preflight-runner.js';
+export type { PreflightDiagnostic, PreflightWorkerResult as PreflightResult };
+export interface PreflightOptions {
+    target?: string;
+    strict?: boolean;
+    catalog?: readonly ToolCatalogEntry[];
+    signal?: AbortSignal;
+}
+export declare function jsonSchemaPropertyToTs(prop: unknown, indent?: string): string;
+interface ExtractedArgsType {
+    typeName: string;
+    typeDeclaration: string;
+    hasRequiredProps: boolean;
+}
+export declare function extractToolArgsType(toolName: string, parameters: unknown, typeIndex: number): ExtractedArgsType;
+/**
+ * Resolve tool catalog entries strictly scoped to `runtime.availableTools`.
+ * Tools not in `runtime.availableTools` are never returned.
+ */
+export declare function resolveScopedToolCatalog(runtime: CodeExecRuntime, context?: IToolExecutionContext): ToolCatalogEntry[];
+/**
+ * Generate TypeScript declarations matching the scoped runtime environment.
+ */
+export declare function generateToolDeclarations(scopedTools: readonly ToolCatalogEntry[]): string;
+/**
+ * Execute isolated TypeScript preflight typechecking in a worker/child process.
+ */
+export declare function runCodeExecPreflight(code: string, runtime: CodeExecRuntime, context?: IToolExecutionContext, options?: PreflightOptions): Promise<PreflightWorkerResult>;