@bridge4dev/runner 0.11.0

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNNER_VERSION = "0.11.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,3 @@
+// Kept in sync with package.json by the release script (manual for now).
+export const RUNNER_VERSION = '0.11.0';
+//# sourceMappingURL=version.js.map

package/dist/ws-client.d.ts

@@ -0,0 +1,30 @@
+import { type GatewayFrame, type RunnerFrame } from './protocol.js';
+export interface WsClientEvents {
+    frame: (frame: GatewayFrame) => void;
+    open: () => void;
+    close: () => void;
+    revoked: (reason: string) => void;
+}
+export declare class RunnerWsClient {
+    private readonly wsUrl;
+    private readonly token;
+    private readonly capabilities;
+    private readonly emitter;
+    private socket;
+    private attempts;
+    private authFailures;
+    private stopped;
+    private reconnectTimer;
+    private livenessTimer;
+    private lastInboundAt;
+    constructor(wsUrl: string, token: string, capabilities?: Record<string, unknown>);
+    on<E extends keyof WsClientEvents>(event: E, listener: WsClientEvents[E]): this;
+    private emit;
+    start(): void;
+    stop(): void;
+    private ensureLivenessWatchdog;
+    get connected(): boolean;
+    send(frame: RunnerFrame): boolean;
+    private connect;
+}
+//# sourceMappingURL=ws-client.d.ts.map

package/dist/ws-client.js

