xibecode 0.9.9 → 1.0.0

package/dist/core/tools.js

@@ -20,8 +20,26 @@ import { SwarmOrchestrator } from './swarm.js';
 import { PermissionManager } from './permissions.js';
 import { McpOAuthFlowManager } from './mcp/oauth-flow.js';
 const execAsync = promisify(exec);
+const DEFAULT_COMMAND_OUTPUT_CHARS = 20000;
+function compactCommandOutput(value, maxChars) {
+    if (value.length <= maxChars) {
+        return { output: value, truncated: false, originalLength: value.length };
+    }
+    const marker = `\n\n[output truncated: kept head/tail, original length ${value.length} chars]\n\n`;
+    const available = Math.max(0, maxChars - marker.length);
+    const headLength = Math.ceil(available * 0.6);
+    const tailLength = Math.floor(available * 0.4);
+    return {
+        output: `${value.slice(0, headLength)}${marker}${value.slice(value.length - tailLength)}`,
+        truncated: true,
+        originalLength: value.length,
+    };
+}
 /** Returned by former Playwright-backed browser tools; XibeCode does not bundle browsers. */
 export const NO_EMBEDDED_BROWSER_MESSAGE = 'XibeCode does not bundle Playwright, Chromium, or agent-browser. Install agent-browser globally on supported OS/arch if you want it, or use your environment browser MCP / fetch_url. For Playwright E2E in a repo, add @playwright/test there and run it via run_command.';
