@hotmeshio/long-tail 0.1.6 → 0.1.8

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

@@ -34,35 +34,24 @@ 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 yamlGenerator = __importStar(require("../../services/yaml-workflow/generator"));
-const task_1 = require("../../services/task");
-const helpers_1 = require("./helpers");
+const api = __importStar(require("../../api/yaml-workflows"));
 const router = (0, express_1.Router)();
 /**
  * GET /api/yaml-workflows
  * List YAML workflows with optional status filter.
  */
 router.get('/', async (req, res) => {
-    try {
-        const result = await yamlDb.listYamlWorkflows({
-            status: req.query.status,
-            graph_topic: req.query.graph_topic,
-            app_id: req.query.app_id,
-            search: req.query.search,
-            source_workflow_id: req.query.source_workflow_id,
-            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
-            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
-        });
-        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.listYamlWorkflows({
+        status: req.query.status,
+        graph_topic: req.query.graph_topic,
+        app_id: req.query.app_id,
+        search: req.query.search,
+        source_workflow_id: req.query.source_workflow_id,
+        set_id: req.query.set_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 });
 });
 /**
  * POST /api/yaml-workflows
@@ -70,82 +59,16 @@ router.get('/', async (req, res) => {
  * Body: { workflow_id, task_queue, workflow_name, name, description? }
  */
 router.post('/', async (req, res) => {
-    try {
-        const { workflow_id, task_queue, workflow_name, name, description, app_id, subscribes, tags: userTags, compilation_feedback } = req.body;
-        if (!workflow_id || !task_queue || !workflow_name || !name) {
-            res.status(400).json({
-                error: 'workflow_id, task_queue, workflow_name, and name are required',
-            });
-            return;
-        }
-        // Reject compilation of executions that exhausted their tool rounds —
-        // the trace is incomplete and would produce a broken workflow.
-        const task = await (0, task_1.getTaskByWorkflowId)(workflow_id);
-        if (task) {
-            const milestones = task.milestones ?? [];
-            const roundsExhausted = milestones.some((m) => m.name === 'rounds_exhausted');
-            if (roundsExhausted) {
-                res.status(422).json({
-                    error: 'Cannot compile: the source execution exhausted its tool rounds without completing the task. Resolve the escalation and resubmit.',
-                });
-                return;
-            }
-        }
-        // Generate YAML from execution
-        const result = await yamlGenerator.generateYamlFromExecution({
-            workflowId: workflow_id,
-            taskQueue: task_queue,
-            workflowName: workflow_name,
-            name,
-            description,
-            appId: app_id,
-            subscribes,
-            compilationFeedback: compilation_feedback,
-        });
-        // Merge auto-derived tags with user-provided tags
-        const mergedTags = [...new Set([...(result.tags || []), ...(Array.isArray(userTags) ? userTags : [])])];
-        // Store in DB
-        const record = await yamlDb.createYamlWorkflow({
-            name,
-            description,
-            app_id: result.appId,
-            yaml_content: result.yaml,
-            graph_topic: result.graphTopic,
-            input_schema: result.inputSchema,
-            output_schema: result.outputSchema,
-            activity_manifest: result.activityManifest,
-            tags: mergedTags,
-            source_workflow_id: workflow_id,
-            source_workflow_type: workflow_name,
-            original_prompt: result.originalPrompt || undefined,
-            category: result.category || undefined,
-            metadata: {
-                input_field_meta: result.inputFieldMeta,
-                ...(result.validationIssues?.length ? { validation_warnings: result.validationIssues } : {}),
-            },
-        });
-        res.status(201).json(record);
-    }
-    catch (err) {
-        if (err.message?.includes('duplicate key') || err.code === '23505') {
-            res.status(409).json({ error: 'A tool with that name already exists' });
-            return;
-        }
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.createYamlWorkflow(req.body);
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * GET /api/yaml-workflows/app-ids
  * Return distinct app_id values from non-archived workflows.
  */
 router.get('/app-ids', async (_req, res) => {
-    try {
-        const appIds = await yamlDb.getDistinctAppIds();
-        res.json({ app_ids: appIds });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.getAppIds();
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/yaml-workflows/direct
@@ -154,36 +77,8 @@ router.get('/app-ids', async (_req, res) => {
  * Body: { name, description?, yaml_content, input_schema?, activity_manifest?, tags?, app_id? }
  */
 router.post('/direct', async (req, res) => {
-    try {
-        const { name, description, yaml_content, input_schema, activity_manifest, tags, app_id, graph_topic } = req.body;
-        if (!name || !yaml_content) {
-            res.status(400).json({ error: 'name and yaml_content are required' });
-            return;
-        }
-        // Extract subscribes topic from YAML content, or fall back to name-derived slug
-        let graphTopic = graph_topic || name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-        const subscribesMatch = yaml_content.match(/subscribes:\s*(.+)/);
-        if (subscribesMatch) {
-            graphTopic = subscribesMatch[1].trim().replace(/^['"]|['"]$/g, '');
-        }
-        const wf = await yamlDb.createYamlWorkflow({
-            name,
-            description,
-            app_id: app_id || 'longtail',
-            yaml_content,
-            graph_topic: graphTopic,
-            input_schema: input_schema || {},
-            output_schema: {},
-            activity_manifest: activity_manifest || [],
-            tags: tags || [],
-            original_prompt: description,
-            category: 'builder',
-        });
-        res.json(wf);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+    const result = await api.createYamlWorkflowDirect(req.body);
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 // -- Parameterized routes --
 /**
@@ -191,42 +86,16 @@ router.post('/direct', async (req, res) => {
  * Get a single YAML workflow.
  */
 router.get('/:id', async (req, res) => {
-    try {
-        const wf = await yamlDb.getYamlWorkflow(req.params.id);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.json(wf);
-    }
-    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.getYamlWorkflow({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * PUT /api/yaml-workflows/:id
  * Update a YAML workflow's metadata.
  */
 router.put('/:id', async (req, res) => {
-    try {
-        const wf = await yamlDb.updateYamlWorkflow(req.params.id, req.body);
-        if (!wf) {
-            res.status(404).json({ error: 'YAML workflow not found' });
-            return;
-        }
-        res.json(wf);
-    }
-    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.updateYamlWorkflow({ id: req.params.id, ...req.body });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * POST /api/yaml-workflows/:id/regenerate
@@ -234,81 +103,19 @@ router.put('/:id', async (req, res) => {
  * Only allowed for non-archived workflows.
  */
 router.post('/:id/regenerate', 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 === 'archived') {
-            res.status(400).json({ error: 'Archived workflows cannot be regenerated' });
-            return;
-        }
-        if (!wf.source_workflow_id || !wf.source_workflow_type) {
-            res.status(400).json({ error: 'Missing source workflow reference — cannot regenerate' });
-            return;
-        }
-        // Look up task queue from the source task record, or use body override
-        let taskQueue = req.body.task_queue;
-        if (!taskQueue) {
-            const sourceTask = await (0, task_1.getTaskByWorkflowId)(wf.source_workflow_id);
-            taskQueue = sourceTask?.task_queue || 'v1';
-        }
-        const feedback = req.body.compilation_feedback;
-        const result = await yamlGenerator.generateYamlFromExecution({
-            workflowId: wf.source_workflow_id,
-            taskQueue,
-            workflowName: wf.source_workflow_type,
-            name: wf.name,
-            description: wf.description || undefined,
-            appId: wf.app_id,
-            compilationFeedback: feedback || undefined,
-            priorFailedYaml: feedback ? wf.yaml_content : undefined,
-        });
-        const updated = await yamlDb.updateYamlWorkflow(wf.id, {
-            app_id: result.appId,
-            graph_topic: result.graphTopic,
-            yaml_content: result.yaml,
-            input_schema: result.inputSchema,
-            output_schema: result.outputSchema,
-            activity_manifest: result.activityManifest,
-            tags: result.tags,
-            metadata: { input_field_meta: result.inputFieldMeta },
-        });
-        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.regenerateYamlWorkflow({
+        id: req.params.id,
+        task_queue: req.body.task_queue,
+        compilation_feedback: req.body.compilation_feedback,
+    });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 /**
  * DELETE /api/yaml-workflows/:id
  * Delete a YAML workflow (must be draft or archived).
  */
 router.delete('/:id', 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' || wf.status === 'deployed') {
-            res.status(400).json({ error: 'Cannot delete an active or deployed workflow. Archive it first.' });
-            return;
-        }
-        await yamlDb.deleteYamlWorkflow(req.params.id);
-        res.json({ deleted: true });
-    }
-    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.deleteYamlWorkflow({ id: req.params.id });
+    res.status(result.status).json(result.data ?? { error: result.error });
 });
 exports.default = router;

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;