@exaudeus/workrail 3.26.1 → 3.27.0

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

@@ -35,17 +35,26 @@ var __importStar = (this && this.__importStar) || (function () {
 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;
@@ -59,8 +68,10 @@ async function detectHealthyPrimary(port, opts = {}) {
             });
             if (response.ok) {
                 const body = (await response.json().catch(() => null));
-                if (body?.service === 'workrail')
-                    return port;
+                if (body?.service === 'workrail') {
+                    const pid = typeof body.pid === 'number' ? body.pid : 0;
+                    return { port, pid };
+                }
             }
         }
         catch {
@@ -71,10 +82,71 @@ async function detectHealthyPrimary(port, opts = {}) {
     }
     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() * 300);
-    const alreadyUp = await detectHealthyPrimary(port, { retries: 1, fetch: deps.fetch });
-    if (alreadyUp != null) {
+    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;
@@ -140,9 +212,14 @@ async function handleReconnectOutcome(outcome, reconnectingState, deps) {
                 deps.startReconnectLoop();
             }
             else {
-                (0, bridge_events_js_1.logBridgeEvent)({ kind: 'budget_exhausted', budgetUsed: reconnectingState.maxAttempts });
-                deps.setConnectionState({ kind: 'closed' });
-                deps.performShutdown('respawn budget exhausted — primary repeatedly unavailable');
+                (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;
     }
@@ -183,10 +260,23 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             if (shutdownSignal.aborted)
                 return;
             const current = connectionState;
-            if (current.kind === 'connecting' || current.kind === 'reconnecting')
+            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,
@@ -213,6 +303,17 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             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 });
@@ -230,7 +331,20 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
                 setConnectionState,
                 performShutdown,
                 startReconnectLoop,
-                triggerSpawn: () => spawnPrimary(primaryPort, { spawn: spawnFn, fetch: deps.fetch }),
+                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,
             });
         })
@@ -244,6 +358,40 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             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) {
@@ -259,6 +407,7 @@ async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CO
             }
             case 'connecting':
             case 'reconnecting':
+            case 'waiting_for_primary':
                 sendUnavailableError(msg, (m) => stdioTransport.send(m));
                 return;
             case 'closed':

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

