rebellm-bridge 0.1.0

package/dist/tab.js

@@ -0,0 +1,257 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { PROTOCOL_VERSION, encode, parseTabMessage, } from './protocol.js';
+export const PING_MS = 20_000;
+export const SILENCE_MS = 50_000;
+/** Close codes for a refused `hello`, as the app's stand-in bridge uses them. */
+export const CLOSE = { auth: 4000, version: 4001, busy: 4002, helloFirst: 4003 };
+export class ChatError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.name = 'ChatError';
+        this.kind = kind;
+    }
+}
+const digest = (s) => createHash('sha256').update(s).digest();
+/** Constant-time comparison; hashing first makes the lengths equal. */
+export const sameToken = (a, b) => timingSafeEqual(digest(a), digest(b));
+const text = (d) => (Buffer.isBuffer(d) ? d : Array.isArray(d) ? Buffer.concat(d) : Buffer.from(d)).toString('utf8');
+/**
+ * The one RebeLLM tab connected to this bridge: its `hello`, its model state, and the chats
+ * sent to it, each settled by the tab's `done` or `error` or by the connection closing.
+ * Emits `change` when a tab connects, disconnects or reports a new status.
+ */
+export class TabLink extends EventEmitter {
+    token;
+    pingMs;
+    silenceMs;
+    log;
+    ws = null;
+    hello = null;
+    status = null;
+    pinger = null;
+    pending = new Map();
+    seq = 0;
+    // Ids differ across restarts, so tool call ids in a client's history never repeat.
+    prefix = randomBytes(4).toString('hex');
+    constructor(o) {
+        super();
+        this.setMaxListeners(0);
+        this.token = o.token;
+        this.pingMs = o.pingMs ?? PING_MS;
+        this.silenceMs = o.silenceMs ?? SILENCE_MS;
+        this.log = o.log ?? (() => undefined);
+    }
+    get connected() {
+        return !!this.ws;
+    }
+    /** Takes a new WebSocket; it becomes the tab after a valid `hello`. */
+    accept(ws) {
+        let authed = false;
+        const silence = setTimeout(() => {
+            if (authed)
+                this.log('the RebeLLM tab stopped answering; dropped it');
+            ws.terminate();
+        }, this.silenceMs);
+        ws.on('message', (data, isBinary) => {
+            silence.refresh();
+            const m = isBinary ? null : parseTabMessage(text(data));
+            if (authed)
+                return m ? this.receive(m) : this.log('ignored a frame from the tab that is not protocol v1');
+            if (m?.t !== 'hello')
+                return ws.close(CLOSE.helloFirst, 'hello first');
+            const refuse = (code, message) => {
+                send(ws, { t: 'error', code, message });
+                ws.close(CLOSE[code], code);
+                this.log(`refused a tab: ${message}`);
+            };
+            if (m.v !== PROTOCOL_VERSION)
+                return refuse('version', `this bridge speaks protocol v${PROTOCOL_VERSION}, not v${m.v}`);
+            if (!sameToken(m.token, this.token))
+                return refuse('auth', 'wrong token');
+            if (this.ws)
+                return refuse('busy', 'another RebeLLM tab is connected');
+            authed = true;
+            this.attach(ws, m);
+        });
+        ws.on('close', () => {
+            clearTimeout(silence);
+            if (this.ws === ws)
+                this.detach();
+        });
+        // A close event follows every error.
+        ws.on('error', () => undefined);
+    }
+    health() {
+        if (!this.ws || !this.hello)
+            return { tab: false, state: 'none' };
+        const s = this.status;
+        const model = s?.model || this.hello.model;
+        return {
+            tab: true,
+            // The tab sends its status right after `ok`; until then its model counts as loading.
+            state: s?.state ?? 'loading',
+            ...(model ? { model } : {}),
+            ...(s?.detail ? { detail: s.detail } : {}),
+            contextTokens: this.hello.contextTokens,
+            app: this.hello.app,
+        };
+    }
+    /** The tab's model name for responses. */
+    get modelName() {
+        return this.health().model ?? 'rebellm';
+    }
+    /** Why a chat cannot start now, or null when the tab's model is ready. */
+    unavailable() {
+        const h = this.health();
+        if (!h.tab)
+            return { code: 'no_tab', message: 'no RebeLLM tab connected' };
+        if (h.state === 'ready')
+            return null;
+        const [code, base] = h.state === 'unavailable'
+            ? ['model_unavailable', 'model unavailable']
+            : ['model_loading', 'model loading'];
+        return { code, message: h.detail ? `${base}: ${h.detail}` : base };
+    }
+    /** Resolves null once the model is ready, or the reason it is not after `ms` or an abort. */
+    waitReady(ms, signal) {
+        const now = this.unavailable();
+        if (!now || ms <= 0 || signal?.aborted)
+            return Promise.resolve(now);
+        return new Promise((resolve) => {
+            const done = () => {
+                clearTimeout(timer);
+                this.off('change', check);
+                signal?.removeEventListener('abort', done);
+                resolve(this.unavailable());
+            };
+            const check = () => !this.unavailable() && done();
+            const timer = setTimeout(done, ms);
+            this.on('change', check);
+            signal?.addEventListener('abort', done, { once: true });
+        });
+    }
+    /** Sends one chat to the tab; resolves with its answer when the tab says `done`. */
+    chat(input, opts = {}) {
+        const ws = this.ws;
+        if (!ws)
+            return Promise.reject(new ChatError('no RebeLLM tab connected', 'no_tab'));
+        if (opts.signal?.aborted)
+            return Promise.reject(new ChatError('the request was cancelled', 'aborted'));
+        const id = `${this.prefix}-${++this.seq}`;
+        const { signal, onEvent } = opts;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (!this.pending.delete(id))
+                    return;
+                send(ws, { t: 'abort', id });
+                reject(new ChatError('the request was cancelled', 'aborted'));
+            };
+            const cleanup = () => {
+                this.pending.delete(id);
+                signal?.removeEventListener('abort', onAbort);
+            };
+            this.pending.set(id, {
+                text: '',
+                calls: [],
+                ...(onEvent ? { onEvent } : {}),
+                finish: (r) => (cleanup(), resolve(r)),
+                fail: (e) => (cleanup(), reject(e)),
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            send(ws, {
+                t: 'chat',
+                id,
+                messages: input.messages,
+                ...(input.tools?.length ? { tools: input.tools } : {}),
+                ...(input.maxTokens !== undefined ? { maxTokens: input.maxTokens } : {}),
+                ...(input.temperature !== undefined ? { temperature: input.temperature } : {}),
+            });
+        });
+    }
+    /** Drops the tab, failing its open chats. */
+    close() {
+        const ws = this.ws;
+        if (!ws)
+            return;
+        this.detach();
+        ws.terminate();
+    }
+    attach(ws, hello) {
+        this.ws = ws;
+        this.hello = hello;
+        this.status = null;
+        send(ws, { t: 'ok' });
+        this.pinger = setInterval(() => send(ws, { t: 'ping' }), this.pingMs);
+        const model = hello.model ? `, model ${hello.model}` : '';
+        this.log(`RebeLLM tab connected (app ${hello.app || 'unknown'}${model})`);
+        this.emit('change');
+    }
+    detach() {
+        if (this.pinger)
+            clearInterval(this.pinger);
+        this.pinger = null;
+        this.ws = null;
+        this.hello = null;
+        this.status = null;
+        const open = [...this.pending.values()];
+        this.pending.clear();
+        for (const p of open)
+            p.fail(new ChatError('the RebeLLM tab disconnected', 'disconnected'));
+        this.log('RebeLLM tab disconnected');
+        this.emit('change');
+    }
+    receive(m) {
+        switch (m.t) {
+            case 'ping':
+                if (this.ws)
+                    send(this.ws, { t: 'pong' });
+                return;
+            case 'status': {
+                const prev = this.status?.state;
+                this.status = {
+                    state: m.state,
+                    ...(m.model ? { model: m.model } : {}),
+                    ...(m.detail ? { detail: m.detail } : {}),
+                };
+                if (prev !== m.state)
+                    this.log(`model ${m.state}${m.model ? ` (${m.model})` : ''}${m.detail ? `: ${m.detail}` : ''}`);
+                this.emit('change');
+                return;
+            }
+            case 'token':
+            case 'tool_call':
+            case 'queued':
+            case 'done':
+            case 'error': {
+                if (m.id === undefined)
+                    return m.t === 'error' && this.log(`the tab reported: ${m.message}`);
+                // Frames of a chat that was aborted or never sent have no one to go to.
+                const p = this.pending.get(m.id);
+                if (p)
+                    route(p, m, m.id);
+            }
+        }
+    }
+}
+function route(p, m, id) {
+    switch (m.t) {
+        case 'token':
+            p.text += m.text;
+            return p.onEvent?.({ t: 'token', text: m.text });
+        case 'tool_call':
+            p.calls.push(...m.calls);
+            return p.onEvent?.({ t: 'tool_call', calls: m.calls });
+        case 'queued':
+            return p.onEvent?.({ t: 'queued', position: m.position });
+        case 'done':
+            return p.finish({ id, text: p.text, calls: p.calls, stop: m.stop, usage: m.usage });
+        case 'error':
+            return p.fail(new ChatError(m.message, 'tab'));
+    }
+}
+function send(ws, m) {
+    if (ws.readyState === ws.OPEN)
+        ws.send(encode(m));
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "rebellm-bridge",
+  "version": "0.1.0",
+  "description": "Use the model in your RebeLLM browser tab from the command line, OpenAI/Anthropic clients and Claude Code",
+  "keywords": [
+    "rebellm",
+    "llm",
+    "bridge",
+    "mcp",
+    "claude-code",
+    "openai-compatible",
+    "anthropic-compatible",
+    "webgpu"
+  ],
+  "author": "Byteleap Oy",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://rebellm.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Byteleap-Oy/RebeLLM-Bridge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Byteleap-Oy/RebeLLM-Bridge/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "rebellm-bridge": "dist/cli.js",
+    "rebellm-claude": "dist/launcher.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepare": "git config core.hooksPath .githooks",
+    "prepublishOnly": "npm run check && npm run build",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "check": "npm run typecheck && npm run lint && npm run format:check && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "cross-spawn": "^7.0.6",
+    "ws": "^8.21.3",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.128.0",
+    "@eslint/js": "^10.0.1",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^24.0.0",
+    "@types/ws": "^8.18.1",
+    "eslint": "^10.11.0",
+    "globals": "^17.12.0",
+    "prettier": "^3.9.9",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.70.1",
+    "vitest": "^4.0.0"
+  }
+}