+export const __testing = {
+    compactCommandOutput,
+};
 /**
  * Main tool executor for XibeCode agent
  *
@@ -420,7 +438,7 @@ export class CodingToolExecutor {
                     if (!p.command || typeof p.command !== 'string') {
                         return { error: true, success: false, message: 'Missing required parameter: command (string)' };
                     }
-                    return this.runCommand(p.command, p.cwd, p.input, p.timeout);
+                    return this.runCommand(p.command, p.cwd, p.input, p.timeout, p.max_output_chars);
                 }
                 case 'create_directory': {
                     if (!p.path || typeof p.path !== 'string') {
@@ -1116,6 +1134,10 @@ export class CodingToolExecutor {
                             type: 'number',
                             description: 'Timeout in seconds (default: 120). Increase for long-running commands like installs.',
                         },
+                        max_output_chars: {
+                            type: 'number',
+                            description: `Maximum stdout/stderr characters to return per stream (default: ${DEFAULT_COMMAND_OUTPUT_CHARS}). Large output is summarized with head/tail context.`,
+                        },
                     },
                     required: ['command'],
                 },
@@ -1821,10 +1843,16 @@ export class CodingToolExecutor {
         }
     }
     async readMultipleFiles(paths) {
-        const results = await Promise.allSettled(paths.map(async (p) => {
-            const content = await this.readFile(p);
-            return { path: p, ...content };
-        }));
+        const CONCURRENCY_LIMIT = 20;
+        const results = [];
+        for (let i = 0; i < paths.length; i += CONCURRENCY_LIMIT) {
+            const chunk = paths.slice(i, i + CONCURRENCY_LIMIT);
+            const chunkResults = await Promise.allSettled(chunk.map(async (p) => {
+                const content = await this.readFile(p);
+                return { path: p, ...content };
+            }));
+            results.push(...chunkResults);
+        }
         return {
             files: results
                 .filter((r) => r.status === 'fulfilled')
@@ -1984,25 +2012,31 @@ export class CodingToolExecutor {
         const fullPath = this.resolvePath(dirPath);
         try {
             const entries = await fs.readdir(fullPath, { withFileTypes: true });
-            const results = await Promise.all(entries.map(async (entry) => {
-                const entryPath = path.join(fullPath, entry.name);
-                try {
-                    const stats = await fs.stat(entryPath);
-                    return {
-                        name: entry.name,
-                        type: entry.isDirectory() ? 'directory' : 'file',
-                        size: stats.size,
-                        modified: stats.mtime,
-                    };
-                }
-                catch {
-                    return {
-                        name: entry.name,
-                        type: entry.isDirectory() ? 'directory' : 'file',
-                        size: 0,
-                    };
-                }
-            }));
+            const CONCURRENCY_LIMIT = 50;
+            const results = [];
+            for (let i = 0; i < entries.length; i += CONCURRENCY_LIMIT) {
+                const chunk = entries.slice(i, i + CONCURRENCY_LIMIT);
+                const chunkResults = await Promise.all(chunk.map(async (entry) => {
+                    const entryPath = path.join(fullPath, entry.name);
+                    try {
+                        const stats = await fs.stat(entryPath);
+                        return {
+                            name: entry.name,
+                            type: entry.isDirectory() ? 'directory' : 'file',
+                            size: stats.size,
+                            modified: stats.mtime,
+                        };
+                    }
+                    catch {
+                        return {
+                            name: entry.name,
+                            type: entry.isDirectory() ? 'directory' : 'file',
+                            size: 0,
+                        };
+                    }
+                }));
+                results.push(...chunkResults);
+            }
             return { path: dirPath, entries: results, count: results.length };
         }
         catch (error) {
@@ -2078,86 +2112,69 @@ export class CodingToolExecutor {
             return { error: true, success: false, message: `Dynamic tool "${toolName}" not found` };
         return this.runCommand(def.script, this.workingDir, undefined, 60);
     }
-    async runCommand(command, cwd, input, timeout) {
+    async runCommand(command, cwd, input, timeout, maxOutputChars) {
         const workDir = cwd ? this.resolvePath(cwd) : this.workingDir;
         const timeoutMs = (timeout || 120) * 1000;
         const shell = this.platform === 'win32' ? 'powershell.exe' : '/bin/sh';
-        // ── Use spawn when stdin input is provided ──
-        if (input) {
-            return new Promise((resolve) => {
-                const child = spawn(shell, this.platform === 'win32' ? ['-Command', command] : ['-c', command], {
-                    cwd: workDir,
-                    env: { ...process.env },
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                });
-                let stdout = '';
-                let stderr = '';
-                let killed = false;
-                const timer = setTimeout(() => {
-                    killed = true;
-                    child.kill('SIGTERM');
-                }, timeoutMs);
-                child.stdout.on('data', (data) => { stdout += data.toString(); });
-                child.stderr.on('data', (data) => { stderr += data.toString(); });
-                // Pipe stdin input (supports \n for multiple answers)
-                const stdinData = input.replace(/\\n/g, '\n');
-                child.stdin.write(stdinData);
-                child.stdin.end();
-                child.on('close', (code) => {
-                    clearTimeout(timer);
-                    resolve({
-                        stdout: stdout.trim(),
-                        stderr: stderr.trim(),
-                        success: !killed && code === 0,
-                        exitCode: code,
-                        timedOut: killed,
-                        platform: this.platform,
-                    });
-                });
-                child.on('error', (err) => {
-                    clearTimeout(timer);
-                    resolve({
-                        stdout: stdout.trim(),
-                        stderr: err.message,
-                        success: false,
-                        platform: this.platform,
-                    });
-                });
-            });
-        }
-        // ── Regular exec with timeout ──
-        try {
-            const { stdout, stderr } = await execAsync(command, {
+        const outputLimit = Math.max(1000, maxOutputChars ?? DEFAULT_COMMAND_OUTPUT_CHARS);
+        return new Promise((resolve) => {
+            const child = spawn(shell, this.platform === 'win32' ? ['-Command', command] : ['-c', command], {
                 cwd: workDir,
-                maxBuffer: 1024 * 1024 * 10,
-                timeout: timeoutMs,
-                shell: this.platform === 'win32' ? 'powershell.exe' : undefined,
+                env: { ...process.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
             });
-            return {
-                stdout: stdout.trim(),
-                stderr: stderr.trim(),
-                success: true,
-                platform: this.platform,
-            };
-        }
-        catch (error) {
-            if (error.killed) {
-                return {
-                    stdout: error.stdout?.trim() || '',
-                    stderr: 'Command timed out after ' + (timeout || 120) + 's. Try increasing the timeout parameter, or use non-interactive flags like --yes to avoid prompts.',
-                    success: false,
-                    timedOut: true,
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            let settled = false;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                const compactedStdout = compactCommandOutput(String(result.stdout ?? '').trim(), outputLimit);
+                const compactedStderr = compactCommandOutput(String(result.stderr ?? '').trim(), outputLimit);
+                resolve({
+                    ...result,
+                    stdout: compactedStdout.output,
+                    stderr: compactedStderr.output,
+                    truncated: compactedStdout.truncated || compactedStderr.truncated,
+                    originalStdoutLength: compactedStdout.originalLength,
+                    originalStderrLength: compactedStderr.originalLength,
                     platform: this.platform,
-                };
-            }
-            return {
-                stdout: error.stdout?.trim() || '',
-                stderr: error.stderr?.trim() || error.message,
-                success: false,
-                exitCode: error.code,
-                platform: this.platform,
+                });
             };
-        }
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+            }, timeoutMs);
+            child.stdout.on('data', (data) => { stdout += data.toString(); });
+            child.stderr.on('data', (data) => { stderr += data.toString(); });
+            if (input) {
+                child.stdin.write(input.replace(/\\n/g, '\n'));
+            }
+            child.stdin.end();
+            child.on('close', (code) => {
+                finish({
+                    stdout,
+                    stderr: timedOut
+                        ? `${stderr}\nCommand timed out after ${timeout || 120}s. Try increasing the timeout parameter, or use non-interactive flags like --yes to avoid prompts.`
+                        : stderr,
+                    success: !timedOut && code === 0,
+                    exitCode: code,
+                    timedOut,
+                });
+            });
+            child.on('error', (err) => {
+                finish({
+                    stdout,
+                    stderr: err.message,
+                    success: false,
+                    exitCode: undefined,
+                    timedOut,
+                });
+            });
+        });
     }
     async createDirectory(dirPath) {
         const fullPath = this.resolvePath(dirPath);