@hotmeshio/long-tail 0.1.3 → 0.1.5

package/build/system/mcp-servers/admin/tasks.js

@@ -0,0 +1,112 @@
+"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.registerTaskTools = registerTaskTools;
+const taskService = __importStar(require("../../../services/task"));
+const escalationService = __importStar(require("../../../services/escalation"));
+const schemas_1 = require("./schemas");
+function registerTaskTools(server) {
+    server.registerTool('find_tasks', {
+        title: 'Find Tasks',
+        description: 'Search tasks with optional filters. Returns task records with ' +
+            'workflow_id, status, workflow_type, and timestamps.',
+        inputSchema: schemas_1.findTasksSchema,
+    }, async (args) => {
+        const { tasks, total } = await taskService.listTasks({
+            status: args.status,
+            workflow_type: args.workflow_type,
+            workflow_id: args.workflow_id,
+            origin_id: args.origin_id,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: tasks.length,
+                        tasks: tasks.map((t) => ({
+                            id: t.id,
+                            workflow_id: t.workflow_id,
+                            workflow_type: t.workflow_type,
+                            status: t.status,
+                            priority: t.priority,
+                            origin_id: t.origin_id,
+                            created_at: t.created_at,
+                            completed_at: t.completed_at,
+                            error: t.error,
+                        })),
+                    }),
+                }],
+        };
+    });
+    server.registerTool('get_process_detail', {
+        title: 'Get Process Detail',
+        description: 'Get all tasks and escalations for a process (origin_id). ' +
+            'Returns the full history of a multi-step workflow execution.',
+        inputSchema: schemas_1.getProcessDetailSchema,
+    }, async (args) => {
+        const [tasks, escalations] = await Promise.all([
+            taskService.getProcessTasks(args.origin_id),
+            escalationService.getEscalationsByOriginId(args.origin_id),
+        ]);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        origin_id: args.origin_id,
+                        task_count: tasks.length,
+                        escalation_count: escalations.length,
+                        tasks: tasks.map((t) => ({
+                            id: t.id,
+                            workflow_id: t.workflow_id,
+                            workflow_type: t.workflow_type,
+                            status: t.status,
+                            created_at: t.created_at,
+                            completed_at: t.completed_at,
+                        })),
+                        escalations: escalations.map((e) => ({
+                            id: e.id,
+                            type: e.type,
+                            role: e.role,
+                            status: e.status,
+                            created_at: e.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/users.d.ts

@@ -0,0 +1,5 @@
+/**
+ * User and role management tools — mirrors routes/users.ts + routes/roles.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerUserTools(server: McpServer): void;

package/build/system/mcp-servers/admin/users.js

@@ -0,0 +1,167 @@
+"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.registerUserTools = registerUserTools;
+const userService = __importStar(require("../../../services/user"));
+const roleService = __importStar(require("../../../services/role"));
+const schemas_1 = require("./schemas");
+function registerUserTools(server) {
+    // mirrors GET /api/users
+    server.registerTool('list_users', {
+        title: 'List Users',
+        description: 'List user accounts with optional role and status filters.',
+        inputSchema: schemas_1.listUsersSchema,
+    }, async (args) => {
+        const { users, total } = await userService.listUsers({
+            role: args.role,
+            status: args.status,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: users.length,
+                        users: users.map((u) => ({
+                            id: u.id,
+                            external_id: u.external_id,
+                            display_name: u.display_name,
+                            account_type: u.account_type,
+                            status: u.status,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/users
+    server.registerTool('create_user', {
+        title: 'Create User',
+        description: 'Create a new user account with optional roles. The user can then ' +
+            'claim and resolve escalations for their assigned roles.',
+        inputSchema: schemas_1.createUserSchema,
+    }, async (args) => {
+        const user = await userService.createUser({
+            external_id: args.external_id,
+            display_name: args.display_name,
+            email: args.email,
+            roles: args.roles,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(user) }],
+        };
+    });
+    // mirrors POST /api/users/:id/roles
+    server.registerTool('add_user_role', {
+        title: 'Add User Role',
+        description: 'Assign a role to a user. Role type: member, admin, or superadmin.',
+        inputSchema: schemas_1.addUserRoleSchema,
+    }, async (args) => {
+        const result = await userService.addUserRole(args.user_id, args.role, args.type);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    // mirrors DELETE /api/users/:id/roles/:role
+    server.registerTool('remove_user_role', {
+        title: 'Remove User Role',
+        description: 'Remove a role from a user.',
+        inputSchema: schemas_1.removeUserRoleSchema,
+    }, async (args) => {
+        const removed = await userService.removeUserRole(args.user_id, args.role);
+        if (!removed) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Role not found' }) }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ removed: true }) }],
+        };
+    });
+    // mirrors GET /api/roles
+    server.registerTool('list_roles', {
+        title: 'List Roles',
+        description: 'List all distinct roles known to the system.',
+        inputSchema: schemas_1.listRolesSchema,
+    }, async (_args) => {
+        const roles = await roleService.listDistinctRoles();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ roles }) }],
+        };
+    });
+    // mirrors POST /api/roles
+    server.registerTool('create_role', {
+        title: 'Create Role',
+        description: 'Create a new role. Role names must be lowercase alphanumeric ' +
+            'with hyphens/underscores, starting with a letter.',
+        inputSchema: schemas_1.createRoleSchema,
+    }, async (args) => {
+        const trimmed = args.role.trim().toLowerCase();
+        if (!/^[a-z][a-z0-9_-]*$/.test(trimmed)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: 'Role must start with a letter and contain only lowercase letters, numbers, hyphens, and underscores' }),
+                    }],
+                isError: true,
+            };
+        }
+        await roleService.createRole(trimmed);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ role: trimmed, created: true }) }],
+        };
+    });
+    // mirrors POST /api/roles/escalation-chains
+    server.registerTool('add_escalation_chain', {
+        title: 'Add Escalation Chain',
+        description: 'Define an escalation path from one role to another. Users with ' +
+            'the source role can escalate work to the target role.',
+        inputSchema: schemas_1.addEscalationChainSchema,
+    }, async (args) => {
+        await roleService.addEscalationChain(args.source_role, args.target_role);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        created: true,
+                        source_role: args.source_role,
+                        target_role: args.target_role,
+                    }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/workflow-config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Workflow configuration tools — mirrors routes/workflows/config.ts
+ *
+ * Certifying a workflow creates an lt_config_workflows entry, which
+ * activates the interceptor for task tracking, escalation chains,
+ * and the never-fail guarantee. De-certifying removes it.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerWorkflowConfigTools(server: McpServer): void;

package/build/system/mcp-servers/admin/workflow-config.js

@@ -0,0 +1,118 @@
+"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.registerWorkflowConfigTools = registerWorkflowConfigTools;
+const configService = __importStar(require("../../../services/config"));
+const ltconfig_1 = require("../../../modules/ltconfig");
+const cron_1 = require("../../../services/cron");
+const schemas_1 = require("./schemas");
+function registerWorkflowConfigTools(server) {
+    // mirrors GET /api/workflows/config
+    server.registerTool('list_workflow_configs', {
+        title: 'List Workflow Configs',
+        description: 'List all certified workflow configurations. Shows workflow type, ' +
+            'task queue, roles, invocable flag, and description.',
+        inputSchema: schemas_1.listWorkflowConfigsSchema,
+    }, async (_args) => {
+        const configs = await configService.listWorkflowConfigs();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        count: configs.length,
+                        workflows: configs.map((c) => ({
+                            workflow_type: c.workflow_type,
+                            invocable: c.invocable,
+                            task_queue: c.task_queue,
+                            default_role: c.default_role,
+                            description: c.description,
+                            roles: c.roles,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors PUT /api/workflows/:type/config
+    server.registerTool('upsert_workflow_config', {
+        title: 'Upsert Workflow Config',
+        description: 'Create or replace a workflow configuration (certify). Activates the ' +
+            'interceptor for task tracking, escalation chains, and invocation controls. ' +
+            'Invalidates the config cache and restarts cron if schedule changes.',
+        inputSchema: schemas_1.upsertWorkflowConfigSchema,
+    }, async (args) => {
+        const config = await configService.upsertWorkflowConfig({
+            workflow_type: args.workflow_type,
+            invocable: args.invocable,
+            task_queue: args.task_queue,
+            default_role: args.default_role,
+            description: args.description,
+            execute_as: args.execute_as,
+            roles: args.roles,
+            invocation_roles: args.invocation_roles,
+            consumes: args.consumes,
+            tool_tags: args.tool_tags,
+            envelope_schema: args.envelope_schema,
+            resolver_schema: args.resolver_schema,
+            cron_schedule: args.cron_schedule,
+        });
+        ltconfig_1.ltConfig.invalidate();
+        await cron_1.cronRegistry.restartCron(config);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(config) }],
+        };
+    });
+    // mirrors DELETE /api/workflows/:type/config
+    server.registerTool('delete_workflow_config', {
+        title: 'Delete Workflow Config',
+        description: 'De-certify a workflow by removing its lt_config_workflows entry. ' +
+            'The workflow remains durable but loses interceptor wrapping.',
+        inputSchema: schemas_1.deleteWorkflowConfigSchema,
+    }, async (args) => {
+        const deleted = await configService.deleteWorkflowConfig(args.workflow_type);
+        if (!deleted) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow config not found' }) }],
+                isError: true,
+            };
+        }
+        ltconfig_1.ltConfig.invalidate();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ deleted: true, workflow_type: args.workflow_type }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/workflows.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Workflow discovery and invocation tools — mirrors routes/workflows/discovery.ts
+ * and routes/workflows/invocation.ts
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerWorkflowTools(server: McpServer): void;

package/build/system/mcp-servers/admin/workflows.js

@@ -0,0 +1,138 @@
+"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.registerWorkflowTools = registerWorkflowTools;
+const configService = __importStar(require("../../../services/config"));
+const registry_1 = require("../../../services/workers/registry");
+const workflow_invocation_1 = require("../../../services/workflow-invocation");
+const workers_1 = require("../../../workers");
+const schemas_1 = require("./schemas");
+function registerWorkflowTools(server) {
+    // mirrors GET /api/workflows/discovered
+    server.registerTool('list_discovered_workflows', {
+        title: 'List Discovered Workflows',
+        description: 'Unified list of all known workflows: active workers, historical ' +
+            'entities, and registered configs merged together. Shows which are ' +
+            'certified (registered), active, invocable, and their roles.',
+        inputSchema: schemas_1.listDiscoveredWorkflowsSchema,
+    }, async (args) => {
+        const activeWorkers = (0, registry_1.getRegisteredWorkers)();
+        const configs = await configService.listWorkflowConfigs();
+        const configMap = new Map(configs.map((c) => [c.workflow_type, c]));
+        const allTypes = new Set();
+        for (const [name] of activeWorkers)
+            allTypes.add(name);
+        for (const c of configs)
+            allTypes.add(c.workflow_type);
+        const workflows = [...allTypes]
+            .filter((t) => args.include_system || !registry_1.SYSTEM_WORKFLOWS.has(t))
+            .sort()
+            .map((wt) => {
+            const config = configMap.get(wt);
+            const worker = activeWorkers.get(wt);
+            return {
+                workflow_type: wt,
+                task_queue: config?.task_queue ?? worker?.taskQueue ?? null,
+                registered: !!config,
+                active: !!worker,
+                invocable: config?.invocable ?? false,
+                description: config?.description ?? null,
+                roles: config?.roles ?? [],
+            };
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ count: workflows.length, workflows }),
+                }],
+        };
+    });
+    // mirrors POST /api/workflows/:type/invoke
+    server.registerTool('invoke_workflow', {
+        title: 'Invoke Workflow',
+        description: 'Start a certified workflow by type. The workflow must have invocable=true ' +
+            'in its config. Returns the workflow ID immediately; the workflow runs ' +
+            'durably in the background.',
+        inputSchema: schemas_1.invokeWorkflowSchema,
+    }, async (args) => {
+        const result = await (0, workflow_invocation_1.invokeWorkflow)({
+            workflowType: args.workflow_type,
+            data: args.data,
+            metadata: args.metadata,
+            executeAs: args.execute_as,
+            auth: { userId: 'lt-system', role: 'superadmin' },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ workflow_id: result.workflowId, message: 'Workflow started' }),
+                }],
+        };
+    });
+    // mirrors GET /api/workflows/:workflowId/status + /result
+    server.registerTool('get_workflow_status', {
+        title: 'Get Workflow Status',
+        description: 'Check the status and result of a workflow execution. Returns ' +
+            'status (0=complete, positive=running) and the result if complete.',
+        inputSchema: schemas_1.getWorkflowStatusSchema,
+    }, async (args) => {
+        const { getTaskByWorkflowId } = await Promise.resolve().then(() => __importStar(require('../../../services/task')));
+        const task = await getTaskByWorkflowId(args.workflow_id);
+        if (!task) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow not found' }) }],
+                isError: true,
+            };
+        }
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(task.task_queue || 'long-tail-system', task.workflow_type, args.workflow_id);
+        const status = await handle.status();
+        if (status !== 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ workflow_id: args.workflow_id, status: 'running' }),
+                    }],
+            };
+        }
+        const result = await handle.result();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ workflow_id: args.workflow_id, status: 'complete', result }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/yaml-workflows.d.ts

@@ -0,0 +1,8 @@
+/**
+ * YAML workflow (pipeline) tools — mirrors routes/yaml-workflows/
+ *
+ * Replaces both the workflow-compiler server (compile + deploy)
+ * and the mcp-workflows server (list + get + invoke).
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerYamlWorkflowTools(server: McpServer): void;