npm - @exaudeus/workrail - Versions diffs - 3.24.0 → 3.24.2 - Mend

@exaudeus/workrail 3.24.0 → 3.24.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/console/assets/index-BXRk3te_.css +1 -0
package/dist/console/assets/{index-CWETdPGj.js → index-TMfptYpQ.js} +9 -9
package/dist/console/index.html +2 -2
package/dist/di/container.js +1 -1
package/dist/infrastructure/session/HttpServer.js +11 -0
package/dist/manifest.json +33 -25
package/dist/mcp/transports/bridge-entry.d.ts +70 -0
package/dist/mcp/transports/bridge-entry.js +287 -0
package/dist/mcp/transports/http-entry.js +3 -0
package/dist/mcp-server.d.ts +1 -0
package/dist/mcp-server.js +36 -17
package/dist/v2/infra/local/session-lock/index.d.ts +3 -1
package/dist/v2/infra/local/session-lock/index.js +18 -1
package/dist/v2/usecases/console-service.js +71 -1
package/dist/v2/usecases/console-types.d.ts +5 -0
package/package.json +1 -1
package/workflows/rich-object-contribution.json +258 -0
package/dist/console/assets/index-ByW7d9qr.css +0 -1

package/dist/console/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>WorkRail Console</title>
-    <script type="module" crossorigin src="/console/assets/index-CWETdPGj.js"></script>
-    <link rel="stylesheet" crossorigin href="/console/assets/index-ByW7d9qr.css">
+    <script type="module" crossorigin src="/console/assets/index-TMfptYpQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/console/assets/index-BXRk3te_.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/di/container.js CHANGED Viewed

@@ -303,7 +303,7 @@ async function registerV2Services() {
             const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
             const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
             const clock = c.resolve(tokens_js_1.DI.V2.TimeClock);
-            return new LocalSessionLockV2(dataDir, fs, clock);
+            return new LocalSessionLockV2(dataDir, fs, clock, 'mcp-server');
         }),
     });
     const { ExecutionSessionGateV2 } = await Promise.resolve().then(() => __importStar(require('../v2/usecases/execution-session-gate.js')));

package/dist/infrastructure/session/HttpServer.js CHANGED Viewed

