@exaudeus/workrail 0.8.6 → 0.9.0

package/dist/mcp/v2/tools.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { ToolAnnotations } from '../tool-factory.js';
+export declare const V2ListWorkflowsInput: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type V2ListWorkflowsInput = z.infer<typeof V2ListWorkflowsInput>;
+export declare const V2InspectWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<["metadata", "preview"]>>;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+    mode: "metadata" | "preview";
+}, {
+    workflowId: string;
+    mode?: "metadata" | "preview" | undefined;
+}>;
+export type V2InspectWorkflowInput = z.infer<typeof V2InspectWorkflowInput>;
+export declare const V2_TOOL_TITLES: {
+    readonly list_workflows: "List Workflows (v2)";
+    readonly inspect_workflow: "Inspect Workflow (v2)";
+};
+export declare const V2_TOOL_ANNOTATIONS: Readonly<Record<keyof typeof V2_TOOL_TITLES, ToolAnnotations>>;

package/dist/mcp/v2/tools.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2_TOOL_ANNOTATIONS = exports.V2_TOOL_TITLES = exports.V2InspectWorkflowInput = exports.V2ListWorkflowsInput = void 0;
+const zod_1 = require("zod");
+exports.V2ListWorkflowsInput = zod_1.z.object({});
+exports.V2InspectWorkflowInput = zod_1.z.object({
+    workflowId: zod_1.z.string().min(1).describe('The workflow ID to inspect'),
+    mode: zod_1.z.enum(['metadata', 'preview']).default('preview').describe('Detail level'),
+});
+exports.V2_TOOL_TITLES = {
+    list_workflows: 'List Workflows (v2)',
+    inspect_workflow: 'Inspect Workflow (v2)',
+};
+exports.V2_TOOL_ANNOTATIONS = {
+    list_workflows: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    inspect_workflow: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+};

package/dist/mcp/validation/bounded-json.d.ts

@@ -0,0 +1,3 @@
+export declare function byteLengthUtf8(input: string): number;
+export declare function toBoundedJsonString(value: unknown, maxBytes: number): string;
+export declare function toBoundedJsonValue(value: unknown, maxBytes: number): unknown | undefined;

package/dist/mcp/validation/bounded-json.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.byteLengthUtf8 = byteLengthUtf8;
+exports.toBoundedJsonString = toBoundedJsonString;
+exports.toBoundedJsonValue = toBoundedJsonValue;
+function byteLengthUtf8(input) {
+    return Buffer.byteLength(input, 'utf8');
+}
+function toBoundedJsonString(value, maxBytes) {
+    const json = JSON.stringify(value, null, 2);
+    if (byteLengthUtf8(json) <= maxBytes)
+        return json;
+    const buf = Buffer.from(json, 'utf8');
+    const truncated = buf.subarray(0, Math.max(0, maxBytes - 32)).toString('utf8');
+    return `${truncated}\n...truncated...\n`;
+}
+function toBoundedJsonValue(value, maxBytes) {
+    const json = toBoundedJsonString(value, maxBytes);
+    if (json.includes('...truncated...'))
+        return undefined;
+    return JSON.parse(json);
+}

package/dist/mcp/validation/workflow-next-prevalidate.d.ts

@@ -0,0 +1,9 @@
+export type PreValidateResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly code: 'VALIDATION_ERROR' | 'PRECONDITION_FAILED';
+    readonly message: string;
+    readonly correctTemplate?: unknown;
+};
+export declare function preValidateWorkflowNextArgs(args: unknown): PreValidateResult;

package/dist/mcp/validation/workflow-next-prevalidate.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preValidateWorkflowNextArgs = preValidateWorkflowNextArgs;
+function normalizeWorkflowIdForTemplate(value) {
+    if (typeof value !== 'string')
+        return '<workflowId>';
+    if (value.length === 0)
+        return '<workflowId>';
+    if (value.length > 64)
+        return '<workflowId>';
+    return value;
+}
+function variablesToContextTemplate(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return value;
+}
+function preValidateWorkflowNextArgs(args) {
+    if (args == null || typeof args !== 'object' || Array.isArray(args)) {
+        return { ok: false, code: 'VALIDATION_ERROR', message: 'Invalid input: expected a JSON object.' };
+    }
+    const a = args;
+    const suggestedContext = variablesToContextTemplate(a.variables);
+    if (!('workflowId' in a)) {
+        return { ok: false, code: 'VALIDATION_ERROR', message: 'Missing required field: workflowId.' };
+    }
+    if (!('state' in a)) {
+        return {
+            ok: false,
+            code: 'VALIDATION_ERROR',
+            message: 'Missing required field: state. For the first call, use { kind: "init" }.',
+            correctTemplate: {
+                workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
+                state: { kind: 'init' },
+                context: suggestedContext,
+            },
+        };
+    }
+    const state = a.state;
+    if (state == null || typeof state !== 'object' || Array.isArray(state)) {
+        return {
+            ok: false,
+            code: 'VALIDATION_ERROR',
+            message: 'Invalid state: expected an object with discriminator field "kind".',
+            correctTemplate: { kind: 'init' },
+        };
+    }
+    const kind = state.kind;
+    if (typeof kind !== 'string') {
+        return {
+            ok: false,
+            code: 'VALIDATION_ERROR',
+            message: 'Invalid state: missing state.kind. Valid values: "init" | "running" | "complete".',
+            correctTemplate: { kind: 'init' },
+        };
+    }
+    if (kind === 'running') {
+        const completed = state.completed;
+        const loopStack = state.loopStack;
+        if (!Array.isArray(completed) || !Array.isArray(loopStack)) {
+            return {
+                ok: false,
+                code: 'VALIDATION_ERROR',
+                message: 'Invalid state: state.kind="running" requires completed: string[] and loopStack: LoopFrame[].',
+                correctTemplate: { kind: 'running', completed: [], loopStack: [] },
+            };
+        }
+    }
+    if ('variables' in a && !('context' in a)) {
+        return {
+            ok: false,
+            code: 'VALIDATION_ERROR',
+            message: 'Unexpected top-level key: variables. Use context (object) for condition evaluation and loop inputs.',
+            correctTemplate: {
+                workflowId: normalizeWorkflowIdForTemplate(a.workflowId),
+                state: a.state,
+                ...(a.event ? { event: a.event } : {}),
+                context: suggestedContext,
+            },
+        };
+    }
+    return { ok: true };
+}

