@exaudeus/workrail 3.32.0 → 3.34.0

package/dist/mcp/transports/bridge-entry.d.ts

@@ -1,102 +0,0 @@
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-export interface BridgeConfig {
-    readonly reconnectBaseDelayMs: number;
-    readonly reconnectMaxAttempts: number;
-    readonly forwardTimeoutMs: number;
-    readonly maxRespawnAttempts: number;
-    readonly spawnLockStaleMs: number;
-    readonly waitForPrimaryPollMs: number;
-}
-export declare const DEFAULT_BRIDGE_CONFIG: BridgeConfig;
-type HttpBridgeTransport = {
-    readonly send: (msg: JSONRPCMessage) => Promise<void>;
-    readonly close: () => Promise<void>;
-};
-export type ConnectionState = {
-    readonly kind: 'connecting';
-} | {
-    readonly kind: 'connected';
-    readonly transport: HttpBridgeTransport;
-} | {
-    readonly kind: 'reconnecting';
-    readonly attempt: number;
-    readonly maxAttempts: number;
-    readonly respawnBudget: number;
-} | {
-    readonly kind: 'waiting_for_primary';
-} | {
-    readonly kind: 'closed';
-};
-export type ReconnectOutcome = {
-    readonly kind: 'reconnected';
-} | {
-    readonly kind: 'exhausted';
-} | {
-    readonly kind: 'aborted';
-};
-export type SpawnLockResult = {
-    readonly kind: 'acquired';
-} | {
-    readonly kind: 'skipped';
-    readonly reason: string;
-};
-export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
-export type SpawnLike = (command: string, args: ReadonlyArray<string>, opts: {
-    readonly env: NodeJS.ProcessEnv;
-    readonly detached: boolean;
-    readonly stdio: 'ignore';
-}) => {
-    unref: () => void;
-};
-export type WriteFileSyncLike = (path: string, content: string, opts: {
-    flag: 'wx';
-}) => void;
-export type StatSyncLike = (path: string) => {
-    mtimeMs: number;
-};
-export type UnlinkSyncLike = (path: string) => void;
-export type HealthResponse = {
-    readonly port: number;
-    readonly pid: number;
-};
-export declare function detectHealthyPrimary(port: number, opts?: {
-    retries?: number;
-    baseDelayMs?: number;
-    fetch?: FetchLike;
-}): Promise<HealthResponse | null>;
-export declare function spawnLockPath(port: number): string;
-export declare function acquireSpawnLock(port: number, staleMs: number, deps?: {
-    readonly writeFileSync?: WriteFileSyncLike;
-    readonly statSync?: StatSyncLike;
-    readonly unlinkSync?: UnlinkSyncLike;
-}): SpawnLockResult;
-export declare function releaseSpawnLock(port: number, deps?: {
-    readonly unlinkSync?: UnlinkSyncLike;
-}): void;
-export declare function spawnPrimary(port: number, deps: {
-    spawn: SpawnLike;
-    fetch?: FetchLike;
-}): Promise<void>;
-type ReconnectDeps = {
-    readonly detect: (attempt: number) => Promise<boolean>;
-    readonly config: Pick<BridgeConfig, 'reconnectBaseDelayMs' | 'reconnectMaxAttempts'>;
-    readonly signal: AbortSignal;
-};
-export declare function reconnectWithBackoff(deps: ReconnectDeps): Promise<ReconnectOutcome>;
-type OutcomeHandlerDeps = {
-    readonly setConnectionState: (state: ConnectionState) => void;
-    readonly performShutdown: (reason: string) => void;
-    readonly startReconnectLoop: () => void;
-    readonly startWaitLoop: () => void;
-    readonly triggerSpawn: () => Promise<void>;
-    readonly config: Pick<BridgeConfig, 'reconnectMaxAttempts'>;
-};
-export declare function handleReconnectOutcome(outcome: ReconnectOutcome, reconnectingState: Extract<ConnectionState, {
-    kind: 'reconnecting';
-}>, deps: OutcomeHandlerDeps): Promise<void>;
-export declare function startBridgeServer(primaryPort: number, config?: BridgeConfig, deps?: {
-    spawn?: SpawnLike;
-    fetch?: FetchLike;
-    originalPrimaryPid?: number;
-}): Promise<void>;
-export {};

