@blockrun/cc 0.2.0

package/LICENSE

@@ -0,0 +1,63 @@
+Business Source License 1.1
+
+Licensor: BlockRun AI (Piebald LLC)
+
+Licensed Work: brcc
+
+Change Date: 2030-03-23
+
+Change License: MIT
+
+Parameters:
+  Additional Use Grant: You may use the Licensed Work for any purpose,
+  including production use, provided that you do not offer the Licensed
+  Work as a commercial hosted service that competes with BlockRun's
+  paid offerings.
+
+Notice:
+  The Business Source License (this document, or the "License") is not
+  an Open Source license. However, the Licensed Work will eventually be
+  made available under an Open Source License, as stated in this License.
+
+Terms:
+
+The Licensor hereby grants you the right to copy, modify, create
+derivative works, redistribute, and make non-production use of the
+Licensed Work. The Licensor may make an Additional Use Grant, above,
+permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first
+publicly available distribution of a specific version of the Licensed
+Work under this License, whichever comes first, the Licensor hereby
+grants you rights under the terms of the Change License, and the
+rights granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or
+authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative
+works of the Licensed Work, are subject to this License. This License
+applies separately for each version of the Licensed Work and the
+Change Date may vary for each version of the Licensed Work released by
+Licensor.
+
+You must conspicuously display this License on each original or
+modified copy of the Licensed Work. If you receive the Licensed Work
+in original or modified form from a third party, the terms and
+conditions set forth in this License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will
+automatically terminate your rights under this License for the current
+and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or
+logo of Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS
+PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES
+AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION)
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+NON-INFRINGEMENT, AND TITLE.

package/README.md

