rebellm-bridge 0.1.0

package/dist/anthropic/routes.js

@@ -0,0 +1,140 @@
+import { HttpError, clientGone, pathOf, readJson, sendJson } from '../http.js';
+import { ChatError } from '../tab.js';
+import { content, estimateTokens, message, newId, stopReason, tabError, tabUsage, toChatInput, tooLong, toolUse, usage, } from './map.js';
+import { EventWriter } from './sse.js';
+import { StopMatcher } from './stop.js';
+/** The Messages API sends a ping about this often; clients expect something within a minute. */
+export const PING_MS = 10_000;
+/** Anthropic's error shape, the only one its SDKs (and Claude Code) read. */
+export function sendApiError(res, status, type, message) {
+    sendJson(res, status, { type: 'error', error: { type, message } });
+}
+export const isMessagesPath = (path) => path === '/v1/messages' || path.startsWith('/v1/messages/');
+/**
+ * Runs one chat on the tab, passing text through the stop sequences. A match aborts the chat;
+ * its usage is then the bridge's own count, since the tab's `done` is not awaited.
+ */
+async function answer(tab, input, stops, estimate, signal, sink) {
+    const matcher = new StopMatcher(stops);
+    const halt = new AbortController();
+    let frames = 0;
+    try {
+        const r = await tab.chat(input, {
+            signal: AbortSignal.any([signal, halt.signal]),
+            onEvent: (e) => {
+                if (e.t === 'token') {
+                    frames++;
+                    sink.text(matcher.push(e.text));
+                    if (matcher.matched !== null)
+                        halt.abort();
+                }
+                else if (e.t === 'tool_call')
+                    for (const c of e.calls)
+                        sink.toolUse(toolUse(c));
+            },
+        });
+        sink.text(matcher.flush());
+        return { reason: stopReason(r.stop, r.calls.length), sequence: null, usage: tabUsage(r.usage) };
+    }
+    catch (e) {
+        if (matcher.matched === null || signal.aborted)
+            throw e;
+        return { reason: 'stop_sequence', sequence: matcher.matched, usage: usage(estimate, frames) };
+    }
+}
+/** `POST /v1/messages` and `POST /v1/messages/count_tokens` for Anthropic clients such as Claude Code. */
+export function messagesRoutes(tab, o) {
+    async function body(req, res) {
+        try {
+            return await readJson(req);
+        }
+        catch (e) {
+            const status = e instanceof HttpError ? e.status : 400;
+            sendApiError(res, status, status === 413 ? 'request_too_large' : 'invalid_request_error', e.message);
+            return undefined;
+        }
+    }
+    async function messages(req, res) {
+        const raw = await body(req, res);
+        if (raw === undefined)
+            return;
+        const parsed = toChatInput(raw);
+        if ('error' in parsed)
+            return sendApiError(res, 400, 'invalid_request_error', parsed.error);
+        const gone = clientGone(res);
+        const missing = await tab.waitReady(o.waitMs, gone);
+        if (gone.aborted)
+            return;
+        if (missing)
+            return sendApiError(res, 503, 'api_error', missing.message);
+        const estimate = estimateTokens(parsed.input);
+        const context = tab.health().contextTokens;
+        if (context && estimate >= context)
+            return sendApiError(res, 400, 'invalid_request_error', tooLong(estimate, context - 1));
+        const meta = { id: `msg_${newId()}`, model: tab.modelName };
+        const { input, stopSequences } = parsed;
+        if (parsed.stream) {
+            res.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-cache' });
+            res.socket?.setNoDelay(true);
+            const w = new EventWriter(res);
+            w.start(message(meta, [], { reason: null, sequence: null }, usage(estimate, 0)));
+            const beat = setInterval(() => w.ping(), o.pingMs ?? PING_MS);
+            try {
+                const out = await answer(tab, input, stopSequences, estimate, gone, {
+                    text: (t) => w.text(t),
+                    toolUse: (b) => w.toolUse(b),
+                });
+                w.finish(out.reason, out.sequence, out.usage);
+            }
+            catch (e) {
+                if (!gone.aborted)
+                    w.error(tabError(e.message));
+            }
+            finally {
+                clearInterval(beat);
+            }
+            return;
+        }
+        let text = '';
+        const calls = [];
+        try {
+            const out = await answer(tab, input, stopSequences, estimate, gone, {
+                text: (t) => (text += t),
+                toolUse: (b) => calls.push(b),
+            });
+            sendJson(res, 200, message(meta, content(text, calls), { reason: out.reason, sequence: out.sequence }, out.usage));
+        }
+        catch (e) {
+            if (gone.aborted)
+                return;
+            const err = e;
+            if (err instanceof ChatError && err.kind === 'no_tab')
+                return sendApiError(res, 503, 'api_error', err.message);
+            const api = tabError(err.message);
+            sendApiError(res, api.type === 'invalid_request_error' ? 400 : 502, api.type, api.message);
+        }
+    }
+    async function countTokens(req, res) {
+        const raw = await body(req, res);
+        if (raw === undefined)
+            return;
+        const parsed = toChatInput(raw);
+        if ('error' in parsed)
+            return sendApiError(res, 400, 'invalid_request_error', parsed.error);
+        sendJson(res, 200, { input_tokens: estimateTokens(parsed.input) });
+    }
+    return function route(req, res) {
+        const path = pathOf(req);
+        const handler = path === '/v1/messages' ? messages : path === '/v1/messages/count_tokens' ? countTokens : undefined;
+        if (!handler)
+            return sendApiError(res, 404, 'not_found_error', `no route for ${req.method} ${path}`);
+        if (req.method !== 'POST')
+            return sendApiError(res, 405, 'invalid_request_error', 'use POST');
+        void handler(req, res).catch((e) => {
+            if (!res.headersSent)
+                sendApiError(res, 500, 'api_error', e.message);
+            else
+                res.end();
+        });
+    };
+}