@@ -0,0 +1,171 @@
+import { EventEmitter } from 'node:events';
+import os from 'node:os';
+import WebSocket from 'ws';
+import { log } from './log.js';
+import { GatewayFrameSchema } from './protocol.js';
+import { RUNNER_VERSION } from './version.js';
+// Outbound WSS to the DevBridge API — the only channel between this server
+// and DevBridge (plan §3). Reconnects with capped exponential backoff.
+const BACKOFF_BASE_MS = 1_000;
+const BACKOFF_MAX_MS = 60_000;
+const REPLACED_COOLDOWN_MS = 60_000;
+// The gateway pings every 30s; no inbound traffic for 90s means the path is
+// half-dead even though the socket looks OPEN (QA-96 F16).
+const LIVENESS_TIMEOUT_MS = 90_000;
+const LIVENESS_CHECK_MS = 30_000;
+// Repeated HTTP 401/403 on the upgrade = bad token; slow way down.
+const AUTH_FAILURE_THRESHOLD = 5;
+const AUTH_FAILURE_COOLDOWN_MS = 10 * 60_000;
+export class RunnerWsClient {
+    wsUrl;
+    token;
+    capabilities;
+    emitter = new EventEmitter();
+    socket = null;
+    attempts = 0;
+    authFailures = 0;
+    stopped = false;
+    reconnectTimer = null;
+    livenessTimer = null;
+    lastInboundAt = 0;
+    constructor(wsUrl, token, capabilities = { agents: ['claude'], git: true }) {
+        this.wsUrl = wsUrl;
+        this.token = token;
+        this.capabilities = capabilities;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    emit(event, ...args) {
+        this.emitter.emit(event, ...args);
+    }
+    start() {
+        this.stopped = false;
+        this.connect();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        if (this.livenessTimer)
+            clearInterval(this.livenessTimer);
+        this.livenessTimer = null;
+        this.socket?.close(1000, 'runner shutting down');
+        this.socket = null;
+    }
+    ensureLivenessWatchdog() {
+        if (this.livenessTimer)
+            return;
+        this.livenessTimer = setInterval(() => {
+            if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+                return;
+            if (Date.now() - this.lastInboundAt > LIVENESS_TIMEOUT_MS) {
+                log.warn('ws: no inbound traffic, terminating half-dead connection');
+                this.socket.terminate(); // close handler schedules the reconnect
+            }
+        }, LIVENESS_CHECK_MS);
+        this.livenessTimer.unref();
+    }
+    get connected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    send(frame) {
+        if (!this.connected || !this.socket)
+            return false;
+        try {
+            this.socket.send(JSON.stringify(frame));
+            return true;
+        }
+        catch (error) {
+            log.warn('ws: send failed', { error: String(error) });
+            return false;
+        }
+    }
+    connect() {
+        if (this.stopped)
+            return;
+        log.info('ws: connecting', { url: this.wsUrl, attempt: this.attempts + 1 });
+        const socket = new WebSocket(this.wsUrl, {
+            headers: { Authorization: `Bearer ${this.token}` },
+            handshakeTimeout: 15_000,
+        });
+        this.socket = socket;
+        socket.on('open', () => {
+            this.attempts = 0;
+            this.authFailures = 0;
+            this.lastInboundAt = Date.now();
+            this.ensureLivenessWatchdog();
+            this.send({
+                type: 'hello',
+                runnerVersion: RUNNER_VERSION,
+                osInfo: `${os.type()} ${os.release()} ${os.arch()}`.slice(0, 200),
+                capabilities: this.capabilities,
+            });
+            this.emit('open');
+        });
+        socket.on('ping', () => {
+            this.lastInboundAt = Date.now();
+        });
+        socket.on('message', (data) => {
+            this.lastInboundAt = Date.now();
+            let parsed;
+            try {
+                parsed = JSON.parse(String(data));
+            }
+            catch {
+                log.warn('ws: non-JSON frame from server');
+                return;
+            }
+            const frame = GatewayFrameSchema.safeParse(parsed);
+            if (!frame.success) {
+                log.warn('ws: unrecognized frame', { issue: frame.error.issues[0]?.message });
+                return;
+            }
+            if (frame.data.type === 'revoked') {
+                log.error(`ws: server access revoked — ${frame.data.reason}`);
+                this.stopped = true;
+                this.emit('revoked', frame.data.reason);
+                return;
+            }
+            this.emit('frame', frame.data);
+        });
+        socket.on('close', (code, reason) => {
+            if (this.socket === socket)
+                this.socket = null;
+            this.emit('close');
+            if (this.stopped)
+                return;
+            if (code === 4003) {
+                log.error('ws: connection refused as revoked — stopping reconnects');
+                this.stopped = true;
+                this.emit('revoked', reason.toString() || 'revoked');
+                return;
+            }
+            // 4001 = another connection replaced us (a second runner instance?) —
+            // back off hard instead of fighting for the slot. Repeated auth
+            // rejections during the upgrade get a long cooldown (QA-96 F16).
+            const delay = code === 4001
+                ? REPLACED_COOLDOWN_MS
+                : this.authFailures >= AUTH_FAILURE_THRESHOLD
+                    ? AUTH_FAILURE_COOLDOWN_MS
+                    : Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** this.attempts) +
+                        Math.floor(Math.random() * 1_000);
+            this.attempts += 1;
+            log.info('ws: disconnected, will reconnect', { code, delayMs: delay });
+            this.reconnectTimer = setTimeout(() => this.connect(), delay);
+        });
+        socket.on('unexpected-response', (_req, res) => {
+            log.error(`ws: handshake rejected with HTTP ${res.statusCode ?? '?'}`);
+            if (res.statusCode === 401 || res.statusCode === 403) {
+                this.authFailures += 1;
+                log.error('ws: runner token rejected — re-pair or set a rotated token');
+            }
+            socket.terminate();
+        });
+        socket.on('error', (error) => {
+            log.warn('ws: socket error', { error: String(error) });
+        });
+    }
+}
+//# sourceMappingURL=ws-client.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@bridge4dev/runner",
+  "version": "0.11.0",
+  "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
+  "homepage": "https://bridge4.dev",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "devbridge-runner": "./dist/index.js"
+  },
+  "keywords": [
+    "devbridge",
+    "agent",
+    "claude-code",
+    "codex",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts daemon",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "test": "vitest run",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.218",
+    "smol-toml": "^1.7.0",
+    "ws": "^8.21.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.19.2",
+    "typescript": "~5.7.2",
+    "vitest": "^2.1.9"
+  }
+}