@blockrun/cc 0.2.0 → 0.4.0

package/README.md

@@ -5,7 +5,7 @@
 Hitting usage limits? Account disabled? Can't verify your phone? brcc fixes all of that.
 
 ```bash
-npm install -g brcc
+npm install -g @blockrun/cc
 brcc start
 ```
 
@@ -35,7 +35,7 @@ Claude Code  -->  brcc (local proxy)  -->  BlockRun API  -->  Any model
 
 ```bash
 # Install
-npm install -g brcc
+npm install -g @blockrun/cc
 
 # Create a wallet (one time)
 brcc setup

package/dist/commands/balance.js

@@ -1,14 +1,30 @@
 import chalk from 'chalk';
-import { setupAgentWallet } from '@blockrun/llm';
+import { setupAgentWallet, setupAgentSolanaWallet } from '@blockrun/llm';
+import { loadChain } from '../config.js';
 export async function balanceCommand() {
+    const chain = loadChain();
     try {
-        const client = setupAgentWallet({ silent: true });
-        const address = client.getWalletAddress();
-        const balance = await client.getBalance();
-        console.log(`Wallet: ${chalk.cyan(address)}`);
-        console.log(`USDC Balance: ${chalk.green(`$${balance.toFixed(2)}`)}`);
-        if (balance === 0) {
-            console.log(chalk.dim(`\nSend USDC on Base to ${address} to get started.`));
+        if (chain === 'solana') {
+            const client = await setupAgentSolanaWallet({ silent: true });
+            const address = await client.getWalletAddress();
+            const balance = await client.getBalance();
+            console.log(`Chain:  ${chalk.magenta('solana')}`);
+            console.log(`Wallet: ${chalk.cyan(address)}`);
+            console.log(`USDC Balance: ${chalk.green(`$${balance.toFixed(2)}`)}`);
+            if (balance === 0) {
+                console.log(chalk.dim(`\nSend USDC on Solana to ${address} to get started.`));
+            }
+        }
+        else {
+            const client = setupAgentWallet({ silent: true });
+            const address = client.getWalletAddress();
+            const balance = await client.getBalance();
+            console.log(`Chain:  ${chalk.magenta('base')}`);
+            console.log(`Wallet: ${chalk.cyan(address)}`);
+            console.log(`USDC Balance: ${chalk.green(`$${balance.toFixed(2)}`)}`);
+            if (balance === 0) {
+                console.log(chalk.dim(`\nSend USDC on Base to ${address} to get started.`));
+            }
         }
     }
     catch {

package/dist/commands/models.d.ts

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

package/dist/commands/models.js

@@ -0,0 +1,42 @@
+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 response = await fetch(`${apiUrl}/v1/models`);
+        if (!response.ok) {
+            console.log(chalk.red(`Failed to fetch models: ${response.status}`));
+            return;
+        }
+        const data = (await response.json());
+        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('brcc start --model <model-id>')}`);
+    }
+    catch (err) {
+        console.log(chalk.red(`Error: ${err instanceof Error ? err.message : 'Failed to fetch models'}`));
+    }
+}

package/dist/commands/setup.d.ts

@@ -1 +1 @@
-export declare function setupCommand(): Promise<void>;
+export declare function setupCommand(chainArg?: string): Promise<void>;

package/dist/commands/setup.js

@@ -1,19 +1,41 @@
 import chalk from 'chalk';
