@exaudeus/workrail 0.8.6 → 0.10.0

package/dist/mcp/output-schemas.d.ts

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+export type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export declare const JsonValueSchema: z.ZodType<JsonValue>;
+export declare const WorkflowSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+}, {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+}>;
+export declare const WorkflowListOutputSchema: z.ZodObject<{
+    workflows: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        version: string;
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        version: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    workflows: {
+        id: string;
+        name: string;
+        description: string;
+        version: string;
+    }[];
+}, {
+    workflows: {
+        id: string;
+        name: string;
+        description: string;
+        version: string;
+    }[];
+}>;
+export declare const WorkflowGetOutputSchema: z.ZodObject<{
+    workflow: z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>;
+}, "strip", z.ZodTypeAny, {
+    workflow: JsonValue;
+}, {
+    workflow: JsonValue;
+}>;
+export declare const WorkflowNextOutputSchema: z.ZodObject<{
+    state: z.ZodType<import("../domain/execution/state.js").ExecutionState, z.ZodTypeDef, import("../domain/execution/state.js").ExecutionState>;
+    next: z.ZodNullable<z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>;
+    isComplete: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    state: import("../domain/execution/state.js").ExecutionState;
+    next: JsonValue;
+    isComplete: boolean;
+}, {
+    state: import("../domain/execution/state.js").ExecutionState;
+    next: JsonValue;
+    isComplete: boolean;
+}>;
+export declare const WorkflowValidateJsonOutputSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        path?: string | undefined;
+    }, {
+        message: string;
+        path?: string | undefined;
+    }>, "many">>;
+    suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    valid: boolean;
+    suggestions?: string[] | undefined;
+    errors?: {
+        message: string;
+        path?: string | undefined;
+    }[] | undefined;
+}, {
+    valid: boolean;
+    suggestions?: string[] | undefined;
+    errors?: {
+        message: string;
+        path?: string | undefined;
+    }[] | undefined;
+}>;
+export declare const WorkflowGetSchemaOutputSchema: z.ZodObject<{
+    schema: z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>;
+    metadata: z.ZodObject<{
+        version: z.ZodString;
+        description: z.ZodString;
+        usage: z.ZodString;
+        schemaPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        version: string;
+        usage: string;
+        schemaPath: string;
+    }, {
+        description: string;
+        version: string;
+        usage: string;
+        schemaPath: string;
+    }>;
+    commonPatterns: z.ZodObject<{
+        basicWorkflow: z.ZodRecord<z.ZodString, z.ZodString>;
+        stepStructure: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        basicWorkflow: Record<string, string>;
+        stepStructure: Record<string, string>;
+    }, {
+        basicWorkflow: Record<string, string>;
+        stepStructure: Record<string, string>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schema: JsonValue;
+    metadata: {
+        description: string;
+        version: string;
+        usage: string;
+        schemaPath: string;
+    };
+    commonPatterns: {
+        basicWorkflow: Record<string, string>;
+        stepStructure: Record<string, string>;
+    };
+}, {
+    schema: JsonValue;
+    metadata: {
+        description: string;
+        version: string;
+        usage: string;
+        schemaPath: string;
+    };
+    commonPatterns: {
+        basicWorkflow: Record<string, string>;
+        stepStructure: Record<string, string>;
+    };
+}>;
+export declare const V2WorkflowListItemSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    kind: z.ZodLiteral<"workflow">;
+    workflowHash: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    version: string;
+    kind: "workflow";
+    workflowId: string;
+    workflowHash: string | null;
+}, {
+    name: string;
+    description: string;
+    version: string;
+    kind: "workflow";
+    workflowId: string;
+    workflowHash: string | null;
+}>;
+export declare const V2WorkflowListOutputSchema: z.ZodObject<{
+    workflows: z.ZodArray<z.ZodObject<{
+        workflowId: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        version: z.ZodString;
+        kind: z.ZodLiteral<"workflow">;
+        workflowHash: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        version: string;
+        kind: "workflow";
+        workflowId: string;
+        workflowHash: string | null;
+    }, {
+        name: string;
+        description: string;
+        version: string;
+        kind: "workflow";
+        workflowId: string;
+        workflowHash: string | null;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    workflows: {
+        name: string;
+        description: string;
+        version: string;
+        kind: "workflow";
+        workflowId: string;
+        workflowHash: string | null;
+    }[];
+}, {
+    workflows: {
+        name: string;
+        description: string;
+        version: string;
+        kind: "workflow";
+        workflowId: string;
+        workflowHash: string | null;
+    }[];
+}>;
+export declare const V2WorkflowInspectOutputSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    workflowHash: z.ZodString;
+    mode: z.ZodEnum<["metadata", "preview"]>;
+    compiled: z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    mode: "metadata" | "preview";
+    workflowHash: string;
+    compiled: JsonValue;
+}, {
+    workflowId: string;
+    mode: "metadata" | "preview";
+    workflowHash: string;
+    compiled: JsonValue;
+}>;
+export declare const CreateSessionOutputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    workflowId: z.ZodString;
+    path: z.ZodString;
+    dashboardUrl: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    workflowId: string;
+    sessionId: string;
+    dashboardUrl: string | null;
+    createdAt: string;
+}, {
+    path: string;
+    workflowId: string;
+    sessionId: string;
+    dashboardUrl: string | null;
+    createdAt: string;
+}>;
+export declare const UpdateSessionOutputSchema: z.ZodObject<{
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    updatedAt: string;
+}, {
+    updatedAt: string;
+}>;
+export declare const ReadSessionOutputSchema: z.ZodObject<{
+    query: z.ZodString;
+    data: z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    data: JsonValue;
+}, {
+    query: string;
+    data: JsonValue;
+}>;
+export declare const ReadSessionSchemaOutputSchema: z.ZodObject<{
+    query: z.ZodLiteral<"$schema">;
+    schema: z.ZodObject<{
+        description: z.ZodString;
+        mainSections: z.ZodRecord<z.ZodString, z.ZodString>;
+        commonQueries: z.ZodRecord<z.ZodString, z.ZodString>;
+        updatePatterns: z.ZodRecord<z.ZodString, z.ZodString>;
+        fullSchemaDoc: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        mainSections: Record<string, string>;
+        commonQueries: Record<string, string>;
+        updatePatterns: Record<string, string>;
+        fullSchemaDoc: string;
+    }, {
+        description: string;
+        mainSections: Record<string, string>;
+        commonQueries: Record<string, string>;
+        updatePatterns: Record<string, string>;
+        fullSchemaDoc: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    schema: {
+        description: string;
+        mainSections: Record<string, string>;
+        commonQueries: Record<string, string>;
+        updatePatterns: Record<string, string>;
+        fullSchemaDoc: string;
+    };
+    query: "$schema";
+}, {
+    schema: {
+        description: string;
+        mainSections: Record<string, string>;
+        commonQueries: Record<string, string>;
+        updatePatterns: Record<string, string>;
+        fullSchemaDoc: string;
+    };
+    query: "$schema";
+}>;
+export declare const OpenDashboardOutputSchema: z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>;

package/dist/mcp/output-schemas.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenDashboardOutputSchema = exports.ReadSessionSchemaOutputSchema = exports.ReadSessionOutputSchema = exports.UpdateSessionOutputSchema = exports.CreateSessionOutputSchema = exports.V2WorkflowInspectOutputSchema = exports.V2WorkflowListOutputSchema = exports.V2WorkflowListItemSchema = exports.WorkflowGetSchemaOutputSchema = exports.WorkflowValidateJsonOutputSchema = exports.WorkflowNextOutputSchema = exports.WorkflowGetOutputSchema = exports.WorkflowListOutputSchema = exports.WorkflowSummarySchema = exports.JsonValueSchema = void 0;
+const zod_1 = require("zod");
+const state_js_1 = require("../domain/execution/state.js");
+const JsonPrimitiveSchema = zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean(), zod_1.z.null()]);
+exports.JsonValueSchema = zod_1.z.lazy(() => zod_1.z.union([JsonPrimitiveSchema, zod_1.z.array(exports.JsonValueSchema), zod_1.z.record(exports.JsonValueSchema)]));
+exports.WorkflowSummarySchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    version: zod_1.z.string(),
+});
+exports.WorkflowListOutputSchema = zod_1.z.object({
+    workflows: zod_1.z.array(exports.WorkflowSummarySchema),
+});
+exports.WorkflowGetOutputSchema = zod_1.z.object({
+    workflow: exports.JsonValueSchema,
+});
+exports.WorkflowNextOutputSchema = zod_1.z.object({
+    state: state_js_1.ExecutionStateSchema,
+    next: exports.JsonValueSchema.nullable(),
+    isComplete: zod_1.z.boolean(),
+});
+exports.WorkflowValidateJsonOutputSchema = zod_1.z.object({
+    valid: zod_1.z.boolean(),
+    errors: zod_1.z
+        .array(zod_1.z.object({
+        message: zod_1.z.string(),
+        path: zod_1.z.string().optional(),
+    }))
+        .optional(),
+    suggestions: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.WorkflowGetSchemaOutputSchema = zod_1.z.object({
+    schema: exports.JsonValueSchema,
+    metadata: zod_1.z.object({
+        version: zod_1.z.string(),
+        description: zod_1.z.string(),
+        usage: zod_1.z.string(),
+        schemaPath: zod_1.z.string(),
+    }),
+    commonPatterns: zod_1.z.object({
+        basicWorkflow: zod_1.z.record(zod_1.z.string()),
+        stepStructure: zod_1.z.record(zod_1.z.string()),
+    }),
+});
+exports.V2WorkflowListItemSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1),
+    name: zod_1.z.string().min(1),
+    description: zod_1.z.string().min(1),
+    version: zod_1.z.string().min(1),
+    kind: zod_1.z.literal('workflow'),
+    workflowHash: zod_1.z.string().nullable(),
+});
+exports.V2WorkflowListOutputSchema = zod_1.z.object({
+    workflows: zod_1.z.array(exports.V2WorkflowListItemSchema),
+});
+exports.V2WorkflowInspectOutputSchema = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1),
+    workflowHash: zod_1.z.string().min(1),
+    mode: zod_1.z.enum(['metadata', 'preview']),
+    compiled: exports.JsonValueSchema,
+});
+exports.CreateSessionOutputSchema = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1),
+    workflowId: zod_1.z.string().min(1),
+    path: zod_1.z.string(),
+    dashboardUrl: zod_1.z.string().nullable(),
+    createdAt: zod_1.z.string(),
+});
+exports.UpdateSessionOutputSchema = zod_1.z.object({
+    updatedAt: zod_1.z.string(),
+});
+exports.ReadSessionOutputSchema = zod_1.z.object({
+    query: zod_1.z.string(),
+    data: exports.JsonValueSchema,
+});
+exports.ReadSessionSchemaOutputSchema = zod_1.z.object({
+    query: zod_1.z.literal('$schema'),
+    schema: zod_1.z.object({
+        description: zod_1.z.string(),
+        mainSections: zod_1.z.record(zod_1.z.string()),
+        commonQueries: zod_1.z.record(zod_1.z.string()),
+        updatePatterns: zod_1.z.record(zod_1.z.string()),
+        fullSchemaDoc: zod_1.z.string(),
+    }),
+});
+exports.OpenDashboardOutputSchema = zod_1.z.object({
+    url: zod_1.z.string(),
+});