package/dist/mcp/transports/bridge-entry.js

@@ -1,454 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_BRIDGE_CONFIG = void 0;
-exports.detectHealthyPrimary = detectHealthyPrimary;
-exports.spawnLockPath = spawnLockPath;
-exports.acquireSpawnLock = acquireSpawnLock;
-exports.releaseSpawnLock = releaseSpawnLock;
-exports.spawnPrimary = spawnPrimary;
-exports.reconnectWithBackoff = reconnectWithBackoff;
-exports.handleReconnectOutcome = handleReconnectOutcome;
-exports.startBridgeServer = startBridgeServer;
-const fatal_exit_js_1 = require("./fatal-exit.js");
-const bridge_events_js_1 = require("./bridge-events.js");
-const primary_tombstone_js_1 = require("./primary-tombstone.js");
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-exports.DEFAULT_BRIDGE_CONFIG = {
-    reconnectBaseDelayMs: 250,
-    reconnectMaxAttempts: 8,
-    forwardTimeoutMs: 30000,
-    maxRespawnAttempts: 3,
-    spawnLockStaleMs: 30000,
-    waitForPrimaryPollMs: 5000,
-};
-async function detectHealthyPrimary(port, opts = {}) {
-    const retries = opts.retries ?? 3;
-    const baseDelayMs = opts.baseDelayMs ?? 200;
-    const fetchFn = opts.fetch ?? globalThis.fetch;
-    for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            const response = await fetchFn(`http://localhost:${port}/workrail-health`, {
-                method: 'GET',
-                signal: AbortSignal.timeout(500),
-            });
-            if (response.ok) {
-                const body = (await response.json().catch(() => null));
-                if (body?.service === 'workrail') {
-                    const pid = typeof body.pid === 'number' ? body.pid : 0;
-                    return { port, pid };
-                }
-            }
-        }
-        catch {
-        }
-        if (attempt < retries - 1) {
-            await sleep(baseDelayMs * (attempt + 1));
-        }
-    }
-    return null;
-}
-function spawnLockPath(port) {
-    return (0, path_1.join)((0, os_1.homedir)(), '.workrail', `spawn-coordinator-${port}.lock`);
-}
-function acquireSpawnLock(port, staleMs, deps = {}) {
-    const lockPath = spawnLockPath(port);
-    const writeFn = deps.writeFileSync ?? fs_1.writeFileSync;
-    const statFn = deps.statSync ?? require('fs').statSync;
-    const unlinkFn = deps.unlinkSync ?? require('fs').unlinkSync;
-    try {
-        (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.workrail'), { recursive: true });
-    }
-    catch {
-        return { kind: 'skipped', reason: 'mkdirSync failed' };
-    }
-    try {
-        writeFn(lockPath, String(process.pid), { flag: 'wx' });
-        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_acquired', port });
-        return { kind: 'acquired' };
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'EEXIST') {
-            try {
-                const stat = statFn(lockPath);
-                const ageMs = Date.now() - stat.mtimeMs;
-                if (ageMs > staleMs) {
-                    try {
-                        unlinkFn(lockPath);
-                    }
-                    catch {
-                    }
-                    try {
-                        writeFn(lockPath, String(process.pid), { flag: 'wx' });
-                        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_acquired', port });
-                        return { kind: 'acquired' };
-                    }
-                    catch {
-                        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_skipped', reason: 'lost race after stale reclaim' });
-                        return { kind: 'skipped', reason: 'lost race after stale reclaim' };
-                    }
-                }
-                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_skipped', reason: 'lock held by another bridge' });
-                return { kind: 'skipped', reason: 'lock held by another bridge' };
-            }
-            catch {
-                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_skipped', reason: 'lock contested' });
-                return { kind: 'skipped', reason: 'lock contested' };
-            }
-        }
-        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_lock_skipped', reason: `unexpected error: ${code ?? String(err)}` });
-        return { kind: 'skipped', reason: `unexpected error: ${code ?? String(err)}` };
-    }
-}
-function releaseSpawnLock(port, deps = {}) {
-    const unlinkFn = deps.unlinkSync ?? require('fs').unlinkSync;
-    try {
-        unlinkFn(spawnLockPath(port));
-    }
-    catch {
-    }
-}
-async function spawnPrimary(port, deps) {
-    await sleep(Math.random() * 2000);
-    const primaryDetected = await detectHealthyPrimary(port, { retries: 3, baseDelayMs: 500, fetch: deps.fetch });
-    if (primaryDetected != null) {
-        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_skipped', reason: 'primary already up after jitter' });
-        console.error('[Bridge] Primary already available after jitter — skipping spawn');
-        return;
-    }
-    const scriptPath = process.argv[1];
-    if (scriptPath == null) {
-        console.error('[Bridge] Cannot spawn primary: process.argv[1] is undefined');
-        return;
-    }
-    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'spawn_primary', port });
-    console.error('[Bridge] Spawning new WorkRail primary process');
-    try {
-        const child = deps.spawn(process.execPath, [scriptPath], {
-            env: {
-                ...process.env,
-                WORKRAIL_TRANSPORT: 'http',
-                WORKRAIL_HTTP_PORT: String(port),
-            },
-            detached: true,
-            stdio: 'ignore',
-        });
-        child.unref();
-    }
-    catch (err) {
-        console.error('[Bridge] Failed to spawn primary:', err);
-    }
-}
-async function reconnectWithBackoff(deps) {
-    const { detect, config, signal } = deps;
-    const { reconnectBaseDelayMs, reconnectMaxAttempts } = config;
-    for (let attempt = 0; attempt < reconnectMaxAttempts; attempt++) {
-        if (signal.aborted)
-            return { kind: 'aborted' };
-        const succeeded = await detect(attempt);
-        if (succeeded)
-            return { kind: 'reconnected' };
-        if (attempt < reconnectMaxAttempts - 1) {
-            const delay = reconnectBaseDelayMs * Math.pow(2, attempt);
-            await sleep(delay);
-            if (signal.aborted)
-                return { kind: 'aborted' };
-        }
-    }
-    return { kind: 'exhausted' };
-}
-async function handleReconnectOutcome(outcome, reconnectingState, deps) {
-    switch (outcome.kind) {
-        case 'reconnected':
-            (0, bridge_events_js_1.logBridgeEvent)({ kind: 'reconnected', attempt: reconnectingState.attempt });
-            console.error('[Bridge] Reconnected to primary');
-            return;
-        case 'aborted':
-            return;
-        case 'exhausted':
-            if (reconnectingState.respawnBudget > 0) {
-                await deps.triggerSpawn();
-                deps.setConnectionState({
-                    kind: 'reconnecting',
-                    attempt: 0,
-                    maxAttempts: deps.config.reconnectMaxAttempts,
-                    respawnBudget: reconnectingState.respawnBudget - 1,
-                });
-                deps.startReconnectLoop();
-            }
-            else {
-                (0, bridge_events_js_1.logBridgeEvent)({
-                    kind: 'budget_exhausted',
-                    budgetUsed: reconnectingState.maxAttempts,
-                    respawnBudget: reconnectingState.respawnBudget,
-                });
-                console.error('[Bridge] Spawn budget exhausted — entering slow-poll mode (5s interval)');
-                deps.setConnectionState({ kind: 'waiting_for_primary' });
-                deps.startWaitLoop();
-            }
-            return;
-    }
-}
-async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CONFIG, deps = {}) {
-    (0, fatal_exit_js_1.registerFatalHandlers)('bridge');
-    (0, fatal_exit_js_1.logStartup)('bridge', { primaryPort });
-    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'started', primaryPort, ppid: process.ppid });
-    const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
-    const { StreamableHTTPClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/streamableHttp.js')));
-    const { spawn: nodeSpawn } = await Promise.resolve().then(() => __importStar(require('child_process')));
-    const spawnFn = deps.spawn ?? ((command, args, opts) => nodeSpawn(command, args, opts));
-    const shutdownController = new AbortController();
-    const { signal: shutdownSignal } = shutdownController;
-    const stdioTransport = new StdioServerTransport();
-    let connectionState = { kind: 'connecting' };
-    const setConnectionState = (next) => {
-        connectionState = next;
-    };
-    const performShutdown = (reason) => {
-        if (shutdownSignal.aborted)
-            return;
-        shutdownController.abort();
-        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'shutdown', reason });
-        process.stderr.write(`[Bridge] Shutdown pid=${process.pid} reason="${reason}" ts=${new Date().toISOString()}\n`);
-        const state = connectionState;
-        void (state.kind === 'connected' ? state.transport.close() : Promise.resolve()).finally(() => process.exit(0));
-    };
-    const buildConnectedTransport = async () => {
-        const t = new StreamableHTTPClientTransport(new URL(`http://localhost:${primaryPort}/mcp`));
-        t.onerror = (err) => console.error('[Bridge] HTTP transport error:', err);
-        t.onmessage = (msg) => {
-            void stdioTransport.send(msg).catch((err) => {
-                console.error('[Bridge] Forward to IDE failed:', err);
-            });
-        };
-        t.onclose = () => {
-            if (shutdownSignal.aborted)
-                return;
-            const current = connectionState;
-            if (current.kind === 'connecting' ||
-                current.kind === 'reconnecting' ||
-                current.kind === 'waiting_for_primary')
-                return;
-            (0, bridge_events_js_1.logBridgeEvent)({ kind: 'disconnected' });
-            console.error('[Bridge] Primary connection lost — reconnecting');
-            const connectedPrimaryPid = deps.originalPrimaryPid ?? 0;
-            if (connectedPrimaryPid > 0) {
-                const tombstone = (0, primary_tombstone_js_1.readTombstone)();
-                if (tombstone?.pid === connectedPrimaryPid) {
-                    console.error('[Bridge] Tombstone detected — primary died cleanly, entering slow-poll mode');
-                    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'waiting_for_primary', port: primaryPort });
-                    setConnectionState({ kind: 'waiting_for_primary' });
-                    startWaitLoop();
-                    return;
-                }
-            }
-            setConnectionState({
-                kind: 'reconnecting',
-                attempt: 0,
-                maxAttempts: config.reconnectMaxAttempts,
-                respawnBudget: config.maxRespawnAttempts,
-            });
-            startReconnectLoop();
-        };
-        try {
-            await t.start();
-            const transport = { send: (msg) => t.send(msg), close: () => t.close() };
-            setConnectionState({ kind: 'connected', transport });
-            return transport;
-        }
-        catch {
-            return null;
-        }
-    };
-    const startReconnectLoop = () => {
-        const stateAtStart = connectionState;
-        if (stateAtStart.kind !== 'reconnecting')
-            return;
-        void reconnectWithBackoff({
-            signal: shutdownSignal,
-            config,
-            detect: async (attempt) => {
-                const connectedPrimaryPid = deps.originalPrimaryPid ?? 0;
-                if (connectedPrimaryPid > 0) {
-                    const tombstone = (0, primary_tombstone_js_1.readTombstone)();
-                    if (tombstone?.pid === connectedPrimaryPid) {
-                        console.error('[Bridge] Tombstone detected during reconnect — entering slow-poll mode');
-                        (0, bridge_events_js_1.logBridgeEvent)({ kind: 'waiting_for_primary', port: primaryPort });
-                        setConnectionState({ kind: 'waiting_for_primary' });
-                        startWaitLoop();
-                        return true;
-                    }
-                }
-                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'reconnect_attempt', attempt: attempt + 1, maxAttempts: config.reconnectMaxAttempts });
-                console.error(`[Bridge] Reconnect attempt ${attempt + 1}/${config.reconnectMaxAttempts}`);
-                const detected = await detectHealthyPrimary(primaryPort, { retries: 1, fetch: deps.fetch });
-                if (detected == null)
-                    return false;
-                const transport = await buildConnectedTransport();
-                return transport != null;
-            },
-        })
-            .then((outcome) => {
-            const stateAtOutcome = connectionState;
-            if (stateAtOutcome.kind !== 'reconnecting')
-                return;
-            return handleReconnectOutcome(outcome, stateAtOutcome, {
-                setConnectionState,
-                performShutdown,
-                startReconnectLoop,
-                startWaitLoop,
-                triggerSpawn: async () => {
-                    const lockResult = acquireSpawnLock(primaryPort, config.spawnLockStaleMs);
-                    if (lockResult.kind === 'skipped') {
-                        console.error(`[Bridge] Spawn skipped (coordinator lock): ${lockResult.reason}`);
-                        return;
-                    }
-                    try {
-                        await spawnPrimary(primaryPort, { spawn: spawnFn, fetch: deps.fetch });
-                    }
-                    finally {
-                        releaseSpawnLock(primaryPort);
-                    }
-                },
-                config,
-            });
-        })
-            .catch((err) => {
-            const errObj = err instanceof Error ? err : new Error(String(err));
-            (0, bridge_events_js_1.logBridgeEvent)({
-                kind: 'reconnect_loop_error',
-                message: errObj.message,
-                stack: errObj.stack ?? null,
-            });
-            console.error('[Bridge] Unexpected error in reconnect loop:', err);
-        });
-    };
-    const startWaitLoop = () => {
-        const stateAtStart = connectionState;
-        if (stateAtStart.kind !== 'waiting_for_primary')
-            return;
-        void (async () => {
-            (0, bridge_events_js_1.logBridgeEvent)({ kind: 'waiting_for_primary', port: primaryPort });
-            while (!shutdownSignal.aborted) {
-                await sleep(config.waitForPrimaryPollMs);
-                if (shutdownSignal.aborted)
-                    return;
-                const detected = await detectHealthyPrimary(primaryPort, { retries: 1, fetch: deps.fetch });
-                if (detected != null) {
-                    console.error('[Bridge] Primary found after waiting — resuming normal operation');
-                    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'primary_found_after_wait', port: primaryPort });
-                    setConnectionState({
-                        kind: 'reconnecting',
-                        attempt: 0,
-                        maxAttempts: config.reconnectMaxAttempts,
-                        respawnBudget: config.maxRespawnAttempts,
-                    });
-                    startReconnectLoop();
-                    return;
-                }
-            }
-        })().catch((err) => {
-            const errObj = err instanceof Error ? err : new Error(String(err));
-            (0, bridge_events_js_1.logBridgeEvent)({
-                kind: 'reconnect_loop_error',
-                message: `wait loop error: ${errObj.message}`,
-                stack: errObj.stack ?? null,
-            });
-            console.error('[Bridge] Unexpected error in wait loop:', err);
-        });
-    };
-    stdioTransport.onmessage = (msg) => {
-        const state = connectionState;
-        switch (state.kind) {
-            case 'connected': {
-                const timer = setTimeout(() => {
-                    console.error('[Bridge] Warning: no response from primary after', config.forwardTimeoutMs, 'ms');
-                }, config.forwardTimeoutMs);
-                void state.transport
-                    .send(msg)
-                    .catch((err) => console.error('[Bridge] Forward to primary failed:', err))
-                    .finally(() => clearTimeout(timer));
-                return;
-            }
-            case 'connecting':
-            case 'reconnecting':
-            case 'waiting_for_primary':
-                sendUnavailableError(msg, (m) => stdioTransport.send(m));
-                return;
-            case 'closed':
-                return;
-        }
-    };
-    stdioTransport.onerror = (err) => console.error('[Bridge] Stdio error:', err);
-    const initialTransport = await buildConnectedTransport();
-    if (initialTransport == null) {
-        throw new Error(`[Bridge] Failed to connect to primary on port ${primaryPort}`);
-    }
-    (0, bridge_events_js_1.logBridgeEvent)({ kind: 'connected', primaryPort });
-    console.error('[Bridge] Connected to primary');
-    process.stdout.on('error', (err) => {
-        const code = err.code;
-        const reason = code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED'
-            ? 'stdout pipe broken (client disconnected)'
-            : `stdout error: ${String(err)}`;
-        performShutdown(reason);
-    });
-    await stdioTransport.start();
-    console.error('[Bridge] WorkRail MCP bridge running on stdio');
-    process.stdin.once('end', () => performShutdown('stdin closed'));
-    process.once('SIGINT', () => performShutdown('SIGINT'));
-    process.once('SIGTERM', () => performShutdown('SIGTERM'));
-    process.once('SIGHUP', () => performShutdown('SIGHUP'));
-}
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-function sendUnavailableError(msg, send) {
-    if (!('id' in msg) || msg.id == null)
-        return;
-    void send({
-        jsonrpc: '2.0',
-        id: msg.id,
-        error: {
-            code: -32603,
-            message: 'WorkRail primary server is temporarily unavailable — reconnecting. ' +
-                'Wait a few seconds and retry your tool call. ' +
-                'If this persists, tell the user: ' +
-                '"WorkRail disconnected. Check the terminal running workrail for the ' +
-                'error message, then run /mcp in Claude to reconnect."',
-        },
-    }).catch(() => undefined);
-}

