@hotmeshio/long-tail 0.1.6 → 0.1.7

package/build/api/users.js

@@ -0,0 +1,162 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listUsers = listUsers;
+exports.getUser = getUser;
+exports.createUser = createUser;
+exports.updateUser = updateUser;
+exports.deleteUser = deleteUser;
+exports.getUserRoles = getUserRoles;
+exports.addUserRole = addUserRole;
+exports.removeUserRole = removeUserRole;
+const userService = __importStar(require("../services/user"));
+async function listUsers(input) {
+    try {
+        const result = await userService.listUsers(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getUser(input) {
+    try {
+        const user = await userService.getUser(input.id);
+        if (!user) {
+            return { status: 404, error: 'User not found' };
+        }
+        return { status: 200, data: user };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function createUser(input) {
+    try {
+        if (!input.external_id) {
+            return { status: 400, error: 'external_id is required' };
+        }
+        if (input.roles) {
+            for (const r of input.roles) {
+                if (!r.role || !r.type || !userService.isValidRoleType(r.type)) {
+                    return {
+                        status: 400,
+                        error: 'Each role must have a role name and type (superadmin, admin, member)',
+                    };
+                }
+            }
+        }
+        const user = await userService.createUser({
+            external_id: input.external_id,
+            email: input.email,
+            display_name: input.display_name,
+            roles: input.roles,
+            metadata: input.metadata,
+        });
+        return { status: 201, data: user };
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            return { status: 409, error: 'User with this external_id already exists' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function updateUser(input) {
+    try {
+        const { id, ...fields } = input;
+        const user = await userService.updateUser(id, fields);
+        if (!user) {
+            return { status: 404, error: 'User not found' };
+        }
+        return { status: 200, data: user };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function deleteUser(input) {
+    try {
+        const deleted = await userService.deleteUser(input.id);
+        if (!deleted) {
+            return { status: 404, error: 'User not found' };
+        }
+        return { status: 200, data: { deleted: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getUserRoles(input) {
+    try {
+        const roles = await userService.getUserRoles(input.id);
+        return { status: 200, data: { roles } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function addUserRole(input) {
+    try {
+        if (!input.role || !input.type) {
+            return { status: 400, error: 'role and type are required' };
+        }
+        if (!userService.isValidRoleType(input.type)) {
+            return { status: 400, error: 'type must be superadmin, admin, or member' };
+        }
+        const result = await userService.addUserRole(input.id, input.role, input.type);
+        return { status: 201, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function removeUserRole(input) {
+    try {
+        const removed = await userService.removeUserRole(input.id, input.role);
+        if (!removed) {
+            return { status: 404, error: 'Role not found' };
+        }
+        return { status: 200, data: { removed: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/workflow-sets.d.ts

@@ -0,0 +1,26 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+export declare function createWorkflowSet(input: {
+    name: string;
+    description?: string;
+    specification: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+export declare function listWorkflowSets(input: {
+    status?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+export declare function getWorkflowSet(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function updateWorkflowSetPlanApi(input: {
+    id: string;
+    plan: any[];
+    namespaces?: any[];
+}): Promise<LTApiResult>;
+export declare function buildWorkflowSet(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function deployWorkflowSet(input: {
+    id: string;
+}): Promise<LTApiResult>;

package/build/api/workflow-sets.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflowSet = createWorkflowSet;
+exports.listWorkflowSets = listWorkflowSets;
+exports.getWorkflowSet = getWorkflowSet;
+exports.updateWorkflowSetPlanApi = updateWorkflowSetPlanApi;
+exports.buildWorkflowSet = buildWorkflowSet;
+exports.deployWorkflowSet = deployWorkflowSet;
+const workflow_sets_1 = require("../services/workflow-sets");
+const insight_1 = require("../services/insight");
+async function createWorkflowSet(input, auth) {
+    try {
+        if (!input.specification || typeof input.specification !== 'string') {
+            return { status: 400, error: 'specification is required' };
+        }
+        if (!input.name || typeof input.name !== 'string') {
+            return { status: 400, error: 'name is required' };
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return { status: 503, error: 'Workflow planner requires an LLM API key' };
+        }
+        const set = await (0, workflow_sets_1.createWorkflowSet)({
+            name: input.name,
+            description: input.description,
+            specification: input.specification,
+        });
+        const plannerResult = await (0, insight_1.startWorkflowPlanner)({
+            specification: input.specification,
+            setId: set.id,
+            wait: false,
+            userId: auth?.userId,
+        });
+        await (0, workflow_sets_1.updateWorkflowSetSourceWorkflow)(set.id, plannerResult.workflow_id);
+        return {
+            status: 201,
+            data: {
+                ...set,
+                source_workflow_id: plannerResult.workflow_id,
+                planner_workflow_id: plannerResult.workflow_id,
+            },
+        };
+    }
+    catch (err) {
+        if (err.code === '23505') {
+            return { status: 409, error: 'A workflow set with this name already exists' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function listWorkflowSets(input) {
+    try {
+        const result = await (0, workflow_sets_1.listWorkflowSets)({
+            status: input.status,
+            search: input.search,
+            limit: input.limit,
+            offset: input.offset,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getWorkflowSet(input) {
+    try {
+        const set = await (0, workflow_sets_1.getWorkflowSet)(input.id);
+        if (!set) {
+            return { status: 404, error: 'Workflow set not found' };
+        }
+        return { status: 200, data: set };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function updateWorkflowSetPlanApi(input) {
+    try {
+        if (!Array.isArray(input.plan)) {
+            return { status: 400, error: 'plan must be an array' };
+        }
+        const updated = await (0, workflow_sets_1.updateWorkflowSetPlan)(input.id, input.plan, input.namespaces || []);
+        if (!updated) {
+            return { status: 404, error: 'Workflow set not found' };
+        }
+        return { status: 200, data: updated };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function buildWorkflowSet(input) {
+    try {
+        const set = await (0, workflow_sets_1.getWorkflowSet)(input.id);
+        if (!set) {
+            return { status: 404, error: 'Workflow set not found' };
+        }
+        if (set.status !== 'planned') {
+            return { status: 409, error: `Cannot build set in '${set.status}' status` };
+        }
+        await (0, workflow_sets_1.updateWorkflowSetStatus)(input.id, 'building');
+        return { status: 200, data: { status: 'building', id: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function deployWorkflowSet(input) {
+    try {
+        const set = await (0, workflow_sets_1.getWorkflowSet)(input.id);
+        if (!set) {
+            return { status: 404, error: 'Workflow set not found' };
+        }
+        await (0, workflow_sets_1.updateWorkflowSetStatus)(input.id, 'deploying');
+        return { status: 200, data: { status: 'deploying', id: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/workflows.d.ts

@@ -0,0 +1,48 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+export declare function invokeWorkflow(input: {
+    type: string;
+    data?: Record<string, any>;
+    metadata?: Record<string, any>;
+    execute_as?: string;
+}, auth: LTApiAuth): Promise<LTApiResult>;
+export declare function getWorkflowStatus(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+export declare function getWorkflowResult(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+export declare function terminateWorkflow(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+export declare function exportWorkflow(input: {
+    workflowId: string;
+}): Promise<LTApiResult>;
+export declare function listWorkers(input: {
+    include_system?: boolean;
+}): Promise<LTApiResult>;
+export declare function listDiscoveredWorkflows(input: {
+    include_system?: boolean;
+}): Promise<LTApiResult>;
+export declare function getCronStatus(): Promise<LTApiResult>;
+export declare function listWorkflowConfigs(): Promise<LTApiResult>;
+export declare function getWorkflowConfig(input: {
+    type: string;
+}): Promise<LTApiResult>;
+export declare function upsertWorkflowConfig(input: {
+    type: string;
+    invocable?: boolean;
+    task_queue?: string | null;
+    default_role?: string;
+    description?: string | null;
+    execute_as?: string | null;
+    roles?: string[];
+    invocation_roles?: string[];
+    consumes?: string[];
+    tool_tags?: string[];
+    envelope_schema?: any;
+    resolver_schema?: any;
+    cron_schedule?: string | null;
+}): Promise<LTApiResult>;
+export declare function deleteWorkflowConfig(input: {
+    type: string;
+}): Promise<LTApiResult>;

package/build/api/workflows.js

@@ -0,0 +1,298 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWorkflow = invokeWorkflow;
+exports.getWorkflowStatus = getWorkflowStatus;
+exports.getWorkflowResult = getWorkflowResult;
+exports.terminateWorkflow = terminateWorkflow;
+exports.exportWorkflow = exportWorkflow;
+exports.listWorkers = listWorkers;
+exports.listDiscoveredWorkflows = listDiscoveredWorkflows;
+exports.getCronStatus = getCronStatus;
+exports.listWorkflowConfigs = listWorkflowConfigs;
+exports.getWorkflowConfig = getWorkflowConfig;
+exports.upsertWorkflowConfig = upsertWorkflowConfig;
+exports.deleteWorkflowConfig = deleteWorkflowConfig;
+const workers_1 = require("../workers");
+const exportService = __importStar(require("../services/export"));
+const configService = __importStar(require("../services/config"));
+const cron_1 = require("../services/cron");
+const db_1 = require("../lib/db");
+const registry_1 = require("../services/workers/registry");
+const sql_1 = require("../services/mcp-runs/sql");
+const task_1 = require("../services/task");
+const workflow_invocation_1 = require("../services/workflow-invocation");
+const ltconfig_1 = require("../modules/ltconfig");
+function isResolveError(err) {
+    return err?.message?.includes('Cannot resolve workflow');
+}
+// ── Invocation ──────────────────────────────────────────────────────────────
+async function invokeWorkflow(input, auth) {
+    try {
+        await (0, workflow_invocation_1.checkInvocationRoles)(input.type, auth.userId);
+        const result = await (0, workflow_invocation_1.invokeWorkflow)({
+            workflowType: input.type,
+            data: input.data || {},
+            metadata: input.metadata,
+            executeAs: input.execute_as,
+            auth: {
+                userId: auth.userId,
+            },
+        });
+        return {
+            status: 202,
+            data: { workflowId: result.workflowId, message: 'Workflow started' },
+        };
+    }
+    catch (err) {
+        const status = err instanceof workflow_invocation_1.InvocationError ? err.statusCode : 500;
+        return { status, error: err.message };
+    }
+}
+async function getWorkflowStatus(input) {
+    try {
+        const resolved = await (0, task_1.resolveWorkflowHandle)(input.workflowId);
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, input.workflowId);
+        const status = await handle.status();
+        return {
+            status: 200,
+            data: { workflowId: input.workflowId, status },
+        };
+    }
+    catch (err) {
+        if (isResolveError(err))
+            return { status: 404, error: err.message };
+        return { status: 500, error: err.message };
+    }
+}
+async function getWorkflowResult(input) {
+    try {
+        const resolved = await (0, task_1.resolveWorkflowHandle)(input.workflowId);
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, input.workflowId);
+        const status = await handle.status();
+        if (status !== 0) {
+            return {
+                status: 202,
+                data: { workflowId: input.workflowId, status: 'running' },
+            };
+        }
+        const result = await handle.result();
+        return {
+            status: 200,
+            data: { workflowId: input.workflowId, result },
+        };
+    }
+    catch (err) {
+        if (isResolveError(err))
+            return { status: 404, error: err.message };
+        return { status: 500, error: err.message };
+    }
+}
+async function terminateWorkflow(input) {
+    try {
+        const resolved = await (0, task_1.resolveWorkflowHandle)(input.workflowId);
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(resolved.taskQueue, resolved.workflowName, input.workflowId);
+        await handle.terminate();
+        return {
+            status: 200,
+            data: { terminated: true, workflowId: input.workflowId },
+        };
+    }
+    catch (err) {
+        if (isResolveError(err))
+            return { status: 404, error: err.message };
+        return { status: 500, error: err.message };
+    }
+}
+async function exportWorkflow(input) {
+    try {
+        const resolved = await (0, task_1.resolveWorkflowHandle)(input.workflowId);
+        const exported = await exportService.exportWorkflow(input.workflowId, resolved.taskQueue, resolved.workflowName);
+        return { status: 200, data: exported };
+    }
+    catch (err) {
+        if (isResolveError(err))
+            return { status: 404, error: err.message };
+        return { status: 500, error: err.message };
+    }
+}
+// ── Discovery ───────────────────────────────────────────────────────────────
+async function listWorkers(input) {
+    try {
+        const activeWorkers = (0, registry_1.getRegisteredWorkers)();
+        const configs = await configService.listWorkflowConfigs();
+        const registeredTypes = new Set(configs.map((c) => c.workflow_type));
+        const workers = [...activeWorkers.entries()]
+            .filter(([name]) => input.include_system || !registry_1.SYSTEM_WORKFLOWS.has(name))
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([name, { taskQueue }]) => ({
+            name,
+            task_queue: taskQueue,
+            registered: registeredTypes.has(name),
+            system: registry_1.SYSTEM_WORKFLOWS.has(name),
+        }));
+        return { status: 200, data: { workers } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listDiscoveredWorkflows(input) {
+    try {
+        // 1. Active workers from in-memory registry
+        const activeWorkers = (0, registry_1.getRegisteredWorkers)();
+        // 2. Historical entities from durable.jobs
+        const pool = (0, db_1.getPool)();
+        const { rows: entityRows } = await pool.query(sql_1.DISTINCT_ENTITIES_DURABLE);
+        const historicalEntities = new Set(entityRows.map((r) => r.entity));
+        // 3. Registered configs
+        const configs = await configService.listWorkflowConfigs();
+        const configMap = new Map(configs.map((c) => [c.workflow_type, c]));
+        // Build unified set of all workflow types
+        const allTypes = new Set();
+        for (const [name] of activeWorkers)
+            allTypes.add(name);
+        for (const entity of historicalEntities)
+            allTypes.add(entity);
+        for (const c of configs)
+            allTypes.add(c.workflow_type);
+        const workflows = [...allTypes]
+            .filter((t) => input.include_system || !registry_1.SYSTEM_WORKFLOWS.has(t))
+            .sort()
+            .map((workflowType) => {
+            const config = configMap.get(workflowType);
+            const worker = activeWorkers.get(workflowType);
+            return {
+                workflow_type: workflowType,
+                task_queue: config?.task_queue ?? worker?.taskQueue ?? null,
+                registered: !!config,
+                active: !!worker,
+                invocable: config?.invocable ?? !!worker,
+                system: registry_1.SYSTEM_WORKFLOWS.has(workflowType),
+                description: config?.description ?? null,
+                roles: config?.roles ?? [],
+                invocation_roles: config?.invocation_roles ?? [],
+                execute_as: config?.execute_as ?? null,
+            };
+        });
+        return { status: 200, data: { workflows } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getCronStatus() {
+    try {
+        const configs = await configService.listWorkflowConfigs();
+        const cronConfigs = configs.filter((c) => c.cron_schedule);
+        const activeTypes = cron_1.cronRegistry.activeWorkflowTypes;
+        const schedules = cronConfigs.map((c) => ({
+            workflow_type: c.workflow_type,
+            cron_schedule: c.cron_schedule,
+            description: c.description,
+            task_queue: c.task_queue,
+            invocable: c.invocable,
+            active: activeTypes.includes(c.workflow_type),
+            envelope_schema: c.envelope_schema,
+        }));
+        return { status: 200, data: { schedules } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// ── Configuration ───────────────────────────────────────────────────────────
+async function listWorkflowConfigs() {
+    try {
+        const configs = await configService.listWorkflowConfigs();
+        return { status: 200, data: { workflows: configs } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getWorkflowConfig(input) {
+    try {
+        const config = await configService.getWorkflowConfig(input.type);
+        if (!config) {
+            return { status: 404, error: 'Workflow config not found' };
+        }
+        return { status: 200, data: config };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function upsertWorkflowConfig(input) {
+    try {
+        const config = await configService.upsertWorkflowConfig({
+            workflow_type: input.type,
+            invocable: input.invocable ?? false,
+            task_queue: input.task_queue ?? null,
+            default_role: input.default_role ?? 'reviewer',
+            description: input.description ?? null,
+            execute_as: input.execute_as ?? null,
+            roles: input.roles ?? [],
+            invocation_roles: input.invocation_roles ?? [],
+            consumes: input.consumes ?? [],
+            tool_tags: input.tool_tags ?? [],
+            envelope_schema: input.envelope_schema ?? null,
+            resolver_schema: input.resolver_schema ?? null,
+            cron_schedule: input.cron_schedule ?? null,
+        });
+        ltconfig_1.ltConfig.invalidate();
+        await cron_1.cronRegistry.restartCron(config);
+        return { status: 200, data: config };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function deleteWorkflowConfig(input) {
+    try {
+        const deleted = await configService.deleteWorkflowConfig(input.type);
+        if (!deleted) {
+            return { status: 404, error: 'Workflow config not found' };
+        }
+        ltconfig_1.ltConfig.invalidate();
+        return { status: 200, data: { deleted: true, workflow_type: input.type } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}