@hotmeshio/long-tail 0.1.3 → 0.1.5

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

@@ -0,0 +1,237 @@
+"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.registerYamlWorkflowTools = registerYamlWorkflowTools;
+const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
+const yamlGenerator = __importStar(require("../../../services/yaml-workflow/generator"));
+const yamlDeployer = __importStar(require("../../../services/yaml-workflow/deployer"));
+const yamlWorkers = __importStar(require("../../../services/yaml-workflow/workers"));
+const task_1 = require("../../../services/task");
+const schemas_1 = require("./schemas");
+function registerYamlWorkflowTools(server) {
+    // mirrors GET /api/yaml-workflows
+    server.registerTool('list_yaml_workflows', {
+        title: 'List Pipeline Workflows',
+        description: 'List compiled YAML workflows with optional filters by status, ' +
+            'namespace, or search term. Returns name, status, source, and activity count.',
+        inputSchema: schemas_1.listYamlWorkflowsSchema,
+    }, async (args) => {
+        const { workflows, total } = await yamlDb.listYamlWorkflows({
+            status: args.status,
+            app_id: args.app_id,
+            search: args.search,
+            source_workflow_id: args.source_workflow_id,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: workflows.length,
+                        workflows: workflows.map((w) => ({
+                            id: w.id,
+                            name: w.name,
+                            app_id: w.app_id,
+                            status: w.status,
+                            source_workflow_type: w.source_workflow_type,
+                            graph_topic: w.graph_topic,
+                            activity_count: w.activity_manifest?.filter((a) => a.type === 'worker').length ?? 0,
+                            tags: w.tags,
+                            created_at: w.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors GET /api/yaml-workflows/:id
+    server.registerTool('get_yaml_workflow', {
+        title: 'Get Pipeline Workflow',
+        description: 'Inspect a compiled workflow by ID. Returns the activity manifest, ' +
+            'input/output schemas, YAML content, and provenance.',
+        inputSchema: schemas_1.getYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(wf) }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows
+    server.registerTool('create_yaml_workflow', {
+        title: 'Compile Execution to Pipeline',
+        description: 'Generate a deterministic YAML workflow from a completed execution. ' +
+            'Extracts the tool call sequence and replaces LLM reasoning with ' +
+            'direct tool-to-tool data piping. Stored as a draft.',
+        inputSchema: schemas_1.createYamlWorkflowSchema,
+    }, async (args) => {
+        // Reject incomplete executions (same check as route)
+        const task = await (0, task_1.getTaskByWorkflowId)(args.workflow_id);
+        if (task) {
+            const milestones = task.milestones ?? [];
+            if (milestones.some((m) => m.name === 'rounds_exhausted')) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Cannot compile: source execution exhausted its tool rounds without completing.',
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        const result = await yamlGenerator.generateYamlFromExecution({
+            workflowId: args.workflow_id,
+            taskQueue: args.task_queue,
+            workflowName: args.workflow_name,
+            name: args.name,
+            description: args.description,
+            compilationFeedback: args.compilation_feedback,
+        });
+        const mergedTags = [...new Set([
+                ...(result.tags || []),
+                ...(args.tags || []),
+            ])];
+        const record = await yamlDb.createYamlWorkflow({
+            name: args.name,
+            description: args.description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: mergedTags,
+            source_workflow_id: args.workflow_id,
+            source_workflow_type: args.workflow_name,
+            original_prompt: result.originalPrompt || undefined,
+            category: result.category || undefined,
+            metadata: {
+                input_field_meta: result.inputFieldMeta,
+                ...(result.validationIssues?.length ? { validation_warnings: result.validationIssues } : {}),
+            },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        id: record.id,
+                        name: record.name,
+                        app_id: record.app_id,
+                        status: record.status,
+                        activity_count: record.activity_manifest?.filter((a) => a.type === 'worker').length ?? 0,
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows/:id/deploy
+    server.registerTool('deploy_yaml_workflow', {
+        title: 'Deploy Pipeline Workflow',
+        description: 'Deploy a compiled YAML workflow to HotMesh, activate it, and ' +
+            'register workers. All sibling workflows sharing the same app_id ' +
+            'are deployed together.',
+        inputSchema: schemas_1.deployYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        const deployVersion = wf.app_version || '1';
+        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
+        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
+        for (const sibling of siblings) {
+            await yamlDb.updateYamlWorkflowVersion(sibling.id, deployVersion);
+            await yamlWorkers.registerWorkersForWorkflow(sibling);
+            if (sibling.status === 'draft' || sibling.status === 'deployed') {
+                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
+            }
+        }
+        await yamlDb.markAppIdContentDeployed(wf.app_id);
+        const updated = await yamlDb.getYamlWorkflow(args.id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        deployed: true,
+                        id: updated?.id,
+                        name: updated?.name,
+                        status: updated?.status,
+                        app_id: updated?.app_id,
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows/:id/invoke
+    server.registerTool('invoke_yaml_workflow', {
+        title: 'Invoke Pipeline Workflow',
+        description: 'Run a compiled YAML workflow. Deterministic — no LLM reasoning, ' +
+            'just direct tool-to-tool data piping. Set sync=true to wait for result.',
+        inputSchema: schemas_1.invokeYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        if (wf.status !== 'active') {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow must be active to invoke' }) }],
+                isError: true,
+            };
+        }
+        if (args.sync) {
+            const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, args.data, args.timeout, wf.graph_topic);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ job_id, result }) }],
+            };
+        }
+        const jobId = await yamlDeployer.invokeYamlWorkflow(wf.app_id, wf.graph_topic, args.data, wf.graph_topic);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ job_id: jobId }) }],
+        };
+    });
+}

package/build/system/mcp-servers/claude-code.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createClaudeCodeServer = createClaudeCodeServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const claudeCode = __importStar(require("../activities/claude-code"));
 // ── Schemas ──────────────────────────────────────────────────────────────────
 const executeTaskSchema = zod_1.z.object({

package/build/system/mcp-servers/db-query/index.js

@@ -4,7 +4,7 @@ exports.createDbServer = createDbServer;
 exports.getDbServer = getDbServer;
 exports.stopDbServer = stopDbServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const logger_1 = require("../../../services/logger");
+const logger_1 = require("../../../lib/logger");
 const tools_1 = require("./tools");
 let server = null;
 /**

package/build/system/mcp-servers/db-query/tools.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerTools = registerTools;
-const db_1 = require("../../../services/db");
+const db_1 = require("../../../lib/db");
 const taskService = __importStar(require("../../../services/task"));
 const escalationService = __importStar(require("../../../services/escalation"));
 const configService = __importStar(require("../../../services/config"));
@@ -190,16 +190,22 @@ function registerTools(instance) {
     // ── get_system_health ──────────────────────────────────────────
     instance.registerTool('get_system_health', {
         title: 'Get System Health',
-        description: 'Overall system health snapshot: task counts by status, escalation counts by status, ' +
-            'active workflow types, and recent activity window.',
+        description: 'Full system overview: durable workflow execution counts by type (active/completed), ' +
+            'task counts by status, escalation counts by status, recent activity window, ' +
+            'MCP servers (with tool counts and tags), compiled workflow totals, and workflow configurations.',
         inputSchema: schemas_1.getSystemHealthSchema,
     }, async (_args) => {
         const pool = (0, db_1.getPool)();
-        const [taskCounts, escalationCounts, activeTypes, recentActivity] = await Promise.all([
+        const [taskCounts, escalationCounts, activeTypes, recentActivity, mcpServers, mcpServerList, compiledWorkflows, workflowConfigs, durableWorkflows,] = await Promise.all([
             pool.query(sql_1.HEALTH_TASK_COUNTS),
             pool.query(sql_1.HEALTH_ESCALATION_COUNTS),
             pool.query(sql_1.HEALTH_ACTIVE_WORKFLOW_TYPES),
             pool.query(sql_1.HEALTH_RECENT_ACTIVITY),
+            pool.query(sql_1.HEALTH_MCP_SERVERS),
+            pool.query(sql_1.HEALTH_MCP_SERVER_LIST),
+            pool.query(sql_1.HEALTH_COMPILED_WORKFLOWS),
+            pool.query(sql_1.HEALTH_WORKFLOW_CONFIGS),
+            pool.query(sql_1.HEALTH_DURABLE_WORKFLOWS),
         ]);
         const tasksByStatus = {};
         for (const row of taskCounts.rows) {
@@ -213,10 +219,17 @@ function registerTools(instance) {
             content: [{
                     type: 'text',
                     text: JSON.stringify({
+                        durable_workflows: durableWorkflows.rows,
                         tasks: tasksByStatus,
                         escalations: escalationsByStatus,
                         active_workflow_types: activeTypes.rows.map((r) => r.workflow_type),
                         recent_activity: recentActivity.rows[0],
+                        mcp_servers: {
+                            ...mcpServers.rows[0],
+                            servers: mcpServerList.rows,
+                        },
+                        compiled_workflows: compiledWorkflows.rows[0],
+                        workflow_configs: workflowConfigs.rows,
                     }),
                 }],
         };

package/build/system/mcp-servers/docs.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createDocsServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+export declare function stopDocsServer(): Promise<void>;

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

@@ -0,0 +1,147 @@
+"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.createDocsServer = createDocsServer;
+exports.stopDocsServer = stopDocsServer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../lib/logger");
+// Resolve docs directory (works from ts-node root and compiled build/)
+function docsDir() {
+    const candidates = [
+        path.join(__dirname, '..', '..', 'docs'),
+        path.join(__dirname, '..', '..', '..', 'docs'),
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(dir))
+            return dir;
+    }
+    return candidates[0];
+}
+function listMarkdownFiles(dir, prefix = '') {
+    if (!fs.existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            results.push(...listMarkdownFiles(path.join(dir, entry.name), rel));
+        }
+        else if (entry.name.endsWith('.md')) {
+            const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+            const firstLine = content.split('\n').find(l => l.startsWith('# '));
+            const title = firstLine ? firstLine.replace(/^#\s+/, '') : entry.name;
+            results.push({ path: rel, title });
+        }
+    }
+    return results;
+}
+const listDocsSchema = zod_1.z.object({});
+const searchDocsSchema = zod_1.z.object({
+    query: zod_1.z.string().describe('Search term or phrase to find in documentation'),
+});
+const readDocSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('Document path relative to docs/ (e.g. "mcp.md" or "api/tasks.md")'),
+});
+function registerTools(srv) {
+    srv.registerTool('list_docs', {
+        title: 'List Documentation',
+        description: 'List all available documentation files with their titles.',
+        inputSchema: listDocsSchema,
+    }, async () => {
+        const docs = listMarkdownFiles(docsDir());
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ docs }) }],
+        };
+    });
+    srv.registerTool('search_docs', {
+        title: 'Search Documentation',
+        description: 'Search across all documentation for a keyword or phrase. Returns matching files with line context.',
+        inputSchema: searchDocsSchema,
+    }, async (args) => {
+        const dir = docsDir();
+        const files = listMarkdownFiles(dir);
+        const query = args.query.toLowerCase();
+        const matches = [];
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(dir, file.path), 'utf-8');
+            const fileLines = content.split('\n');
+            const hits = [];
+            for (let i = 0; i < fileLines.length; i++) {
+                if (fileLines[i].toLowerCase().includes(query)) {
+                    // Include surrounding context
+                    const start = Math.max(0, i - 1);
+                    const end = Math.min(fileLines.length, i + 2);
+                    hits.push(fileLines.slice(start, end).join('\n'));
+                }
+            }
+            if (hits.length > 0) {
+                matches.push({ path: file.path, title: file.title, lines: hits.slice(0, 5) });
+            }
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ query: args.query, matches }) }],
+        };
+    });
+    srv.registerTool('read_doc', {
+        title: 'Read Documentation',
+        description: 'Read the full content of a documentation file.',
+        inputSchema: readDocSchema,
+    }, async (args) => {
+        const filePath = path.join(docsDir(), args.path);
+        if (!fs.existsSync(filePath)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: `Document not found: ${args.path}` }) }],
+            };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ path: args.path, content }) }],
+        };
+    });
+}
+async function createDocsServer(options) {
+    const name = options?.name || 'long-tail-docs';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    registerTools(instance);
+    const docs = listMarkdownFiles(docsDir());
+    logger_1.loggerRegistry.info(`[lt-mcp:docs] ${name} ready (3 tools, ${docs.length} docs indexed)`);
+    return instance;
+}
+async function stopDocsServer() {
+    logger_1.loggerRegistry.info('[lt-mcp:docs] stopped');
+}

package/build/system/mcp-servers/file-storage.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileStorageServer = createFileStorageServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const fileStorage = __importStar(require("../activities/file-storage"));
 const writeFileSchema = zod_1.z.object({
     path: zod_1.z.string().describe('File path relative to storage root'),

package/build/system/mcp-servers/http-fetch.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHttpFetchServer = createHttpFetchServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const http = __importStar(require("../activities/http"));
 const httpRequestSchema = zod_1.z.object({
     url: zod_1.z.string().describe('URL to request'),

package/build/system/mcp-servers/human-queue.js

@@ -39,7 +39,7 @@ exports.stopServer = stopServer;
 const crypto = __importStar(require("crypto"));
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const escalationService = __importStar(require("../../services/escalation"));
 let server = null;
 // ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──

package/build/system/mcp-servers/knowledge.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createKnowledgeServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

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

@@ -0,0 +1,137 @@
+"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.createKnowledgeServer = createKnowledgeServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../lib/logger");
+const knowledge = __importStar(require("../activities/knowledge"));
+const storeSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain (namespace)'),
+    key: zod_1.z.string().describe('Unique key within domain'),
+    data: zod_1.z.record(zod_1.z.any()).describe('JSONB payload to store'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Categorization tags'),
+});
+const getSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+});
+const searchSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain to search'),
+    query: zod_1.z.record(zod_1.z.any()).describe('JSONB containment query (e.g. {"type":"screenshot"})'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
+    limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
+});
+const listSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (any match)'),
+    limit: zod_1.z.number().optional().describe('Max results (default 50, max 200)'),
+    offset: zod_1.z.number().optional().describe('Pagination offset'),
+});
+const deleteSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key to delete'),
+});
+const appendSchema = zod_1.z.object({
+    domain: zod_1.z.string().describe('Knowledge domain'),
+    key: zod_1.z.string().describe('Document key'),
+    path: zod_1.z.string().describe('JSONB path to array field (e.g. "screenshots" or "analysis.variations")'),
+    value: zod_1.z.any().refine((v) => v !== undefined, 'value is required').describe('Value to append to the array'),
+});
+function registerTools(server) {
+    server.registerTool('store_knowledge', {
+        title: 'Store Knowledge',
+        description: 'Store or update a knowledge entry. Upserts by domain+key: merges data and unions tags if the entry already exists.',
+        inputSchema: storeSchema,
+    }, async (args) => {
+        const result = await knowledge.storeKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('get_knowledge', {
+        title: 'Get Knowledge',
+        description: 'Retrieve a single knowledge entry by domain and key.',
+        inputSchema: getSchema,
+    }, async (args) => {
+        const result = await knowledge.getKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('search_knowledge', {
+        title: 'Search Knowledge',
+        description: 'Search knowledge entries using JSONB containment queries. The query object matches entries whose data contains the specified key-value pairs.',
+        inputSchema: searchSchema,
+    }, async (args) => {
+        const result = await knowledge.searchKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('list_knowledge', {
+        title: 'List Knowledge',
+        description: 'List knowledge entries in a domain, optionally filtered by tags. Returns most recently updated first.',
+        inputSchema: listSchema,
+    }, async (args) => {
+        const result = await knowledge.listKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('delete_knowledge', {
+        title: 'Delete Knowledge',
+        description: 'Delete a knowledge entry by domain and key.',
+        inputSchema: deleteSchema,
+    }, async (args) => {
+        const result = await knowledge.deleteKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('list_domains', {
+        title: 'List Knowledge Domains',
+        description: 'List all knowledge domains with entry counts and last-updated timestamps.',
+        inputSchema: zod_1.z.object({}),
+    }, async () => {
+        const result = await knowledge.listDomains();
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+    server.registerTool('append_knowledge', {
+        title: 'Append to Knowledge',
+        description: 'Append a value to an array field within a knowledge entry. Creates the entry and array if they do not exist.',
+        inputSchema: appendSchema,
+    }, async (args) => {
+        const result = await knowledge.appendKnowledge(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    });
+}
+async function createKnowledgeServer(options) {
+    const name = options?.name || 'long-tail-knowledge';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    registerTools(instance);
+    logger_1.loggerRegistry.info(`[lt-mcp:knowledge] ${name} ready`);
+    return instance;
+}

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

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOAuthServer = createOAuthServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const oauth = __importStar(require("../activities/oauth"));
 const getAccessTokenSchema = zod_1.z.object({
     provider: zod_1.z.string().describe('OAuth provider name (google, github, microsoft, anthropic, etc.)'),

package/build/system/mcp-servers/playwright/browser-lifecycle.js

@@ -7,7 +7,7 @@ exports.resolvePage = resolvePage;
 exports.buildHandle = buildHandle;
 exports.stopPlaywrightServer = stopPlaywrightServer;
 const playwright_1 = require("playwright");
-const logger_1 = require("../../../services/logger");
+const logger_1 = require("../../../lib/logger");
 const types_1 = require("./types");
 // ── Browser lifecycle ────────────────────────────────────────────────────────
 // Shared browser instance across tool calls within a single server lifetime.