@hotmeshio/long-tail 0.1.4 → 0.1.5

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

@@ -0,0 +1,146 @@
+"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.registerMcpServerTools = registerMcpServerTools;
+const mcpDb = __importStar(require("../../../services/mcp/db"));
+const mcp_1 = require("../../../services/mcp");
+const schemas_1 = require("./schemas");
+function registerMcpServerTools(server) {
+    // mirrors GET /api/mcp/servers
+    server.registerTool('list_mcp_servers', {
+        title: 'List MCP Servers',
+        description: 'List registered MCP servers with optional filters by status, tags, ' +
+            'or search term. Returns server name, status, tags, and tool count.',
+        inputSchema: schemas_1.listMcpServersSchema,
+    }, async (args) => {
+        const tagsArray = args.tags
+            ? args.tags.split(',').map((t) => t.trim()).filter(Boolean)
+            : undefined;
+        const { servers, total } = await mcpDb.listMcpServers({
+            status: args.status,
+            tags: tagsArray,
+            search: args.search,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: servers.length,
+                        servers: servers.map((s) => ({
+                            id: s.id,
+                            name: s.name,
+                            description: s.description,
+                            status: s.status,
+                            tags: s.tags,
+                            auto_connect: s.auto_connect,
+                            tool_count: s.tool_manifest?.length ?? 0,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors PUT /api/mcp/servers/:id
+    server.registerTool('update_mcp_server', {
+        title: 'Update MCP Server',
+        description: 'Update an MCP server registration. Use this to change tags ' +
+            '(which controls tool discovery scope), description, or auto_connect.',
+        inputSchema: schemas_1.updateMcpServerSchema,
+    }, async (args) => {
+        const { id, ...updates } = args;
+        const updated = await mcpDb.updateMcpServer(id, updates);
+        if (!updated) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'MCP server not found' }) }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        updated: true,
+                        server: { id: updated.id, name: updated.name, tags: updated.tags, status: updated.status },
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/mcp/servers/:id/connect
+    server.registerTool('connect_mcp_server', {
+        title: 'Connect MCP Server',
+        description: 'Connect to a registered MCP server. Re-establishes the transport ' +
+            'and refreshes the tool manifest.',
+        inputSchema: schemas_1.connectMcpServerSchema,
+    }, async (args) => {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'MCP adapter not registered' }) }],
+                isError: true,
+            };
+        }
+        await adapter.connectClient(args.id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ connected: true, server_id: args.id }),
+                }],
+        };
+    });
+    // mirrors POST /api/mcp/servers/:id/disconnect
+    server.registerTool('disconnect_mcp_server', {
+        title: 'Disconnect MCP Server',
+        description: 'Disconnect from an MCP server. The server remains registered ' +
+            'but its tools become unavailable until reconnected.',
+        inputSchema: schemas_1.disconnectMcpServerSchema,
+    }, async (args) => {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'MCP adapter not registered' }) }],
+                isError: true,
+            };
+        }
+        await adapter.disconnectClient(args.id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ disconnected: true, server_id: args.id }),
+                }],
+        };
+    });
+}

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

