@hotmeshio/long-tail 0.1.0

package/build/routes/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const auth_1 = require("../modules/auth");
+const auth_2 = __importDefault(require("./auth"));
+const oauth_1 = __importDefault(require("./oauth"));
+const delegation_1 = __importDefault(require("./delegation"));
+const tasks_1 = __importDefault(require("./tasks"));
+const escalations_1 = __importDefault(require("./escalations"));
+const workflows_1 = __importDefault(require("./workflows"));
+const exports_1 = __importDefault(require("./exports"));
+const users_1 = __importDefault(require("./users"));
+const roles_1 = __importDefault(require("./roles"));
+const dba_1 = __importDefault(require("./dba"));
+const maintenance_1 = __importDefault(require("./maintenance"));
+const mcp_1 = __importDefault(require("./mcp"));
+const insight_1 = __importDefault(require("./insight"));
+const yaml_workflows_1 = __importDefault(require("./yaml-workflows"));
+const settings_1 = __importDefault(require("./settings"));
+const mcp_runs_1 = __importDefault(require("./mcp-runs"));
+const namespaces_1 = __importDefault(require("./namespaces"));
+const files_1 = __importDefault(require("./files"));
+const controlplane_1 = __importDefault(require("./controlplane"));
+const bot_accounts_1 = __importDefault(require("./bot-accounts"));
+const router = (0, express_1.Router)();
+// Public routes (no auth required — they handle their own auth)
+router.use('/auth', auth_2.default);
+router.use('/auth/oauth', oauth_1.default);
+router.use('/delegation', delegation_1.default);
+router.use('/files', files_1.default);
+router.use('/settings', settings_1.default);
+// Apply auth to all API routes
+router.use(auth_1.requireAuth);
+router.use('/tasks', tasks_1.default);
+router.use('/escalations', escalations_1.default);
+router.use('/workflows', workflows_1.default);
+router.use('/workflow-states', exports_1.default);
+router.use('/config/maintenance', maintenance_1.default);
+router.use('/users', users_1.default);
+router.use('/roles', roles_1.default);
+router.use('/dba', dba_1.default);
+router.use('/mcp', mcp_1.default);
+router.use('/insight', insight_1.default);
+router.use('/yaml-workflows', yaml_workflows_1.default);
+router.use('/mcp-runs', mcp_runs_1.default);
+router.use('/namespaces', namespaces_1.default);
+router.use('/controlplane', controlplane_1.default);
+router.use('/bot-accounts', bot_accounts_1.default);
+exports.default = router;

