@hotmeshio/long-tail 0.1.6 → 0.1.7

package/build/routes/yaml-workflows/deployment.js

@@ -34,11 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
-const yamlDeployer = __importStar(require("../../services/yaml-workflow/deployer"));
-const yamlWorkers = __importStar(require("../../services/yaml-workflow/workers"));
-const invoke_1 = require("../../services/yaml-workflow/invoke");
-const helpers_1 = require("./helpers");
+const api = __importStar(require("../../api/yaml-workflows"));
 const router = (0, express_1.Router)();
 /**
  * POST /api/yaml-workflows/:id/deploy
@@ -46,77 +42,16 @@ const router = (0, express_1.Router)();
  * Bumps the version and deploys all graphs together.
  */
 router.post('/:id/deploy', async (req, res) => {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        // Use the version declared in the YAML (like package.json)
-        const deployVersion = wf.app_version || '1';
-        // Deploy + activate merged YAML for the full app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
-        // Register workers and mark all non-archived siblings as active
-        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');
-            }
-        }
-        // Mark content as deployed for the entire app_id
-        await yamlDb.markAppIdContentDeployed(wf.app_id);
-        const updated = await yamlDb.getYamlWorkflow(req.params.id);
-        res.json(updated);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({
-            error: err.message,
-            hint: err.message.includes('Duplicate activity id')
-                ? 'Colliding activity IDs across workflows. A Claude Code repair was attempted — check server logs. You may need to archive conflicting workflows and recompile.'
-                : undefined,
-        });
-    }
+    const result = await api.deployYamlWorkflow({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/yaml-workflows/:id/activate
  * Activate the deployed version for this workflow's app_id and register all workers.
  */
 router.post('/:id/activate', async (req, res) => {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        if (wf.status !== 'deployed' && wf.status !== 'active') {
-            res.status(400).json({ error: 'Workflow must be deployed before activation' });
-            return;
-        }
-        await yamlDeployer.activateYamlWorkflow(wf.app_id, wf.app_version);
-        // Register workers for ALL workflows sharing this app_id
-        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
-        for (const sibling of siblings) {
-            await yamlWorkers.registerWorkersForWorkflow(sibling);
-            if (sibling.status === 'deployed') {
-                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
-            }
-        }
-        const updated = await yamlDb.getYamlWorkflow(req.params.id);
-        res.json(updated);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.activateYamlWorkflow({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/yaml-workflows/:id/invoke
@@ -124,56 +59,21 @@ router.post('/:id/activate', async (req, res) => {
  * Body: { data, sync?: boolean }
  */
 router.post('/:id/invoke', async (req, res) => {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        if (wf.status !== 'active') {
-            res.status(400).json({ error: 'Workflow must be active to invoke' });
-            return;
-        }
-        const result = await (0, invoke_1.invokeYamlWorkflow)(wf, {
-            data: req.body.data,
-            sync: req.body.sync,
-            timeout: req.body.timeout,
-            execute_as: req.body.execute_as,
-            userId: req.auth?.userId,
-        });
-        res.json(result);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.invokeYamlWorkflow({
+        id: req.params.id,
+        data: req.body.data,
+        sync: req.body.sync,
+        timeout: req.body.timeout,
+        execute_as: req.body.execute_as,
+    }, req.auth?.userId ? { userId: req.auth.userId } : undefined);
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/yaml-workflows/:id/archive
  * Archive a YAML workflow (stops accepting new invocations).
  */
 router.post('/:id/archive', async (req, res) => {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        if (wf.status === 'active') {
-            await yamlDeployer.stopEngine(wf.app_id);
-        }
-        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'archived');
-        res.json(updated);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.archiveYamlWorkflow({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

package/build/routes/yaml-workflows/versions.js

@@ -34,83 +34,45 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
-const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
-const helpers_1 = require("./helpers");
+const api = __importStar(require("../../api/yaml-workflows"));
 const router = (0, express_1.Router)();
 /**
  * GET /api/yaml-workflows/:id/versions
  * Return version history for a YAML workflow.
  */
 router.get('/:id/versions', async (req, res) => {
-    try {
-        const limit = req.query.limit ? parseInt(req.query.limit, 10) : 20;
-        const offset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
-        const result = await yamlDb.getVersionHistory(req.params.id, limit, offset);
-        res.json(result);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getVersionHistory({
+        id: req.params.id,
+        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/yaml-workflows/:id/versions/:version
  * Return a single version snapshot with YAML, schemas, and manifest.
  */
 router.get('/:id/versions/:version', async (req, res) => {
-    try {
-        const version = parseInt(req.params.version, 10);
-        if (isNaN(version) || version < 1) {
-            res.status(400).json({ error: 'Invalid version number' });
-            return;
-        }
-        const snapshot = await yamlDb.getVersionSnapshot(req.params.id, version);
-        if (!snapshot) {
-            res.status(404).json({ error: `Version ${version} not found` });
-            return;
-        }
-        res.json(snapshot);
-    }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getVersionSnapshot({
+        id: req.params.id,
+        version: parseInt(req.params.version, 10),
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/yaml-workflows/:id/yaml
  * Return raw YAML content. Supports ?version=N query param.
  */
 router.get('/:id/yaml', async (req, res) => {
-    try {
-        const versionParam = req.query.version ? parseInt(req.query.version, 10) : null;
-        if (versionParam) {
-            const snapshot = await yamlDb.getVersionSnapshot(req.params.id, versionParam);
-            if (!snapshot) {
-                res.status(404).json({ error: `Version ${versionParam} not found` });
-                return;
-            }
-            res.type('text/yaml').send(snapshot.yaml_content);
-            return;
-        }
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.type('text/yaml').send(wf.yaml_content);
+    const result = await api.getYamlContent({
+        id: req.params.id,
+        version: req.query.version ? parseInt(req.query.version, 10) : undefined,
+    });
+    if (result.status === 200) {
+        res.type('text/yaml').send(result.data);
     }
-    catch (err) {
-        if ((0, helpers_1.isNotFoundError)(err)) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
+    else {
+        res.status(result.status).json({ error: result.error });
     }
 });
 exports.default = router;

package/build/sdk/index.d.ts

@@ -0,0 +1,327 @@
+import * as tasksApi from '../api/tasks';
+import * as escalationsApi from '../api/escalations';
+import * as workflowsApi from '../api/workflows';
+import * as yamlWorkflowsApi from '../api/yaml-workflows';
+import * as usersApi from '../api/users';
+import * as rolesApi from '../api/roles';
+import * as authApi from '../api/auth';
+import * as mcpApi from '../api/mcp';
+import * as mcpRunsApi from '../api/mcp-runs';
+import * as insightApi from '../api/insight';
+import * as settingsApi from '../api/settings';
+import * as exportsApi from '../api/exports';
+import * as controlplaneApi from '../api/controlplane';
+import * as botAccountsApi from '../api/bot-accounts';
+import * as workflowSetsApi from '../api/workflow-sets';
+import * as dbaApi from '../api/dba';
+import * as namespacesApi from '../api/namespaces';
+import * as maintenanceApi from '../api/maintenance';
+import type { LTApiAuth, LTApiResult } from '../types/sdk';
+import type { LTEvent, LTEventType } from '../types/events';
+/**
+ * Options for createClient.
+ */
+export interface LTClientOptions {
+    /** Default auth context bound to every API call. Override per-call if needed. */
+    auth?: LTApiAuth;
+}
+/**
+ * Create a Long Tail SDK client for direct in-process API calls.
+ *
+ * All operations go through the same API layer as HTTP routes —
+ * same validation, same RBAC, same event publishing — without
+ * HTTP transport overhead.
+ *
+ * ```typescript
+ * import { createClient } from '@hotmeshio/long-tail/sdk';
+ *
+ * const lt = createClient({ auth: { userId: 'system' } });
+ *
+ * const result = await lt.escalations.claim({ id: 'esc_123', durationMinutes: 30 });
+ * // { status: 200, data: { escalation: {...}, isExtension: false } }
+ *
+ * lt.events.on('escalation.claimed', (event) => {
+ *   console.log('claimed:', event.escalationId);
+ * });
+ * ```
+ */
+export declare function createClient(options?: LTClientOptions): {
+    tasks: {
+        list: typeof tasksApi.listTasks;
+        get: typeof tasksApi.getTask;
+        listProcesses: typeof tasksApi.listProcesses;
+        getProcess: typeof tasksApi.getProcess;
+        getProcessStats: typeof tasksApi.getProcessStats;
+    };
+    escalations: {
+        list: (input: {
+            status?: string;
+            role?: string;
+            type?: string;
+            subtype?: string;
+            assigned_to?: string;
+            priority?: number;
+            limit?: number;
+            offset?: number;
+            sort_by?: string;
+            order?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        listAvailable: (input: {
+            role?: string;
+            type?: string;
+            subtype?: string;
+            priority?: number;
+            limit?: number;
+            offset?: number;
+            sort_by?: string;
+            order?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        listTypes: typeof escalationsApi.listDistinctTypes;
+        getStats: (input: {
+            period?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        get: (input: {
+            id: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        getByWorkflowId: typeof escalationsApi.getEscalationsByWorkflowId;
+        escalate: (input: {
+            id: string;
+            targetRole: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        claim: (input: {
+            id: string;
+            durationMinutes?: number;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        release: (input: {
+            id: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        resolve: (input: {
+            id: string;
+            resolverPayload: Record<string, any>;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        releaseExpired: typeof escalationsApi.releaseExpiredClaims;
+        updatePriority: (input: {
+            ids: string[];
+            priority: number;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        bulkClaim: (input: {
+            ids: string[];
+            durationMinutes?: number;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        bulkAssign: (input: {
+            ids: string[];
+            targetUserId: string;
+            durationMinutes?: number;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        bulkEscalate: (input: {
+            ids: string[];
+            targetRole: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        bulkTriage: (input: {
+            ids: string[];
+            hint?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+    };
+    workflows: {
+        invoke: (input: {
+            type: string;
+            data?: Record<string, any>;
+            metadata?: Record<string, any>;
+            execute_as?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        getStatus: typeof workflowsApi.getWorkflowStatus;
+        getResult: typeof workflowsApi.getWorkflowResult;
+        terminate: typeof workflowsApi.terminateWorkflow;
+        export: typeof workflowsApi.exportWorkflow;
+        listWorkers: typeof workflowsApi.listWorkers;
+        listDiscovered: typeof workflowsApi.listDiscoveredWorkflows;
+        getCronStatus: typeof workflowsApi.getCronStatus;
+        listConfigs: typeof workflowsApi.listWorkflowConfigs;
+        getConfig: typeof workflowsApi.getWorkflowConfig;
+        upsertConfig: typeof workflowsApi.upsertWorkflowConfig;
+        deleteConfig: typeof workflowsApi.deleteWorkflowConfig;
+    };
+    yamlWorkflows: {
+        list: typeof yamlWorkflowsApi.listYamlWorkflows;
+        create: typeof yamlWorkflowsApi.createYamlWorkflow;
+        createDirect: typeof yamlWorkflowsApi.createYamlWorkflowDirect;
+        getAppIds: typeof yamlWorkflowsApi.getAppIds;
+        get: typeof yamlWorkflowsApi.getYamlWorkflow;
+        update: typeof yamlWorkflowsApi.updateYamlWorkflow;
+        regenerate: typeof yamlWorkflowsApi.regenerateYamlWorkflow;
+        delete: typeof yamlWorkflowsApi.deleteYamlWorkflow;
+        deploy: typeof yamlWorkflowsApi.deployYamlWorkflow;
+        activate: typeof yamlWorkflowsApi.activateYamlWorkflow;
+        invoke: (input: {
+            id: string;
+            data?: any;
+            sync?: boolean;
+            timeout?: number;
+            execute_as?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        archive: typeof yamlWorkflowsApi.archiveYamlWorkflow;
+        getVersionHistory: typeof yamlWorkflowsApi.getVersionHistory;
+        getVersionSnapshot: typeof yamlWorkflowsApi.getVersionSnapshot;
+        getYamlContent: typeof yamlWorkflowsApi.getYamlContent;
+        setCronSchedule: typeof yamlWorkflowsApi.setCronSchedule;
+        clearCronSchedule: typeof yamlWorkflowsApi.clearCronSchedule;
+        getCronStatus: typeof yamlWorkflowsApi.getCronStatus;
+    };
+    users: {
+        list: typeof usersApi.listUsers;
+        get: typeof usersApi.getUser;
+        create: typeof usersApi.createUser;
+        update: typeof usersApi.updateUser;
+        delete: typeof usersApi.deleteUser;
+        getRoles: typeof usersApi.getUserRoles;
+        addRole: typeof usersApi.addUserRole;
+        removeRole: typeof usersApi.removeUserRole;
+    };
+    roles: {
+        list: typeof rolesApi.listRoles;
+        listWithDetails: typeof rolesApi.listRolesWithDetails;
+        create: typeof rolesApi.createRole;
+        delete: typeof rolesApi.deleteRole;
+        getEscalationChains: typeof rolesApi.getEscalationChains;
+        addEscalationChain: typeof rolesApi.addEscalationChain;
+        removeEscalationChain: typeof rolesApi.removeEscalationChain;
+        getEscalationTargets: typeof rolesApi.getEscalationTargets;
+        replaceEscalationTargets: typeof rolesApi.replaceEscalationTargets;
+    };
+    auth: {
+        login: typeof authApi.login;
+    };
+    mcp: {
+        listServers: typeof mcpApi.listMcpServers;
+        createServer: typeof mcpApi.createMcpServer;
+        testConnection: typeof mcpApi.testConnection;
+        getServer: typeof mcpApi.getMcpServer;
+        updateServer: typeof mcpApi.updateMcpServer;
+        deleteServer: typeof mcpApi.deleteMcpServer;
+        connectServer: typeof mcpApi.connectMcpServer;
+        disconnectServer: typeof mcpApi.disconnectMcpServer;
+        getCredentialStatus: (input: {
+            id: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        listTools: typeof mcpApi.listMcpServerTools;
+        callTool: (input: {
+            id: string;
+            toolName: string;
+            arguments?: Record<string, any>;
+            execute_as?: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+    };
+    mcpRuns: {
+        listEntities: typeof mcpRunsApi.listEntities;
+        listJobs: typeof mcpRunsApi.listJobs;
+        getExecution: typeof mcpRunsApi.getJobExecution;
+    };
+    insight: {
+        mcpQuery: (input: {
+            prompt: string;
+            tags?: string[];
+            wait?: boolean;
+            direct?: boolean;
+            context?: any;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        buildWorkflow: (input: {
+            prompt: string;
+            tags?: string[];
+            wait?: boolean;
+            feedback?: string;
+            prior_yaml?: string;
+            answers?: any;
+            prior_questions?: any;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        refineWorkflow: (input: {
+            prompt: string;
+            prior_yaml: string;
+            feedback: string;
+            tags?: string[];
+            wait?: boolean;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        describeWorkflow: typeof insightApi.describeWorkflow;
+    };
+    settings: {
+        get: typeof settingsApi.getSettings;
+    };
+    exports: {
+        listJobs: typeof exportsApi.listJobs;
+        exportState: typeof exportsApi.exportWorkflowState;
+        exportExecution: typeof exportsApi.exportWorkflowExecution;
+        getStatus: typeof exportsApi.getWorkflowStatus;
+        getState: typeof exportsApi.getWorkflowState;
+    };
+    controlplane: {
+        listApps: typeof controlplaneApi.listApps;
+        rollCall: typeof controlplaneApi.rollCall;
+        throttle: typeof controlplaneApi.applyThrottle;
+        getStreamStats: typeof controlplaneApi.getStreamStats;
+        subscribe: typeof controlplaneApi.subscribeMesh;
+    };
+    botAccounts: {
+        list: typeof botAccountsApi.listBots;
+        get: typeof botAccountsApi.getBot;
+        create: (input: {
+            name: string;
+            description?: string;
+            display_name?: string;
+            roles?: {
+                role: string;
+                type: string;
+            }[];
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        update: typeof botAccountsApi.updateBot;
+        delete: typeof botAccountsApi.deleteBot;
+        getRoles: typeof botAccountsApi.getBotRoles;
+        addRole: typeof botAccountsApi.addBotRole;
+        removeRole: typeof botAccountsApi.removeBotRole;
+        listKeys: typeof botAccountsApi.listBotKeys;
+        createKey: typeof botAccountsApi.createBotKey;
+        revokeKey: typeof botAccountsApi.revokeBotKey;
+    };
+    workflowSets: {
+        create: (input: {
+            name: string;
+            description?: string;
+            specification: string;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        list: typeof workflowSetsApi.listWorkflowSets;
+        get: typeof workflowSetsApi.getWorkflowSet;
+        updatePlan: typeof workflowSetsApi.updateWorkflowSetPlanApi;
+        build: typeof workflowSetsApi.buildWorkflowSet;
+        deploy: typeof workflowSetsApi.deployWorkflowSet;
+    };
+    dba: {
+        prune: typeof dbaApi.prune;
+        deploy: typeof dbaApi.deploy;
+    };
+    namespaces: {
+        list: typeof namespacesApi.listNamespaces;
+        register: typeof namespacesApi.registerNamespace;
+    };
+    maintenance: {
+        getConfig: typeof maintenanceApi.getMaintenanceConfig;
+        updateConfig: typeof maintenanceApi.updateMaintenanceConfig;
+    };
+    events: {
+        /**
+         * Subscribe to Long Tail events.
+         *
+         * Supports exact types (`'task.created'`), category wildcards (`'task.*'`),
+         * and global wildcard (`'*'`).
+         *
+         * Returns an unsubscribe function.
+         *
+         * ```typescript
+         * const unsub = lt.events.on('escalation.claimed', (event) => {
+         *   console.log('claimed:', event.escalationId);
+         * });
+         * // Later: unsub();
+         * ```
+         */
+        on: (pattern: LTEventType | "*" | (string & {}), callback: (event: LTEvent) => void) => (() => void);
+    };
+};
+/** The return type of createClient(). */
+export type LTClient = ReturnType<typeof createClient>;