@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/lib/db/migrate.js

@@ -38,12 +38,9 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const index_1 = require("./index");
 const logger_1 = require("../logger");
-// In dev: __dirname = lib/db → schemas is ./schemas
-// In built/published: __dirname = build/lib/db → schemas is ../../../lib/db/schemas
-const devPath = path.join(__dirname, 'schemas');
-const SCHEMAS_DIR = fs.existsSync(devPath)
-    ? devPath
-    : path.join(__dirname, '..', '..', '..', 'services', 'db', 'schemas');
+// Both dev (lib/db/) and build (build/lib/db/) have schemas/ as a sibling.
+// In dev it exists naturally; in build it's copied by the build script.
+const SCHEMAS_DIR = path.join(__dirname, 'schemas');
 async function migrate() {
     const pool = (0, index_1.getPool)();
     // ensure migration tracking table

package/{lib → build/lib}/db/schemas/001_schema.sql

@@ -258,6 +258,9 @@ CREATE TABLE IF NOT EXISTS lt_yaml_workflows (
   tags                     TEXT[] NOT NULL DEFAULT '{}',
   input_field_meta         JSONB NOT NULL DEFAULT '[]'::JSONB,
   metadata                 JSONB,
+  cron_schedule            TEXT,
+  cron_envelope            JSONB,
+  execute_as               TEXT,
   created_at               TIMESTAMPTZ NOT NULL DEFAULT NOW(),
   updated_at               TIMESTAMPTZ NOT NULL DEFAULT NOW()
 );

package/build/lib/db/schemas/004_workflow_sets.sql

@@ -0,0 +1,29 @@
+-- Workflow sets: groups of related workflows produced by plan mode.
+
+CREATE TABLE IF NOT EXISTS lt_workflow_sets (
+  id                 UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  name               TEXT UNIQUE NOT NULL,
+  description        TEXT,
+  specification      TEXT NOT NULL,
+  plan               JSONB NOT NULL DEFAULT '[]'::JSONB,
+  namespaces         TEXT[] NOT NULL DEFAULT '{}',
+  status             TEXT NOT NULL DEFAULT 'planning'
+                       CHECK (status IN ('planning','planned','building','deploying','completed','failed')),
+  source_workflow_id TEXT,
+  created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE OR REPLACE TRIGGER trg_lt_workflow_sets_updated_at
+  BEFORE UPDATE ON lt_workflow_sets
+  FOR EACH ROW EXECUTE FUNCTION lt_set_updated_at();
+
+-- Extend lt_yaml_workflows with set membership columns
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_id UUID
+  REFERENCES lt_workflow_sets(id) ON DELETE SET NULL;
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_role TEXT
+  CHECK (set_role IN ('leaf', 'composition', 'router'));
+ALTER TABLE lt_yaml_workflows ADD COLUMN IF NOT EXISTS set_build_order INTEGER;
+
+CREATE INDEX IF NOT EXISTS idx_lt_yaml_workflows_set_id
+  ON lt_yaml_workflows (set_id) WHERE set_id IS NOT NULL;

package/build/lib/db/schemas/005_unique_graph_topic.sql

@@ -0,0 +1,7 @@
+-- Enforce unique graph_topic per app_id for non-archived workflows.
+-- Two active/deployed/draft workflows in the same namespace must not
+-- share a subscribes topic — deploying them would cause routing collisions.
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_yaml_workflows_app_topic_unique
+  ON lt_yaml_workflows (app_id, graph_topic)
+  WHERE status != 'archived';

package/{lib → build/lib}/db/schemas/011_system_workflow_configs.sql

@@ -10,6 +10,12 @@ VALUES
    '{}'),
   ('mcpTriage', 'long-tail-system', 'engineer', false,
    'Dynamic MCP triage — LLM agentic loop for escalation remediation',
+   '{}'),
+  ('mcpWorkflowBuilder', 'long-tail-system', 'engineer', false,
+   'Direct pipeline builder — LLM constructs DAG from tool schemas',
+   '{}'),
+  ('mcpWorkflowPlanner', 'long-tail-system', 'engineer', false,
+   'Plan mode — decomposes specifications into multi-workflow sets',
    '{}')
 ON CONFLICT (workflow_type) DO NOTHING;
 
@@ -21,3 +27,11 @@ ON CONFLICT (workflow_type, role) DO NOTHING;
 INSERT INTO lt_config_roles (workflow_type, role)
 SELECT 'mcpTriage', unnest(ARRAY['reviewer', 'engineer', 'admin'])
 ON CONFLICT (workflow_type, role) DO NOTHING;
+
+INSERT INTO lt_config_roles (workflow_type, role)
+SELECT 'mcpWorkflowBuilder', unnest(ARRAY['reviewer', 'engineer', 'admin'])
+ON CONFLICT (workflow_type, role) DO NOTHING;
+
+INSERT INTO lt_config_roles (workflow_type, role)
+SELECT 'mcpWorkflowPlanner', unnest(ARRAY['reviewer', 'engineer', 'admin'])
+ON CONFLICT (workflow_type, role) DO NOTHING;

package/build/lib/db/schemas/016_streamable_http.sql

@@ -0,0 +1,7 @@
+-- Allow 'streamable-http' as a transport type for MCP servers
+ALTER TABLE lt_mcp_servers
+  DROP CONSTRAINT IF EXISTS lt_mcp_servers_transport_type_check;
+
+ALTER TABLE lt_mcp_servers
+  ADD CONSTRAINT lt_mcp_servers_transport_type_check
+  CHECK (transport_type IN ('stdio', 'sse', 'streamable-http'));

package/build/lib/events/callback.d.ts

@@ -0,0 +1,41 @@
+import type { LTEvent, LTEventAdapter, LTEventType } from '../../types';
+type EventCallback = (event: LTEvent) => void;
+/**
+ * In-process event adapter that delivers events via registered callbacks.
+ *
+ * Plugs into the existing `eventRegistry` alongside Socket.IO / NATS.
+ * SDK callers subscribe with `.on()` and receive events as direct
+ * function calls — no network transport, no serialization overhead.
+ *
+ * Supports:
+ * - Exact type matching: `on('task.created', cb)`
+ * - Category wildcards: `on('task.*', cb)` — matches all task.* events
+ * - Global wildcard: `on('*', cb)` — matches every event
+ *
+ * Usage:
+ * ```typescript
+ * import { CallbackEventAdapter } from '@hotmeshio/long-tail';
+ * import { eventRegistry } from '@hotmeshio/long-tail';
+ *
+ * const adapter = new CallbackEventAdapter();
+ * eventRegistry.register(adapter);
+ *
+ * const unsub = adapter.on('escalation.claimed', (event) => {
+ *   console.log('claimed:', event.escalationId);
+ * });
+ *
+ * // Later: unsub() to remove the listener
+ * ```
+ */
+export declare class CallbackEventAdapter implements LTEventAdapter {
+    private listeners;
+    /**
+     * Subscribe to events by type, pattern, or wildcard.
+     * Returns an unsubscribe function.
+     */
+    on(pattern: LTEventType | '*' | (string & {}), callback: EventCallback): () => void;
+    connect(): Promise<void>;
+    publish(event: LTEvent): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export {};

package/build/lib/events/callback.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallbackEventAdapter = void 0;
+const logger_1 = require("../logger");
+/**
+ * In-process event adapter that delivers events via registered callbacks.
+ *
+ * Plugs into the existing `eventRegistry` alongside Socket.IO / NATS.
+ * SDK callers subscribe with `.on()` and receive events as direct
+ * function calls — no network transport, no serialization overhead.
+ *
+ * Supports:
+ * - Exact type matching: `on('task.created', cb)`
+ * - Category wildcards: `on('task.*', cb)` — matches all task.* events
+ * - Global wildcard: `on('*', cb)` — matches every event
+ *
+ * Usage:
+ * ```typescript
+ * import { CallbackEventAdapter } from '@hotmeshio/long-tail';
+ * import { eventRegistry } from '@hotmeshio/long-tail';
+ *
+ * const adapter = new CallbackEventAdapter();
+ * eventRegistry.register(adapter);
+ *
+ * const unsub = adapter.on('escalation.claimed', (event) => {
+ *   console.log('claimed:', event.escalationId);
+ * });
+ *
+ * // Later: unsub() to remove the listener
+ * ```
+ */
+class CallbackEventAdapter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    /**
+     * Subscribe to events by type, pattern, or wildcard.
+     * Returns an unsubscribe function.
+     */
+    on(pattern, callback) {
+        let set = this.listeners.get(pattern);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(pattern, set);
+        }
+        set.add(callback);
+        return () => {
+            set.delete(callback);
+            if (set.size === 0) {
+                this.listeners.delete(pattern);
+            }
+        };
+    }
+    async connect() {
+        logger_1.loggerRegistry.info('[lt-events:callback] adapter connected');
+    }
+    async publish(event) {
+        // Exact match listeners
+        const exact = this.listeners.get(event.type);
+        if (exact) {
+            for (const cb of exact) {
+                try {
+                    cb(event);
+                }
+                catch { /* fire-and-forget */ }
+            }
+        }
+        // Category wildcard listeners (e.g. 'task.*' matches 'task.created')
+        const dotIdx = event.type.indexOf('.');
+        if (dotIdx > 0) {
+            const category = event.type.slice(0, dotIdx) + '.*';
+            const catListeners = this.listeners.get(category);
+            if (catListeners) {
+                for (const cb of catListeners) {
+                    try {
+                        cb(event);
+                    }
+                    catch { /* fire-and-forget */ }
+                }
+            }
+        }
+        // Global wildcard listeners
+        const global = this.listeners.get('*');
+        if (global) {
+            for (const cb of global) {
+                try {
+                    cb(event);
+                }
+                catch { /* fire-and-forget */ }
+            }
+        }
+    }
+    async disconnect() {
+        this.listeners.clear();
+        logger_1.loggerRegistry.info('[lt-events:callback] adapter disconnected');
+    }
+}
+exports.CallbackEventAdapter = CallbackEventAdapter;