@@ -0,0 +1,183 @@
+# brcc
+
+**Run Claude Code without rate limits.**
+
+Hitting usage limits? Account disabled? Can't verify your phone? brcc fixes all of that.
+
+```bash
+npm install -g brcc
+brcc start
+```
+
+One command. No Anthropic account needed. No rate limits. No phone verification. Just USDC.
+
+## The Problem
+
+Claude Code users hit these walls daily ([4,350+ GitHub issue comments](https://github.com/anthropics/claude-code/issues)):
+
+- **"Instantly hitting usage limits with Max subscription"** — 1,252 comments
+- **"Account disabled after payment"** — 145 comments
+- **"Phone verification — unable to send code"** — 546 comments
+- **"5-hour limit reached in less than 1h30"** — 108 comments
+- **"Rate limit reached despite Max subscription"** — 89 comments
+
+## The Fix
+
+brcc routes Claude Code through [BlockRun](https://blockrun.ai), a pay-per-use AI gateway. You pay exactly what you use — no subscriptions, no limits, no accounts.
+
+```
+Claude Code  -->  brcc (local proxy)  -->  BlockRun API  -->  Any model
+                  auto-signs payments      40+ models         GPT-5, Claude, Gemini, ...
+                  with your wallet         pay per token
+```
+
+## Quick Start
+
+```bash
+# Install
+npm install -g brcc
+
+# Create a wallet (one time)
+brcc setup
+# -> Wallet created: 0xCC8c...5EF8
+# -> Send USDC on Base to this address
+
+# Fund your wallet
+# Send $5-10 USDC on Base chain to your wallet address
+# Buy USDC on Coinbase, send directly to your address
+
+# Launch Claude Code
+brcc start
+```
+
+That's it. Claude Code opens with access to 40+ models, no rate limits.
+
+## What $5 Gets You
+
+| Model | ~Requests per $5 | Best For |
+|-------|-------------------|----------|
+| Claude Sonnet 4.6 | ~100 | Coding (default) |
+| GPT-5.4 | ~80 | Reasoning |
+| Claude Haiku 4.5 | ~500 | Fast tasks |
+| DeepSeek V3 | ~5,000 | Budget coding |
+| GPT-OSS 120B | Unlimited | Free tier |
+
+## Why brcc vs Claude Max Subscription
+
+| | Claude Max ($100-200/mo) | brcc |
+|--|--------------------------|------|
+| **Rate limits** | Constantly hit | None |
+| **Account locks** | Common | Impossible — no account |
+| **Phone verification** | Required | Not needed |
+| **Pricing** | Opaque, subscription | Transparent, pay-per-token |
+| **Region restrictions** | Some countries blocked | Works everywhere |
+| **Models** | Claude only | 40+ models (GPT, Gemini, DeepSeek...) |
+| **Monthly cost** | $100-200 fixed | $5-50 based on usage |
+| **Auth issues** | OAuth, API key conflicts | Wallet = identity |
+
+## Commands
+
+### `brcc setup`
+
+Creates a wallet and shows the address for funding.
+
+```
+$ brcc setup
+Wallet created!
+Address: 0xCC8c44AD3dc2A58D841c3EB26131E49b22665EF8
+Send USDC on Base to this address to fund your account.
+```
+
+Your wallet is saved to `~/.blockrun/` and shared with all BlockRun tools.
+
+### `brcc start`
+
+Starts the payment proxy and launches Claude Code.
+
+```
+$ brcc start
+brcc — BlockRun Claude Code
+
+Wallet:  0xCC8c...5EF8
+Proxy:   http://localhost:8402
+Backend: https://blockrun.ai/api
+
+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 balance`
+
+Check your USDC balance.
+
+```
+$ brcc balance
+Wallet: 0xCC8c44AD3dc2A58D841c3EB26131E49b22665EF8
+USDC Balance: $4.17
+```
+
+## How It Works
+
+1. `brcc start` launches a local HTTP proxy on port 8402
+2. Claude Code connects to the proxy (via `ANTHROPIC_BASE_URL`)
+3. When Claude Code makes an API request, the proxy forwards it to BlockRun
+4. If payment is needed, the proxy automatically signs a USDC micropayment
+5. BlockRun processes the request and returns the response
+6. Claude Code gets the response as normal
+
+Your private key never leaves your machine. Only payment signatures are sent.
+
+## Funding Your Wallet
+
+brcc uses USDC on Base (Coinbase's L2 chain). To fund:
+
+1. **Buy USDC** on [Coinbase](https://coinbase.com), [Binance](https://binance.com), or any exchange
+2. **Send USDC** to your brcc wallet address (shown in `brcc setup`)
+3. **Make sure it's on Base chain** — not Ethereum mainnet
+
+Typical cost: $0.001-0.05 per Claude Code interaction. $5 lasts most developers a week.
+
+## Available Models
+
+All [BlockRun models](https://blockrun.ai) work through brcc:
+
+- **OpenAI**: GPT-5.4, GPT-5.2, GPT-5-mini, o3, o4-mini
+- **Anthropic**: Claude Opus 4.6, Sonnet 4.6, Haiku 4.5
+- **Google**: Gemini 3.1 Pro, 2.5 Pro, 2.5 Flash
+- **DeepSeek**: V3, Reasoner
+- **xAI**: Grok 3, Grok 4
+- **Free**: NVIDIA GPT-OSS 120B (no payment needed)
+
+## FAQ
+
+**Q: Is this legal?**
+A: Yes. brcc is an API proxy. You're using Claude Code (Anthropic's open CLI) with a different API backend. OpenRouter, LiteLLM, and others do the same thing. No Anthropic terms are violated because no Anthropic services are used.
+
+**Q: Do I need an Anthropic account?**
+A: No. brcc bypasses Anthropic entirely. You don't need an Anthropic account, API key, or subscription.
+
+**Q: Is my wallet safe?**
+A: Your private key stays on your machine (`~/.blockrun/.session`, chmod 600). It's only used for local signing — never transmitted over the network.
+
+**Q: What if BlockRun goes down?**
+A: Your wallet and funds are yours on-chain. USDC is always withdrawable regardless of BlockRun's status.
+
+**Q: Can I use models other than Claude?**
+A: Yes. Claude Code works with any model that speaks the Anthropic Messages API format. Through brcc, you can use GPT-5, Gemini, DeepSeek, and 30+ other models.
+
+## Links
+
+- [BlockRun](https://blockrun.ai) — The AI gateway powering brcc
+- [BlockRun TypeScript SDK](https://www.npmjs.com/package/@blockrun/llm)
+- [Telegram](https://t.me/+mroQv4-4hGgzOGUx)
+- [GitHub Issues](https://github.com/BlockRunAI/brcc/issues)
+
+## License
+
+[Business Source License 1.1](LICENSE) — Free to use, modify, and deploy. Cannot be used to build a competing hosted service. Converts to MIT in 2030.

package/dist/commands/balance.d.ts

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

package/dist/commands/balance.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { setupAgentWallet } from '@blockrun/llm';
+export async function balanceCommand() {
+    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.`));
+        }
+    }
+    catch {
+        console.log(chalk.red('No wallet found. Run `brcc setup` first.'));
+        process.exit(1);
+    }
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,19 @@
+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;
+    }
+    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(`Then run ${chalk.bold('brcc start')} to launch Claude Code.\n`);
+    console.log(chalk.dim('Wallet saved to ~/.blockrun/'));
+}

package/dist/commands/start.d.ts

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

package/dist/commands/start.js

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { getOrCreateWallet } from '@blockrun/llm';
+import { createProxy } from '../proxy/server.js';
+import { DEFAULT_API_URL, 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 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 });
+    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', [], {
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    ANTHROPIC_BASE_URL: `http://localhost:${port}/api`,
+                    ANTHROPIC_API_KEY: 'brcc',
+                },
+            });
+            claude.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.log(chalk.red('\nClaude Code not found. Install it first:'));
+                    console.log(chalk.dim('  npm install -g @anthropic-ai/claude-code'));
+                }
+                else {
+                    console.error('Failed to start Claude Code:', err.message);
+                }
+                server.close();
+                process.exit(1);
+            });
+            claude.on('exit', (code) => {
+                server.close();
+                process.exit(code ?? 0);
+            });
+        }
+        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(`\nThen run ${chalk.bold('claude')} in another terminal.`);
+        }
+    });
+    process.on('SIGINT', () => {
+        console.log('\nShutting down...');
+        server.close();
+        process.exit(0);
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_API_URL = "https://blockrun.ai/api";
+export declare const DEFAULT_PROXY_PORT = 8402;

package/dist/config.js

@@ -0,0 +1,2 @@
+export const DEFAULT_API_URL = 'https://blockrun.ai/api';
+export const DEFAULT_PROXY_PORT = 8402;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { setupCommand } from './commands/setup.js';
+import { startCommand } from './commands/start.js';
+import { balanceCommand } from './commands/balance.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);
+program
+    .command('start')
+    .description('Start proxy and launch Claude Code')
+    .option('-p, --port <port>', 'Proxy port', '8402')
+    .option('--no-launch', 'Start proxy only, do not launch Claude Code')
+    .action(startCommand);
+program
+    .command('balance')
+    .description('Check wallet USDC balance')
+    .action(balanceCommand);
+program.parse();

package/dist/proxy/server.d.ts

@@ -0,0 +1,6 @@
+import http from 'node:http';
+export interface ProxyOptions {
+    port: number;
+    apiUrl: string;
+}
+export declare function createProxy(options: ProxyOptions): http.Server;

package/dist/proxy/server.js

@@ -0,0 +1,106 @@
+import http from 'node:http';
+import { getOrCreateWallet, createPaymentPayload, parsePaymentRequired, extractPaymentDetails, } from '@blockrun/llm';
+export function createProxy(options) {
+    const wallet = getOrCreateWallet();
+    const privateKey = wallet.privateKey;
+    const fromAddress = wallet.address;
+    const server = http.createServer(async (req, res) => {
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const path = req.url?.replace(/^\/api/, '') || '';
+        const targetUrl = `${options.apiUrl}${path}`;
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk;
+        });
+        req.on('end', async () => {
+            try {
+                const headers = {
+                    'Content-Type': 'application/json',
+                };
+                for (const [key, value] of Object.entries(req.headers)) {
+                    if (key.toLowerCase() !== 'host' &&
+                        key.toLowerCase() !== 'content-length' &&
+                        value) {
+                        headers[key] = Array.isArray(value) ? value[0] : value;
+                    }
+                }
+                let response = await fetch(targetUrl, {
+                    method: req.method || 'POST',
+                    headers,
+                    body: body || undefined,
+                });
+                if (response.status === 402) {
+                    response = await handlePayment(response, targetUrl, req.method || 'POST', headers, body, privateKey, fromAddress);
+                }
+                const responseHeaders = {};
+                response.headers.forEach((v, k) => {
+                    responseHeaders[k] = v;
+                });
+                res.writeHead(response.status, responseHeaders);
+                if (response.body) {
+                    const reader = response.body.getReader();
+                    const pump = async () => {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done) {
+                                res.end();
+                                break;
+                            }
+                            res.write(value);
+                        }
+                    };
+                    pump().catch(() => res.end());
+                }
+                else {
+                    res.end(await response.text());
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : 'Proxy error';
+                res.writeHead(502, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    type: 'error',
+                    error: { type: 'api_error', message: msg },
+                }));
+            }
+        });
+    });
+    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
+        }
+    }
+    if (!paymentHeader) {
+        throw new Error('402 response but no payment requirements found');
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired);
+    const paymentPayload = await createPaymentPayload(privateKey, fromAddress, details.recipient, details.amount, details.network || 'eip155:8453', {
+        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,
+    });
+}