-import { getOrCreateWallet, scanWallets } from '@blockrun/llm';
-export async function setupCommand() {
-    const wallets = scanWallets();
-    if (wallets.length > 0) {
-        console.log(chalk.yellow('Wallet already exists.'));
-        console.log(`Address: ${chalk.cyan(wallets[0].address)}`);
-        return;
+import { getOrCreateWallet, scanWallets, getOrCreateSolanaWallet, scanSolanaWallets, } from '@blockrun/llm';
+import { saveChain } from '../config.js';
+export async function setupCommand(chainArg) {
+    const chain = chainArg === 'solana' ? 'solana' : 'base';
+    if (chain === 'solana') {
+        const wallets = scanSolanaWallets();
+        if (wallets.length > 0) {
+            console.log(chalk.yellow('Solana wallet already exists.'));
+            console.log(`Address: ${chalk.cyan(wallets[0].publicKey)}`);
+            saveChain('solana');
+            return;
+        }
+        console.log('Creating new Solana wallet...\n');
+        const { address, isNew } = await getOrCreateSolanaWallet();
+        if (isNew) {
+            console.log(chalk.green('Solana wallet created!\n'));
+        }
+        console.log(`Address: ${chalk.cyan(address)}`);
+        console.log(`\nSend USDC on Solana to this address to fund your account.`);
     }
-    console.log('Creating new wallet...\n');
-    const { address, isNew } = getOrCreateWallet();
-    if (isNew) {
-        console.log(chalk.green('Wallet created!\n'));
+    else {
+        const wallets = scanWallets();
+        if (wallets.length > 0) {
+            console.log(chalk.yellow('Wallet already exists.'));
+            console.log(`Address: ${chalk.cyan(wallets[0].address)}`);
+            saveChain('base');
+            return;
+        }
+        console.log('Creating new wallet...\n');
+        const { address, isNew } = getOrCreateWallet();
+        if (isNew) {
+            console.log(chalk.green('Wallet created!\n'));
+        }
+        console.log(`Address: ${chalk.cyan(address)}`);
+        console.log(`\nSend USDC on Base to this address to fund your account.`);
     }
-    console.log(`Address: ${chalk.cyan(address)}`);
-    console.log(`\nSend USDC on Base to this address to fund your account.`);
+    saveChain(chain);
     console.log(`Then run ${chalk.bold('brcc start')} to launch Claude Code.\n`);
-    console.log(chalk.dim('Wallet saved to ~/.blockrun/'));
+    console.log(chalk.dim(`Chain: ${chain} — saved to ~/.blockrun/`));
 }

package/dist/commands/start.d.ts

@@ -1,5 +1,6 @@
 interface StartOptions {
     port?: string;
+    model?: string;
     launch?: boolean;
 }
 export declare function startCommand(options: StartOptions): Promise<void>;

package/dist/commands/start.js

@@ -1,33 +1,71 @@
 import { spawn } from 'node:child_process';
 import chalk from 'chalk';
-import { getOrCreateWallet } from '@blockrun/llm';
+import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
 import { createProxy } from '../proxy/server.js';
-import { DEFAULT_API_URL, DEFAULT_PROXY_PORT } from '../config.js';
+import { loadChain, API_URLS, DEFAULT_PROXY_PORT } from '../config.js';
 export async function startCommand(options) {
-    const wallet = getOrCreateWallet();
-    if (wallet.isNew) {
-        console.log(chalk.yellow('No wallet found — created a new one.'));
-        console.log(`Address: ${chalk.cyan(wallet.address)}`);
-        console.log(`\nSend USDC on Base to this address, then run ${chalk.bold('brcc start')} again.\n`);
-        return;
+    const chain = loadChain();
+    const apiUrl = API_URLS[chain];
+    if (chain === 'solana') {
+        const wallet = await getOrCreateSolanaWallet();
+        if (wallet.isNew) {
+            console.log(chalk.yellow('No Solana wallet found — created a new one.'));
+            console.log(`Address: ${chalk.cyan(wallet.address)}`);
+            console.log(`\nSend USDC on Solana to this address, then run ${chalk.bold('brcc start')} again.\n`);
+            return;
+        }
+        const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
+        const shouldLaunch = options.launch !== false;
+        const model = options.model;
+        console.log(chalk.bold('brcc — BlockRun Claude Code\n'));
+        console.log(`Chain:   ${chalk.magenta('solana')}`);
+        console.log(`Wallet:  ${chalk.cyan(wallet.address)}`);
+        if (model)
+            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' });
+        launchServer(server, port, shouldLaunch, model);
+    }
+    else {
+        const wallet = getOrCreateWallet();
+        if (wallet.isNew) {
+            console.log(chalk.yellow('No wallet found — created a new one.'));
+            console.log(`Address: ${chalk.cyan(wallet.address)}`);
+            console.log(`\nSend USDC on Base to this address, then run ${chalk.bold('brcc start')} again.\n`);
+            return;
+        }
+        const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
+        const shouldLaunch = options.launch !== false;
+        const model = options.model;
+        console.log(chalk.bold('brcc — BlockRun Claude Code\n'));
+        console.log(`Chain:   ${chalk.magenta('base')}`);
+        console.log(`Wallet:  ${chalk.cyan(wallet.address)}`);
+        if (model)
+            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' });
+        launchServer(server, port, shouldLaunch, model);
     }
-    const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
-    const shouldLaunch = options.launch !== false;
-    console.log(chalk.bold('brcc — BlockRun Claude Code\n'));
-    console.log(`Wallet:  ${chalk.cyan(wallet.address)}`);
-    console.log(`Proxy:   ${chalk.cyan(`http://localhost:${port}`)}`);
-    console.log(`Backend: ${chalk.dim(DEFAULT_API_URL)}\n`);
-    const server = createProxy({ port, apiUrl: DEFAULT_API_URL });
+}
+function launchServer(server, port, shouldLaunch, model) {
     server.listen(port, () => {
         console.log(chalk.green(`Proxy running on port ${port}\n`));
         if (shouldLaunch) {
             console.log('Starting Claude Code...\n');
-            const claude = spawn('claude', [], {
+            const cleanEnv = { ...process.env };
+            delete cleanEnv.CLAUDE_ACCESS_TOKEN;
+            delete cleanEnv.CLAUDE_OAUTH_TOKEN;
+            const claudeArgs = ['--api-key-auth'];
+            if (model)
+                claudeArgs.push('--model', model);
+            const claude = spawn('claude', claudeArgs, {
                 stdio: 'inherit',
                 env: {
-                    ...process.env,
+                    ...cleanEnv,
                     ANTHROPIC_BASE_URL: `http://localhost:${port}/api`,
-                    ANTHROPIC_API_KEY: 'brcc',
+                    ANTHROPIC_API_KEY: 'sk-ant-api03-brcc-proxy-00000000000000000000000000000000000000000000-00000000000000',
                 },
             });
             claude.on('error', (err) => {
@@ -49,7 +87,7 @@ export async function startCommand(options) {
         else {
             console.log('Proxy-only mode. Set this in your shell:\n');
             console.log(chalk.bold(`  export ANTHROPIC_BASE_URL=http://localhost:${port}/api`));
-            console.log(chalk.bold(`  export ANTHROPIC_API_KEY=brcc`));
+            console.log(chalk.bold(`  export ANTHROPIC_API_KEY=sk-ant-api03-brcc-proxy-00000000000000000000000000000000000000000000-00000000000000`));
             console.log(`\nThen run ${chalk.bold('claude')} in another terminal.`);
         }
     });

package/dist/config.d.ts

@@ -1,2 +1,7 @@
-export declare const DEFAULT_API_URL = "https://blockrun.ai/api";
+export type Chain = 'base' | 'solana';
+export declare const BLOCKRUN_DIR: string;
+export declare const CHAIN_FILE: string;
+export declare const API_URLS: Record<Chain, string>;
 export declare const DEFAULT_PROXY_PORT = 8402;
+export declare function saveChain(chain: Chain): void;
+export declare function loadChain(): Chain;

package/dist/config.js

@@ -1,2 +1,30 @@
-export const DEFAULT_API_URL = 'https://blockrun.ai/api';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+export const BLOCKRUN_DIR = path.join(os.homedir(), '.blockrun');
+export const CHAIN_FILE = path.join(BLOCKRUN_DIR, 'payment-chain');
+export const API_URLS = {
+    base: 'https://blockrun.ai/api',
+    solana: 'https://sol.blockrun.ai/api',
+};
 export const DEFAULT_PROXY_PORT = 8402;
+export function saveChain(chain) {
+    fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+    fs.writeFileSync(CHAIN_FILE, chain + '\n', { mode: 0o600 });
+}
+export function loadChain() {
+    const envChain = process.env.BRCC_CHAIN;
+    if (envChain === 'solana')
+        return 'solana';
+    if (envChain === 'base')
+        return 'base';
+    try {
+        const content = fs.readFileSync(CHAIN_FILE, 'utf-8').trim();
+        if (content === 'solana')
+            return 'solana';
+        return 'base';
+    }
+    catch {
+        return 'base';
+    }
+}

package/dist/index.js

@@ -3,21 +3,27 @@ import { Command } from 'commander';
 import { setupCommand } from './commands/setup.js';
 import { startCommand } from './commands/start.js';
 import { balanceCommand } from './commands/balance.js';
+import { modelsCommand } from './commands/models.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');
 program
-    .command('setup')
-    .description('Create a new wallet for payments')
-    .action(setupCommand);
+    .command('setup [chain]')
+    .description('Create a new wallet for payments (base or solana)')
+    .action((chain) => setupCommand(chain));
 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('--no-launch', 'Start proxy only, do not launch Claude Code')
     .action(startCommand);
+program
+    .command('models')
+    .description('List available models and pricing')
+    .action(modelsCommand);
 program
     .command('balance')
     .description('Check wallet USDC balance')

package/dist/proxy/server.d.ts

@@ -1,6 +1,8 @@
 import http from 'node:http';
+import type { Chain } from '../config.js';
 export interface ProxyOptions {
     port: number;
     apiUrl: string;
+    chain?: Chain;
 }
 export declare function createProxy(options: ProxyOptions): http.Server;

package/dist/proxy/server.js

@@ -1,15 +1,26 @@
 import http from 'node:http';
-import { getOrCreateWallet, createPaymentPayload, parsePaymentRequired, extractPaymentDetails, } from '@blockrun/llm';
+import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 export function createProxy(options) {
-    const wallet = getOrCreateWallet();
-    const privateKey = wallet.privateKey;
-    const fromAddress = wallet.address;
+    const chain = options.chain || 'base';
+    let baseWallet = null;
+    let solanaWallet = null;
+    if (chain === 'base') {
+        const w = getOrCreateWallet();
+        baseWallet = { privateKey: w.privateKey, address: w.address };
+    }
+    const initSolana = async () => {
+        if (chain === 'solana' && !solanaWallet) {
+            const w = await getOrCreateSolanaWallet();
+            solanaWallet = { privateKey: w.privateKey, address: w.address };
+        }
+    };
     const server = http.createServer(async (req, res) => {
         if (req.method === 'OPTIONS') {
             res.writeHead(200);
             res.end();
             return;
         }
+        await initSolana();
         const path = req.url?.replace(/^\/api/, '') || '';
         const targetUrl = `${options.apiUrl}${path}`;
         let body = '';
@@ -34,7 +45,12 @@ export function createProxy(options) {
                     body: body || undefined,
                 });
                 if (response.status === 402) {
-                    response = await handlePayment(response, targetUrl, req.method || 'POST', headers, body, privateKey, fromAddress);
+                    if (chain === 'solana' && solanaWallet) {
+                        response = await handleSolanaPayment(response, targetUrl, req.method || 'POST', headers, body, solanaWallet.privateKey, solanaWallet.address);
+                    }
+                    else if (baseWallet) {
+                        response = await handleBasePayment(response, targetUrl, req.method || 'POST', headers, body, baseWallet.privateKey, baseWallet.address);
+                    }
                 }
                 const responseHeaders = {};
                 response.headers.forEach((v, k) => {
@@ -71,19 +87,11 @@ export function createProxy(options) {
     });
     return server;
 }
-async function handlePayment(response, url, method, headers, body, privateKey, fromAddress) {
-    let paymentHeader = response.headers.get('payment-required');
-    if (!paymentHeader) {
-        try {
-            const respBody = (await response.json());
-            if (respBody.x402 || respBody.accepts) {
-                paymentHeader = btoa(JSON.stringify(respBody));
-            }
-        }
-        catch {
-            // ignore parse errors
-        }
-    }
+// ======================================================================
+// Base (EIP-712) payment handler
+// ======================================================================
+async function handleBasePayment(response, url, method, headers, body, privateKey, fromAddress) {
+    const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
         throw new Error('402 response but no payment requirements found');
     }
@@ -104,3 +112,48 @@ async function handlePayment(response, url, method, headers, body, privateKey, f
         body: body || undefined,
     });
 }
+// ======================================================================
+// Solana payment handler
+// ======================================================================
+async function handleSolanaPayment(response, url, method, headers, body, privateKey, fromAddress) {
+    const paymentHeader = await extractPaymentHeader(response);
+    if (!paymentHeader) {
+        throw new Error('402 response but no payment requirements found');
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);
+    const secretKey = await solanaKeyToBytes(privateKey);
+    const feePayer = details.extra?.feePayer || details.recipient;
+    const paymentPayload = await createSolanaPaymentPayload(secretKey, fromAddress, details.recipient, details.amount, feePayer, {
+        resourceUrl: details.resource?.url || url,
+        resourceDescription: details.resource?.description || 'BlockRun AI API call',
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+    });
+    return fetch(url, {
+        method,
+        headers: {
+            ...headers,
+            'PAYMENT-SIGNATURE': paymentPayload,
+        },
+        body: body || undefined,
+    });
+}
+// ======================================================================
+// Shared helpers
+// ======================================================================
+async function extractPaymentHeader(response) {
+    let paymentHeader = response.headers.get('payment-required');
+    if (!paymentHeader) {
+        try {
+            const respBody = (await response.json());
+            if (respBody.x402 || respBody.accepts) {
+                paymentHeader = btoa(JSON.stringify(respBody));
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    }
+    return paymentHeader;
+}

package/dist/wallet/manager.d.ts

@@ -3,4 +3,8 @@ export declare function setupWallet(): {
     address: string;
     isNew: boolean;
 };
+export declare function setupSolanaWallet(): Promise<{
+    address: string;
+    isNew: boolean;
+}>;
 export declare function getAddress(): string;

package/dist/wallet/manager.js

@@ -1,12 +1,20 @@
-import { getOrCreateWallet, scanWallets, getWalletAddress, } from '@blockrun/llm';
+import { getOrCreateWallet, scanWallets, getWalletAddress, getOrCreateSolanaWallet, scanSolanaWallets, } from '@blockrun/llm';
+import { loadChain } from '../config.js';
 export function walletExists() {
-    const wallets = scanWallets();
-    return wallets.length > 0;
+    const chain = loadChain();
+    if (chain === 'solana') {
+        return scanSolanaWallets().length > 0;
+    }
+    return scanWallets().length > 0;
 }
 export function setupWallet() {
     const { address, isNew } = getOrCreateWallet();
     return { address, isNew };
 }
+export async function setupSolanaWallet() {
+    const { address, isNew } = await getOrCreateSolanaWallet();
+    return { address, isNew };
+}
 export function getAddress() {
     const addr = getWalletAddress();
     if (!addr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/cc",
-  "version": "0.2.0",
+  "version": "0.4.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": {
@@ -43,6 +43,9 @@
   },
   "dependencies": {
     "@blockrun/llm": "^1.4.2",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "bs58": "^6.0.0",
     "chalk": "^5.4.0",
     "commander": "^13.0.0"
   },