package/build/modules/config.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.postgres_options = exports.config = void 0;
 exports.config = {
     POSTGRES_HOST: process.env.POSTGRES_HOST || 'localhost',
-    POSTGRES_PORT: parseInt(process.env.POSTGRES_PORT || '5432', 10),
+    POSTGRES_PORT: parseInt(process.env.POSTGRES_PORT || '5415', 10),
     POSTGRES_USER: process.env.POSTGRES_USER || 'postgres',
     POSTGRES_PASSWORD: process.env.POSTGRES_PASSWORD || 'password',
     // In test environments, always use the test database to prevent accidental

package/build/routes/auth.js

@@ -1,8 +1,40 @@
 "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 user_1 = require("../services/user");
-const auth_1 = require("../modules/auth");
+const api = __importStar(require("../api/auth"));
 const router = (0, express_1.Router)();
 /**
  * POST /api/auth/login
@@ -10,39 +42,8 @@ const router = (0, express_1.Router)();
  * Returns a JWT token on success.
  */
 router.post('/login', async (req, res) => {
-    try {
-        const { username, password } = req.body || {};
-        if (!username || !password) {
-            res.status(400).json({ error: 'username and password are required' });
-            return;
-        }
-        const user = await (0, user_1.verifyPassword)(username, password);
-        if (!user) {
-            res.status(401).json({ error: 'Invalid credentials' });
-            return;
-        }
-        const highestType = user.roles.some((r) => r.type === 'superadmin')
-            ? 'superadmin'
-            : user.roles.some((r) => r.type === 'admin')
-                ? 'admin'
-                : 'member';
-        const token = (0, auth_1.signToken)({
-            userId: user.id,
-            role: highestType,
-            roles: user.roles.map((r) => ({ role: r.role, type: r.type })),
-        }, '24h');
-        res.json({
-            token,
-            user: {
-                id: user.id,
-                external_id: user.external_id,
-                display_name: user.display_name,
-                roles: user.roles,
-            },
-        });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const { username, password } = req.body || {};
+    const result = await api.login({ username, password });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

package/build/routes/bot-accounts.js

@@ -35,8 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const auth_1 = require("../modules/auth");
-const iam = __importStar(require("../services/iam"));
-const user_1 = require("../services/user");
+const api = __importStar(require("../api/bot-accounts"));
 const router = (0, express_1.Router)();
 // All bot account routes require admin access
 router.use(auth_1.requireAdmin);
@@ -47,32 +46,19 @@ router.use(auth_1.requireAdmin);
  * Query: ?limit=50&offset=0
  */
 router.get('/', async (req, res) => {
-    try {
-        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 50;
-        const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
-        const result = await iam.listBots(limit, offset);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.listBots({
+        limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+        offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/bot-accounts/:id
  * Get a single bot account.
  */
 router.get('/:id', async (req, res) => {
-    try {
-        const bot = await iam.getBot(req.params.id);
-        if (!bot) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        res.json(bot);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getBot({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/bot-accounts
@@ -80,38 +66,9 @@ router.get('/:id', async (req, res) => {
  * Body: { name, description?, display_name?, roles?: [{ role, type }] }
  */
 router.post('/', async (req, res) => {
-    try {
-        const { name, description, display_name, roles } = req.body || {};
-        if (!name) {
-            res.status(400).json({ error: 'name is required' });
-            return;
-        }
-        if (roles) {
-            for (const r of roles) {
-                if (!r.role || !r.type || !(0, user_1.isValidRoleType)(r.type)) {
-                    res.status(400).json({
-                        error: 'Each role must have a role name and type (superadmin, admin, member)',
-                    });
-                    return;
-                }
-            }
-        }
-        const bot = await iam.createBot({
-            name,
-            description,
-            display_name,
-            roles,
-            created_by: req.auth?.userId,
-        });
-        res.status(201).json(bot);
-    }
-    catch (err) {
-        if (err.code === '23505') {
-            res.status(409).json({ error: 'Bot with this name already exists' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const { name, description, display_name, roles } = req.body || {};
+    const result = await api.createBot({ name, description, display_name, roles }, req.auth ? { userId: req.auth.userId } : undefined);
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * PUT /api/bot-accounts/:id
@@ -119,34 +76,16 @@ router.post('/', async (req, res) => {
  * Body: { display_name?, description?, status? }
  */
 router.put('/:id', async (req, res) => {
-    try {
-        const bot = await iam.updateBot(req.params.id, req.body || {});
-        if (!bot) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        res.json(bot);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.updateBot({ id: req.params.id, ...(req.body || {}) });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * DELETE /api/bot-accounts/:id
  * Delete a bot account.
  */
 router.delete('/:id', async (req, res) => {
-    try {
-        const deleted = await iam.deleteBot(req.params.id);
-        if (!deleted) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        res.json({ deleted: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.deleteBot({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 // ── Bot roles ────────────────────────────────────────────────────────────────
 /**
@@ -154,18 +93,8 @@ router.delete('/:id', async (req, res) => {
  * List roles for a bot.
  */
 router.get('/:id/roles', async (req, res) => {
-    try {
-        const bot = await iam.getBot(req.params.id);
-        if (!bot) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        const roles = await iam.getBotRoles(req.params.id);
-        res.json({ roles });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getBotRoles({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/bot-accounts/:id/roles
@@ -173,44 +102,17 @@ router.get('/:id/roles', async (req, res) => {
  * Body: { role, type }
  */
 router.post('/:id/roles', async (req, res) => {
-    try {
-        const { role, type } = req.body || {};
-        if (!role || !type) {
-            res.status(400).json({ error: 'role and type are required' });
-            return;
-        }
-        if (!(0, user_1.isValidRoleType)(type)) {
-            res.status(400).json({ error: 'type must be superadmin, admin, or member' });
-            return;
-        }
-        const bot = await iam.getBot(req.params.id);
-        if (!bot) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        const result = await iam.addBotRole(req.params.id, role, type);
-        res.status(201).json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const { role, type } = req.body || {};
+    const result = await api.addBotRole({ id: req.params.id, role, type });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * DELETE /api/bot-accounts/:id/roles/:role
  * Remove a role from a bot.
  */
 router.delete('/:id/roles/:role', async (req, res) => {
-    try {
-        const removed = await iam.removeBotRole(req.params.id, req.params.role);
-        if (!removed) {
-            res.status(404).json({ error: 'Role not found' });
-            return;
-        }
-        res.json({ removed: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.removeBotRole({ id: req.params.id, role: req.params.role });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 // ── API keys ─────────────────────────────────────────────────────────────────
 /**
@@ -218,18 +120,8 @@ router.delete('/:id/roles/:role', async (req, res) => {
  * List API keys for a bot (without secret values).
  */
 router.get('/:id/api-keys', async (req, res) => {
-    try {
-        const bot = await iam.getBot(req.params.id);
-        if (!bot) {
-            res.status(404).json({ error: 'Bot not found' });
-            return;
-        }
-        const keys = await iam.listBotKeys(req.params.id);
-        res.json({ keys });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.listBotKeys({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/bot-accounts/:id/api-keys
@@ -238,43 +130,21 @@ router.get('/:id/api-keys', async (req, res) => {
  * Returns the raw key ONCE — it cannot be retrieved again.
  */
 router.post('/:id/api-keys', async (req, res) => {
-    try {
-        const { name, scopes, expires_at } = req.body || {};
-        if (!name) {
-            res.status(400).json({ error: 'name is required' });
-            return;
-        }
-        const expiresAt = expires_at ? new Date(expires_at) : undefined;
-        const result = await iam.createBotKey(req.params.id, name, scopes || [], expiresAt);
-        res.status(201).json(result);
-    }
-    catch (err) {
-        if (err.message === 'Bot not found') {
-            res.status(404).json({ error: err.message });
-            return;
-        }
-        if (err.code === '23505') {
-            res.status(409).json({ error: 'API key with this name already exists for this bot' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const { name, scopes, expires_at } = req.body || {};
+    const result = await api.createBotKey({
+        id: req.params.id,
+        name,
+        scopes,
+        expires_at,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * DELETE /api/bot-accounts/:id/api-keys/:keyId
  * Revoke (delete) a bot API key.
  */
 router.delete('/:id/api-keys/:keyId', async (req, res) => {
-    try {
-        const revoked = await iam.revokeBotKey(req.params.keyId);
-        if (!revoked) {
-            res.status(404).json({ error: 'API key not found' });
-            return;
-        }
-        res.json({ revoked: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.revokeBotKey({ keyId: req.params.keyId });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;