package/dist/anthropic/sse.d.ts

@@ -0,0 +1,24 @@
+import type { ServerResponse } from 'node:http';
+import type { ApiError, Message, StopReason, ToolUseBlock, Usage } from './types.js';
+/**
+ * Writes one streamed message as the Messages API does: `message_start`, the content blocks
+ * (a text block opened by the first text, one block per tool call), `message_delta`,
+ * `message_stop`.
+ */
+export declare class EventWriter {
+    private readonly res;
+    private blocks;
+    private textOpen;
+    constructor(res: ServerResponse);
+    private send;
+    start(message: Message): void;
+    text(text: string): void;
+    toolUse(block: ToolUseBlock): void;
+    /** Ends the message; an answer with no content still gets one empty text block. */
+    finish(reason: StopReason, sequence: string | null, usage: Usage): void;
+    /** Keeps clients' read timeouts from cutting a slow first token. */
+    ping(): void;
+    /** Ends the stream with an error; Anthropic's SDKs raise it as an API error. */
+    error(error: ApiError): void;
+    private closeText;
+}

package/dist/anthropic/sse.js

@@ -0,0 +1,66 @@
+/**
+ * Writes one streamed message as the Messages API does: `message_start`, the content blocks
+ * (a text block opened by the first text, one block per tool call), `message_delta`,
+ * `message_stop`.
+ */
+export class EventWriter {
+    res;
+    blocks = 0;
+    textOpen = false;
+    constructor(res) {
+        this.res = res;
+    }
+    send(e) {
+        this.res.write(`event: ${e.type}\ndata: ${JSON.stringify(e)}\n\n`);
+    }
+    start(message) {
+        this.send({ type: 'message_start', message });
+    }
+    text(text) {
+        if (!text)
+            return;
+        if (!this.textOpen) {
+            this.send({ type: 'content_block_start', index: this.blocks, content_block: { type: 'text', text: '' } });
+            this.textOpen = true;
+        }
+        this.send({ type: 'content_block_delta', index: this.blocks, delta: { type: 'text_delta', text } });
+    }
+    toolUse(block) {
+        this.closeText();
+        const index = this.blocks++;
+        this.send({ type: 'content_block_start', index, content_block: { ...block, input: {} } });
+        const partial_json = JSON.stringify(block.input);
+        this.send({ type: 'content_block_delta', index, delta: { type: 'input_json_delta', partial_json } });
+        this.send({ type: 'content_block_stop', index });
+    }
+    /** Ends the message; an answer with no content still gets one empty text block. */
+    finish(reason, sequence, usage) {
+        if (!this.blocks && !this.textOpen) {
+            this.send({ type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } });
+            this.textOpen = true;
+        }
+        this.closeText();
+        this.send({
+            type: 'message_delta',
+            delta: { stop_reason: reason, stop_sequence: sequence },
+            usage: { input_tokens: usage.input_tokens, output_tokens: usage.output_tokens },
+        });
+        this.send({ type: 'message_stop' });
+        this.res.end();
+    }
+    /** Keeps clients' read timeouts from cutting a slow first token. */
+    ping() {
+        this.send({ type: 'ping' });
+    }
+    /** Ends the stream with an error; Anthropic's SDKs raise it as an API error. */
+    error(error) {
+        this.send({ type: 'error', error });
+        this.res.end();
+    }
+    closeText() {
+        if (!this.textOpen)
+            return;
+        this.send({ type: 'content_block_stop', index: this.blocks++ });
+        this.textOpen = false;
+    }
+}