package/dist/mcp/transports/bridge-events.d.ts

@@ -1,51 +0,0 @@
-export type BridgeEvent = {
-    readonly kind: 'started';
-    readonly primaryPort: number;
-    readonly ppid: number;
-} | {
-    readonly kind: 'connected';
-    readonly primaryPort: number;
-} | {
-    readonly kind: 'disconnected';
-} | {
-    readonly kind: 'reconnect_attempt';
-    readonly attempt: number;
-    readonly maxAttempts: number;
-} | {
-    readonly kind: 'reconnected';
-    readonly attempt: number;
-} | {
-    readonly kind: 'spawn_primary';
-    readonly port: number;
-} | {
-    readonly kind: 'spawn_skipped';
-    readonly reason: string;
-} | {
-    readonly kind: 'spawn_lock_acquired';
-    readonly port: number;
-} | {
-    readonly kind: 'spawn_lock_skipped';
-    readonly reason: string;
-} | {
-    readonly kind: 'budget_exhausted';
-    readonly budgetUsed: number;
-    readonly respawnBudget: number;
-} | {
-    readonly kind: 'waiting_for_primary';
-    readonly port: number;
-} | {
-    readonly kind: 'primary_found_after_wait';
-    readonly port: number;
-} | {
-    readonly kind: 'reconnect_loop_error';
-    readonly message: string;
-    readonly stack: string | null;
-} | {
-    readonly kind: 'shutdown';
-    readonly reason: string;
-} | {
-    readonly kind: 'orphaned';
-    readonly expectedPid: number;
-    readonly actualPid: number;
-};
-export declare function logBridgeEvent(event: BridgeEvent): void;

