@blockrun/runcode 2.5.1 → 2.5.3

package/dist/agent/commands.js

@@ -12,6 +12,8 @@ import { execSync } from 'node:child_process';
 import { BLOCKRUN_DIR, VERSION } from '../config.js';
 import { estimateHistoryTokens, getAnchoredTokenCount, getContextWindow, resetTokenAnchor } from './tokens.js';
 import { forceCompact } from './compact.js';
+import { getStatsSummary } from '../stats/tracker.js';
+import { resolveModel } from '../ui/model-picker.js';
 import { listSessions, loadSessionHistory, } from '../session/storage.js';
 // ─── Git helpers ──────────────────────────────────────────────────────────
 function gitExec(cmd, cwd, timeout = 5000, maxBuffer) {
@@ -28,7 +30,12 @@ function gitCmd(ctx, cmd, timeout, maxBuffer) {
         return gitExec(cmd, ctx.config.workingDir || process.cwd(), timeout, maxBuffer);
     }
     catch (e) {
-        ctx.onEvent({ kind: 'text_delta', text: `Git error: ${e.message?.split('\n')[0] || 'unknown'}\n` });
+        // Prefer stderr (actual git error message) over the noisy "Command failed: ..." header
+        const errObj = e;
+        const stderr = errObj.stderr ? String(errObj.stderr).trim() : '';
+        // Take only the first meaningful line (git sometimes dumps full usage on errors)
+        const firstLine = (stderr || errObj.message || 'unknown').split('\n')[0].trim();
+        ctx.onEvent({ kind: 'text_delta', text: `Git: ${firstLine}\n` });
         return null;
     }
 }
@@ -41,34 +48,51 @@ const DIRECT_COMMANDS = {
     '/stash': (ctx) => {
         const r = gitCmd(ctx, 'git stash push -m "runcode auto-stash"', 10000);
         if (r !== null)
-            ctx.onEvent({ kind: 'text_delta', text: r || 'No changes to stash.\n' });
+            ctx.onEvent({ kind: 'text_delta', text: r ? `${r}\n` : 'No changes to stash.\n' });
         emitDone(ctx);
     },
     '/unstash': (ctx) => {
         const r = gitCmd(ctx, 'git stash pop', 10000);
         if (r !== null)
-            ctx.onEvent({ kind: 'text_delta', text: r || 'Stash applied.\n' });
+            ctx.onEvent({ kind: 'text_delta', text: r ? `${r}\n` : 'Stash applied.\n' });
         emitDone(ctx);
     },
     '/log': (ctx) => {
         const r = gitCmd(ctx, 'git log --oneline -15 --no-color');
-        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'No commits or not a git repo.\n' });
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'No commits yet.\n' });
         emitDone(ctx);
     },
     '/status': (ctx) => {
         const r = gitCmd(ctx, 'git status --short --branch');
-        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+        if (r !== null)
+            ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Working tree clean.\n' });
         emitDone(ctx);
     },
     '/diff': (ctx) => {
-        const r = gitCmd(ctx, 'git diff --stat && echo "---" && git diff', 10000, 512 * 1024);
-        ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`diff\n${r}\n\`\`\`\n` : 'No changes.\n' });
+        // git diff with stat header then full diff
+        const stat = gitCmd(ctx, 'git diff --stat --no-color');
+        if (stat === null) {
+            emitDone(ctx);
+            return;
+        }
+        const full = gitCmd(ctx, 'git diff --no-color');
+        if (full === null) {
+            emitDone(ctx);
+            return;
+        }
+        if (!stat && !full) {
+            ctx.onEvent({ kind: 'text_delta', text: 'No unstaged changes.\n' });
+        }
+        else {
+            ctx.onEvent({ kind: 'text_delta', text: `\`\`\`diff\n${[stat, full].filter(Boolean).join('\n---\n')}\n\`\`\`\n` });
+        }
         emitDone(ctx);
     },
     '/undo': (ctx) => {
         const r = gitCmd(ctx, 'git reset --soft HEAD~1');
         if (r !== null)
-            ctx.onEvent({ kind: 'text_delta', text: 'Last commit undone. Changes preserved in staging.\n' });
+            ctx.onEvent({ kind: 'text_delta', text: `Last commit undone. Changes preserved in staging.\n` });
         emitDone(ctx);
     },
     '/tokens': (ctx) => {
@@ -179,7 +203,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');
@@ -254,6 +280,64 @@ const DIRECT_COMMANDS = {
         }
         emitDone(ctx);
     },