package/dist/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import type { ToolContext } from './types.js';
+export declare function createToolContext(): ToolContext;
+export declare function startServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,258 @@
+"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.createToolContext = createToolContext;
+exports.startServer = startServer;
+const zod_to_json_schema_js_1 = require("./zod-to-json-schema.js");
+const container_js_1 = require("../di/container.js");
+const tokens_js_1 = require("../di/tokens.js");
+const tool_factory_js_1 = require("./tool-factory.js");
+const workflow_next_prevalidate_js_1 = require("./validation/workflow-next-prevalidate.js");
+const bounded_json_js_1 = require("./validation/bounded-json.js");
+const tools_js_1 = require("./tools.js");
+const tool_registry_js_1 = require("./v2/tool-registry.js");
+const workflow_js_1 = require("./handlers/workflow.js");
+const session_js_1 = require("./handlers/session.js");
+function toMcpResult(result) {
+    switch (result.type) {
+        case 'success':
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
+            };
+        case 'error':
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: result.message,
+                            code: result.code,
+                            ...(result.suggestion && { suggestion: result.suggestion }),
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+    }
+}
+function createToolContext() {
+    const workflowService = container_js_1.container.resolve(tokens_js_1.DI.Services.Workflow);
+    const featureFlags = container_js_1.container.resolve(tokens_js_1.DI.Infra.FeatureFlags);
+    let sessionManager = null;
+    let httpServer = null;
+    if (featureFlags.isEnabled('sessionTools')) {
+        sessionManager = container_js_1.container.resolve(tokens_js_1.DI.Infra.SessionManager);
+        httpServer = container_js_1.container.resolve(tokens_js_1.DI.Infra.HttpServer);
+        console.error('[FeatureFlags] Session tools enabled');
+    }
+    else {
+        console.error('[FeatureFlags] Session tools disabled (enable with WORKRAIL_ENABLE_SESSION_TOOLS=true)');
+    }
+    return {
+        workflowService,
+        featureFlags,
+        sessionManager,
+        httpServer,
+    };
+}
+function toMcpTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: (0, zod_to_json_schema_js_1.zodToJsonSchema)(tool.inputSchema),
+        annotations: tool.annotations,
+    };
+}
+function createHandler(schema, handler) {
+    return async (args, ctx) => {
+        const parseResult = schema.safeParse(args);
+        if (!parseResult.success) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Invalid input',
+                            code: 'VALIDATION_ERROR',
+                            details: parseResult.error.errors.map(e => ({
+                                path: e.path.join('.'),
+                                message: e.message,
+                            })),
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+        return toMcpResult(await handler(parseResult.data, ctx));
+    };
+}
+function createValidatingHandler(schema, preValidate, handler) {
+    return async (args, ctx) => {
+        const pre = preValidate(args);
+        if (!pre.ok) {
+            const bounded = pre.correctTemplate ? (0, bounded_json_js_1.toBoundedJsonValue)(pre.correctTemplate, 512) : undefined;
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: pre.message,
+                            code: pre.code,
+                            ...(bounded ? { correctTemplate: bounded } : {}),
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+        return createHandler(schema, handler)(args, ctx);
+    };
+}
+async function startServer() {
+    await (0, container_js_1.bootstrap)({ runtimeMode: { kind: 'production' } });
+    const ctx = createToolContext();
+    const descriptionProvider = container_js_1.container.resolve(tokens_js_1.DI.Mcp.DescriptionProvider);
+    const buildTool = (0, tool_factory_js_1.createToolFactory)(descriptionProvider);
+    const workflowListTool = buildTool({
+        name: 'workflow_list',
+        title: tools_js_1.WORKFLOW_TOOL_TITLES.workflow_list,
+        inputSchema: tools_js_1.WorkflowListInput,
+        annotations: tools_js_1.WORKFLOW_TOOL_ANNOTATIONS.workflow_list,
+    });
+    const workflowGetTool = buildTool({
+        name: 'workflow_get',
+        title: tools_js_1.WORKFLOW_TOOL_TITLES.workflow_get,
+        inputSchema: tools_js_1.WorkflowGetInput,
+        annotations: tools_js_1.WORKFLOW_TOOL_ANNOTATIONS.workflow_get,
+    });
+    const workflowNextTool = buildTool({
+        name: 'workflow_next',
+        title: tools_js_1.WORKFLOW_TOOL_TITLES.workflow_next,
+        inputSchema: tools_js_1.WorkflowNextInput,
+        annotations: tools_js_1.WORKFLOW_TOOL_ANNOTATIONS.workflow_next,
+    });
+    const workflowValidateJsonTool = buildTool({
+        name: 'workflow_validate_json',
+        title: tools_js_1.WORKFLOW_TOOL_TITLES.workflow_validate_json,
+        inputSchema: tools_js_1.WorkflowValidateJsonInput,
+        annotations: tools_js_1.WORKFLOW_TOOL_ANNOTATIONS.workflow_validate_json,
+    });
+    const workflowGetSchemaTool = buildTool({
+        name: 'workflow_get_schema',
+        title: tools_js_1.WORKFLOW_TOOL_TITLES.workflow_get_schema,
+        inputSchema: tools_js_1.WorkflowGetSchemaInput,
+        annotations: tools_js_1.WORKFLOW_TOOL_ANNOTATIONS.workflow_get_schema,
+    });
+    const { Server } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/index.js')));
+    const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
+    const { CallToolRequestSchema, ListToolsRequestSchema, } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/types.js')));
+    const server = new Server({
+        name: 'workrail-server',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    const tools = [
+        toMcpTool(workflowListTool),
+        toMcpTool(workflowGetTool),
+        toMcpTool(workflowNextTool),
+        toMcpTool(workflowValidateJsonTool),
+        toMcpTool(workflowGetSchemaTool),
+    ];
+    if (ctx.featureFlags.isEnabled('sessionTools')) {
+        tools.push(toMcpTool(tools_js_1.createSessionTool), toMcpTool(tools_js_1.updateSessionTool), toMcpTool(tools_js_1.readSessionTool), toMcpTool(tools_js_1.openDashboardTool));
+    }
+    const v2Registry = ctx.featureFlags.isEnabled('v2Tools') ? (0, tool_registry_js_1.buildV2ToolRegistry)(buildTool) : null;
+    if (v2Registry) {
+        console.error('[FeatureFlags] v2 tools enabled (enable with WORKRAIL_ENABLE_V2_TOOLS=true)');
+        tools.push(...v2Registry.tools.map(toMcpTool));
+    }
+    else {
+        console.error('[FeatureFlags] v2 tools disabled (enable with WORKRAIL_ENABLE_V2_TOOLS=true)');
+    }
+    const handlers = {
+        workflow_list: createHandler(tools_js_1.WorkflowListInput, workflow_js_1.handleWorkflowList),
+        workflow_get: createHandler(tools_js_1.WorkflowGetInput, workflow_js_1.handleWorkflowGet),
+        workflow_next: createValidatingHandler(tools_js_1.WorkflowNextInput, workflow_next_prevalidate_js_1.preValidateWorkflowNextArgs, workflow_js_1.handleWorkflowNext),
+        workflow_validate_json: createHandler(tools_js_1.WorkflowValidateJsonInput, workflow_js_1.handleWorkflowValidateJson),
+        workflow_get_schema: createHandler(tools_js_1.WorkflowGetSchemaInput, workflow_js_1.handleWorkflowGetSchema),
+        workrail_create_session: createHandler(tools_js_1.createSessionTool.inputSchema, session_js_1.handleCreateSession),
+        workrail_update_session: createHandler(tools_js_1.updateSessionTool.inputSchema, session_js_1.handleUpdateSession),
+        workrail_read_session: createHandler(tools_js_1.readSessionTool.inputSchema, session_js_1.handleReadSession),
+        workrail_open_dashboard: createHandler(tools_js_1.openDashboardTool.inputSchema, session_js_1.handleOpenDashboard),
+    };
+    if (v2Registry) {
+        for (const [name, entry] of Object.entries(v2Registry.handlers)) {
+            handlers[name] = createHandler(entry.schema, entry.handler);
+        }
+    }
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const handler = handlers[name];
+        if (!handler) {
+            return {
+                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        return handler(args ?? {}, ctx);
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('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' }));
+    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/tool-description-provider.d.ts

@@ -0,0 +1,16 @@
+import type { IFeatureFlagProvider } from '../config/feature-flags.js';
+import type { DescriptionMode, WorkflowToolName } from './types/tool-description-types.js';
+export interface IToolDescriptionProvider {
+    readonly mode: DescriptionMode;
+    getDescription(toolName: WorkflowToolName): string;
+}
+export declare class ToolDescriptionProvider implements IToolDescriptionProvider {
+    readonly mode: DescriptionMode;
+    constructor(featureFlags: IFeatureFlagProvider);
+    getDescription(toolName: WorkflowToolName): string;
+}
+export declare class StaticToolDescriptionProvider implements IToolDescriptionProvider {
+    readonly mode: DescriptionMode;
+    constructor(mode: DescriptionMode);
+    getDescription(toolName: WorkflowToolName): string;
+}