@@ -0,0 +1,411 @@
+/**
+ * Zod schemas for the admin MCP server tools.
+ *
+ * Each schema mirrors the exact parameter shape of the corresponding
+ * REST API route handler. When a route accepts `req.query.status`,
+ * the schema has `status: z.string().optional()`. When a route
+ * reads `req.body.roles`, the schema has `roles: z.array(...)`.
+ *
+ * Schemas are extracted here (rather than inline) to avoid TS2589
+ * deep-instantiation errors in the registerTool() generic.
+ */
+import { z } from 'zod';
+export declare const findTasksSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    workflow_type: z.ZodOptional<z.ZodString>;
+    workflow_id: z.ZodOptional<z.ZodString>;
+    origin_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    status?: string | undefined;
+    workflow_type?: string | undefined;
+    workflow_id?: string | undefined;
+    origin_id?: string | undefined;
+}, {
+    status?: string | undefined;
+    workflow_type?: string | undefined;
+    limit?: number | undefined;
+    workflow_id?: string | undefined;
+    origin_id?: string | undefined;
+    offset?: number | undefined;
+}>;
+export declare const getProcessDetailSchema: z.ZodObject<{
+    origin_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    origin_id: string;
+}, {
+    origin_id: string;
+}>;
+export declare const findEscalationsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["pending", "resolved"]>>;
+    role: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    role?: string | undefined;
+    status?: "pending" | "resolved" | undefined;
+    type?: string | undefined;
+    priority?: number | undefined;
+}, {
+    role?: string | undefined;
+    status?: "pending" | "resolved" | undefined;
+    type?: string | undefined;
+    priority?: number | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const getEscalationStatsSchema: z.ZodObject<{
+    period: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    period?: string | undefined;
+}, {
+    period?: string | undefined;
+}>;
+export declare const claimEscalationSchema: z.ZodObject<{
+    id: z.ZodString;
+    duration_minutes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    duration_minutes: number;
+}, {
+    id: string;
+    duration_minutes?: number | undefined;
+}>;
+export declare const releaseExpiredClaimsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const bulkTriageSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString, "many">;
+    hint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    ids: string[];
+    hint?: string | undefined;
+}, {
+    ids: string[];
+    hint?: string | undefined;
+}>;
+export declare const listWorkflowConfigsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const upsertWorkflowConfigSchema: z.ZodObject<{
+    workflow_type: z.ZodString;
+    invocable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    task_queue: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    default_role: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    description: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    execute_as: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    roles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    invocation_roles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    consumes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    tool_tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    envelope_schema: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    resolver_schema: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    cron_schedule: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    workflow_type: string;
+    invocable: boolean;
+    task_queue: string | null;
+    default_role: string;
+    description: string | null;
+    roles: string[];
+    invocation_roles: string[];
+    consumes: string[];
+    tool_tags: string[];
+    envelope_schema: Record<string, any> | null;
+    resolver_schema: Record<string, any> | null;
+    cron_schedule: string | null;
+    execute_as: string | null;
+}, {
+    workflow_type: string;
+    invocable?: boolean | undefined;
+    task_queue?: string | null | undefined;
+    default_role?: string | undefined;
+    description?: string | null | undefined;
+    roles?: string[] | undefined;
+    invocation_roles?: string[] | undefined;
+    consumes?: string[] | undefined;
+    tool_tags?: string[] | undefined;
+    envelope_schema?: Record<string, any> | null | undefined;
+    resolver_schema?: Record<string, any> | null | undefined;
+    cron_schedule?: string | null | undefined;
+    execute_as?: string | null | undefined;
+}>;
+export declare const deleteWorkflowConfigSchema: z.ZodObject<{
+    workflow_type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    workflow_type: string;
+}, {
+    workflow_type: string;
+}>;
+export declare const listDiscoveredWorkflowsSchema: z.ZodObject<{
+    include_system: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    include_system: boolean;
+}, {
+    include_system?: boolean | undefined;
+}>;
+export declare const invokeWorkflowSchema: z.ZodObject<{
+    workflow_type: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodAny>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    execute_as: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, any>;
+    workflow_type: string;
+    execute_as?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    data: Record<string, any>;
+    workflow_type: string;
+    execute_as?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export declare const getWorkflowStatusSchema: z.ZodObject<{
+    workflow_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    workflow_id: string;
+}, {
+    workflow_id: string;
+}>;
+export declare const listMcpServersSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    status?: string | undefined;
+    search?: string | undefined;
+    tags?: string | undefined;
+}, {
+    status?: string | undefined;
+    search?: string | undefined;
+    tags?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const updateMcpServerSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    auto_connect: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    auto_connect?: boolean | undefined;
+    tags?: string[] | undefined;
+}, {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    auto_connect?: boolean | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare const connectMcpServerSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const disconnectMcpServerSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const listYamlWorkflowsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    source_workflow_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    status?: string | undefined;
+    search?: string | undefined;
+    app_id?: string | undefined;
+    source_workflow_id?: string | undefined;
+}, {
+    status?: string | undefined;
+    search?: string | undefined;
+    limit?: number | undefined;
+    app_id?: string | undefined;
+    source_workflow_id?: string | undefined;
+    offset?: number | undefined;
+}>;
+export declare const getYamlWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const createYamlWorkflowSchema: z.ZodObject<{
+    workflow_id: z.ZodString;
+    task_queue: z.ZodString;
+    workflow_name: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    app_id: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    compilation_feedback: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    task_queue: string;
+    workflow_id: string;
+    workflow_name: string;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    app_id?: string | undefined;
+    compilation_feedback?: string | undefined;
+}, {
+    name: string;
+    task_queue: string;
+    workflow_id: string;
+    workflow_name: string;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    app_id?: string | undefined;
+    compilation_feedback?: string | undefined;
+}>;
+export declare const deployYamlWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const invokeYamlWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    sync: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    data: Record<string, any>;
+    id: string;
+    sync: boolean;
+    timeout?: number | undefined;
+}, {
+    id: string;
+    data?: Record<string, any> | undefined;
+    timeout?: number | undefined;
+    sync?: boolean | undefined;
+}>;
+export declare const listUsersSchema: z.ZodObject<{
+    role: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    offset: number;
+    role?: string | undefined;
+    status?: string | undefined;
+}, {
+    role?: string | undefined;
+    status?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export declare const createUserSchema: z.ZodObject<{
+    external_id: z.ZodString;
+    display_name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    roles: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        type: z.ZodEnum<["superadmin", "admin", "member"]>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        type: "superadmin" | "admin" | "member";
+    }, {
+        role: string;
+        type: "superadmin" | "admin" | "member";
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    roles: {
+        role: string;
+        type: "superadmin" | "admin" | "member";
+    }[];
+    external_id: string;
+    email?: string | undefined;
+    display_name?: string | undefined;
+}, {
+    external_id: string;
+    roles?: {
+        role: string;
+        type: "superadmin" | "admin" | "member";
+    }[] | undefined;
+    email?: string | undefined;
+    display_name?: string | undefined;
+}>;
+export declare const addUserRoleSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    role: z.ZodString;
+    type: z.ZodEnum<["superadmin", "admin", "member"]>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    type: "superadmin" | "admin" | "member";
+    user_id: string;
+}, {
+    role: string;
+    type: "superadmin" | "admin" | "member";
+    user_id: string;
+}>;
+export declare const removeUserRoleSchema: z.ZodObject<{
+    user_id: z.ZodString;
+    role: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    user_id: string;
+}, {
+    role: string;
+    user_id: string;
+}>;
+export declare const listRolesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const createRoleSchema: z.ZodObject<{
+    role: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+}, {
+    role: string;
+}>;
+export declare const addEscalationChainSchema: z.ZodObject<{
+    source_role: z.ZodString;
+    target_role: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source_role: string;
+    target_role: string;
+}, {
+    source_role: string;
+    target_role: string;
+}>;
+export declare const pruneSchema: z.ZodObject<{
+    expire: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    jobs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    streams: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    entities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    prune_transient: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    streams: boolean;
+    jobs: boolean;
+    expire: string;
+    prune_transient: boolean;
+    entities?: string[] | undefined;
+}, {
+    streams?: boolean | undefined;
+    jobs?: boolean | undefined;
+    expire?: string | undefined;
+    entities?: string[] | undefined;
+    prune_transient?: boolean | undefined;
+}>;