package/dist/anthropic/stop.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ends an answer at the first stop sequence. Text arrives in pieces that may split a
+ * sequence, so the end of the text is held back while it could still become one.
+ */
+export declare class StopMatcher {
+    private readonly stops;
+    private held;
+    /** The sequence that ended the answer, once one has. */
+    matched: string | null;
+    constructor(stops: string[]);
+    /** The text safe to pass on now; after a match, only what came before it. */
+    push(text: string): string;
+    /** What is still held back when the answer ends without a match. */
+    flush(): string;
+    /** Length of the longest end of `buf` that begins some stop sequence. */
+    private partial;
+}

package/dist/anthropic/stop.js

@@ -0,0 +1,51 @@
+/**
+ * Ends an answer at the first stop sequence. Text arrives in pieces that may split a
+ * sequence, so the end of the text is held back while it could still become one.
+ */
+export class StopMatcher {
+    stops;
+    held = '';
+    /** The sequence that ended the answer, once one has. */
+    matched = null;
+    constructor(stops) {
+        this.stops = stops.filter((s) => s.length > 0);
+    }
+    /** The text safe to pass on now; after a match, only what came before it. */
+    push(text) {
+        if (this.matched !== null)
+            return '';
+        const buf = this.held + text;
+        let at = -1;
+        for (const s of this.stops) {
+            const i = buf.indexOf(s);
+            if (i >= 0 && (at < 0 || i < at)) {
+                at = i;
+                this.matched = s;
+            }
+        }
+        if (this.matched !== null) {
+            this.held = '';
+            return buf.slice(0, at);
+        }
+        const keep = this.partial(buf);
+        this.held = buf.slice(buf.length - keep);
+        return buf.slice(0, buf.length - keep);
+    }
+    /** What is still held back when the answer ends without a match. */
+    flush() {
+        const rest = this.held;
+        this.held = '';
+        return rest;
+    }
+    /** Length of the longest end of `buf` that begins some stop sequence. */
+    partial(buf) {
+        let best = 0;
+        for (const s of this.stops)
+            for (let n = Math.min(s.length - 1, buf.length); n > best; n--)
+                if (buf.endsWith(s.slice(0, n))) {
+                    best = n;
+                    break;
+                }
+        return best;
+    }
+}

package/dist/anthropic/types.d.ts