package/dist/mcp/transports/bridge-events.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logBridgeEvent = logBridgeEvent;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const BRIDGE_LOG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.workrail', 'bridge.log');
-const BRIDGE_LOG_MAX_BYTES = 512 * 1024;
-function logBridgeEvent(event) {
-    try {
-        (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.workrail'), { recursive: true });
-        try {
-            const { statSync } = require('fs');
-            if (statSync(BRIDGE_LOG_PATH).size > BRIDGE_LOG_MAX_BYTES) {
-                const { writeFileSync } = require('fs');
-                writeFileSync(BRIDGE_LOG_PATH, '');
-            }
-        }
-        catch { }
-        const entry = { ts: new Date().toISOString(), pid: process.pid, ...event };
-        (0, fs_1.appendFileSync)(BRIDGE_LOG_PATH, JSON.stringify(entry) + '\n');
-    }
-    catch { }
-}

package/dist/mcp/transports/primary-tombstone.d.ts

@@ -1,21 +0,0 @@
-export interface PrimaryTombstone {
-    readonly pid: number;
-    readonly port: number;
-    readonly diedAt: string;
-}
-export type WriteSyncLike = (path: string, content: string) => void;
-export type ReadSyncLike = (path: string, encoding: 'utf-8') => string;
-export type UnlinkSyncLike = (path: string) => void;
-export type MkdirSyncLike = (path: string, opts: {
-    recursive: true;
-}) => void;
-export interface TombstoneDeps {
-    readonly writeSync?: WriteSyncLike;
-    readonly readSync?: ReadSyncLike;
-    readonly unlinkSync?: UnlinkSyncLike;
-    readonly mkdirSync?: MkdirSyncLike;
-}
-export declare function tombstonePath(): string;
-export declare function writeTombstone(port: number, pid: number, deps?: TombstoneDeps): void;
-export declare function readTombstone(deps?: TombstoneDeps): PrimaryTombstone | null;
-export declare function clearTombstone(deps?: TombstoneDeps): void;