@hotmeshio/long-tail 0.1.12 → 0.1.14

package/README.md

@@ -1,6 +1,6 @@
 # Long Tail
 
-Turn your PostgreSQL database into a workflow engine with identity-aware durable execution, human-in-the-loop escalation, and MCP tool orchestration.
+Long Tail turns your PostgreSQL database into a workflow engine where human and AI work share the same durable execution path. Hand off, pull back, escalate, automate — without rewriting systems or losing continuity.
 
 ```bash
 npm install @hotmeshio/long-tail

package/build/api/files.d.ts

@@ -0,0 +1,13 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function browseFiles(input: {
+    prefix?: string;
+    pageSize?: number;
+    continuationToken?: string;
+}): Promise<LTApiResult>;
+export declare function getFileMetadata(input: {
+    filePath: string;
+}): Promise<LTApiResult>;
+export declare function generateSignedUrl(input: {
+    filePath: string;
+    expiresIn: number;
+}): Promise<LTApiResult>;

package/build/api/files.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseFiles = browseFiles;
+exports.getFileMetadata = getFileMetadata;
+exports.generateSignedUrl = generateSignedUrl;
+const storage_1 = require("../lib/storage");
+const ALLOWED_EXPIRY = [3600, 21600, 86400, 604800, 2592000]; // 1h, 6h, 24h, 7d, 30d
+async function browseFiles(input) {
+    try {
+        const result = await (0, storage_1.getStorageBackend)().listWithPrefixes(input.prefix, input.pageSize || 100, input.continuationToken);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getFileMetadata(input) {
+    try {
+        const metadata = await (0, storage_1.getStorageBackend)().getMetadata(input.filePath);
+        return { status: 200, data: { path: input.filePath, ...metadata } };
+    }
+    catch (err) {
+        if (err.message?.includes('not found') || err.name === 'NotFound') {
+            return { status: 404, error: 'File not found' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function generateSignedUrl(input) {
+    if (!ALLOWED_EXPIRY.includes(input.expiresIn)) {
+        return {
+            status: 400,
+            error: `expiresIn must be one of: ${ALLOWED_EXPIRY.join(', ')} (seconds)`,
+        };
+    }
+    try {
+        const url = await (0, storage_1.getStorageBackend)().getSignedUrl(input.filePath, input.expiresIn);
+        const expiresAt = new Date(Date.now() + input.expiresIn * 1000).toISOString();
+        return { status: 200, data: { url, expiresAt } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

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

@@ -26,6 +26,8 @@ export declare function listJobs(input: {
     entity?: string;
     search?: string;
     status?: string;
+    sort_by?: string;
+    order?: string;
 }): Promise<LTApiResult>;
 /**
  * Get the full execution history for a single job.

package/build/api/mcp-runs.js

@@ -49,6 +49,8 @@ async function listJobs(input) {
             entity: input.entity,
             search: input.search,
             status: input.status,
+            sort_by: input.sort_by,
+            order: input.order,
         });
         return { status: 200, data: result };
     }

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

@@ -75,3 +75,14 @@ export declare function buildWorkflowSet(input: {
 export declare function deployWorkflowSet(input: {
     id: string;
 }): Promise<LTApiResult>;
+/**
+ * Add additional workflows to an existing set.
+ *
+ * Invokes the planner with the new specification and existing set context.
+ * The planner appends new plan items (offset build_order) and builds them
+ * with sibling schema awareness so composition wiring works.
+ */
+export declare function addToWorkflowSet(input: {
+    id: string;
+    specification: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;

package/build/api/workflow-sets.js

@@ -6,8 +6,10 @@ exports.getWorkflowSet = getWorkflowSet;
 exports.updateWorkflowSetPlanApi = updateWorkflowSetPlanApi;
 exports.buildWorkflowSet = buildWorkflowSet;
 exports.deployWorkflowSet = deployWorkflowSet;
+exports.addToWorkflowSet = addToWorkflowSet;
 const workflow_sets_1 = require("../services/workflow-sets");
 const insight_1 = require("../services/insight");
+const yaml_workflows_1 = require("./yaml-workflows");
 /**
  * Create a new workflow set and kick off the LLM-powered planner.
  *
@@ -168,3 +170,63 @@ async function deployWorkflowSet(input) {
         return { status: 500, error: err.message };
     }
 }
+/**
+ * Add additional workflows to an existing set.
+ *
+ * Invokes the planner with the new specification and existing set context.
+ * The planner appends new plan items (offset build_order) and builds them
+ * with sibling schema awareness so composition wiring works.
+ */
+async function addToWorkflowSet(input, auth) {
+    try {
+        if (!input.specification || typeof input.specification !== 'string') {
+            return { status: 400, error: 'specification 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.getWorkflowSet)(input.id);
+        if (!set) {
+            return { status: 404, error: 'Workflow set not found' };
+        }
+        // Gather existing plan items and built workflow schemas
+        const existingPlan = (set.plan || []).map(p => ({
+            name: p.name,
+            description: p.description,
+            namespace: p.namespace,
+        }));
+        const yamlResult = await (0, yaml_workflows_1.listYamlWorkflows)({ set_id: input.id, limit: 100 });
+        const workflows = yamlResult.data?.workflows || [];
+        const existingSchemas = workflows
+            .filter((w) => w.status === 'active' || w.status === 'draft')
+            .map((w) => ({
+            name: w.name,
+            input_schema: w.input_schema || {},
+            output_schema: w.output_schema || {},
+            graph_topic: w.graph_topic,
+        }));
+        // Append the new spec to the set's specification field so the full
+        // history of what was pasted is preserved and visible on step 1.
+        await (0, workflow_sets_1.appendWorkflowSetSpecification)(input.id, input.specification);
+        const plannerResult = await (0, insight_1.startWorkflowPlanner)({
+            specification: input.specification,
+            setId: input.id,
+            wait: false,
+            userId: auth?.userId,
+            existingPlan,
+            existingSchemas,
+        });
+        await (0, workflow_sets_1.updateWorkflowSetSourceWorkflow)(input.id, plannerResult.workflow_id);
+        return {
+            status: 200,
+            data: {
+                ...set,
+                source_workflow_id: plannerResult.workflow_id,
+                planner_workflow_id: plannerResult.workflow_id,
+            },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/yaml-workflows.d.ts

@@ -200,6 +200,15 @@ export declare function invokeYamlWorkflow(input: {
 export declare function archiveYamlWorkflow(input: {
     id: string;
 }): Promise<LTApiResult>;
+/**
+ * Restore an archived YAML workflow back to draft status.
+ *
+ * Transitions the workflow from "archived" to "draft" so it can be
+ * redeployed. The workflow must be in "archived" status.
+ */
+export declare function restoreYamlWorkflow(input: {
+    id: string;
+}): Promise<LTApiResult>;
 /**
  * Retrieve the version history for a YAML workflow.
  *

package/build/api/yaml-workflows.js

@@ -45,6 +45,7 @@ exports.deployYamlWorkflow = deployYamlWorkflow;
 exports.activateYamlWorkflow = activateYamlWorkflow;
 exports.invokeYamlWorkflow = invokeYamlWorkflow;
 exports.archiveYamlWorkflow = archiveYamlWorkflow;
+exports.restoreYamlWorkflow = restoreYamlWorkflow;
 exports.getVersionHistory = getVersionHistory;
 exports.getVersionSnapshot = getVersionSnapshot;
 exports.getYamlContent = getYamlContent;
@@ -58,6 +59,7 @@ const yamlWorkers = __importStar(require("../services/yaml-workflow/workers"));
 const invoke_1 = require("../services/yaml-workflow/invoke");
 const task_1 = require("../services/task");
 const cron_1 = require("../services/cron");
+const utils_1 = require("../modules/utils");
 /** Return true if a Postgres error indicates an invalid/missing ID */
 function isNotFoundError(err) {
     const msg = err?.message ?? '';
@@ -143,8 +145,8 @@ async function createYamlWorkflow(input) {
             }
         }
         // Check for topic collision in the target namespace
-        const compileAppId = app_id || 'longtail';
-        const compileTopic = subscribes || name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+        const compileAppId = (0, utils_1.sanitizeServerName)(app_id || 'longtail');
+        const compileTopic = (0, utils_1.sanitizeToolName)(subscribes || name);
         const conflicting = await yamlDb.checkTopicConflict(compileAppId, compileTopic);
         if (conflicting) {
             return {
@@ -220,15 +222,15 @@ async function createYamlWorkflowDirect(input) {
         if (!name || !yaml_content) {
             return { status: 400, error: 'name and yaml_content are required' };
         }
-        // Sanitize name (tool name): lowercase alphanumeric, periods, dashes, underscores
-        const sanitizedName = name.toLowerCase().replace(/[^a-z0-9._-]/g, '');
-        // Sanitize app_id (MCP server name): force lowercase alphanumeric only
-        const targetAppId = (app_id || 'longtail').toLowerCase().replace(/[^a-z0-9]/g, '');
-        // Sanitize graph topic: lowercase alphanumeric, periods, dashes, underscores
-        let graphTopic = (graph_topic || sanitizedName).toLowerCase().replace(/[^a-z0-9._-]/g, '');
+        // Sanitize name (tool name): snake_case only
+        const sanitizedName = (0, utils_1.sanitizeToolName)(name);
+        // Sanitize app_id (MCP server name): lowercase alphanumeric, must start with a letter
+        const targetAppId = (0, utils_1.sanitizeServerName)(app_id || 'longtail');
+        // Sanitize graph topic: snake_case only
+        let graphTopic = (0, utils_1.sanitizeToolName)(graph_topic || sanitizedName);
         const subscribesMatch = yaml_content.match(/subscribes:\s*(.+)/);
         if (subscribesMatch) {
-            graphTopic = subscribesMatch[1].trim().replace(/^['"]|['"]$/g, '').toLowerCase().replace(/[^a-z0-9._-]/g, '');
+            graphTopic = (0, utils_1.sanitizeToolName)(subscribesMatch[1].trim().replace(/^['"]|['"]$/g, ''));
         }
         // Rewrite the subscribes line in the YAML to match the sanitized topic
         let finalYaml = yaml_content;
@@ -438,8 +440,10 @@ async function deployYamlWorkflow(input) {
         if (!wf) {
             return { status: 404, error: 'YAML workflow not found' };
         }
-        // Use the version declared in the YAML (like package.json)
-        const deployVersion = wf.app_version || '1';
+        // Compute the next app-level version for the namespace.
+        // Each deploy increments regardless of individual tool versions —
+        // adding a second tool (v1 of itself) to an app already at v1 produces app v2.
+        const deployVersion = await yamlDb.getNextAppVersion(wf.app_id);
         // Deploy + activate merged YAML for the full app_id
         const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
         await yamlDeployer.deployAppId(wf.app_id, deployVersion);
@@ -573,6 +577,31 @@ async function archiveYamlWorkflow(input) {
         return { status: 500, error: err.message };
     }
 }
+/**
+ * Restore an archived YAML workflow back to draft status.
+ *
+ * Transitions the workflow from "archived" to "draft" so it can be
+ * redeployed. The workflow must be in "archived" status.
+ */
+async function restoreYamlWorkflow(input) {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(input.id);
+        if (!wf) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        if (wf.status !== 'archived') {
+            return { status: 400, error: 'Only archived workflows can be restored' };
+        }
+        const updated = await yamlDb.updateYamlWorkflowStatus(wf.id, 'draft');
+        return { status: 200, data: updated };
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
 // ---------------------------------------------------------------------------
 // Versions
 // ---------------------------------------------------------------------------

package/build/examples/seed.js

@@ -4,6 +4,7 @@ exports.seedExamples = seedExamples;
 const hotmesh_1 = require("@hotmeshio/hotmesh");
 const defaults_1 = require("../modules/defaults");
 const logger_1 = require("../lib/logger");
+const db_1 = require("../lib/db");
 const user_1 = require("../services/user");
 const roles_1 = require("../services/user/roles");
 const role_1 = require("../services/role");
@@ -211,11 +212,60 @@ async function seedEscalationChains() {
     }
     logger_1.loggerRegistry.info(`[examples] escalation chains verified (${SEED_CHAINS.length} entries)`);
 }
+/**
+ * Seed example workflow configs into lt_config_workflows.
+ * Previously done by 002_seed.sql (which ran unconditionally).
+ * Now only runs when examples: true.
+ */
+async function seedExampleConfigs() {
+    const pool = (0, db_1.getPool)();
+    await pool.query(`
+    INSERT INTO lt_config_workflows
+      (workflow_type, task_queue, default_role, invocable, description, tool_tags, envelope_schema, resolver_schema)
+    VALUES
+      ('reviewContent', 'long-tail-examples', 'reviewer', true,
+       'Content review — AI-powered moderation with human escalation for low-confidence results',
+       ARRAY['document-processing', 'vision', 'ocr', 'translation'],
+       '{"data": {"contentId": "article-001", "content": "Content to review...", "contentType": "article"}, "metadata": {"source": "dashboard"}}'::jsonb,
+       '{"approved": true, "analysis": {"confidence": 0.95, "flags": [], "summary": "Manually reviewed and approved."}}'::jsonb),
+      ('verifyDocument', 'long-tail-examples', 'reviewer', true,
+       'Document verification — AI Vision analyzes identity documents',
+       ARRAY['document-processing', 'vision', 'ocr', 'translation'],
+       '{"data": {"documentId": "doc-001", "documentUrl": "https://example.com/doc.jpg", "documentType": "drivers_license", "memberId": "member-12345"}, "metadata": {"source": "dashboard"}}'::jsonb,
+       '{"memberId": "", "extractedInfo": {}, "validationResult": "match", "confidence": 1.0}'::jsonb),
+      ('processClaim', 'long-tail-examples', 'reviewer', true,
+       'Insurance claim processing — document analysis, validation, and human review',
+       ARRAY['document-processing', 'vision', 'database', 'query'],
+       '{"data": {"claimId": "CLM-2024-001", "claimantId": "POL-5551234", "claimType": "auto_collision", "amount": 12500, "documents": ["incident_report.pdf", "photo_evidence.jpg"]}, "metadata": {"source": "dashboard"}}'::jsonb,
+       '{"approved": true, "analysis": {"confidence": 0.92, "flags": [], "summary": "Documents reviewed and verified."}, "status": "resolved"}'::jsonb),
+      ('kitchenSink', 'long-tail-examples', 'reviewer', true,
+       'Kitchen sink — demonstrates sleep, signals, parallel activities, escalation, and every durable primitive',
+       '{}',
+       '{"data": {"name": "World", "mode": "full"}, "metadata": {"source": "dashboard"}}'::jsonb,
+       NULL),
+      ('basicSignal', 'long-tail-examples', 'reviewer', true,
+       'Signal-based escalation — workflow stays running while waiting for human input via conditionLT',
+       '{}',
+       '{"data": {"message": "Deployment approval needed for v2.1.0", "role": "reviewer"}, "metadata": {"certified": false, "source": "dashboard"}}'::jsonb,
+       '{"properties": {"approved": {"type": "boolean", "default": false, "description": "Approve this deployment?"}, "notes": {"type": "string", "default": "", "description": "Reviewer notes — visible to the workflow author"}}}'::jsonb)
+    ON CONFLICT (workflow_type) DO NOTHING
+  `);
+    // Assign roles to example workflows
+    await pool.query(`
+    INSERT INTO lt_config_roles (workflow_type, role)
+    SELECT workflow_type, unnest(ARRAY['reviewer', 'engineer', 'admin'])
+    FROM lt_config_workflows
+    WHERE workflow_type IN ('reviewContent', 'verifyDocument', 'processClaim', 'kitchenSink')
+    ON CONFLICT (workflow_type, role) DO NOTHING
+  `);
+    logger_1.loggerRegistry.info('[examples] workflow configs seeded');
+}
 /**
  * Seed example workflows so the dashboard tells a story immediately.
  * Called automatically when `examples: true` is set in the start config.
  */
 async function seedExamples(client) {
+    await seedExampleConfigs();
     await seedRoles();
     await seedUsers();
     await seedEscalationChains();