+    '/cost': async (ctx) => {
+        const { stats, saved } = getStatsSummary();
+        ctx.onEvent({ kind: 'text_delta', text: `**Session Cost**\n` +
+                `  Requests: ${stats.totalRequests}\n` +
+                `  Cost:     $${stats.totalCostUsd.toFixed(4)} USDC\n` +
+                `  Saved:    $${saved.toFixed(2)} vs Claude Opus\n` +
+                `  Tokens:   ${stats.totalInputTokens.toLocaleString()} in / ${stats.totalOutputTokens.toLocaleString()} out\n`
+        });
+        emitDone(ctx);
+    },
+    '/wallet': async (ctx) => {
+        const chain = (await import('../config.js')).loadChain();
+        try {
+            let address;
+            let balance;
+            if (chain === 'solana') {
+                const { getOrCreateSolanaWallet, setupAgentSolanaWallet } = await import('@blockrun/llm');
+                const w = await getOrCreateSolanaWallet();
+                address = w.address;
+                try {
+                    const client = await setupAgentSolanaWallet({ silent: true });
+                    const bal = await client.getBalance();
+                    balance = `$${bal.toFixed(2)} USDC`;
+                }
+                catch {
+                    balance = '(fetch failed)';
+                }
+            }
+            else {
+                const { getOrCreateWallet, setupAgentWallet } = await import('@blockrun/llm');
+                const w = getOrCreateWallet();
+                address = w.address;
+                try {
+                    const client = setupAgentWallet({ silent: true });
+                    const bal = await client.getBalance();
+                    balance = `$${bal.toFixed(2)} USDC`;
+                }
+                catch {
+                    balance = '(fetch failed)';
+                }
+            }
+            ctx.onEvent({ kind: 'text_delta', text: `**Wallet**\n` +
+                    `  Chain:   ${chain}\n` +
+                    `  Address: ${address}\n` +
+                    `  Balance: ${balance}\n`
+            });
+        }
+        catch (err) {
+            ctx.onEvent({ kind: 'text_delta', text: `Wallet error: ${err.message}\n` });
+        }
+        emitDone(ctx);
+    },
+    '/clear': (ctx) => {
+        ctx.history.length = 0;
+        resetTokenAnchor();
+        ctx.onEvent({ kind: 'text_delta', text: 'Conversation history cleared.\n' });
+        emitDone(ctx);
+    },
     '/compact': async (ctx) => {
         const beforeTokens = estimateHistoryTokens(ctx.history);
         const { history: compacted, compacted: didCompact } = await forceCompact(ctx.history, ctx.config.model, ctx.client, ctx.config.debug);
@@ -318,12 +402,28 @@ export async function handleSlashCommand(input, ctx) {
         await DIRECT_COMMANDS[input](ctx);
         return { handled: true };
     }
+    // /model — show current model or switch with /model <name>
+    if (input === '/model' || input.startsWith('/model ')) {
+        if (input === '/model') {
+            ctx.onEvent({ kind: 'text_delta', text: `Current model: **${ctx.config.model}**\n` +
+                    `Switch with: \`/model <name>\` (e.g. \`/model sonnet\`, \`/model free\`, \`/model gemini\`)\n`
+            });
+        }
+        else {
+            const newModel = resolveModel(input.slice(7).trim());
+            ctx.config.model = newModel;
+            ctx.onEvent({ kind: 'text_delta', text: `Model → **${newModel}**\n` });
+        }
+        emitDone(ctx);
+        return { handled: true };
+    }
     // /branch has both no-arg and with-arg forms
     if (input === '/branch' || input.startsWith('/branch ')) {
         const cwd = ctx.config.workingDir || process.cwd();
         if (input === '/branch') {
             const r = gitCmd(ctx, 'git branch -v --no-color');
-            ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'Not a git repo.\n' });
+            if (r !== null)
+                ctx.onEvent({ kind: 'text_delta', text: r ? `\`\`\`\n${r}\n\`\`\`\n` : 'No branches yet.\n' });
         }
         else {
             const branchName = input.slice(8).trim();

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.d.ts

@@ -4,11 +4,6 @@
  * Original implementation with different architecture from any reference codebase.
  */
 import type { AgentConfig, Dialogue, StreamEvent } from './types.js';
-/**
- * Run the agent loop.
- * Yields StreamEvents for the UI to render. Returns when the conversation ends.
- */
-export declare function runAgent(config: AgentConfig, initialPrompt: string): AsyncGenerator<StreamEvent, void>;
 /**
  * Run a multi-turn interactive session.
  * Each user message triggers a full agent loop.

package/dist/agent/loop.js

@@ -14,182 +14,6 @@ import { optimizeHistory, CAPPED_MAX_TOKENS, ESCALATED_MAX_TOKENS, getMaxOutputT
 import { recordUsage } from '../stats/tracker.js';
 import { estimateCost } from '../pricing.js';
 import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, } from '../session/storage.js';
-// ─── Main Entry Point ──────────────────────────────────────────────────────
-/**
- * Run the agent loop.
- * Yields StreamEvents for the UI to render. Returns when the conversation ends.
- */
-export async function* runAgent(config, initialPrompt) {
-    const client = new ModelClient({
-        apiUrl: config.apiUrl,
-        chain: config.chain,
-        debug: config.debug,
-    });
-    const capabilityMap = new Map();
-    for (const cap of config.capabilities) {
-        capabilityMap.set(cap.spec.name, cap);
-    }
-    const toolDefs = config.capabilities.map((c) => c.spec);
-    const maxTurns = config.maxTurns ?? 100;
-    const workDir = config.workingDir ?? process.cwd();
-    const state = {
-        history: [
-            { role: 'user', content: initialPrompt },
-        ],
-        turnIndex: 0,
-        abort: new AbortController(),
-    };
-    // ─── Reasoning-Action Cycle ────────────────────────────────────────────
-    while (state.turnIndex < maxTurns) {
-        state.turnIndex++;
-        // 1. Call model
-        const { content: responseParts, usage } = await callModel(client, config, state, toolDefs);
-        // Emit usage
-        yield {
-            kind: 'usage',
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            model: config.model,
-        };
-        // 2. Classify response parts
-        const textParts = [];
-        const invocations = [];
-        for (const part of responseParts) {
-            if (part.type === 'text') {
-                textParts.push(part.text);
-                yield { kind: 'text_delta', text: part.text };
-            }
-            else if (part.type === 'tool_use') {
-                invocations.push(part);
-            }
-            else if (part.type === 'thinking') {
-                yield { kind: 'thinking_delta', text: part.thinking };
-            }
-        }
-        // 3. Append assistant response to history
-        state.history.push({
-            role: 'assistant',
-            content: responseParts,
-        });
-        // 4. If no capability invocations, the agent is done
-        if (invocations.length === 0) {
-            yield { kind: 'turn_done', reason: 'completed' };
-            return;
-        }
-        // 5. Execute capabilities
-        const outcomes = await executeCapabilities(invocations, capabilityMap, workDir, state.abort, (evt) => { config.onEvent?.(evt); });
-        // Emit capability results
-        for (const [invocation, result] of outcomes) {
-            yield {
-                kind: 'capability_done',
-                id: invocation.id,
-                result,
-            };
-        }
-        // 6. Append capability outcomes as user message
-        const outcomeContent = outcomes.map(([invocation, result]) => ({
-            type: 'tool_result',
-            tool_use_id: invocation.id,
-            content: result.output,
-            is_error: result.isError,
-        }));
-        state.history.push({
-            role: 'user',
-            content: outcomeContent,
-        });
-        // Continue to next cycle...
-    }
-    yield { kind: 'turn_done', reason: 'max_turns' };
-}
-// ─── Model Call ────────────────────────────────────────────────────────────
-async function callModel(client, config, state, tools) {
-    const systemPrompt = config.systemInstructions.join('\n\n');
-    return client.complete({
-        model: config.model,
-        messages: state.history,
-        system: systemPrompt,
-        tools,
-        max_tokens: 16384,
-        stream: true,
-    }, state.abort.signal);
-}
-// ─── Capability Execution ──────────────────────────────────────────────────
-async function executeCapabilities(invocations, handlers, workDir, abort, emitEvent, permissions) {
-    // Partition into concurrent-safe and sequential
-    const concurrent = [];
-    const sequential = [];
-    for (const inv of invocations) {
-        const handler = handlers.get(inv.name);
-        if (handler?.concurrent) {
-            concurrent.push(inv);
-        }
-        else {
-            sequential.push(inv);
-        }
-    }
-    const results = [];
-    const scope = {
-        workingDir: workDir,
-        abortSignal: abort.signal,
-    };
-    // Run concurrent capabilities in parallel
-    if (concurrent.length > 0) {
-        const batch = concurrent.map(async (inv) => {
-            const result = await checkAndRun(inv, handlers, scope, permissions, emitEvent);
-            return [inv, result];
-        });
-        const batchResults = await Promise.all(batch);
-        results.push(...batchResults);
-    }
-    // Run sequential capabilities one at a time
-    for (const inv of sequential) {
-        const result = await checkAndRun(inv, handlers, scope, permissions, emitEvent);
-        results.push([inv, result]);
-    }
-    return results;
-}
-async function checkAndRun(invocation, handlers, scope, permissions, emitEvent) {
-    // Permission check
-    if (permissions) {
-        const decision = await permissions.check(invocation.name, invocation.input);
-        if (decision.behavior === 'deny') {
-            return {
-                output: `Permission denied for ${invocation.name}: ${decision.reason || 'denied by policy'}`,
-                isError: true,
-            };
-        }
-        if (decision.behavior === 'ask') {
-            const allowed = await permissions.promptUser(invocation.name, invocation.input);
-            if (!allowed) {
-                return {
-                    output: `User denied permission for ${invocation.name}`,
-                    isError: true,
-                };
-            }
-        }
-    }
-    emitEvent({ kind: 'capability_start', id: invocation.id, name: invocation.name });
-    return runSingleCapability(invocation, handlers, scope);
-}
-async function runSingleCapability(invocation, handlers, scope) {
-    const handler = handlers.get(invocation.name);
-    if (!handler) {
-        return {
-            output: `Unknown capability: ${invocation.name}`,
-            isError: true,
-        };
-    }
-    try {
-        return await handler.execute(invocation.input, scope);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            output: `Error executing ${invocation.name}: ${message}`,
-            isError: true,
-        };
-    }
-}
 // ─── Interactive Session ───────────────────────────────────────────────────
 /**
  * Run a multi-turn interactive session.
@@ -211,6 +35,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     const workDir = config.workingDir ?? process.cwd();
     const permissions = new PermissionManager(config.permissionMode ?? 'default');
     const history = [];
+    let lastUserInput = ''; // For /retry
     // Session persistence
     const sessionId = createSessionId();
     let turnCount = 0;
@@ -224,14 +49,26 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             continue; // Empty input → re-prompt
         // ── Slash command dispatch ──
         if (input.startsWith('/')) {
-            const cmdResult = await handleSlashCommand(input, {
-                history, config, client, sessionId, onEvent,
-            });
-            if (cmdResult.handled)
-                continue;
-            if (cmdResult.rewritten)
-                input = cmdResult.rewritten;
+            // /retry re-sends the last user message
+            if (input === '/retry') {
+                if (!lastUserInput) {
+                    onEvent({ kind: 'text_delta', text: 'No previous message to retry.\n' });
+                    onEvent({ kind: 'turn_done', reason: 'completed' });
+                    continue;
+                }
+                input = lastUserInput;
+            }
+            else {
+                const cmdResult = await handleSlashCommand(input, {
+                    history, config, client, sessionId, onEvent,
+                });
+                if (cmdResult.handled)
+                    continue;
+                if (cmdResult.rewritten)
+                    input = cmdResult.rewritten;
+            }
         }
+        lastUserInput = input;
         history.push({ role: 'user', content: input });
         appendToSession(sessionId, { role: 'user', content: input });
         turnCount++;
@@ -396,18 +233,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/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

package/dist/ui/app.js

@@ -171,8 +171,10 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                     setStreamText('');
                     setTools(new Map());
                     setTurnTokens({ input: 0, output: 0 });
-                    setStatusMsg('Conversation cleared');
-                    setTimeout(() => setStatusMsg(''), 3000);
+                    setWaiting(true);
+                    setReady(false);
+                    // Pass through to agent loop to clear the actual conversation history
+                    onSubmit('/clear');
                     return;
                 case '/retry':
                     if (!lastPrompt) {

package/dist/ui/terminal.js

@@ -154,7 +154,9 @@ export class TerminalUI {
         });
         rl.on('close', () => {
             this.stdinEOF = true;
-            this.lineQueue = []; // Don't deliver buffered lines after EOF — signal exit cleanly
+            // Keep lineQueue intact — buffered lines should still drain before signaling EOF.
+            // If there are active waiters, queue is already empty (nextLine checks queue first),
+            // so it's safe to resolve them with null now.
             for (const waiter of this.lineWaiters)
                 waiter(null);
             this.lineWaiters = [];

package/package.json

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