@exaudeus/workrail 1.16.1 → 1.17.0

package/dist/manifest.json

@@ -598,8 +598,8 @@
       "bytes": 67
     },
     "mcp-server.js": {
-      "sha256": "7c431887c5601a5e49d17da6f8d687ef45d36d5c5d1e5b91696a6f9dcf90f014",
-      "bytes": 476
+      "sha256": "bf97a81d9bc5bb40d10ec8a06c73b322320e0a0afdaa88f19730efe781ace7cf",
+      "bytes": 1135
     },
     "mcp/error-mapper.d.ts": {
       "sha256": "c6e9db65c565063726442b73a4a0cf1a1c07d54c778a85cf0122c4c04ea6a5a9",
@@ -842,12 +842,12 @@
       "bytes": 12115
     },
     "mcp/server.d.ts": {
-      "sha256": "bec49b8d07e189a53db7100d2f0e1e84ffe03150f04e1b06908ee3282982b4a2",
-      "bytes": 168
+      "sha256": "782a9a50797cac9c5f30e79556f809351d7eb176a16d7c603c09a5133cc25303",
+      "bytes": 882
     },
     "mcp/server.js": {
-      "sha256": "4ca61965fdf522e5cc839e26220491638f03053a12f23c4eaf000b54b50ab7ad",
-      "bytes": 12934
+      "sha256": "5086b482d2eb3c42caac637282a5361b4db6e5d14aaeeb7c5ffdf75d211af0d8",
+      "bytes": 13422
     },
     "mcp/tool-description-provider.d.ts": {
       "sha256": "1d46abc3112e11b68e57197e846f5708293ec9b2281fa71a9124ee2aad71e41b",
@@ -881,6 +881,38 @@
       "sha256": "aa364f3e613fc61a39fc7336a723231da06852d92ec7840a95327aa370e42e1c",
       "bytes": 8360
     },
+    "mcp/transports/http-entry.d.ts": {
+      "sha256": "35d313b120dcf38643de9462559163581b89943fe432706986252e8b698b9507",
+      "bytes": 70
+    },
+    "mcp/transports/http-entry.js": {
+      "sha256": "3ecf3a39d4eb2d4b844e83296cf04238acfc7c91e9eca0e10c1e8a0fbae71721",
+      "bytes": 4279
+    },
+    "mcp/transports/http-listener.d.ts": {
+      "sha256": "5c512d31f001bd65eaaca5421ca8f80e614896fdfe803773aa1f6c893257f20e",
+      "bytes": 316
+    },
+    "mcp/transports/http-listener.js": {
+      "sha256": "9e055636c281b5fe09623aa017d2e773462ddbe65e42c0938ed897cac606bb62",
+      "bytes": 2555
+    },
+    "mcp/transports/stdio-entry.d.ts": {
+      "sha256": "4ced3c9e00ef67555781dea74315290eea8a9dbffd38155bc00c3fb07b0c1794",
+      "bytes": 59
+    },
+    "mcp/transports/stdio-entry.js": {
+      "sha256": "a1f75205084e632b78e1ec28fb82498f04ecdb66fa4a9d9678d885268b0ed885",
+      "bytes": 4509
+    },
+    "mcp/transports/transport-mode.d.ts": {
+      "sha256": "1c59128ab0174bd2a113fff17521e6339ca367f2b8980c2f2c164ec393c10518",
+      "bytes": 206
+    },
+    "mcp/transports/transport-mode.js": {
+      "sha256": "6627303319e87e047caf99d910626a331742089b90db180f6031aa9a1afc98eb",
+      "bytes": 747
+    },
     "mcp/types.d.ts": {
       "sha256": "2ef7f9c1bffbe365b06469dfad43b45c4ae3b5292dd269b33423bf1c8c9c7c43",
       "bytes": 4355

package/dist/mcp/server.d.ts

@@ -1,3 +1,21 @@
 import type { ToolContext } from './types.js';
+import { WorkspaceRootsManager } from './workspace-roots-manager.js';
+import { type ToolAnnotations } from './tool-factory.js';
+import type { WrappedToolHandler } from './types/workflow-tool-edition.js';
+interface Tool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: ToolAnnotations;
+}
 export declare function createToolContext(): Promise<ToolContext>;