@@ -0,0 +1,112 @@
+/**
+ * The parts of the Anthropic Messages API the bridge reads and writes. Requests arrive as
+ * unknown JSON and are checked in `map.ts`; these are the shapes it accepts and answers with.
+ */
+export interface TextBlock {
+    type: 'text';
+    text: string;
+}
+export interface ToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export type ContentBlock = TextBlock | ToolUseBlock;
+/** Request content blocks the mapping looks into; any other type is degraded or dropped. */
+export interface ToolResultBlockParam {
+    type: 'tool_result';
+    tool_use_id: string;
+    content?: string | {
+        type: string;
+        text?: string;
+    }[];
+    is_error?: boolean;
+}
+export interface MessageParam {
+    role: 'user' | 'assistant' | 'system';
+    content: string | ({
+        type: string;
+    } & Record<string, unknown>)[];
+}
+export interface ToolParam {
+    type?: 'custom';
+    name: string;
+    description?: string;
+    input_schema?: Record<string, unknown>;
+}
+export interface MessagesRequest {
+    model?: string;
+    system?: string | TextBlock[];
+    messages: MessageParam[];
+    tools?: ToolParam[];
+    tool_choice?: {
+        type: 'auto' | 'any' | 'tool' | 'none';
+    };
+    max_tokens?: number;
+    temperature?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+}
+export type StopReason = 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+export interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+}
+export interface Message {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    model: string;
+    content: ContentBlock[];
+    stop_reason: StopReason | null;
+    stop_sequence: string | null;
+    usage: Usage;
+}
+/** Server-sent events of a streamed message, in the order the API sends them. */
+export type StreamEvent = {
+    type: 'message_start';
+    message: Message;
+} | {
+    type: 'content_block_start';
+    index: number;
+    content_block: ContentBlock;
+} | {
+    type: 'content_block_delta';
+    index: number;
+    delta: {
+        type: 'text_delta';
+        text: string;
+    } | {
+        type: 'input_json_delta';
+        partial_json: string;
+    };
+} | {
+    type: 'content_block_stop';
+    index: number;
+} | {
+    type: 'message_delta';
+    delta: {
+        stop_reason: StopReason;
+        stop_sequence: string | null;
+    };
+    usage: Omit<Usage, 'cache_creation_input_tokens' | 'cache_read_input_tokens'>;
+} | {
+    type: 'message_stop';
+} | {
+    type: 'ping';
+} | {
+    type: 'error';
+    error: ApiError;
+};
+export type ErrorType = 'invalid_request_error' | 'permission_error' | 'not_found_error' | 'request_too_large' | 'api_error';
+export interface ApiError {
+    type: ErrorType;
+    message: string;
+}
+export interface ErrorBody {
+    type: 'error';
+    error: ApiError;
+}

package/dist/anthropic/types.js

@@ -0,0 +1,5 @@
+/**
+ * The parts of the Anthropic Messages API the bridge reads and writes. Requests arrive as
+ * unknown JSON and are checked in `map.ts`; these are the shapes it accepts and answers with.
+ */
+export {};

