@blockrun/cc 0.4.1 → 0.6.0

package/README.md

@@ -33,8 +33,21 @@ Claude Code  -->  brcc (local proxy)  -->  BlockRun API  -->  Any model
 
 ## Quick Start
 
+### One-line install (Linux/macOS)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/BlockRunAI/brcc/main/install.sh | bash
+```
+
+Installs Node.js (if missing) + Claude Code + brcc + creates wallet.
+
+### Manual install
+
 ```bash
-# Install
+# Prerequisites: Node.js 20+ and Claude Code
+curl -fsSL https://claude.ai/install.sh | bash
+
+# Install brcc (use sudo on Linux)
 npm install -g @blockrun/cc
 
 # Create a wallet (one time)
@@ -81,14 +94,21 @@ That's it. Claude Code opens with access to 40+ models, no rate limits.
 
 Creates a wallet and shows the address for funding.
 
+```bash
+brcc setup          # Default: Base chain
+brcc setup base     # Explicit Base (Coinbase L2)
+brcc setup solana   # Solana chain
+```
+
 ```
-$ brcc setup
+$ brcc setup base
 Wallet created!
 Address: 0xCC8c44AD3dc2A58D841c3EB26131E49b22665EF8
 Send USDC on Base to this address to fund your account.
+Chain: base — saved to ~/.blockrun/
 ```
 
-Your wallet is saved to `~/.blockrun/` and shared with all BlockRun tools.
+Your wallet is saved to `~/.blockrun/` and shared with all BlockRun tools (Python SDK, TS SDK, ClawRouter).
 
 ### `brcc start`
 
@@ -107,9 +127,56 @@ Starting Claude Code...
 
 Options:
 ```bash
-brcc start              # Start proxy + launch Claude Code
-brcc start --no-launch  # Proxy only (for manual Claude Code setup)
-brcc start -p 9000      # Custom port
+brcc start                              # Default model (Sonnet 4.6)
+brcc start --model nvidia/gpt-oss-120b  # Free model
+brcc start --model openai/gpt-5.4      # GPT-5.4
+brcc start --model deepseek/deepseek-chat  # Budget option
+brcc start --no-launch                  # Proxy only
+brcc start -p 9000                      # Custom port
+```
+
+Inside Claude Code, use `/model` to switch between Sonnet, Opus, and Haiku — each maps to the BlockRun model you configured.
+
+### `brcc models`
+
+List all available models with pricing.
+
+```
+$ brcc models
+Available Models
+
+Free Models (no USDC needed)
+──────────────────────────────────────────────────────────────────────
+  nvidia/gpt-oss-120b
+  nvidia/gpt-oss-20b
+
+Paid Models
+──────────────────────────────────────────────────────────────────────
+  Model                               Input        Output
+  deepseek/deepseek-chat              $0.28/M      $0.42/M
+  anthropic/claude-haiku-4.5          $1.00/M      $5.00/M
+  openai/gpt-5.4                      $2.50/M      $15.00/M
+  anthropic/claude-sonnet-4.6         $3.00/M      $15.00/M
+  anthropic/claude-opus-4.6           $5.00/M      $25.00/M
+  ...
+```
+
+### `brcc config`
+
+Customize model mappings for Claude Code's `/model` picker.
+
+```bash
+# Map Claude Code's "Haiku" to a cheap model
+brcc config set haiku-model deepseek/deepseek-chat
+
+# Map "Sonnet" to GPT-5.4
+brcc config set sonnet-model openai/gpt-5.4
+
+# Set default model
+brcc config set default-model nvidia/gpt-oss-120b
+
+# View all settings
+brcc config list
 ```
 
 ### `brcc balance`

package/dist/commands/config.d.ts

@@ -0,0 +1,9 @@
+export interface BrccConfig {
+    'default-model'?: string;
+    'sonnet-model'?: string;
+    'opus-model'?: string;
+    'haiku-model'?: string;
+    'smart-routing'?: string;
+}
+export declare function loadConfig(): BrccConfig;
+export declare function configCommand(action: string, keyOrUndefined?: string, value?: string): void;

package/dist/commands/config.js

@@ -0,0 +1,92 @@
+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, 'brcc-config.json');
+const VALID_KEYS = [
+    'default-model',
+    'sonnet-model',
+    'opus-model',
+    'haiku-model',
+    'smart-routing',
+];
+export function loadConfig() {
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(config) {
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', {
+        mode: 0o600,
+    });
+}
+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('brcc 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: brcc 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: brcc 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: brcc config unset <key>'));
+            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: brcc config <set|get|unset|list> [key] [value]');
+    process.exit(1);
+}

package/dist/commands/start.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
 import { createProxy } from '../proxy/server.js';
 import { loadChain, API_URLS, DEFAULT_PROXY_PORT } from '../config.js';