package/build/routes/insight.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/insight.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const insight_1 = require("../services/insight");
+const router = (0, express_1.Router)();
+/**
+ * POST /api/insight/mcp-query
+ * Run a general-purpose MCP query using all available tools.
+ * Body: { prompt: string, tags?: string[], wait?: boolean, direct?: boolean }
+ */
+router.post('/mcp-query', async (req, res) => {
+    try {
+        const { prompt, tags, wait, direct } = req.body;
+        if (!prompt || typeof prompt !== 'string') {
+            res.status(400).json({ error: 'prompt is required' });
+            return;
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            res.status(503).json({ error: 'MCP queries require an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' });
+            return;
+        }
+        const result = await (0, insight_1.startMcpQuery)({
+            prompt,
+            tags,
+            wait,
+            direct,
+            userId: req.auth?.userId,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            res.status(504).json({ error: 'MCP query timed out. Try a simpler prompt.' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/insight/mcp-query/describe
+ * Generate a workflow description and suggested tags from prompt and result.
+ * Body: { prompt: string, result_title?: string, result_summary?: string }
+ */
+router.post('/mcp-query/describe', async (req, res) => {
+    try {
+        const { prompt, result_title, result_summary } = req.body;
+        if (!prompt) {
+            res.status(400).json({ error: 'prompt is required' });
+            return;
+        }
+        const result = await (0, insight_1.describeWorkflow)({ prompt, result_title, result_summary });
+        res.json(result);
+    }
+    catch {
+        res.json({ description: req.body.prompt || '', tags: [] });
+    }
+});
+exports.default = router;

package/build/routes/maintenance.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/maintenance.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const maintenance_1 = require("../services/maintenance");
+const auth_1 = require("../modules/auth");
+const router = (0, express_1.Router)();
+/**
+ * GET /api/config/maintenance
+ * Return the current maintenance configuration.
+ */
+router.get('/', (_req, res) => {
+    const config = maintenance_1.maintenanceRegistry.config;
+    res.json({ config, active: maintenance_1.maintenanceRegistry.hasConfig });
+});
+/**
+ * PUT /api/config/maintenance
+ * Replace the maintenance configuration and restart the cron.
+ * Admin-only.
+ *
+ * Body: { schedule: string, rules: LTMaintenanceRule[] }
+ */
+router.put('/', auth_1.requireAdmin, async (req, res) => {
+    try {
+        const { schedule, rules } = req.body;
+        if (!schedule || !Array.isArray(rules)) {
+            res.status(400).json({ error: 'schedule (string) and rules (array) are required' });
+            return;
+        }
+        await maintenance_1.maintenanceRegistry.disconnect();
+        maintenance_1.maintenanceRegistry.register({ schedule, rules });
+        await maintenance_1.maintenanceRegistry.connect();
+        res.json({ config: maintenance_1.maintenanceRegistry.config, restarted: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/mcp-runs.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/mcp-runs.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const hotmesh_utils_1 = require("../services/hotmesh-utils");
+const mcp_runs_1 = require("../services/mcp-runs");
+const router = (0, express_1.Router)();
+// ── Routes ───────────────────────────────────────────────────────────────────
+/**
+ * GET /api/mcp-runs/entities
+ * Return distinct entity (tool) names from {appId}.jobs,
+ * supplemented with graph_topics from yaml_workflows for this app_id.
+ */
+router.get('/entities', async (req, res) => {
+    try {
+        const rawAppId = req.query.app_id;
+        if (!rawAppId) {
+            res.status(400).json({ error: 'app_id query parameter is required' });
+            return;
+        }
+        const entities = await (0, mcp_runs_1.listEntities)(rawAppId);
+        res.json({ entities });
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            res.json({ entities: [] });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/mcp-runs
+ * List jobs from {appId}.jobs for a given app_id.
+ */
+router.get('/', async (req, res) => {
+    try {
+        const rawAppId = req.query.app_id;
+        if (!rawAppId) {
+            res.status(400).json({ error: 'app_id query parameter is required' });
+            return;
+        }
+        const result = await (0, mcp_runs_1.listJobs)({
+            rawAppId,
+            limit: parseInt(req.query.limit) || undefined,
+            offset: parseInt(req.query.offset) || undefined,
+            entity: req.query.entity || undefined,
+            search: req.query.search || undefined,
+            status: req.query.status || undefined,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            res.json({ jobs: [], total: 0 });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * GET /api/mcp-runs/:jobId/execution
+ * Export execution details for a specific HotMesh pipeline job.
+ */
+router.get('/:jobId/execution', async (req, res) => {
+    try {
+        const rawAppId = req.query.app_id;
+        if (!rawAppId) {
+            res.status(400).json({ error: 'app_id query parameter is required' });
+            return;
+        }
+        const appId = (0, hotmesh_utils_1.sanitizeAppId)(rawAppId);
+        const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
+        const execution = await (0, mcp_runs_1.buildExecution)(req.params.jobId, appId, schema);
+        res.json(execution);
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (err.status === 404 || msg.includes('not found') || msg.includes('does not exist')) {
+            res.status(404).json({ error: msg });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+exports.default = router;

package/build/routes/mcp.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/mcp.js

@@ -0,0 +1,264 @@
+"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 });
+const express_1 = require("express");
+const mcpDbService = __importStar(require("../services/mcp/db"));
+const mcp_1 = require("../services/mcp");
+const router = (0, express_1.Router)();
+// ── Server registration CRUD ──────────────────────────────────────────
+/**
+ * GET /api/mcp/servers
+ * List registered MCP servers.
+ */
+router.get('/servers', async (req, res) => {
+    try {
+        const tagsParam = req.query.tags;
+        const result = await mcpDbService.listMcpServers({
+            status: req.query.status,
+            auto_connect: req.query.auto_connect === 'true' ? true :
+                req.query.auto_connect === 'false' ? false : undefined,
+            search: req.query.search,
+            tags: tagsParam ? tagsParam.split(',').map((t) => t.trim()).filter(Boolean) : undefined,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+        });
+        res.json(result);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/mcp/servers
+ * Register a new MCP server.
+ */
+router.post('/servers', async (req, res) => {
+    try {
+        const { name, description, transport_type, transport_config, auto_connect, metadata } = req.body;
+        if (!name || !transport_type || !transport_config) {
+            res.status(400).json({ error: 'name, transport_type, and transport_config are required' });
+            return;
+        }
+        const server = await mcpDbService.createMcpServer({
+            name,
+            description,
+            transport_type,
+            transport_config,
+            auto_connect,
+            metadata,
+        });
+        res.status(201).json(server);
+    }
+    catch (err) {
+        if (err.message?.includes('duplicate key') || err.code === '23505') {
+            res.status(409).json({ error: 'MCP server with that name already exists' });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Parameterized routes (must come after literal paths) ──────────────
+/**
+ * GET /api/mcp/servers/:id
+ * Get a specific MCP server.
+ */
+router.get('/servers/:id', async (req, res) => {
+    try {
+        const server = await mcpDbService.getMcpServer(req.params.id);
+        if (!server) {
+            res.status(404).json({ error: 'MCP server not found' });
+            return;
+        }
+        res.json(server);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * PUT /api/mcp/servers/:id
+ * Update an MCP server registration.
+ */
+router.put('/servers/:id', async (req, res) => {
+    try {
+        const server = await mcpDbService.updateMcpServer(req.params.id, req.body);
+        if (!server) {
+            res.status(404).json({ error: 'MCP server not found' });
+            return;
+        }
+        res.json(server);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * DELETE /api/mcp/servers/:id
+ * Delete an MCP server registration.
+ */
+router.delete('/servers/:id', async (req, res) => {
+    try {
+        const deleted = await mcpDbService.deleteMcpServer(req.params.id);
+        if (!deleted) {
+            res.status(404).json({ error: 'MCP server not found' });
+            return;
+        }
+        res.json({ deleted: true });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Connection management ─────────────────────────────────────────────
+/**
+ * POST /api/mcp/servers/:id/connect
+ * Connect to a registered MCP server.
+ */
+router.post('/servers/:id/connect', async (req, res) => {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            res.status(400).json({ error: 'MCP adapter not registered' });
+            return;
+        }
+        await adapter.connectClient(req.params.id);
+        res.json({ connected: true, serverId: req.params.id });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/mcp/servers/:id/disconnect
+ * Disconnect from a specific MCP server.
+ */
+router.post('/servers/:id/disconnect', async (req, res) => {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            res.status(400).json({ error: 'MCP adapter not registered' });
+            return;
+        }
+        await adapter.disconnectClient(req.params.id);
+        res.json({ disconnected: true, serverId: req.params.id });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Credential status ────────────────────────────────────────────────
+/**
+ * GET /api/mcp/servers/:id/credential-status
+ * Check which credential providers are required and which the user has.
+ */
+router.get('/servers/:id/credential-status', async (req, res) => {
+    try {
+        const server = await mcpDbService.getMcpServer(req.params.id);
+        if (!server) {
+            res.status(404).json({ error: 'MCP server not found' });
+            return;
+        }
+        const required = server.credential_providers ?? [];
+        const registered = [];
+        const missing = [];
+        if (req.auth?.userId && required.length > 0) {
+            const { resolveCredential } = await Promise.resolve().then(() => __importStar(require('../services/iam/credentials')));
+            for (const provider of required) {
+                const cred = await resolveCredential({ id: req.auth.userId, type: 'user', roles: [] }, provider);
+                if (cred)
+                    registered.push(provider);
+                else
+                    missing.push(provider);
+            }
+        }
+        else {
+            missing.push(...required);
+        }
+        res.json({ required, registered, missing });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+// ── Tool operations ───────────────────────────────────────────────────
+/**
+ * GET /api/mcp/servers/:id/tools
+ * List tools available on a connected MCP server.
+ */
+router.get('/servers/:id/tools', async (req, res) => {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            res.status(400).json({ error: 'MCP adapter not registered' });
+            return;
+        }
+        const tools = await adapter.listTools(req.params.id);
+        res.json({ tools });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/mcp/servers/:id/tools/:toolName/call
+ * Call a tool on a connected MCP server.
+ * Body: { arguments: { ... } }
+ */
+router.post('/servers/:id/tools/:toolName/call', async (req, res) => {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            res.status(400).json({ error: 'MCP adapter not registered' });
+            return;
+        }
+        const authContext = req.auth?.userId
+            ? { userId: req.auth.userId }
+            : undefined;
+        const result = await adapter.callTool(req.params.id, req.params.toolName, req.body.arguments || {}, authContext);
+        res.json({ result });
+    }
+    catch (err) {
+        if (err.name === 'MissingCredentialError') {
+            res.status(422).json({
+                error: 'missing_credential',
+                provider: err.provider,
+                message: err.message,
+            });
+            return;
+        }
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/namespaces.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/build/routes/namespaces.js

@@ -0,0 +1,71 @@
+"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 });
+const express_1 = require("express");
+const namespaceService = __importStar(require("../services/namespace"));
+const router = (0, express_1.Router)();
+/**
+ * GET /api/namespaces
+ * List all registered MCP YAML namespaces.
+ */
+router.get('/', async (_req, res) => {
+    try {
+        const namespaces = await namespaceService.listNamespaces();
+        res.json({ namespaces });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * POST /api/namespaces
+ * Register a new namespace.
+ * Body: { name: string, description?: string, metadata?: object }
+ */
+router.post('/', async (req, res) => {
+    try {
+        const { name, description, metadata } = req.body || {};
+        if (!name || typeof name !== 'string') {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        const namespace = await namespaceService.registerNamespace(name, description, metadata);
+        res.json(namespace);
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = router;

package/build/routes/oauth.d.ts

@@ -0,0 +1,7 @@
+declare const router: import("express-serve-static-core").Router;
+export declare function setOAuthConfig(cfg: {
+    autoProvision?: boolean;
+    defaultRoleType?: 'admin' | 'member';
+    baseUrl?: string;
+}): void;
+export default router;