package/dist/cli.d.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import type { Readable, Writable } from 'node:stream';
+import { type ChatBackend } from './mcp.js';
+import { type BridgeServer } from './server.js';
+import type { Health } from './tab.js';
+export declare const VERSION: string;
+export declare const TOKEN_ENV = "REBELLM_BRIDGE_TOKEN";
+export declare const USAGE = "Usage: rebellm-bridge [options]\n\nLets Claude Code (MCP or rebellm-claude) and OpenAI-style clients use the model in your RebeLLM tab.\n\n  --port <n>      port for the tab and the HTTP API (default 7343)\n  --host <addr>   address to listen on (default 127.0.0.1; anything else exposes the model)\n  --token <t>     token the tab must present (default: REBELLM_BRIDGE_TOKEN, else ~/.rebellm-bridge/token)\n  --wait <s>      seconds a request waits for the tab and its model (default 120)\n  --mcp           serve MCP over stdio as well (Claude Code starts the bridge this way)\n  --version       print the version\n  --help          print this help";
+export interface CliOptions {
+    port: number;
+    host: string;
+    token?: string;
+    waitSec: number;
+    mcp: boolean;
+    help: boolean;
+    version: boolean;
+}
+export declare function parseCli(argv: string[]): CliOptions | {
+    error: string;
+};
+export declare const tokenFile: (home?: string) => string;
+export interface TokenChoice {
+    token: string;
+    source: 'flag' | 'env' | 'file';
+    /** Generated by this start; the only time it is printed. */
+    created: boolean;
+    file: string;
+}
+/** `--token`, else the environment, else the token file, created on first use. */
+export declare function resolveToken(o: {
+    flag?: string;
+    env?: string;
+    home?: string;
+}): TokenChoice;
+export interface Io {
+    stdout: Writable;
+    stderr: Writable;
+    stdin: Readable;
+    env: NodeJS.ProcessEnv;
+    home?: string;
+}
+export interface Running {
+    /** Null when `--mcp` found another bridge on the port and uses that one. */
+    server: BridgeServer | null;
+    backend: ChatBackend | null;
+    /** Resolves when the MCP client closes stdin; never without `--mcp`. */
+    done: Promise<void>;
+    close(): Promise<void>;
+}
+/** The `/health` of a bridge of ours at `base`; null when nothing or something else answers. */
+export declare function bridgeHealth(base: string): Promise<Health | null>;
+/** Anything but loopback lets other machines use the model; the HTTP API has no token. */
+export declare const hostWarning: (host: string) => string | null;
+/** Starts the bridge; throws a readable message when it cannot. */
+export declare function run(o: CliOptions, io: Io): Promise<Running>;
+/** The command line; resolves with the exit code once the bridge has stopped. */
+export declare function main(argv: string[], io: Io): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { randomBytes } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { createMcpServer, httpBackend, serveStdio, tabBackend } from './mcp.js';
+import { DEFAULT_HOST, DEFAULT_PORT, isLoopback, startServer } from './server.js';
+export const VERSION = createRequire(import.meta.url)('../package.json').version;
+export const TOKEN_ENV = 'REBELLM_BRIDGE_TOKEN';
+export const USAGE = `Usage: rebellm-bridge [options]
+
+Lets Claude Code (MCP or rebellm-claude) and OpenAI-style clients use the model in your RebeLLM tab.
+
+  --port <n>      port for the tab and the HTTP API (default ${DEFAULT_PORT})
+  --host <addr>   address to listen on (default ${DEFAULT_HOST}; anything else exposes the model)
+  --token <t>     token the tab must present (default: ${TOKEN_ENV}, else ~/.rebellm-bridge/token)
+  --wait <s>      seconds a request waits for the tab and its model (default 120)
+  --mcp           serve MCP over stdio as well (Claude Code starts the bridge this way)
+  --version       print the version
+  --help          print this help`;
+export function parseCli(argv) {
+    let v;
+    try {
+        v = parseArgs({
+            args: argv,
+            strict: true,
+            options: {
+                port: { type: 'string' },
+                host: { type: 'string' },
+                token: { type: 'string' },
+                wait: { type: 'string' },
+                mcp: { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+                version: { type: 'boolean', short: 'v' },
+            },
+        }).values;
+    }
+    catch (e) {
+        return { error: e.message };
+    }
+    const port = Number(v.port ?? DEFAULT_PORT);
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        return { error: `--port ${v.port} is not a port number` };
+    const waitSec = Number(v.wait ?? 120);
+    if (!Number.isFinite(waitSec) || waitSec < 0)
+        return { error: `--wait ${v.wait} is not a number of seconds` };
+    const host = v.host ?? DEFAULT_HOST;
+    if (!host)
+        return { error: '--host needs an address' };
+    if (v.token !== undefined && !v.token.trim())
+        return { error: '--token needs a value' };
+    return {
+        port,
+        host,
+        ...(v.token !== undefined ? { token: v.token.trim() } : {}),
+        waitSec,
+        mcp: !!v.mcp,
+        help: !!v.help,
+        version: !!v.version,
+    };
+}
+export const tokenFile = (home = homedir()) => join(home, '.rebellm-bridge', 'token');
+/** `--token`, else the environment, else the token file, created on first use. */
+export function resolveToken(o) {
+    const file = tokenFile(o.home);
+    if (o.flag)
+        return { token: o.flag, source: 'flag', created: false, file };
+    if (o.env?.trim())
+        return { token: o.env.trim(), source: 'env', created: false, file };
+    try {
+        const stored = readFileSync(file, 'utf8').trim();
+        if (stored)
+            return { token: stored, source: 'file', created: false, file };
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    const token = randomBytes(24).toString('base64url');
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    writeFileSync(file, `${token}\n`, { mode: 0o600 });
+    // An empty file left from before keeps its old mode otherwise.
+    chmodSync(file, 0o600);
+    return { token, source: 'file', created: true, file };
+}
+/** The `/health` of a bridge of ours at `base`; null when nothing or something else answers. */
+export async function bridgeHealth(base) {
+    try {
+        const r = await fetch(`${base}/health`, { signal: AbortSignal.timeout(2000) });
+        const body = (await r.json());
+        return body.service === 'rebellm-bridge' ? body : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Anything but loopback lets other machines use the model; the HTTP API has no token. */
+export const hostWarning = (host) => isLoopback(host)
+    ? null
+    : `warning: listening on ${host} lets other machines use your model; the HTTP API has no token`;
+const urlHost = (host) => (host.includes(':') ? `[${host}]` : host);
+/** Starts the bridge; throws a readable message when it cannot. */
+export async function run(o, io) {
+    // With --mcp, stdout is the MCP channel.
+    const out = o.mcp ? io.stderr : io.stdout;
+    const say = (line) => void out.write(`${line}\n`);
+    const log = (line) => say(`rebellm-bridge: ${line}`);
+    const tok = resolveToken({
+        ...(o.token ? { flag: o.token } : {}),
+        ...(io.env[TOKEN_ENV] ? { env: io.env[TOKEN_ENV] } : {}),
+        ...(io.home ? { home: io.home } : {}),
+    });
+    if (tok.created)
+        say(`\nNew bridge token (stored in ${tok.file}):\n\n  ${tok.token}\n\n` +
+            'Paste it into RebeLLM → Settings → Local bridge and turn the switch on. It is printed only this once.\n');
+    const warning = hostWarning(o.host);
+    if (warning)
+        log(warning);
+    let server = null;
+    let backend = null;
+    try {
+        server = await startServer({ host: o.host, port: o.port, token: tok.token, waitMs: o.waitSec * 1000, log });
+        if (o.mcp)
+            backend = tabBackend(server.tab, o.waitSec * 1000);
+    }
+    catch (e) {
+        if (e.code !== 'EADDRINUSE')
+            throw e;
+        const probe = `http://${urlHost(isLoopback(o.host) ? o.host : DEFAULT_HOST)}:${o.port}`;
+        if (!o.mcp || !(await bridgeHealth(probe)))
+            throw new Error(`port ${o.port} on ${o.host} is in use${o.mcp ? '' : ' (another rebellm-bridge?)'}`, {
+                cause: e,
+            });
+        backend = httpBackend(probe);
+        log(`using the bridge already running on ${probe}`);
+    }
+    if (server) {
+        const where = `${urlHost(o.host)}:${server.port}`;
+        log(`${VERSION} listening on ${where}`);
+        say(`  tab:    ws://${where}  (RebeLLM → Settings → Local bridge)`);
+        say(`  OpenAI: http://${where}/v1`);
+        say(`  Claude: http://${where}  (Anthropic API; rebellm-claude runs Claude Code on it)`);
+        say(`  token:  ${tok.source === 'flag' ? 'from --token' : tok.source === 'env' ? `from ${TOKEN_ENV}` : `in ${tok.file}`}`);
+        log('waiting for the RebeLLM tab');
+    }
+    let done = new Promise(() => undefined);
+    if (o.mcp && backend) {
+        done = serveStdio(createMcpServer(backend, VERSION), io.stdin, io.stdout);
+    }
+    return {
+        server,
+        backend,
+        done,
+        close: async () => {
+            await server?.close();
+        },
+    };
+}
+/** The command line; resolves with the exit code once the bridge has stopped. */
+export async function main(argv, io) {
+    const o = parseCli(argv);
+    if ('error' in o) {
+        io.stderr.write(`rebellm-bridge: ${o.error}\n\n${USAGE}\n`);
+        return 2;
+    }
+    if (o.help || o.version) {
+        io.stdout.write(`${o.help ? USAGE : VERSION}\n`);
+        return 0;
+    }
+    let running;
+    try {
+        running = await run(o, io);
+    }
+    catch (e) {
+        io.stderr.write(`rebellm-bridge: ${e.message}\n`);
+        return 1;
+    }
+    const stop = new Promise((resolve) => {
+        process.once('SIGINT', resolve);
+        process.once('SIGTERM', resolve);
+    });
+    await Promise.race([running.done, stop]);
+    await running.close();
+    return 0;
+}
+function invokedDirectly() {
+    try {
+        return !!process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    const io = { stdout: process.stdout, stderr: process.stderr, stdin: process.stdin, env: process.env };
+    void main(process.argv.slice(2), io).then((code) => process.exit(code));
+}