@blockrun/franklin 3.0.0

package/dist/commands/config.js

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { BLOCKRUN_DIR } from '../config.js';
+const CONFIG_FILE = path.join(BLOCKRUN_DIR, 'runcode-config.json');
+const VALID_KEYS = [
+    'default-model',
+    'sonnet-model',
+    'opus-model',
+    'haiku-model',
+    'smart-routing',
+    'permission-mode',
+    'max-turns',
+    'auto-compact',
+    'session-save',
+    'debug',
+];
+export function loadConfig() {
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(config) {
+    try {
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', {
+            mode: 0o600,
+        });
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to save config: ${err.message}`));
+    }
+}
+function isValidKey(key) {
+    return VALID_KEYS.includes(key);
+}
+export function configCommand(action, keyOrUndefined, value) {
+    if (action === 'list') {
+        const config = loadConfig();
+        const entries = Object.entries(config);
+        if (entries.length === 0) {
+            console.log(chalk.dim('No config set. Defaults will be used.'));
+            console.log(chalk.dim(`\nConfig file: ${CONFIG_FILE}`));
+            return;
+        }
+        console.log(chalk.bold('runcode config\n'));
+        for (const [k, v] of entries) {
+            console.log(`  ${chalk.cyan(k)} = ${chalk.green(v)}`);
+        }
+        console.log(chalk.dim(`\nConfig file: ${CONFIG_FILE}`));
+        return;
+    }
+    if (action === 'get') {
+        if (!keyOrUndefined) {
+            console.log(chalk.red('Usage: runcode config get <key>'));
+            process.exit(1);
+        }
+        const config = loadConfig();
+        const val = config[keyOrUndefined];
+        if (val !== undefined) {
+            console.log(val);
+        }
+        else {
+            console.log(chalk.dim('(not set)'));
+        }
+        return;
+    }
+    if (action === 'set') {
+        if (!keyOrUndefined || value === undefined) {
+            console.log(chalk.red('Usage: runcode config set <key> <value>'));
+            process.exit(1);
+        }
+        if (!isValidKey(keyOrUndefined)) {
+            console.log(chalk.red(`Unknown config key: ${keyOrUndefined}`));
+            console.log(`Valid keys: ${VALID_KEYS.map((k) => chalk.cyan(k)).join(', ')}`);
+            process.exit(1);
+        }
+        const config = loadConfig();
+        config[keyOrUndefined] = value;
+        saveConfig(config);
+        console.log(`${chalk.cyan(keyOrUndefined)} = ${chalk.green(value)}`);
+        return;
+    }
+    if (action === 'unset') {
+        if (!keyOrUndefined) {
+            console.log(chalk.red('Usage: runcode config unset <key>'));
+            process.exit(1);
+        }
+        if (!isValidKey(keyOrUndefined)) {
+            console.log(chalk.red(`Unknown config key: ${keyOrUndefined}`));
+            console.log(`Valid keys: ${VALID_KEYS.map((k) => chalk.cyan(k)).join(', ')}`);
+            process.exit(1);
+        }
+        const config = loadConfig();
+        delete config[keyOrUndefined];
+        saveConfig(config);
+        console.log(chalk.dim(`Unset ${keyOrUndefined}`));
+        return;
+    }
+    console.log(chalk.red(`Unknown action: ${action}`));
+    console.log('Usage: runcode config <set|get|unset|list> [key] [value]');
+    process.exit(1);
+}

package/dist/commands/daemon.d.ts

@@ -0,0 +1,3 @@
+export declare function daemonCommand(action: string, options: {
+    port?: string;
+}): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,117 @@
+import { spawn, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { BLOCKRUN_DIR, DEFAULT_PROXY_PORT } from '../config.js';
+const PID_FILE = path.join(BLOCKRUN_DIR, 'runcode.pid');
+const LOG_FILE = path.join(BLOCKRUN_DIR, 'runcode-debug.log');
+function readPid() {
+    try {
+        const raw = fs.readFileSync(PID_FILE, 'utf-8').trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function daemonCommand(action, options) {
+    const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.log(chalk.red(`Invalid port "${options.port}". Must be 1-65535. Default: ${DEFAULT_PROXY_PORT}`));
+        return;
+    }
+    switch (action) {
+        case 'start': {
+            const existing = readPid();
+            if (existing && isRunning(existing)) {
+                console.log(chalk.yellow(`runcode daemon already running (PID ${existing})`));
+                console.log(chalk.dim(`  Proxy: http://localhost:${port}/api`));
+                return;
+            }
+            // Find runcode binary
+            let runcodeBin;
+            try {
+                runcodeBin = execSync('which runcode', { encoding: 'utf-8' }).trim();
+            }
+            catch {
+                console.log(chalk.red('runcode binary not found in PATH.'));
+                return;
+            }
+            fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+            const child = spawn(runcodeBin, ['proxy', '--port', String(port)], {
+                detached: true,
+                stdio: ['ignore', fs.openSync(LOG_FILE, 'a'), fs.openSync(LOG_FILE, 'a')],
+            });
+            child.unref();
+            fs.writeFileSync(PID_FILE, String(child.pid));
+            console.log(chalk.green(`✓ runcode daemon started (PID ${child.pid})`));
+            console.log(chalk.dim(`  Proxy: http://localhost:${port}/api`));
+            console.log(chalk.dim(`  Logs:  ${LOG_FILE}`));
+            break;
+        }
+        case 'stop': {
+            const pid = readPid();
+            if (!pid) {
+                console.log(chalk.yellow('No runcode daemon found.'));
+                return;
+            }
+            if (!isRunning(pid)) {
+                fs.unlinkSync(PID_FILE);
+                console.log(chalk.yellow(`Daemon PID ${pid} not running — cleaned up.`));
+                return;
+            }
+            try {
+                process.kill(pid, 'SIGTERM');
+                // Wait for process to exit (up to 5s)
+                for (let i = 0; i < 50; i++) {
+                    if (!isRunning(pid))
+                        break;
+                    await new Promise(r => setTimeout(r, 100));
+                }
+                if (isRunning(pid)) {
+                    process.kill(pid, 'SIGKILL');
+                }
+                try {
+                    fs.unlinkSync(PID_FILE);
+                }
+                catch { /* already gone */ }
+                console.log(chalk.green(`✓ runcode daemon stopped (PID ${pid})`));
+            }
+            catch (e) {
+                console.log(chalk.red(`Failed to stop daemon: ${e.message}`));
+            }
+            break;
+        }
+        case 'status': {
+            const pid = readPid();
+            if (!pid) {
+                console.log(chalk.dim('runcode daemon: not running'));
+                return;
+            }
+            if (isRunning(pid)) {
+                console.log(chalk.green(`✓ runcode daemon running`));
+                console.log(`  PID:   ${chalk.bold(pid)}`);
+                console.log(`  Proxy: ${chalk.cyan(`http://localhost:${port}/api`)}`);
+                console.log(chalk.dim(`  Logs:  ${LOG_FILE}`));
+            }
+            else {
+                fs.unlinkSync(PID_FILE);
+                console.log(chalk.yellow('runcode daemon: not running (stale PID cleaned up)'));
+            }
+            break;
+        }
+        default:
+            console.log(chalk.red(`Unknown daemon action: ${action}`));
+            console.log('Usage: runcode daemon <start|stop|status>');
+    }
+}