+export interface ComposedServer {
+    readonly server: import('@modelcontextprotocol/sdk/server/index.js').Server;
+    readonly ctx: ToolContext;
+    readonly rootsManager: WorkspaceRootsManager;
+    readonly tools: readonly Tool[];
+    readonly handlers: Record<string, WrappedToolHandler>;
+}
+export declare function composeServer(): Promise<ComposedServer>;
 export declare function startServer(): Promise<void>;
+export {};

package/dist/mcp/server.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createToolContext = createToolContext;
+exports.composeServer = composeServer;
 exports.startServer = startServer;
 const zod_to_json_schema_js_1 = require("./zod-to-json-schema.js");
 const container_js_1 = require("../di/container.js");
@@ -134,7 +135,7 @@ function toMcpTool(tool) {
         annotations: tool.annotations,
     };
 }
-async function startServer() {
+async function composeServer() {
     await (0, container_js_1.bootstrap)({ runtimeMode: { kind: 'production' } });
     const ctx = await createToolContext();
     if (ctx.v2 && ctx.httpServer && ctx.v2.dataDir && ctx.v2.directoryListing) {
@@ -204,6 +205,12 @@ async function startServer() {
             : ctx;
         return handler(args ?? {}, requestCtx);
     });
+    return { server, ctx, rootsManager, tools, handlers };
+}
+async function startServer() {
+    const { server, ctx, rootsManager } = await composeServer();
+    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 () => {
         try {
             const result = await server.listRoots();

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

@@ -0,0 +1 @@
+export declare function startHttpServer(port: number): Promise<void>;

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

@@ -0,0 +1,87 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHttpServer = startHttpServer;
+const server_js_1 = require("../server.js");
+const http_listener_js_1 = require("./http-listener.js");
+const container_js_1 = require("../../di/container.js");
+const tokens_js_1 = require("../../di/tokens.js");
+const crypto = __importStar(require("crypto"));
+const express_1 = __importDefault(require("express"));
+async function startHttpServer(port) {
+    const { server, ctx } = await (0, server_js_1.composeServer)();
+    const listener = (0, http_listener_js_1.createHttpListener)(port);
+    const { StreamableHTTPServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/streamableHttp.js')));
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        enableJsonResponse: true,
+    });
+    listener.app.use(express_1.default.json());
+    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));
+    await listener.start();
+    await server.connect(transport);
+    const boundPort = listener.getBoundPort();
+    console.error('[Transport] WorkRail MCP Server running on HTTP');
+    console.error(`[Transport] MCP endpoint: http://localhost:${boundPort}/mcp`);
+    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
+    const processSignals = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessSignals);
+    const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
+    processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
+    processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
+    processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
+    let shutdownStarted = false;
+    shutdownEvents.onShutdown((event) => {
+        if (shutdownStarted)
+            return;
+        shutdownStarted = true;
+        void (async () => {
+            try {
+                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
+                await listener.stop();
+                await ctx.httpServer?.stop();
+                terminator.terminate({ kind: 'success' });
+            }
+            catch (err) {
+                console.error('[Shutdown] Error while stopping services:', err);
+                terminator.terminate({ kind: 'failure' });
+            }
+        })();
+    });
+}

package/dist/mcp/transports/http-listener.d.ts

