@hotmeshio/long-tail 0.1.6 → 0.1.8

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;

package/build/routes/controlplane.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 controlplane = __importStar(require("../services/controlplane"));
-const events_1 = require("../lib/events");
+const api = __importStar(require("../api/controlplane"));
 const router = (0, express_1.Router)();
 /**
  * GET /api/controlplane/apps
@@ -44,13 +43,8 @@ const router = (0, express_1.Router)();
  * Admin-only.
  */
 router.get('/apps', auth_1.requireAdmin, async (_req, res) => {
-    try {
-        const apps = await controlplane.listApps();
-        res.json({ apps });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.listApps();
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/controlplane/rollcall?app_id=durable&delay=1000
@@ -58,15 +52,11 @@ router.get('/apps', auth_1.requireAdmin, async (_req, res) => {
  * Admin-only.
  */
 router.get('/rollcall', auth_1.requireAdmin, async (req, res) => {
-    try {
-        const appId = req.query.app_id || 'durable';
-        const delay = req.query.delay ? parseInt(req.query.delay, 10) : undefined;
-        const profiles = await controlplane.rollCall(appId, delay);
-        res.json({ profiles });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.rollCall({
+        appId: req.query.app_id || 'durable',
+        delay: req.query.delay ? parseInt(req.query.delay, 10) : undefined,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/controlplane/throttle
@@ -77,30 +67,9 @@ router.get('/rollcall', auth_1.requireAdmin, async (req, res) => {
  *   throttle: ms delay (-1 = pause, 0 = resume, >0 = delay per msg)
  */
 router.post('/throttle', auth_1.requireAdmin, async (req, res) => {
-    try {
-        const { appId = 'durable', throttle, topic, guid } = req.body;
-        if (typeof throttle !== 'number') {
-            res.status(400).json({ error: 'throttle (number) is required' });
-            return;
-        }
-        const result = await controlplane.applyThrottle(appId, { throttle, topic, guid });
-        // Publish a synthetic event so the dashboard event stream sees it
-        // (throttle commands don't echo back through the quorum subscription)
-        const throttleEvent = {
-            type: 'mesh.throttle',
-            source: 'controlplane',
-            workflowId: guid || '',
-            workflowName: '',
-            taskQueue: appId,
-            data: { throttle, topic, guid, appId },
-            timestamp: new Date().toISOString(),
-        };
-        events_1.eventRegistry.publish(throttleEvent).catch(() => { });
-        res.json({ success: result });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const { appId = 'durable', throttle, topic, guid } = req.body;
+    const result = await api.applyThrottle({ appId, throttle, topic, guid });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/controlplane/streams?app_id=durable&duration=1h&stream=hmsh:durable:x:
@@ -111,16 +80,12 @@ router.post('/throttle', auth_1.requireAdmin, async (req, res) => {
  * stream: optional stream_name filter (specific task queue topic)
  */
 router.get('/streams', auth_1.requireAdmin, async (req, res) => {
-    try {
-        const schema = req.query.app_id || 'durable';
-        const duration = req.query.duration || '1h';
-        const stream = req.query.stream || undefined;
-        const stats = await controlplane.getStreamStats(schema, duration, stream);
-        res.json(stats);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getStreamStats({
+        app_id: req.query.app_id || 'durable',
+        duration: req.query.duration || '1h',
+        stream: req.query.stream || undefined,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/controlplane/subscribe
@@ -132,13 +97,8 @@ router.get('/streams', auth_1.requireAdmin, async (req, res) => {
  * Body: { appId: string }
  */
 router.post('/subscribe', auth_1.requireAdmin, async (req, res) => {
-    try {
-        const { appId = 'durable' } = req.body;
-        await controlplane.subscribeMesh(appId);
-        res.json({ subscribed: true, appId });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const { appId = 'durable' } = req.body;
+    const result = await api.subscribeMesh({ appId });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;