package/dist/commands/history.d.ts

@@ -0,0 +1,5 @@
+interface HistoryOptions {
+    n?: string;
+}
+export declare function historyCommand(options: HistoryOptions): void;
+export {};

package/dist/commands/history.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import { loadStats } from '../stats/tracker.js';
+export function historyCommand(options) {
+    const { history } = loadStats();
+    const limit = Math.min(parseInt(options.n || '20', 10), history.length);
+    console.log(chalk.bold(`
+📜 Last ${limit} Requests\n`));
+    console.log('─'.repeat(55));
+    if (history.length === 0) {
+        console.log(chalk.gray('\n  No history recorded yet.\n'));
+        console.log('─'.repeat(55) + '\n');
+        return;
+    }
+    const recent = history.slice(-limit).reverse();
+    for (const record of recent) {
+        const time = new Date(record.timestamp).toLocaleString();
+        const model = record.model.split('/').pop() || record.model;
+        const cost = '$' + record.costUsd.toFixed(5);
+        const tokens = `${record.inputTokens}+${record.outputTokens}`.padEnd(10);
+        const latency = `${record.latencyMs}ms`.padEnd(8);
+        const fallbackMark = record.fallback ? chalk.yellow(' ↺') : '';
+        console.log(chalk.gray(`[${time}]`) +
+            ` ${model.padEnd(20)}${fallbackMark} ` +
+            chalk.cyan(tokens) +
+            chalk.magenta(latency) +
+            chalk.green(cost));
+    }
+    console.log('\n' + '─'.repeat(55));
+    console.log(chalk.gray(`  Showing ${limit} of ${history.length} total records.`));
+    console.log(chalk.gray('  Run `runcode stats` for more detailed statistics.\n'));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+export declare function initCommand(options: {
+    port?: string;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import chalk from 'chalk';
+import { DEFAULT_PROXY_PORT } from '../config.js';
+const CLAUDE_SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.json');
+const LAUNCH_AGENT_DIR = path.join(os.homedir(), 'Library', 'LaunchAgents');
+const LAUNCH_AGENT_PLIST = path.join(LAUNCH_AGENT_DIR, 'ai.blockrun.runcode.plist');
+export async function initCommand(options) {
+    const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(chalk.red(`Error: invalid port "${options.port}". Must be 1-65535. Default: ${DEFAULT_PROXY_PORT}`));
+        process.exit(1);
+    }
+    // ── 1. Write ~/.claude/settings.json ────────────────────────────────────
+    let settings = {};
+    try {
+        if (fs.existsSync(CLAUDE_SETTINGS_FILE)) {
+            settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        console.log(chalk.yellow(`  Warning: could not parse ${CLAUDE_SETTINGS_FILE}, starting fresh.`));
+    }
+    settings.env = {
+        ...(settings.env ?? {}),
+        ANTHROPIC_BASE_URL: `http://localhost:${port}/api`,
+        ANTHROPIC_AUTH_TOKEN: 'x402-proxy-handles-auth',
+        ANTHROPIC_MODEL: 'blockrun/auto',
+        ANTHROPIC_DEFAULT_SONNET_MODEL: 'anthropic/claude-sonnet-4.6',
+        ANTHROPIC_DEFAULT_OPUS_MODEL: 'anthropic/claude-opus-4.6',
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: 'anthropic/claude-haiku-4.5-20251001',
+    };
+    fs.mkdirSync(path.dirname(CLAUDE_SETTINGS_FILE), { recursive: true });
+    fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
+    console.log(chalk.green(`✓ Configured ${CLAUDE_SETTINGS_FILE}`));
+    // ── 2. Install macOS LaunchAgent (auto-start on login) ─────────────────
+    if (process.platform === 'darwin') {
+        let runcodeBin = '';
+        try {
+            const { execSync } = await import('node:child_process');
+            runcodeBin = execSync('which runcode', { encoding: 'utf-8' }).trim();
+        }
+        catch {
+            console.log(chalk.yellow('  Warning: runcode not found in PATH — LaunchAgent not installed.'));
+        }
+        if (runcodeBin) {
+            const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.blockrun.runcode</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${runcodeBin}</string>
+    <string>proxy</string>
+    <string>--port</string>
+    <string>${port}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${os.homedir()}/.blockrun/runcode-debug.log</string>
+  <key>StandardErrorPath</key>
+  <string>${os.homedir()}/.blockrun/runcode-debug.log</string>
+</dict>
+</plist>`;
+            fs.mkdirSync(LAUNCH_AGENT_DIR, { recursive: true });
+            fs.writeFileSync(LAUNCH_AGENT_PLIST, plist);
+            try {
+                const { execSync } = await import('node:child_process');
+                execSync(`launchctl load -w "${LAUNCH_AGENT_PLIST}"`, { stdio: 'pipe' });
+                console.log(chalk.green(`✓ LaunchAgent installed — runcode proxy starts automatically on login`));
+            }
+            catch {
+                console.log(chalk.dim(`  LaunchAgent written to ${LAUNCH_AGENT_PLIST}`));
+                console.log(chalk.dim(`  Load manually: launchctl load -w "${LAUNCH_AGENT_PLIST}"`));
+            }
+        }
+    }
+    // ── 3. Start daemon now ──────────────────────────────────────────────────
+    console.log('');
+    console.log(chalk.bold('runcode initialized (proxy mode for Claude Code).'));
+    console.log(`Run ${chalk.bold('runcode daemon start')} to start the background proxy now.`);
+    console.log(`Then just run ${chalk.bold('claude')} — runcode proxy handles payments automatically.`);
+    console.log('');
+    console.log(chalk.dim('Or use runcode directly: runcode start'));
+    console.log(chalk.dim('Note: Claude Code will ask you to trust the proxy URL once.'));
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,5 @@
+export declare function logsCommand(options: {
+    follow?: boolean;
+    lines?: string;
+    clear?: boolean;
+}): void;

package/dist/commands/logs.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { BLOCKRUN_DIR } from '../config.js';
+const LOG_FILE = path.join(BLOCKRUN_DIR, 'runcode-debug.log');
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB auto-rotate threshold
+export function logsCommand(options) {
+    if (options.clear) {
+        try {
+            fs.unlinkSync(LOG_FILE);
+            console.log(chalk.green('Logs cleared.'));
+        }
+        catch {
+            console.log(chalk.dim('No log file to clear.'));
+        }
+        return;
+    }
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log(chalk.dim('No logs yet. Start runcode with --debug to enable logging:'));
+        console.log(chalk.bold('  runcode start --debug'));
+        return;
+    }
+    // Auto-rotate: if file is over threshold, keep only last half
+    try {
+        const stat = fs.statSync(LOG_FILE);
+        if (stat.size > MAX_LOG_SIZE) {
+            const content = fs.readFileSync(LOG_FILE, 'utf-8');
+            const lines = content.split('\n');
+            const half = lines.slice(Math.floor(lines.length / 2));
+            fs.writeFileSync(LOG_FILE, half.join('\n'));
+            console.log(chalk.dim(`(Rotated log — was ${(stat.size / 1024 / 1024).toFixed(1)}MB)`));
+        }
+    }
+    catch { /* ignore rotation errors */ }
+    const parsed = parseInt(options.lines || '50', 10);
+    const tailLines = isNaN(parsed) ? 50 : Math.max(1, Math.min(10000, parsed));
+    if (options.follow) {
+        // Tail -f mode: print last N lines then watch for changes
+        printLastLines(tailLines);
+        console.log(chalk.dim('--- watching for new entries (ctrl+c to stop) ---'));
+        let lastSize = fs.statSync(LOG_FILE).size;
+        const watcher = setInterval(() => {
+            try {
+                const stat = fs.statSync(LOG_FILE);
+                if (stat.size > lastSize) {
+                    const fd = fs.openSync(LOG_FILE, 'r');
+                    const buf = Buffer.alloc(stat.size - lastSize);
+                    fs.readSync(fd, buf, 0, buf.length, lastSize);
+                    fs.closeSync(fd);
+                    process.stdout.write(buf.toString('utf-8'));
+                    lastSize = stat.size;
+                }
+                else if (stat.size < lastSize) {
+                    // File was rotated/cleared
+                    lastSize = 0;
+                }
+            }
+            catch {
+                /* file may have been deleted */
+            }
+        }, 500);
+        process.on('SIGINT', () => {
+            clearInterval(watcher);
+            process.exit(0);
+        });
+    }
+    else {
+        printLastLines(tailLines);
+    }
+}
+function printLastLines(n) {
+    try {
+        const content = fs.readFileSync(LOG_FILE, 'utf-8');
+        const lines = content.split('\n').filter(Boolean);
+        const start = Math.max(0, lines.length - n);
+        const slice = lines.slice(start);
+        if (start > 0) {
+            console.log(chalk.dim(`... (${start} earlier entries, use --lines to see more)`));
+        }
+        for (const line of slice) {
+            // Colorize timestamps
+            const colored = line.replace(/^\[(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\]/, chalk.dim('[$1]'));
+            console.log(colored);
+        }
+    }
+    catch {
+        console.log(chalk.dim('Could not read log file.'));
+    }
+}

package/dist/commands/models.d.ts

@@ -0,0 +1 @@
+export declare function modelsCommand(): Promise<void>;

package/dist/commands/models.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { loadChain, API_URLS } from '../config.js';
+export async function modelsCommand() {
+    const chain = loadChain();
+    const apiUrl = API_URLS[chain];
+    console.log(chalk.bold('Available Models\n'));
+    console.log(`Chain: ${chalk.magenta(chain)} — ${chalk.dim(apiUrl)}\n`);
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        const response = await fetch(`${apiUrl}/v1/models`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!response.ok) {
+            console.log(chalk.red(`Failed to fetch models: ${response.status}`));
+            return;
+        }
+        const data = (await response.json());
+        if (!data.data || data.data.length === 0) {
+            console.log(chalk.yellow('No models returned from API.'));
+            return;
+        }
+        const models = data.data
+            .sort((a, b) => (a.pricing?.input ?? 0) - (b.pricing?.input ?? 0));
+        const free = models.filter((m) => m.billing_mode === 'free');
+        const paid = models.filter((m) => m.billing_mode !== 'free');
+        if (free.length > 0) {
+            console.log(chalk.green.bold('Free Models (no USDC needed)'));
+            console.log(chalk.dim('─'.repeat(70)));
+            for (const m of free) {
+                console.log(`  ${chalk.cyan(m.id)}`);
+            }
+            console.log('');
+        }
+        console.log(chalk.yellow.bold('Paid Models'));
+        console.log(chalk.dim('─'.repeat(70)));
+        console.log(chalk.dim(`  ${'Model'.padEnd(35)} ${'Input'.padEnd(12)} ${'Output'.padEnd(12)} Context`));
+        console.log(chalk.dim('─'.repeat(70)));
+        for (const m of paid) {
+            const input = `$${(m.pricing?.input ?? 0).toFixed(2)}/M`;
+            const output = `$${(m.pricing?.output ?? 0).toFixed(2)}/M`;
+            const ctx = '';
+            console.log(`  ${chalk.cyan(m.id.padEnd(35))} ${input.padEnd(12)} ${output.padEnd(12)} ${ctx}`);
+        }
+        console.log(`\n${chalk.dim(`${models.length} models available. Use:`)} ${chalk.bold('runcode start --model <model-id>')}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'unknown error';
+        if (msg.includes('fetch') || msg.includes('ECONNREFUSED') || msg.includes('ENOTFOUND')) {
+            console.log(chalk.red(`Cannot reach BlockRun API at ${apiUrl}`));
+            console.log(chalk.dim('Check your internet connection or try again later.'));
+        }
+        else {
+            console.log(chalk.red(`Error: ${msg}`));
+        }
+    }
+}

package/dist/commands/plugin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generic plugin command dispatcher.
+ *
+ * `runcode <plugin-id> <action>` works for ANY plugin that registers a workflow.
+ * Core stays plugin-agnostic — adding a new plugin requires zero changes here.
+ */
+export interface PluginCommandOptions {
+    dryRun?: boolean;
+    debug?: boolean;
+}
+/** Run a plugin command. Plugin id is the first arg. */
+export declare function pluginCommand(pluginId: string, action: string | undefined, options: PluginCommandOptions): Promise<void>;
+/** List all installed plugins */
+export declare function listAvailablePlugins(): void;