@@ -0,0 +1,9 @@
+import { type Application } from 'express';
+export interface HttpListener {
+    readonly app: Application;
+    readonly requestedPort: number;
+    getBoundPort(): number | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function createHttpListener(requestedPort: number): HttpListener;

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpListener = createHttpListener;
+const express_1 = __importDefault(require("express"));
+const http_1 = require("http");
+function createHttpListener(requestedPort) {
+    const app = (0, express_1.default)();
+    let state = { kind: 'not_started' };
+    return {
+        app,
+        requestedPort,
+        getBoundPort() {
+            return state.kind === 'running' ? state.boundPort : null;
+        },
+        async start() {
+            if (state.kind === 'running') {
+                throw new Error('[HttpListener] Already started');
+            }
+            if (state.kind === 'stopped') {
+                throw new Error('[HttpListener] Cannot restart a stopped listener');
+            }
+            return new Promise((resolve, reject) => {
+                const server = (0, http_1.createServer)(app);
+                server.on('error', (err) => {
+                    if (err.code === 'EADDRINUSE') {
+                        reject(new Error(`[HttpListener] Port ${requestedPort} is already in use. ` +
+                            `Set WORKRAIL_HTTP_PORT to a different port or stop the conflicting process.`));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                server.listen(requestedPort, () => {
+                    const addr = server.address();
+                    const boundPort = addr && typeof addr === 'object' ? addr.port : requestedPort;
+                    state = { kind: 'running', server, boundPort };
+                    console.error(`[HttpListener] MCP HTTP transport listening on port ${boundPort}`);
+                    resolve();
+                });
+            });
+        },
+        async stop() {
+            if (state.kind !== 'running') {
+                return;
+            }
+            const serverToClose = state.server;
+            return new Promise((resolve, reject) => {
+                serverToClose.close((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        state = { kind: 'stopped' };
+                        console.error(`[HttpListener] MCP HTTP transport stopped`);
+                        resolve();
+                    }
+                });
+            });
+        },
+    };
+}

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

@@ -0,0 +1 @@
+export declare function startStdioServer(): Promise<void>;

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

@@ -0,0 +1,92 @@
+"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.startStdioServer = startStdioServer;
+const server_js_1 = require("../server.js");
+const container_js_1 = require("../../di/container.js");
+const tokens_js_1 = require("../../di/tokens.js");
+async function startStdioServer() {
+    const { server, ctx, rootsManager } = await (0, server_js_1.composeServer)();
+    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 () => {
+        try {
+            const result = await server.listRoots();
+            rootsManager.updateRootUris(result.roots.map((r) => r.uri));
+            console.error(`[Roots] Updated workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}`);
+        }
+        catch {
+            console.error('[Roots] Failed to fetch updated roots after change notification');
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    try {
+        const result = await server.listRoots();
+        rootsManager.updateRootUris(result.roots.map((r) => r.uri));
+        console.error(`[Roots] Initial workspace roots: ${result.roots.map((r) => r.uri).join(', ') || '(none)'}`);
+    }
+    catch {
+        console.error('[Roots] Client does not support roots/list; workspace context will use server CWD fallback');
+    }
+    console.error('[Transport] WorkRail MCP Server running on stdio');
+    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
+    const processSignals = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessSignals);
+    const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
+    processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
+    processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
+    processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
+    process.stdin.on('end', () => {
+        console.error('[MCP] stdin closed, initiating shutdown');
+        shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
+    });
+    let shutdownStarted = false;
+    shutdownEvents.onShutdown((event) => {
+        if (shutdownStarted)
+            return;
+        shutdownStarted = true;
+        void (async () => {
+            try {
+                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
+                await ctx.httpServer?.stop();
+                terminator.terminate({ kind: 'success' });
+            }
+            catch (err) {
+                console.error('[Shutdown] Error while stopping services:', err);
+                terminator.terminate({ kind: 'failure' });
+            }
+        })();
+    });
+}

package/dist/mcp/transports/transport-mode.d.ts

@@ -0,0 +1,7 @@
+export type TransportMode = {
+    readonly kind: 'stdio';
+} | {
+    readonly kind: 'http';
+    readonly port: number;
+};
+export declare function resolveTransportMode(env: NodeJS.ProcessEnv): TransportMode;

package/dist/mcp/transports/transport-mode.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTransportMode = resolveTransportMode;
+function resolveTransportMode(env) {
+    const transport = env.WORKRAIL_TRANSPORT ?? 'stdio';
+    if (transport === 'http') {
+        const portStr = env.WORKRAIL_HTTP_PORT ?? '3100';
+        const port = parseInt(portStr, 10);
+        if (isNaN(port) || port <= 0 || port > 65535) {
+            throw new Error(`Invalid WORKRAIL_HTTP_PORT: "${portStr}". Must be a number between 1-65535.`);
+        }
+        return { kind: 'http', port };
+    }
+    if (transport !== 'stdio') {
+        throw new Error(`Invalid WORKRAIL_TRANSPORT: "${transport}". Must be 'stdio' or 'http'.`);
+    }
+    return { kind: 'stdio' };
+}

package/dist/mcp-server.js

@@ -2,10 +2,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startServer = 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 assert_never_js_1 = require("./runtime/assert-never.js");
 var server_js_1 = require("./mcp/server.js");
 Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_js_1.startServer; } });
-const server_js_2 = require("./mcp/server.js");
-(0, server_js_2.startServer)().catch((error) => {
-    console.error('Fatal error running server:', error);
-    process.exit(1);
-});
+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);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "1.16.1",
+  "version": "1.17.0",
   "description": "Step-by-step workflow enforcement for AI agents via MCP",
   "license": "MIT",
   "repository": {