package/dist/mcp/zod-to-json-schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+type JsonSchema = {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    oneOf?: JsonSchema[];
+    enum?: string[];
+    const?: unknown;
+    default?: unknown;
+    description?: string;
+    pattern?: string;
+    minLength?: number;
+    additionalProperties?: boolean | JsonSchema;
+};
+export declare function zodToJsonSchema(schema: z.ZodType): JsonSchema;
+export {};

package/dist/mcp/zod-to-json-schema.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToJsonSchema = zodToJsonSchema;
+const zod_1 = require("zod");
+function zodToJsonSchema(schema) {
+    return convertZodType(schema);
+}
+function convertZodType(schema) {
+    if (schema instanceof zod_1.z.ZodDefault) {
+        const inner = convertZodType(schema._def.innerType);
+        return {
+            ...inner,
+            default: schema._def.defaultValue(),
+        };
+    }
+    if (schema instanceof zod_1.z.ZodOptional) {
+        return convertZodType(schema._def.innerType);
+    }
+    if (schema instanceof zod_1.z.ZodObject) {
+        const shape = schema._def.shape();
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+            properties[key] = convertZodType(value);
+            if (!(value instanceof zod_1.z.ZodOptional) && !(value instanceof zod_1.z.ZodDefault)) {
+                required.push(key);
+            }
+        }
+        const result = {
+            type: 'object',
+            properties,
+        };
+        if (required.length > 0) {
+            result.required = required;
+        }
+        result.additionalProperties = false;
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
+        const discriminator = schema._def.discriminator;
+        const options = schema._def.options;
+        return {
+            oneOf: options.map((opt) => {
+                const s = convertZodType(opt);
+                if (s.type !== 'object')
+                    return s;
+                const required = new Set(s.required ?? []);
+                required.add(discriminator);
+                return {
+                    ...s,
+                    required: Array.from(required),
+                };
+            }),
+        };
+    }
+    if (schema instanceof zod_1.z.ZodString) {
+        const result = { type: 'string' };
+        for (const check of schema._def.checks) {
+            if (check.kind === 'regex') {
+                result.pattern = check.regex.source;
+            }
+            if (check.kind === 'min') {
+                result.minLength = check.value;
+            }
+        }
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodNumber) {
+        const result = { type: 'number' };
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodBoolean) {
+        const result = { type: 'boolean' };
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodArray) {
+        const result = {
+            type: 'array',
+            items: convertZodType(schema._def.type),
+        };
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodEnum) {
+        const result = {
+            type: 'string',
+            enum: schema._def.values,
+        };
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodLiteral) {
+        const value = schema._def.value;
+        if (typeof value === 'string')
+            return { type: 'string', const: value };
+        if (typeof value === 'number')
+            return { type: 'number', const: value };
+        if (typeof value === 'boolean')
+            return { type: 'boolean', const: value };
+        if (value === null)
+            return { type: 'null', const: null };
+        return { const: value };
+    }
+    if (schema instanceof zod_1.z.ZodRecord) {
+        const result = {
+            type: 'object',
+            additionalProperties: true,
+        };
+        if (schema._def.description) {
+            result.description = schema._def.description;
+        }
+        return result;
+    }
+    if (schema instanceof zod_1.z.ZodUnknown || schema instanceof zod_1.z.ZodAny) {
+        return {};
+    }
+    if (schema instanceof zod_1.z.ZodEffects) {
+        return convertZodType(schema._def.schema);
+    }
+    return { type: 'object' };
+}

package/dist/mcp-server.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+export { startServer } from './mcp/server.js';