package/dist/wallet/manager.d.ts

@@ -0,0 +1,6 @@
+export declare function walletExists(): boolean;
+export declare function setupWallet(): {
+    address: string;
+    isNew: boolean;
+};
+export declare function getAddress(): string;

package/dist/wallet/manager.js

@@ -0,0 +1,15 @@
+import { getOrCreateWallet, scanWallets, getWalletAddress, } from '@blockrun/llm';
+export function walletExists() {
+    const wallets = scanWallets();
+    return wallets.length > 0;
+}
+export function setupWallet() {
+    const { address, isNew } = getOrCreateWallet();
+    return { address, isNew };
+}
+export function getAddress() {
+    const addr = getWalletAddress();
+    if (!addr)
+        throw new Error('No wallet found. Run `brcc setup` first.');
+    return addr;
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@blockrun/cc",
+  "version": "0.2.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": {
+    "brcc": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "claude-code",
+    "ai",
+    "llm",
+    "gpt",
+    "gemini",
+    "deepseek",
+    "anthropic",
+    "openai",
+    "x402",
+    "usdc",
+    "crypto",
+    "pay-per-use",
+    "no-rate-limit",
+    "blockrun"
+  ],
+  "license": "BUSL-1.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlockRunAI/brcc"
+  },
+  "homepage": "https://blockrun.ai",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@blockrun/llm": "^1.4.2",
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}