@@ -392,6 +392,17 @@ let HttpServer = class HttpServer {
         if (!lockData.pid || !lockData.port || !lockData.startedAt) {
             return { reclaim: true, reason: 'invalid lock structure' };
         }
+        if (lockData.projectId) {
+            const currentProjectId = this.sessionManager.getProjectId();
+            if (lockData.projectId !== currentProjectId) {
+                try {
+                    process.kill(lockData.pid, 0);
+                    return { reclaim: false, reason: `different project, primary alive (lock=${lockData.projectId}, current=${currentProjectId})` };
+                }
+                catch {
+                }
+            }
+        }
         if (lockData.version !== CURRENT_VERSION) {
             return { reclaim: true, reason: `version mismatch (lock=${lockData.version}, current=${CURRENT_VERSION})` };
         }

package/dist/manifest.json CHANGED Viewed

@@ -369,16 +369,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console/assets/index-ByW7d9qr.css": {
-      "sha256": "1336e0c417833c4fff933ac519b763ab5945ef86c97d25e31c2f82d83b45d0c1",
-      "bytes": 59845
+    "console/assets/index-BXRk3te_.css": {
+      "sha256": "2151b10aedd5da99f5bac5cdb54c4cb73894b9069eab0fb859db50b9aa71fba2",
+      "bytes": 59906
     },
-    "console/assets/index-CWETdPGj.js": {
-      "sha256": "01ac1ee867b8260ea371d73fee41187368253ac60299ed94846dbcaf1317182d",
-      "bytes": 742813
+    "console/assets/index-TMfptYpQ.js": {
+      "sha256": "475c71c4cca93f8ed30139569638b9ec272b43eb44feccb4ce08c6f7e2064dc7",
+      "bytes": 744551
     },
     "console/index.html": {
-      "sha256": "26f9f87ae94cb739151d893db85be046dc4fe015d30306f80f4ca8e04e375a48",
+      "sha256": "1ff870763f5df29998d56597a3b138e07e23b8fb054c93f6ce9f7f5ae4a0c9a5",
       "bytes": 417
     },
     "core/error-handler.d.ts": {
@@ -394,8 +394,8 @@
       "bytes": 620
     },
     "di/container.js": {
-      "sha256": "7956cb925d40f61746ccdcec245c5ee40d7d317893eff240a10cff595304d467",
-      "bytes": 22026
+      "sha256": "a3ac972a1d9d6412084cebffb1e612f855f8042c861223d9b849c6569af68f5c",
+      "bytes": 22040
     },
     "di/tokens.d.ts": {
       "sha256": "04db6db34348aa36d897c85ab07eb1a386cb04e3595dbcb33525bd33974111ef",
@@ -546,8 +546,8 @@
       "bytes": 2025
     },
     "infrastructure/session/HttpServer.js": {
-      "sha256": "3f2bc1fb56b8191da261567eb7fb8e78f4c3e33b54c71da361aeea51d047ccd8",
-      "bytes": 30743
+      "sha256": "5d526849ef6e97e5341df73fb9b9789a4bfa7e132f2751b9892f3cbfe09aa2c9",
+      "bytes": 31215
     },
     "infrastructure/session/SessionDataNormalizer.d.ts": {
       "sha256": "c89bb5e00d7d01fb4aa6d0095602541de53c425c6b99b67fa8367eb29cb63e9e",
@@ -670,12 +670,12 @@
       "bytes": 6002
     },
     "mcp-server.d.ts": {
-      "sha256": "7ead2e703f41c763d04b37a1cf433380bec3551fbde206af6694fe9286ad4714",
-      "bytes": 203
+      "sha256": "4ef3c55720fc5deb6fff14a1be5958d9cddd94ce4037af0cb842e3f3ce0cfac0",
+      "bytes": 295
     },
     "mcp-server.js": {
-      "sha256": "a825b696428c32b87fdef23722574acb965d8319928b121a287800991a715172",
-      "bytes": 1599
+      "sha256": "ef9c98e49ea95d556e8e8328ff235d7b631a6ef72d1480c22b9409ae4b1c9b5b",
+      "bytes": 2687
     },
     "mcp/assert-output.d.ts": {
       "sha256": "f1b821c3652423b15a09d2d1c5a042ee565a503c3d7196bd8220fbe697e0dc75",
@@ -1085,13 +1085,21 @@
       "sha256": "bdea37dfe3f2ef98be01899b067f841c645bda69c23dddd9e181f94b4b157c5e",
       "bytes": 8822
     },
+    "mcp/transports/bridge-entry.d.ts": {
+      "sha256": "83be835fd6beba67c8eb6f1ec23a998599ca13008522dd472d443d824601bbbe",
+      "bytes": 2496
+    },
+    "mcp/transports/bridge-entry.js": {
+      "sha256": "fe8e3c2bbe4890d4715c4665f13d531fff648b24ba3666ef5b0af498e2bef5fc",
+      "bytes": 11811
+    },
     "mcp/transports/http-entry.d.ts": {
       "sha256": "35d313b120dcf38643de9462559163581b89943fe432706986252e8b698b9507",
       "bytes": 70
     },
     "mcp/transports/http-entry.js": {
-      "sha256": "053280da2abe9a6ef047aa4c866e5db717aedf5f73d59966c7a7578741b0ad64",
-      "bytes": 3205
+      "sha256": "fdebcd58e111f3051081003599e8608fa1becf20abf97a666a957f8048c95334",
+      "bytes": 3314
     },
     "mcp/transports/http-listener.d.ts": {
       "sha256": "6c6cd6dcfe110ed8fa1dc2f9c96caba55959555f98048d3694ac104f42d6d51a",
@@ -2278,12 +2286,12 @@
       "bytes": 7393
     },
     "v2/infra/local/session-lock/index.d.ts": {
-      "sha256": "e180a4202587af03e09dc82e2d8557ee2d3139ac6c5f1edee9a277a7032b9986",
-      "bytes": 883
+      "sha256": "a0c2e5cbafa9633023f571d89bb41da3a7660d8371473a6344269801c001cbfc",
+      "bytes": 966
     },
     "v2/infra/local/session-lock/index.js": {
-      "sha256": "a1cd3eaea35faa014922fe1502a9e029a58528421586c67ab44dc7df0183a0fe",
-      "bytes": 2793
+      "sha256": "4832225abcf2fcff1d7562b15a83cab02c8ea9d000b5d9e60ea1e4ef296394a9",
+      "bytes": 3651
     },
     "v2/infra/local/session-store/index.d.ts": {
       "sha256": "33b18ccce92374f8e444a61c63238634087d222f09e834b49dd2ea38d2be3796",
@@ -2666,12 +2674,12 @@
       "bytes": 1572
     },
     "v2/usecases/console-service.js": {
-      "sha256": "bbc9fc2e64605cd3025c02a20d73c68a454b3e40a59c251b62ea698fd9252f27",
-      "bytes": 27215
+      "sha256": "99f25ac6595cddccb6941c99e9773b075c665eed8b820303efd41a1da1d95e05",
+      "bytes": 30332
     },
     "v2/usecases/console-types.d.ts": {
-      "sha256": "36209a82bcd037b50b71ce6559e1e1835af3c3df50392ca4ac0f20990d9fcbae",
-      "bytes": 7224
+      "sha256": "9f1060c1689eb1fa6e23e6fbba00ad406c1956e196110c8eab7f95e8ceae81c9",
+      "bytes": 7386
     },
     "v2/usecases/console-types.js": {
       "sha256": "d43aa81f5bc89faa359e0f97c814ba25155591ff078fbb9bfd40f8c7c9683230",

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

@@ -0,0 +1,70 @@
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export interface BridgeConfig {
+    readonly reconnectBaseDelayMs: number;
+    readonly reconnectMaxAttempts: number;
+    readonly forwardTimeoutMs: number;
+    readonly maxRespawnAttempts: 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: 'closed';
+};
+export type ReconnectOutcome = {
+    readonly kind: 'reconnected';
+} | {
+    readonly kind: 'exhausted';
+} | {
+    readonly kind: 'aborted';
+};
+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 declare function detectHealthyPrimary(port: number, opts?: {
+    retries?: number;
+    baseDelayMs?: number;
+    fetch?: FetchLike;
+}): Promise<number | null>;
+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 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;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,287 @@
+"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.spawnPrimary = spawnPrimary;
+exports.reconnectWithBackoff = reconnectWithBackoff;
+exports.handleReconnectOutcome = handleReconnectOutcome;
+exports.startBridgeServer = startBridgeServer;
+exports.DEFAULT_BRIDGE_CONFIG = {
+    reconnectBaseDelayMs: 250,
+    reconnectMaxAttempts: 8,
+    forwardTimeoutMs: 30000,
+    maxRespawnAttempts: 3,
+};
+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')
+                    return port;
+            }
+        }
+        catch {
+        }
+        if (attempt < retries - 1) {
+            await sleep(baseDelayMs * (attempt + 1));
+        }
+    }
+    return null;
+}
+async function spawnPrimary(port, deps) {
+    await sleep(Math.random() * 300);
+    const alreadyUp = await detectHealthyPrimary(port, { retries: 1, fetch: deps.fetch });
+    if (alreadyUp != null) {
+        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;
+    }
+    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':
+            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 {
+                deps.setConnectionState({ kind: 'closed' });
+                deps.performShutdown('respawn budget exhausted — primary repeatedly unavailable');
+            }
+            return;
+    }
+}
+async function startBridgeServer(primaryPort, config = exports.DEFAULT_BRIDGE_CONFIG, deps = {}) {
+    console.error(`[Bridge] Forwarding stdio → http://localhost:${primaryPort}/mcp`);
+    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();
+        console.error(`[Bridge] Shutting down: ${reason}`);
+        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')
+                return;
+            console.error('[Bridge] Primary connection lost — reconnecting');
+            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) => {
+                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,
+                triggerSpawn: () => spawnPrimary(primaryPort, { spawn: spawnFn, fetch: deps.fetch }),
+                config,
+            });
+        })
+            .catch((err) => {
+            console.error('[Bridge] Unexpected error in reconnect 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':
+                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}`);
+    }
+    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/http-entry.js CHANGED Viewed

@@ -56,6 +56,9 @@ async function startHttpServer(port) {
     listener.app.post('/mcp', (req, res) => transport.handleRequest(req, res, req.body));
     listener.app.get('/mcp', (req, res) => transport.handleRequest(req, res));
     listener.app.delete('/mcp', (req, res) => transport.handleRequest(req, res));
+    listener.app.get('/workrail-health', (_req, res) => {
+        res.json({ service: 'workrail' });
+    });
     await server.connect(transport);
     const boundPort = listener.getBoundPort();
     console.error('[Transport] WorkRail MCP Server running on HTTP');

package/dist/mcp-server.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 export { startStdioServer } from './mcp/transports/stdio-entry.js';
 export { startHttpServer } from './mcp/transports/http-entry.js';
+export { startBridgeServer, detectHealthyPrimary } from './mcp/transports/bridge-entry.js';
 export { composeServer } from './mcp/server.js';

package/dist/mcp-server.js CHANGED Viewed

@@ -1,31 +1,50 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeServer = exports.startHttpServer = exports.startStdioServer = void 0;
+exports.composeServer = exports.detectHealthyPrimary = exports.startBridgeServer = exports.startHttpServer = exports.startStdioServer = void 0;
 const transport_mode_js_1 = require("./mcp/transports/transport-mode.js");
 const stdio_entry_js_1 = require("./mcp/transports/stdio-entry.js");
 const http_entry_js_1 = require("./mcp/transports/http-entry.js");
+const bridge_entry_js_1 = require("./mcp/transports/bridge-entry.js");
 const assert_never_js_1 = require("./runtime/assert-never.js");
 var stdio_entry_js_2 = require("./mcp/transports/stdio-entry.js");
 Object.defineProperty(exports, "startStdioServer", { enumerable: true, get: function () { return stdio_entry_js_2.startStdioServer; } });
 var http_entry_js_2 = require("./mcp/transports/http-entry.js");
 Object.defineProperty(exports, "startHttpServer", { enumerable: true, get: function () { return http_entry_js_2.startHttpServer; } });
+var bridge_entry_js_2 = require("./mcp/transports/bridge-entry.js");
+Object.defineProperty(exports, "startBridgeServer", { enumerable: true, get: function () { return bridge_entry_js_2.startBridgeServer; } });
+Object.defineProperty(exports, "detectHealthyPrimary", { enumerable: true, get: function () { return bridge_entry_js_2.detectHealthyPrimary; } });
 var server_js_1 = require("./mcp/server.js");
 Object.defineProperty(exports, "composeServer", { enumerable: true, get: function () { return server_js_1.composeServer; } });
-const mode = (0, transport_mode_js_1.resolveTransportMode)(process.env);
-switch (mode.kind) {
-    case 'stdio':
-        (0, stdio_entry_js_1.startStdioServer)().catch((error) => {
-            console.error('[stdio] Fatal error:', error);
-            process.exit(1);
-        });
-        break;
-    case 'http':
-        (0, http_entry_js_1.startHttpServer)(mode.port).catch((error) => {
-            console.error('[http] Fatal error:', error);
-            process.exit(1);
-        });
-        break;
-    default:
-        (0, assert_never_js_1.assertNever)(mode);
+const DEFAULT_MCP_PORT = 3100;
+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) {
+            console.error(`[Startup] Primary detected on :${primaryPort} — starting in bridge mode`);
+            try {
+                await (0, bridge_entry_js_1.startBridgeServer)(primaryPort);
+            }
+            catch (error) {
+                console.error('[Bridge] Fatal error, falling back to full stdio server:', error);
+                await (0, stdio_entry_js_1.startStdioServer)();
+            }
+            return;
+        }
+    }
+    switch (mode.kind) {
+        case 'stdio':
+            await (0, stdio_entry_js_1.startStdioServer)();
+            break;
+        case 'http':
+            await (0, http_entry_js_1.startHttpServer)(mode.port);
+            break;
+        default:
+            (0, assert_never_js_1.assertNever)(mode);
+    }
 }
+main().catch((error) => {
+    console.error('[Startup] Fatal error:', error);
+    process.exit(1);
+});

package/dist/v2/infra/local/session-lock/index.d.ts CHANGED Viewed

@@ -8,7 +8,9 @@ export declare class LocalSessionLockV2 implements SessionLockPortV2 {
     private readonly dataDir;
     private readonly fs;
     private readonly clock;
-    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, clock: TimeClockPortV2);
+    private readonly workerId;
+    private readonly instanceId;
+    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, clock: TimeClockPortV2, workerId?: string);
     private clearIfStaleLock;
     acquire(sessionId: SessionId): ResultAsync<SessionLockHandleV2, SessionLockError>;
     release(handle: SessionLockHandleV2): ResultAsync<void, SessionLockError>;

package/dist/v2/infra/local/session-lock/index.js CHANGED Viewed

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalSessionLockV2 = void 0;
 const neverthrow_1 = require("neverthrow");
+const node_crypto_1 = require("node:crypto");
 class LocalSessionLockV2 {
-    constructor(dataDir, fs, clock) {
+    constructor(dataDir, fs, clock, workerId = 'default') {
         this.dataDir = dataDir;
         this.fs = fs;
         this.clock = clock;
+        this.workerId = workerId;
+        this.instanceId = (0, node_crypto_1.randomUUID)();
     }
     clearIfStaleLock(lockPath) {
         return this.fs
@@ -17,6 +20,18 @@ class LocalSessionLockV2 {
                 const pid = typeof data.pid === 'number' ? data.pid : null;
                 if (pid === null)
                     return false;
+                const myPid = this.clock.getPid();
+                const lockWorkerId = typeof data.workerId === 'string' ? data.workerId : undefined;
+                if (pid === myPid && lockWorkerId !== undefined) {
+                    if (lockWorkerId !== this.workerId) {
+                        return false;
+                    }
+                    const lockInstanceId = typeof data.instanceId === 'string' ? data.instanceId : undefined;
+                    if (lockInstanceId === this.instanceId) {
+                        return false;
+                    }
+                    return true;
+                }
                 try {
                     process.kill(pid, 0);
                     return false;
@@ -58,6 +73,8 @@ class LocalSessionLockV2 {
             v: 1,
             sessionId,
             pid: this.clock.getPid(),
+            workerId: this.workerId,
+            instanceId: this.instanceId,
             startedAtMs: this.clock.nowMs(),
         }))))
             .andThen(({ fd }) => this.fs.fsyncFile(fd).andThen(() => this.fs.closeFile(fd)))