+import { loadConfig } from './config.js';
 export async function startCommand(options) {
     const chain = loadChain();
     const apiUrl = API_URLS[chain];
@@ -24,7 +25,7 @@ export async function startCommand(options) {
             console.log(`Model:   ${chalk.green(model)}`);
         console.log(`Proxy:   ${chalk.cyan(`http://localhost:${port}`)}`);
         console.log(`Backend: ${chalk.dim(apiUrl)}\n`);
-        const server = createProxy({ port, apiUrl, chain: 'solana' });
+        const server = createProxy({ port, apiUrl, chain: 'solana', modelOverride: model });
         launchServer(server, port, shouldLaunch, model);
     }
     else {
@@ -45,7 +46,7 @@ export async function startCommand(options) {
             console.log(`Model:   ${chalk.green(model)}`);
         console.log(`Proxy:   ${chalk.cyan(`http://localhost:${port}`)}`);
         console.log(`Backend: ${chalk.dim(apiUrl)}\n`);
-        const server = createProxy({ port, apiUrl, chain: 'base' });
+        const server = createProxy({ port, apiUrl, chain: 'base', modelOverride: model });
         launchServer(server, port, shouldLaunch, model);
     }
 }
@@ -57,6 +58,10 @@ function launchServer(server, port, shouldLaunch, model) {
             const cleanEnv = { ...process.env };
             delete cleanEnv.CLAUDE_ACCESS_TOKEN;
             delete cleanEnv.CLAUDE_OAUTH_TOKEN;
+            const config = loadConfig();
+            const sonnetModel = config['sonnet-model'] || 'anthropic/claude-sonnet-4.6';
+            const opusModel = config['opus-model'] || 'anthropic/claude-opus-4.6';
+            const haikuModel = config['haiku-model'] || 'anthropic/claude-haiku-4.5';
             const claudeArgs = [];
             if (model)
                 claudeArgs.push('--model', model);
@@ -66,6 +71,10 @@ function launchServer(server, port, shouldLaunch, model) {
                     ...cleanEnv,
                     ANTHROPIC_BASE_URL: `http://localhost:${port}/api`,
                     ANTHROPIC_API_KEY: 'sk-ant-api03-brcc-proxy-00000000000000000000000000000000000000000000-00000000000000',
+                    ANTHROPIC_DEFAULT_SONNET_MODEL: sonnetModel,
+                    ANTHROPIC_DEFAULT_OPUS_MODEL: opusModel,
+                    ANTHROPIC_DEFAULT_HAIKU_MODEL: haikuModel,
+                    ...(model ? { ANTHROPIC_MODEL: model } : {}),
                 },
             });
             claude.on('error', (err) => {

package/dist/index.js

@@ -4,11 +4,13 @@ import { setupCommand } from './commands/setup.js';
 import { startCommand } from './commands/start.js';
 import { balanceCommand } from './commands/balance.js';
 import { modelsCommand } from './commands/models.js';
+import { configCommand } from './commands/config.js';
 const program = new Command();
 program
     .name('brcc')
-    .description('BlockRun Claude Code — run Claude Code with any model, pay with USDC')
-    .version('0.1.0');
+    .description('BlockRun Claude Code — run Claude Code with any model, pay with USDC.\n\n' +
+    'Use /model inside Claude Code to switch between models on the fly.')
+    .version('0.5.0');
 program
     .command('setup [chain]')
     .description('Create a new wallet for payments (base or solana)')
@@ -17,7 +19,7 @@ program
     .command('start')
     .description('Start proxy and launch Claude Code')
     .option('-p, --port <port>', 'Proxy port', '8402')
-    .option('-m, --model <model>', 'Model to use (e.g. openai/gpt-5.4, nvidia/gpt-oss-120b)')
+    .option('-m, --model <model>', 'Default model (e.g. openai/gpt-5.4, anthropic/claude-sonnet-4.6)')
     .option('--no-launch', 'Start proxy only, do not launch Claude Code')
     .action(startCommand);
 program
@@ -28,4 +30,9 @@ program
     .command('balance')
     .description('Check wallet USDC balance')
     .action(balanceCommand);
+program
+    .command('config <action> [key] [value]')
+    .description('Manage brcc config (set, get, unset, list)\n' +
+    'Keys: default-model, sonnet-model, opus-model, haiku-model, smart-routing')
+    .action(configCommand);
 program.parse();

package/dist/proxy/server.d.ts

@@ -4,5 +4,13 @@ export interface ProxyOptions {
     port: number;
     apiUrl: string;
     chain?: Chain;
+    modelOverride?: string;
 }
 export declare function createProxy(options: ProxyOptions): http.Server;
+type RequestCategory = 'simple' | 'code' | 'default';
+interface ClassifiedRequest {
+    category: RequestCategory;
+    suggestedModel?: string;
+}
+export declare function classifyRequest(body: string): ClassifiedRequest;
+export {};

package/dist/proxy/server.js

@@ -29,6 +29,16 @@ export function createProxy(options) {
         });
         req.on('end', async () => {
             try {
+                if (options.modelOverride && body) {
+                    try {
+                        const parsed = JSON.parse(body);
+                        if (parsed.model) {
+                            parsed.model = options.modelOverride;
+                            body = JSON.stringify(parsed);
+                        }
+                    }
+                    catch { /* not JSON, pass through */ }
+                }
                 const headers = {
                     'Content-Type': 'application/json',
                 };
@@ -139,6 +149,38 @@ async function handleSolanaPayment(response, url, method, headers, body, private
         body: body || undefined,
     });
 }
+export function classifyRequest(body) {
+    try {
+        const parsed = JSON.parse(body);
+        const messages = parsed.messages;
+        if (!Array.isArray(messages) || messages.length === 0) {
+            return { category: 'default' };
+        }
+        const lastMessage = messages[messages.length - 1];
+        let content = '';
+        if (typeof lastMessage.content === 'string') {
+            content = lastMessage.content;
+        }
+        else if (Array.isArray(lastMessage.content)) {
+            content = lastMessage.content
+                .filter((b) => b.type === 'text' && b.text)
+                .map((b) => b.text)
+                .join('\n');
+        }
+        if (content.includes('```') || content.includes('function ') ||
+            content.includes('class ') || content.includes('import ') ||
+            content.includes('def ') || content.includes('const ')) {
+            return { category: 'code' };
+        }
+        if (content.length < 100) {
+            return { category: 'simple' };
+        }
+        return { category: 'default' };
+    }
+    catch {
+        return { category: 'default' };
+    }
+}
 // ======================================================================
 // Shared helpers
 // ======================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/cc",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Run Claude Code with any model — no rate limits, no account locks, no phone verification. Pay per use with USDC.",
   "type": "module",
   "bin": {