@@ -20,9 +20,22 @@ export type BridgeEvent = {
 } | {
     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;
@@ -30,5 +43,9 @@ export type BridgeEvent = {
 } | {
     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/fatal-exit.d.ts

@@ -1,5 +1,6 @@
 export type TransportKind = 'stdio' | 'http' | 'bridge';
 export declare function formatFatal(reason: unknown): string;
+export declare function registerGracefulShutdown(fn: (() => Promise<void>) | null, timeoutMs?: number): void;
 export declare function fatalExit(label: string, reason: unknown): void;
 export declare function registerFatalHandlers(transport: TransportKind): void;
 export declare function logStartup(transport: TransportKind, extra?: Record<string, string | number>): void;

package/dist/mcp/transports/fatal-exit.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatFatal = formatFatal;
+exports.registerGracefulShutdown = registerGracefulShutdown;
 exports.fatalExit = fatalExit;
 exports.registerFatalHandlers = registerFatalHandlers;
 exports.logStartup = logStartup;
@@ -10,6 +11,8 @@ const path_1 = require("path");
 const fatalHandlerActive = { value: false };
 let registeredTransport = null;
 const startedAtMs = Date.now();
+let gracefulShutdownFn = null;
+let gracefulShutdownTimeoutMs = 3000;
 const CRASH_LOG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.workrail', 'crash.log');
 const CRASH_LOG_MAX_BYTES = 512 * 1024;
 function writeCrashLog(label, reason) {
@@ -46,6 +49,10 @@ function formatFatal(reason) {
     }
     return String(reason);
 }
+function registerGracefulShutdown(fn, timeoutMs = 3000) {
+    gracefulShutdownFn = fn;
+    gracefulShutdownTimeoutMs = timeoutMs;
+}
 function fatalExit(label, reason) {
     if (fatalHandlerActive.value)
         return;
@@ -56,7 +63,26 @@ function fatalExit(label, reason) {
     }
     catch {
     }
-    process.exit(1);
+    if (gracefulShutdownFn !== null) {
+        const fn = gracefulShutdownFn;
+        const timeout = gracefulShutdownTimeoutMs;
+        try {
+            process.stderr.write(`[FatalExit] Attempting graceful shutdown (${timeout}ms timeout)\n`);
+        }
+        catch {
+        }
+        const hardExit = setTimeout(() => process.exit(1), timeout);
+        void Promise.resolve()
+            .then(() => fn())
+            .catch(() => { })
+            .finally(() => {
+            clearTimeout(hardExit);
+            process.exit(1);
+        });
+    }
+    else {
+        process.exit(1);
+    }
 }
 function registerFatalHandlers(transport) {
     registeredTransport = transport;

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

@@ -41,15 +41,21 @@ const server_js_1 = require("../server.js");
 const http_listener_js_1 = require("./http-listener.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const fatal_exit_js_1 = require("./fatal-exit.js");
+const primary_tombstone_js_1 = require("./primary-tombstone.js");
 const crypto = __importStar(require("crypto"));
 const express_1 = __importDefault(require("express"));
 const HTTP_PORT_SCAN_END = 3199;
 async function startHttpServer(port) {
     (0, fatal_exit_js_1.registerFatalHandlers)('http');
     (0, fatal_exit_js_1.logStartup)('http', { port });
+    (0, primary_tombstone_js_1.clearTombstone)();
     const { server, ctx } = await (0, server_js_1.composeServer)();
     const scanEnd = Math.max(port, HTTP_PORT_SCAN_END);
     const listener = await (0, http_listener_js_1.bindWithPortFallback)(port, scanEnd);
+    (0, fatal_exit_js_1.registerGracefulShutdown)(async () => {
+        await listener.stop();
+        await ctx.httpServer?.stop();
+    });
     const { StreamableHTTPServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/streamableHttp.js')));
     const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => crypto.randomUUID(),
@@ -61,13 +67,16 @@ async function startHttpServer(port) {
     listener.app.delete('/mcp', (req, res) => transport.handleRequest(req, res));
     await server.connect(transport);
     listener.app.get('/workrail-health', (_req, res) => {
-        res.json({ service: 'workrail' });
+        res.json({ service: 'workrail', pid: process.pid });
     });
     const boundPort = listener.getBoundPort();
     console.error('[Transport] WorkRail MCP Server running on HTTP');
     console.error(`[Transport] MCP endpoint: http://localhost:${boundPort}/mcp`);
     (0, shutdown_hooks_js_1.wireShutdownHooks)({
         onBeforeTerminate: async () => {
+            if (boundPort != null) {
+                (0, primary_tombstone_js_1.writeTombstone)(boundPort, process.pid);
+            }
             await listener.stop();
             await ctx.httpServer?.stop();
         },

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

@@ -0,0 +1,21 @@
+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;

package/dist/mcp/transports/primary-tombstone.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tombstonePath = tombstonePath;
+exports.writeTombstone = writeTombstone;
+exports.readTombstone = readTombstone;
+exports.clearTombstone = clearTombstone;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+function tombstonePath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.workrail', 'primary.tombstone');
+}
+function writeTombstone(port, pid, deps = {}) {
+    try {
+        const mkdirFn = deps.mkdirSync ?? fs_1.mkdirSync;
+        mkdirFn((0, path_1.join)((0, os_1.homedir)(), '.workrail'), { recursive: true });
+        const writeFn = deps.writeSync ?? fs_1.writeFileSync;
+        const tombstone = {
+            pid,
+            port,
+            diedAt: new Date().toISOString(),
+        };
+        writeFn(tombstonePath(), JSON.stringify(tombstone, null, 2));
+    }
+    catch {
+    }
+}
+function readTombstone(deps = {}) {
+    try {
+        const readFn = deps.readSync ?? fs_1.readFileSync;
+        const content = readFn(tombstonePath(), 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed.pid === 'number' &&
+            typeof parsed.port === 'number' &&
+            typeof parsed.diedAt === 'string') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function clearTombstone(deps = {}) {
+    try {
+        const unlinkFn = deps.unlinkSync ?? fs_1.unlinkSync;
+        unlinkFn(tombstonePath());
+    }
+    catch {
+    }
+}

package/dist/mcp/transports/shutdown-hooks.js

@@ -23,12 +23,18 @@ function wireShutdownHooks(opts) {
         shutdownStarted = true;
         void (async () => {
             try {
-                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
+                try {
+                    process.stderr.write(`[Shutdown] Requested by ${event.signal}. Stopping services...\n`);
+                }
+                catch { }
                 await opts.onBeforeTerminate();
                 terminator.terminate({ kind: 'success' });
             }
             catch (err) {
-                console.error('[Shutdown] Error while stopping services:', err);
+                try {
+                    process.stderr.write(`[Shutdown] Error while stopping services: ${err?.stack ?? String(err)}\n`);
+                }
+                catch { }
                 terminator.terminate({ kind: 'failure' });
             }
         })();
@@ -40,10 +46,16 @@ function wireStdoutShutdown(opts) {
     stdout.on('error', (err) => {
         const code = err.code;
         if (code === 'EPIPE' || code === 'ERR_STREAM_DESTROYED') {
-            console.error('[MCP] stdout pipe broken (client disconnected), initiating shutdown');
+            try {
+                process.stderr.write('[MCP] stdout pipe broken (client disconnected), initiating shutdown\n');
+            }
+            catch { }
         }
         else {
-            console.error('[MCP] stdout error:', err);
+            try {
+                process.stderr.write(`[MCP] stdout error: ${err.message}\n`);
+            }
+            catch { }
         }
         shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
     });
@@ -52,7 +64,10 @@ function wireStdinShutdown(opts) {
     const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
     const stdin = opts?.stdin ?? process.stdin;
     stdin.once('end', () => {
-        console.error('[MCP] stdin closed, initiating shutdown');
+        try {
+            process.stderr.write('[MCP] stdin closed, initiating shutdown\n');
+        }
+        catch { }
         shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
     });
 }

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

@@ -37,6 +37,7 @@ exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const fatal_exit_js_1 = require("./fatal-exit.js");
+const primary_tombstone_js_1 = require("./primary-tombstone.js");
 const INITIAL_ROOTS_TIMEOUT_MS = 1000;
 async function fetchInitialRootsWithTimeout(server) {
     return Promise.race([
@@ -49,7 +50,9 @@ async function fetchInitialRootsWithTimeout(server) {
 async function startStdioServer() {
     (0, fatal_exit_js_1.registerFatalHandlers)('stdio');
     (0, fatal_exit_js_1.logStartup)('stdio');
+    (0, primary_tombstone_js_1.clearTombstone)();
     const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
+    (0, fatal_exit_js_1.registerGracefulShutdown)(async () => { await ctx.httpServer?.stop(); });
     const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
     const { RootsListChangedNotificationSchema, } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/types.js')));
     server.setNotificationHandler(RootsListChangedNotificationSchema, async () => {
@@ -81,6 +84,10 @@ async function startStdioServer() {
     (0, shutdown_hooks_js_1.wireStdinShutdown)();
     (0, shutdown_hooks_js_1.wireShutdownHooks)({
         onBeforeTerminate: async () => {
+            const port = ctx.httpServer?.getPort();
+            if (port != null) {
+                (0, primary_tombstone_js_1.writeTombstone)(port, process.pid);
+            }
             await ctx.httpServer?.stop();
         },
     });

package/dist/mcp-server.js

@@ -37,16 +37,16 @@ function waitForStdinReadable(timeoutMs, stdin = process.stdin) {
 async function main() {
     const mode = (0, transport_mode_js_1.resolveTransportMode)(process.env);
     if (mode.kind === 'stdio') {
-        const primaryPort = await (0, bridge_entry_js_1.detectHealthyPrimary)(DEFAULT_MCP_PORT);
-        if (primaryPort != null) {
+        const primaryDetected = await (0, bridge_entry_js_1.detectHealthyPrimary)(DEFAULT_MCP_PORT);
+        if (primaryDetected != null) {
             const hasClient = await waitForStdinReadable(STDIO_CLIENT_PROBE_MS, process.stdin);
             if (!hasClient) {
-                console.error(`[Startup] Primary on :${primaryPort}, no stdio client within ${STDIO_CLIENT_PROBE_MS}ms — exiting`);
+                console.error(`[Startup] Primary on :${primaryDetected.port}, no stdio client within ${STDIO_CLIENT_PROBE_MS}ms — exiting`);
                 process.exit(0);
             }
-            console.error(`[Startup] Primary detected on :${primaryPort} — starting in bridge mode`);
+            console.error(`[Startup] Primary detected on :${primaryDetected.port} — starting in bridge mode`);
             try {
-                await (0, bridge_entry_js_1.startBridgeServer)(primaryPort);
+                await (0, bridge_entry_js_1.startBridgeServer)(primaryDetected.port, undefined, { originalPrimaryPid: primaryDetected.pid });
             }
             catch (error) {
                 console.error('[Bridge] Fatal error, falling back to full stdio server:', error);

package/dist/trigger/daemon-console.d.ts

@@ -0,0 +1,24 @@
+import 'reflect-metadata';
+import type { V2ToolContext } from '../mcp/types.js';
+import type { TriggerRouter } from './trigger-router.js';
+import type { WorkflowService } from '../application/services/workflow-service.js';
+import type { Result } from '../runtime/result.js';
+export interface DaemonConsoleHandle {
+    readonly port: number;
+    stop(): Promise<void>;
+}
+export type DaemonConsoleError = {
+    readonly kind: 'port_conflict';
+    readonly port: number;
+} | {
+    readonly kind: 'io_error';
+    readonly message: string;
+};
+export interface StartDaemonConsoleOptions {
+    readonly port?: number;
+    readonly triggerRouter?: TriggerRouter;
+    readonly serverVersion?: string;
+    readonly workflowService?: WorkflowService;
+    readonly lockFilePath?: string;
+}
+export declare function startDaemonConsole(ctx: V2ToolContext, options?: StartDaemonConsoleOptions): Promise<Result<DaemonConsoleHandle, DaemonConsoleError>>;