@blockrun/runcode 2.5.0 → 2.5.2

package/dist/agent/commands.js

@@ -179,7 +179,9 @@ const DIRECT_COMMANDS = {
         catch {
             checks.push('⚠ ripgrep not found (using native grep fallback)');
         }
-        checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'wallet.json')) ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
+        const hasWallet = fs.existsSync(path.join(BLOCKRUN_DIR, 'wallet.json'))
+            || fs.existsSync(path.join(BLOCKRUN_DIR, 'solana-wallet.json'));
+        checks.push(hasWallet ? '✓ wallet configured' : '⚠ no wallet — run: runcode setup');
         checks.push(fs.existsSync(path.join(BLOCKRUN_DIR, 'runcode-config.json')) ? '✓ config file exists' : '⚠ no config — using defaults');
         // Check MCP
         const { listMcpServers } = await import('../mcp/client.js');

package/dist/agent/llm.js

@@ -64,9 +64,16 @@ export class ModelClient {
         }
         if (!response.ok) {
             const errorBody = await response.text().catch(() => 'unknown error');
+            // Extract human-readable message from JSON error bodies ({"error":{"message":"..."}})
+            let message = errorBody;
+            try {
+                const parsed = JSON.parse(errorBody);
+                message = parsed?.error?.message || parsed?.message || errorBody;
+            }
+            catch { /* not JSON — use raw text */ }
             yield {
                 kind: 'error',
-                payload: { status: response.status, message: errorBody },
+                payload: { status: response.status, message },
             };
             return;
         }

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
@@ -395,18 +396,21 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 onEvent({ kind: 'turn_done', reason: 'error', error: errMsg + suggestion });
                 break;
             }
+            // When API doesn't return input tokens (some models return 0), estimate from history
+            const inputTokens = usage.inputTokens > 0
+                ? usage.inputTokens
+                : estimateHistoryTokens(history);
             // Anchor token tracking to actual API counts
-            updateActualTokens(usage.inputTokens, usage.outputTokens, history.length);
+            updateActualTokens(inputTokens, usage.outputTokens, history.length);
             onEvent({
                 kind: 'usage',
-                inputTokens: usage.inputTokens,
+                inputTokens,
                 outputTokens: usage.outputTokens,
                 model: config.model,
             });
             // Record usage for stats tracking (runcode stats command)
-            // Rough cost estimate: use typical pricing if unknown
-            const costEstimate = estimateCost(config.model, usage.inputTokens, usage.outputTokens);
-            recordUsage(config.model, usage.inputTokens, usage.outputTokens, costEstimate, 0);
+            const costEstimate = estimateCost(config.model, inputTokens, usage.outputTokens);
+            recordUsage(config.model, inputTokens, usage.outputTokens, costEstimate, 0);
             // ── Max output tokens recovery ──
             if (stopReason === 'max_tokens' && recoveryAttempts < 3) {
                 recoveryAttempts++;

package/dist/agent/permissions.js

@@ -177,10 +177,17 @@ export class PermissionManager {
 }
 // ─── Helpers ───────────────────────────────────────────────────────────────
 function askQuestion(prompt) {
+    // Non-TTY (piped/scripted) input: cannot ask interactively — auto-allow.
+    // The caller (permissionMode logic in start.ts) already routes piped sessions
+    // to trust mode, so this path is rarely hit. Guard here for safety.
+    if (!process.stdin.isTTY) {
+        process.stderr.write(prompt + 'y (auto-approved: non-interactive mode)\n');
+        return Promise.resolve('y');
+    }
     const rl = readline.createInterface({
         input: process.stdin,
         output: process.stderr,
-        terminal: process.stdin.isTTY ?? false,
+        terminal: true,
     });
     return new Promise((resolve) => {
         let answered = false;
@@ -191,7 +198,7 @@ function askQuestion(prompt) {
         });
         rl.on('close', () => {
             if (!answered)
-                resolve('n'); // Default deny on EOF (piped input) for safety
+                resolve('n'); // Default deny on EOF for safety
         });
     });
 }

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

@@ -123,7 +123,9 @@ export async function startCommand(options) {
         capabilities,
         maxTurns: 100,
         workingDir: workDir,
-        permissionMode: options.trust ? 'trust' : 'default',
+        // Non-TTY (piped) input = scripted mode → trust all tools automatically.
+        // Interactive TTY = default mode (prompts for Bash/Write/Edit).
+        permissionMode: (options.trust || !process.stdin.isTTY) ? 'trust' : 'default',
         debug: options.debug,
     };
     // Use ink UI if TTY, fallback to basic readline for piped input
@@ -170,7 +172,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 +225,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.2",
   "description": "RunCode — AI coding agent powered by 41+ models. Pay per use with USDC.",
   "type": "module",
   "bin": {