@blockrun/runcode 2.5.0 → 2.5.1

package/dist/agent/loop.js

@@ -267,6 +267,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 if (microCompacted !== history) {
                     history.length = 0;
                     history.push(...microCompacted);
+                    resetTokenAnchor(); // History shrunk — resync token tracking
                 }
             }
             // 3. Auto-compact: summarize history if approaching context limit

package/dist/agent/streaming-executor.js

@@ -39,21 +39,27 @@ export class StreamingExecutor {
     async collectResults(allInvocations) {
         const results = [];
         const alreadyStarted = new Set(this.pending.map(p => p.invocation.id));
-        // Wait for concurrent results that were started during streaming
-        for (const p of this.pending) {
-            const result = await p.promise;
-            results.push([p.invocation, result]);
+        const pendingSnapshot = [...this.pending];
+        this.pending = []; // Clear immediately so errors don't leave stale state
+        try {
+            // Wait for concurrent results that were started during streaming
+            for (const p of pendingSnapshot) {
+                const result = await p.promise;
+                results.push([p.invocation, result]);
+            }
+            // Execute sequential (non-concurrent) tools now
+            for (const inv of allInvocations) {
+                if (alreadyStarted.has(inv.id))
+                    continue;
+                this.onStart(inv.id, inv.name);
+                const result = await this.executeWithPermissions(inv);
+                results.push([inv, result]);
+            }
         }
-        // Execute sequential (non-concurrent) tools now
-        for (const inv of allInvocations) {
-            if (alreadyStarted.has(inv.id))
-                continue;
-            this.onStart(inv.id, inv.name);
-            const result = await this.executeWithPermissions(inv);
-            results.push([inv, result]);
+        catch (err) {
+            // Return partial results rather than losing them; caller handles errors
+            throw err;
         }
-        // Clear for next round
-        this.pending = [];
         return results;
     }
     async executeWithPermissions(invocation) {

package/dist/commands/start.js

@@ -170,7 +170,6 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     flushStats();
     await disconnectMcpServers();
     console.log(chalk.dim('\nGoodbye.\n'));
-    process.exit(0);
 }
 // ─── Basic readline UI (piped input) ───────────────────────────────────────
 async function runWithBasicUI(agentConfig, model, workDir) {
@@ -224,7 +223,6 @@ async function runWithBasicUI(agentConfig, model, workDir) {
     }
     ui.printGoodbye();
     flushStats();
-    process.exit(0);
 }
 async function handleSlashCommand(cmd, config, ui) {
     const parts = cmd.trim().split(/\s+/);

package/dist/index.js

@@ -108,6 +108,7 @@ if (firstArg === 'solana' || firstArg === 'base') {
         }
     }
     await startCommand(startOpts);
+    process.exit(0);
 }
 else if (!firstArg || (firstArg.startsWith('-') && !['-h', '--help', '-V', '--version'].includes(firstArg))) {
     // No subcommand or only flags — treat as 'start' with flags
@@ -122,6 +123,7 @@ else if (!firstArg || (firstArg.startsWith('-') && !['-h', '--help', '-V', '--ve
         }
     }
     await startCommand(startOpts);
+    process.exit(0);
 }
 else {
     program.parse();

package/dist/tools/bash.js

@@ -12,15 +12,22 @@ async function execute(input, ctx) {
     const timeoutMs = Math.min(timeout ?? DEFAULT_TIMEOUT_MS, 600_000);
     return new Promise((resolve) => {
         const shell = process.env.SHELL || '/bin/bash';
-        const child = spawn(shell, ['-c', command], {
-            cwd: ctx.workingDir,
-            env: {
-                ...process.env,
-                RUNCODE: '1', // Let scripts detect they're running inside runcode
-                RUNCODE_WORKDIR: ctx.workingDir,
-            },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
+        let child;
+        try {
+            child = spawn(shell, ['-c', command], {
+                cwd: ctx.workingDir,
+                env: {
+                    ...process.env,
+                    RUNCODE: '1', // Let scripts detect they're running inside runcode
+                    RUNCODE_WORKDIR: ctx.workingDir,
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch (spawnErr) {
+            resolve({ output: `Error spawning shell: ${spawnErr.message}`, isError: true });
+            return;
+        }
         let stdout = '';
         let stderr = '';
         let outputBytes = 0;

package/dist/ui/terminal.d.ts

@@ -10,15 +10,23 @@ export declare class TerminalUI {
     private totalInputTokens;
     private totalOutputTokens;
     private mdRenderer;
+    private lineQueue;
+    private lineWaiters;
+    private stdinEOF;
+    constructor();
     /**
      * Prompt the user for input. Returns null on EOF/exit.
+     * Uses a line-queue approach so piped input works across multiple calls.
      */
     promptUser(promptText?: string): Promise<string | null>;
+    private nextLine;
+    /** No-op kept for API compatibility — readline closes when stdin EOF. */
+    closeInput(): void;
     /**
      * Handle a stream event from the agent loop.
      */
     handleEvent(event: StreamEvent): void;
-    /** Check if input is a slash command. Returns true if handled. */
+    /** Check if input is a slash command. Returns true if handled locally (don't pass to agent). */
     handleSlashCommand(input: string): boolean;
     printWelcome(model: string, workDir: string): void;
     printUsageSummary(): void;

package/dist/ui/terminal.js

@@ -131,38 +131,65 @@ export class TerminalUI {
     totalInputTokens = 0;
     totalOutputTokens = 0;
     mdRenderer = new MarkdownRenderer();
-    /**
-     * Prompt the user for input. Returns null on EOF/exit.
-     */
-    async promptUser(promptText) {
+    // Line queue for piped (non-TTY) input — buffers all stdin lines eagerly
+    lineQueue = [];
+    lineWaiters = [];
+    stdinEOF = false;
+    constructor() {
         const rl = readline.createInterface({
             input: process.stdin,
             output: process.stderr,
-            terminal: process.stdin.isTTY ?? false,
+            terminal: false, // Always treat as non-TTY so line events fire for piped input
+        });
+        rl.on('line', (line) => {
+            if (this.lineWaiters.length > 0) {
+                // Someone is already waiting — deliver immediately
+                const waiter = this.lineWaiters.shift();
+                waiter(line);
+            }
+            else {
+                // Buffer the line for the next promptUser() call
+                this.lineQueue.push(line);
+            }
+        });
+        rl.on('close', () => {
+            this.stdinEOF = true;
+            this.lineQueue = []; // Don't deliver buffered lines after EOF — signal exit cleanly
+            for (const waiter of this.lineWaiters)
+                waiter(null);
+            this.lineWaiters = [];
         });
+    }
+    /**
+     * Prompt the user for input. Returns null on EOF/exit.
+     * Uses a line-queue approach so piped input works across multiple calls.
+     */
+    async promptUser(promptText) {
+        const prompt = promptText ?? chalk.bold.green('> ');
+        process.stderr.write(prompt);
+        const raw = await this.nextLine();
+        if (raw === null)
+            return null;
+        const trimmed = raw.trim();
+        if (trimmed === '/exit' || trimmed === '/quit')
+            return null;
+        return trimmed;
+    }
+    nextLine() {
+        if (this.lineQueue.length > 0) {
+            return Promise.resolve(this.lineQueue.shift());
+        }
+        if (this.stdinEOF) {
+            return Promise.resolve(null);
+        }
         return new Promise((resolve) => {
-            let answered = false;
-            const prompt = promptText ?? chalk.bold.green('> ');
-            rl.question(prompt, (answer) => {
-                answered = true;
-                rl.close();
-                const trimmed = answer.trim();
-                if (trimmed === '/exit' || trimmed === '/quit') {
-                    resolve(null);
-                }
-                else if (trimmed === '') {
-                    resolve('');
-                }
-                else {
-                    resolve(trimmed);
-                }
-            });
-            rl.on('close', () => {
-                if (!answered)
-                    resolve(null);
-            });
+            this.lineWaiters.push(resolve);
         });
     }
+    /** No-op kept for API compatibility — readline closes when stdin EOF. */
+    closeInput() {
+        // Nothing to do — readline closes itself on stdin EOF
+    }
     /**
      * Handle a stream event from the agent loop.
      */
@@ -260,26 +287,17 @@ export class TerminalUI {
             }
         }
     }
-    /** Check if input is a slash command. Returns true if handled. */
+    /** Check if input is a slash command. Returns true if handled locally (don't pass to agent). */
     handleSlashCommand(input) {
         const parts = input.trim().split(/\s+/);
         const cmd = parts[0].toLowerCase();
         switch (cmd) {
-            case '/help':
-                console.error(chalk.bold('\n  Commands:'));
-                console.error('  /model [name]  — switch model (e.g. /model sonnet)');
-                console.error('  /cost          — session cost and tokens');
-                console.error('  /retry         — retry the last prompt');
-                console.error('  /compact       — compress conversation history');
-                console.error('  /exit          — quit');
-                console.error('  /help          — this help\n');
-                console.error(chalk.dim('  Shortcuts: sonnet, opus, gpt, gemini, deepseek, flash, free, r1, o4\n'));
-                return true;
             case '/cost':
             case '/usage':
                 console.error(chalk.dim(`\n  Tokens: ${this.totalInputTokens.toLocaleString()} in / ${this.totalOutputTokens.toLocaleString()} out\n`));
                 return true;
             default:
+                // All other slash commands pass through to the agent loop (commands.ts handles them)
                 return false;
         }
     }
@@ -294,6 +312,7 @@ export class TerminalUI {
         }
     }
     printGoodbye() {
+        this.closeInput();
         this.printUsageSummary();
         console.error(chalk.dim('\nGoodbye.\n'));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/runcode",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {