blits-bridge 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ClaudeAuth handles authentication with Claude CLI.
+ * Checks existing auth, triggers login flow if needed,
+ * and extracts OAuth token for API calls.
+ */
+export declare class ClaudeAuth {
+    private claudePath;
+    constructor();
+    private findClaude;
+    checkAuth(): Promise<boolean>;
+    login(): Promise<boolean>;
+    getToken(): Promise<string | null>;
+}

package/dist/auth.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAuth = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * ClaudeAuth handles authentication with Claude CLI.
+ * Checks existing auth, triggers login flow if needed,
+ * and extracts OAuth token for API calls.
+ */
+class ClaudeAuth {
+    claudePath = null;
+    constructor() {
+        this.claudePath = this.findClaude();
+    }
+    findClaude() {
+        const candidates = [
+            'claude',
+            (0, path_1.join)((0, os_1.homedir)(), '.npm', 'bin', 'claude'),
+            '/usr/local/bin/claude',
+            '/usr/bin/claude',
+        ];
+        for (const c of candidates) {
+            try {
+                (0, child_process_1.execSync)(`${c} --version`, { encoding: 'utf8', stdio: 'pipe' });
+                return c;
+            }
+            catch { }
+        }
+        return null;
+    }
+    async checkAuth() {
+        if (!this.claudePath) {
+            console.error('❌ Claude CLI не найден. Установите: npm install -g @anthropic-ai/claude-code');
+            return false;
+        }
+        try {
+            const result = (0, child_process_1.execSync)(`${this.claudePath} auth status`, {
+                encoding: 'utf8',
+                stdio: 'pipe',
+                timeout: 10000,
+            });
+            return result.toLowerCase().includes('logged in') || result.toLowerCase().includes('authenticated');
+        }
+        catch {
+            // auth status might fail if not logged in
+            return false;
+        }
+    }
+    async login() {
+        if (!this.claudePath)
+            return false;
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(this.claudePath, ['auth', 'login'], {
+                stdio: 'inherit', // Let user interact directly
+                env: { ...process.env },
+            });
+            proc.on('close', (code) => {
+                resolve(code === 0);
+            });
+            proc.on('error', () => {
+                resolve(false);
+            });
+        });
+    }
+    async getToken() {
+        // Try to read OAuth token from Claude CLI config
+        const credPaths = [
+            (0, path_1.join)((0, os_1.homedir)(), '.claude', '.credentials.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.claude', 'credentials.json'),
+            (0, path_1.join)((0, os_1.homedir)(), '.config', 'claude', 'credentials.json'),
+        ];
+        for (const p of credPaths) {
+            if ((0, fs_1.existsSync)(p)) {
+                try {
+                    const data = JSON.parse((0, fs_1.readFileSync)(p, 'utf8'));
+                    // Claude CLI stores OAuth token in various formats
+                    const token = data.claudeAiOauth?.accessToken
+                        || data.oauth?.access_token
+                        || data.accessToken
+                        || data.access_token;
+                    if (token)
+                        return token;
+                }
+                catch { }
+            }
+        }
+        // Fallback: try to extract from claude CLI
+        if (this.claudePath) {
+            try {
+                const result = (0, child_process_1.execSync)(`${this.claudePath} auth token 2>/dev/null || true`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                    timeout: 10000,
+                });
+                const token = result.trim();
+                if (token && token.length > 20)
+                    return token;
+            }
+            catch { }
+        }
+        return null;
+    }
+}
+exports.ClaudeAuth = ClaudeAuth;

package/dist/bridge.d.ts

@@ -0,0 +1,24 @@
+/**
+ * BlitsBridge connects to the Blits server via WebSocket,
+ * receives Claude API requests, executes them locally using
+ * the user's OAuth token, and sends results back.
+ */
+export declare class BlitsBridge {
+    private wsUrl;
+    private sessionToken;
+    private oauthToken;
+    private ws;
+    private reconnecting;
+    private shouldReconnect;
+    private heartbeatTimer;
+    private activeRequests;
+    constructor(wsUrl: string, sessionToken: string, oauthToken: string);
+    connect(): void;
+    disconnect(): void;
+    private send;
+    private handleRequest;
+    private callClaudeAPI;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+}

package/dist/bridge.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlitsBridge = void 0;
+const ws_1 = __importDefault(require("ws"));
+const ANTHROPIC_API_URL = 'https://api.anthropic.com/v1/messages';
+const RECONNECT_DELAY = 5000;
+const HEARTBEAT_INTERVAL = 30000;
+/**
+ * BlitsBridge connects to the Blits server via WebSocket,
+ * receives Claude API requests, executes them locally using
+ * the user's OAuth token, and sends results back.
+ */
+class BlitsBridge {
+    wsUrl;
+    sessionToken;
+    oauthToken;
+    ws = null;
+    reconnecting = false;
+    shouldReconnect = true;
+    heartbeatTimer = null;
+    activeRequests = 0;
+    constructor(wsUrl, sessionToken, oauthToken) {
+        this.wsUrl = wsUrl;
+        this.sessionToken = sessionToken;
+        this.oauthToken = oauthToken;
+    }
+    connect() {
+        const url = `${this.wsUrl}?token=${encodeURIComponent(this.sessionToken)}`;
+        try {
+            this.ws = new ws_1.default(url);
+        }
+        catch (err) {
+            console.error('❌ Ошибка подключения:', err.message);
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.on('open', () => {
+            console.log('✅ Подключён к Blits');
+            console.log('⏳ Ожидаю задачи... (Ctrl+C для выхода)');
+            console.log('');
+            this.reconnecting = false;
+            this.startHeartbeat();
+        });
+        this.ws.on('message', async (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === 'ping') {
+                    this.send({ type: 'pong' });
+                    return;
+                }
+                if (msg.type === 'claude_api') {
+                    await this.handleRequest(msg);
+                }
+            }
+            catch (err) {
+                console.error('⚠️  Ошибка обработки сообщения:', err.message);
+            }
+        });
+        this.ws.on('close', (code, reason) => {
+            this.stopHeartbeat();
+            if (this.shouldReconnect) {
+                console.log(`🔄 Соединение закрыто (${code}). Переподключение...`);
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on('error', (err) => {
+            console.error('⚠️  WebSocket ошибка:', err.message);
+        });
+    }
+    disconnect() {
+        this.shouldReconnect = false;
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close(1000, 'Client shutdown');
+            this.ws = null;
+        }
+    }
+    send(data) {
+        if (this.ws?.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    async handleRequest(req) {
+        this.activeRequests++;
+        const startTime = Date.now();
+        console.log(`📨 Задача ${req.id.slice(0, 8)}... (модель: ${req.payload.model})`);
+        try {
+            const response = await this.callClaudeAPI(req.payload);
+            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+            const result = {
+                id: req.id,
+                type: 'claude_api_result',
+                payload: response,
+            };
+            this.send(result);
+            console.log(`✅ Задача ${req.id.slice(0, 8)}... выполнена (${elapsed}с)`);
+        }
+        catch (err) {
+            const result = {
+                id: req.id,
+                type: 'claude_api_result',
+                error: err.message,
+            };
+            this.send(result);
+            console.error(`❌ Задача ${req.id.slice(0, 8)}... ошибка: ${err.message}`);
+        }
+        this.activeRequests--;
+    }
+    async callClaudeAPI(payload) {
+        const res = await fetch(ANTHROPIC_API_URL, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.oauthToken}`,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '');
+            throw new Error(`Claude API ${res.status}: ${errText.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    scheduleReconnect() {
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        setTimeout(() => {
+            if (this.shouldReconnect) {
+                this.connect();
+            }
+        }, RECONNECT_DELAY);
+    }
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.send({ type: 'heartbeat', activeRequests: this.activeRequests });
+        }, HEARTBEAT_INTERVAL);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+}
+exports.BlitsBridge = BlitsBridge;

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bridge_1 = require("./bridge");
+const auth_1 = require("./auth");
+const BLITS_WS_URL = process.env.BLITS_WS_URL || 'wss://blits.app/bridge/ws';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--token' && args[i + 1]) {
+            result.token = args[++i];
+        }
+        else if (args[i] === '--server' && args[i + 1]) {
+            result.server = args[++i];
+        }
+        else if (args[i] === '--help' || args[i] === '-h') {
+            console.log(`
+  blits-bridge — мост между Blits и вашей подпиской Claude
+
+  Использование:
+    npx blits-bridge --token <session-token>
+
+  Опции:
+    --token <token>   Токен сессии (получите на train.blits.app/settings)
+    --server <url>    WebSocket URL сервера (по умолчанию: ${BLITS_WS_URL})
+    --help            Показать справку
+
+  Как это работает:
+    1. Bridge подключается к серверу Blits через WebSocket
+    2. Когда агент запускает задачу, запрос приходит сюда
+    3. Bridge выполняет запрос через ваш локальный Claude CLI
+    4. Результат отправляется обратно на сервер
+    5. Вы используете свою подписку Pro/Max — без API ключей
+`);
+            process.exit(0);
+        }
+    }
+    return result;
+}
+async function main() {
+    const { token, server } = parseArgs();
+    if (!token) {
+        console.error('❌ Укажите токен: blits-bridge --token <session-token>');
+        console.error('   Получите токен на train.blits.app/settings');
+        process.exit(1);
+    }
+    console.log('🔗 Blits Bridge v0.1.0');
+    console.log('');
+    // Step 1: Check Claude CLI auth
+    const auth = new auth_1.ClaudeAuth();
+    console.log('🔍 Проверяю авторизацию Claude CLI...');
+    const isAuthed = await auth.checkAuth();
+    if (!isAuthed) {
+        console.log('⚠️  Claude CLI не авторизован. Запускаю авторизацию...');
+        console.log('');
+        const success = await auth.login();
+        if (!success) {
+            console.error('❌ Не удалось авторизоваться. Запустите вручную: claude auth login');
+            process.exit(1);
+        }
+        console.log('');
+    }
+    const oauthToken = await auth.getToken();
+    if (!oauthToken) {
+        console.error('❌ Не удалось получить OAuth токен. Перезапустите: claude auth login');
+        process.exit(1);
+    }
+    console.log('✅ Claude CLI авторизован');
+    // Step 2: Connect to Blits
+    const wsUrl = server || BLITS_WS_URL;
+    console.log(`🌐 Подключаюсь к ${wsUrl}...`);
+    const bridge = new bridge_1.BlitsBridge(wsUrl, token, oauthToken);
+    bridge.connect();
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log('\n👋 Отключение...');
+        bridge.disconnect();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch(err => {
+    console.error('❌ Ошибка:', err.message);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { BlitsBridge } from './bridge';
+export { ClaudeAuth } from './auth';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAuth = exports.BlitsBridge = void 0;
+var bridge_1 = require("./bridge");
+Object.defineProperty(exports, "BlitsBridge", { enumerable: true, get: function () { return bridge_1.BlitsBridge; } });
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "ClaudeAuth", { enumerable: true, get: function () { return auth_1.ClaudeAuth; } });

package/dist/server.d.ts

@@ -0,0 +1,36 @@
+export declare class BridgeServer {
+    private validateToken;
+    private wss;
+    private bridges;
+    private pendingRequests;
+    constructor(validateToken: (token: string) => Promise<string | null>);
+    /**
+     * Attach to an existing HTTP server or create standalone
+     */
+    attach(server: any, path?: string): void;
+    /**
+     * Check if a bridge is connected for a user
+     */
+    isConnected(userId: string): boolean;
+    /**
+     * Send a Claude API request through the user's bridge
+     */
+    callClaude(userId: string, payload: {
+        model: string;
+        max_tokens: number;
+        system?: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        tools?: any[];
+    }, timeoutMs?: number): Promise<any>;
+    /**
+     * Get status of all connected bridges
+     */
+    getStatus(): Array<{
+        userId: string;
+        connectedAt: number;
+        activeRequests: number;
+    }>;
+}

package/dist/server.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeServer = void 0;
+/**
+ * Bridge Server — runs on the Blits server side.
+ * Accepts WebSocket connections from blits-bridge clients,
+ * routes Claude API requests through them.
+ *
+ * This module can be imported by any Blits app (training-ground, digital-office, etc.)
+ */
+const ws_1 = require("ws");
+const crypto_1 = __importDefault(require("crypto"));
+class BridgeServer {
+    validateToken;
+    wss = null;
+    bridges = new Map(); // userId -> bridge
+    pendingRequests = new Map(); // requestId -> pending
+    constructor(validateToken) {
+        this.validateToken = validateToken;
+    }
+    /**
+     * Attach to an existing HTTP server or create standalone
+     */
+    attach(server, path = '/bridge/ws') {
+        this.wss = new ws_1.WebSocketServer({ server, path });
+        this.wss.on('connection', async (ws, req) => {
+            const url = new URL(req.url || '', 'http://localhost');
+            const token = url.searchParams.get('token');
+            if (!token) {
+                ws.close(4001, 'Missing token');
+                return;
+            }
+            const userId = await this.validateToken(token);
+            if (!userId) {
+                ws.close(4002, 'Invalid token');
+                return;
+            }
+            // Close existing bridge for this user
+            const existing = this.bridges.get(userId);
+            if (existing) {
+                existing.ws.close(4003, 'Replaced by new connection');
+            }
+            const bridge = {
+                ws,
+                userId,
+                connectedAt: Date.now(),
+                lastHeartbeat: Date.now(),
+                activeRequests: 0,
+            };
+            this.bridges.set(userId, bridge);
+            console.log(`[Bridge] Connected: ${userId}`);
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'pong' || msg.type === 'heartbeat') {
+                        bridge.lastHeartbeat = Date.now();
+                        bridge.activeRequests = msg.activeRequests || 0;
+                        return;
+                    }
+                    if (msg.type === 'claude_api_result') {
+                        const pending = this.pendingRequests.get(msg.id);
+                        if (pending) {
+                            clearTimeout(pending.timeout);
+                            this.pendingRequests.delete(msg.id);
+                            if (msg.error) {
+                                pending.reject(new Error(msg.error));
+                            }
+                            else {
+                                pending.resolve(msg.payload);
+                            }
+                        }
+                    }
+                }
+                catch { }
+            });
+            ws.on('close', () => {
+                if (this.bridges.get(userId)?.ws === ws) {
+                    this.bridges.delete(userId);
+                    console.log(`[Bridge] Disconnected: ${userId}`);
+                }
+            });
+            // Send initial ping
+            ws.send(JSON.stringify({ type: 'ping' }));
+        });
+        // Heartbeat check every 60s
+        setInterval(() => {
+            const now = Date.now();
+            for (const [userId, bridge] of this.bridges) {
+                if (now - bridge.lastHeartbeat > 90_000) {
+                    console.log(`[Bridge] Stale connection: ${userId}`);
+                    bridge.ws.close(4004, 'Heartbeat timeout');
+                    this.bridges.delete(userId);
+                }
+                else {
+                    bridge.ws.send(JSON.stringify({ type: 'ping' }));
+                }
+            }
+        }, 60_000);
+    }
+    /**
+     * Check if a bridge is connected for a user
+     */
+    isConnected(userId) {
+        const bridge = this.bridges.get(userId);
+        return !!bridge && bridge.ws.readyState === ws_1.WebSocket.OPEN;
+    }
+    /**
+     * Send a Claude API request through the user's bridge
+     */
+    async callClaude(userId, payload, timeoutMs = 120_000) {
+        const bridge = this.bridges.get(userId);
+        if (!bridge || bridge.ws.readyState !== ws_1.WebSocket.OPEN) {
+            throw new Error('BRIDGE_NOT_CONNECTED');
+        }
+        const requestId = crypto_1.default.randomUUID();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error('BRIDGE_TIMEOUT'));
+            }, timeoutMs);
+            this.pendingRequests.set(requestId, { resolve, reject, timeout });
+            bridge.ws.send(JSON.stringify({
+                id: requestId,
+                type: 'claude_api',
+                payload,
+            }));
+        });
+    }
+    /**
+     * Get status of all connected bridges
+     */
+    getStatus() {
+        return Array.from(this.bridges.entries()).map(([userId, b]) => ({
+            userId,
+            connectedAt: b.connectedAt,
+            activeRequests: b.activeRequests,
+        }));
+    }
+}
+exports.BridgeServer = BridgeServer;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "blits-bridge",
+  "version": "0.1.0",
+  "description": "Bridge between Blits platform and local Claude CLI. Runs Claude API calls through your subscription.",
+  "bin": {
+    "blits-bridge": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.13",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.9.3"
+  }
+}