@hotmeshio/long-tail 0.1.13 → 0.1.15

package/build/api/workflows/invocation.js

@@ -0,0 +1,188 @@
+"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;
+const workers_1 = require("../../workers");
+const exportService = __importStar(require("../../services/export"));
+const task_1 = require("../../services/task");
+const workflow_invocation_1 = require("../../services/workflow-invocation");
+function isResolveError(err) {
+    return err?.message?.includes('Cannot resolve workflow');
+}
+/**
+ * Start a workflow — proxy for `Durable.Client.workflow.start()`.
+ *
+ * Resolves the task queue, enforces auth/role constraints, builds the
+ * LTEnvelope with IAM context, and delegates to the Durable client.
+ * Any WorkflowOptions field (workflowId, expire, entity, namespace,
+ * search, signalIn, pending, etc.) can be passed via `options` and
+ * flows through to the Durable client unchanged.
+ *
+ * @see https://docs.hotmesh.io/types/types_durable.WorkflowOptions.html
+ */
+async function invokeWorkflow(input, auth) {
+    try {
+        await (0, workflow_invocation_1.checkInvocationRoles)(input.type, auth.userId, auth.role);
+        const result = await (0, workflow_invocation_1.invokeWorkflow)({
+            workflowType: input.type,
+            data: input.data || {},
+            metadata: input.metadata,
+            executeAs: input.execute_as,
+            options: input.options,
+            auth: {
+                userId: auth.userId,
+                role: auth.role,
+                scopes: auth.scopes,
+            },
+        });
+        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 };
+    }
+}
+/**
+ * Get the execution status of a workflow.
+ *
+ * Returns the HotMesh status code (0 = completed, 1 = running).
+ * Resolves the workflow handle via task record or worker registry.
+ *
+ * @param input.workflowId — HotMesh workflow ID
+ * @returns `{ status: 200, data: { workflowId, status } }` or 404
+ */
+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 };
+    }
+}
+/**
+ * Get the result of a completed workflow.
+ *
+ * Returns 202 if the workflow is still running, 200 with the result
+ * payload when complete. Never blocks — always returns immediately.
+ *
+ * @param input.workflowId — HotMesh workflow ID
+ * @returns `{ status: 200, data: { workflowId, result } }` or 202 if running
+ */
+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 };
+    }
+}
+/**
+ * Terminate a running workflow.
+ *
+ * Interrupts the workflow execution immediately via HotMesh.
+ *
+ * @param input.workflowId — HotMesh workflow ID
+ * @returns `{ status: 200, data: { terminated: true, workflowId } }` or 404
+ */
+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 };
+    }
+}
+/**
+ * Export the full state of a workflow.
+ *
+ * Returns the serialized workflow state including all activity
+ * results, signals, and metadata.
+ *
+ * @param input.workflowId — HotMesh workflow ID
+ * @returns `{ status: 200, data: <exported state> }` or 404
+ */
+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 };
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { LTApiResult } from '../../types/sdk';
+/**
+ * Set or update the cron schedule for a YAML workflow.
+ *
+ * Persists the schedule in the DB and restarts the in-process cron timer via the
+ * cron registry so the change takes effect immediately.
+ *
+ * @param input.id — UUID of the workflow to schedule
+ * @param input.cron_schedule — cron expression (e.g. "0 * * * *")
+ * @param input.cron_envelope — optional payload passed to each scheduled invocation
+ * @param input.execute_as — optional identity override for scheduled executions
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields set
+ */
+export declare function setCronSchedule(input: {
+    id: string;
+    cron_schedule: string;
+    cron_envelope?: any;
+    execute_as?: string;
+}): Promise<LTApiResult>;
+/**
+ * Remove the cron schedule from a YAML workflow.
+ *
+ * Stops the in-process cron timer first, then clears the schedule fields in the DB.
+ *
+ * @param input.id — UUID of the workflow to unschedule
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields cleared
+ */
+export declare function clearCronSchedule(input: {
+    id: string;
+}): Promise<LTApiResult>;
+/**
+ * List all YAML workflows that have a cron schedule, with their live timer status.
+ *
+ * Fetches all cron-scheduled workflows from the DB and cross-references with the
+ * in-process cron registry to determine which timers are actually running.
+ *
+ * @returns `{ status: 200, data: { schedules: Array<{ id, name, graph_topic, app_id, cron_schedule, execute_as, active }> } }`
+ */
+export declare function getCronStatus(): Promise<LTApiResult>;

package/build/api/yaml-workflows/cron.js

@@ -0,0 +1,127 @@
+"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.setCronSchedule = setCronSchedule;
+exports.clearCronSchedule = clearCronSchedule;
+exports.getCronStatus = getCronStatus;
+const yamlDb = __importStar(require("../../services/yaml-workflow/db"));
+const cron_1 = require("../../services/cron");
+const helpers_1 = require("./helpers");
+/**
+ * Set or update the cron schedule for a YAML workflow.
+ *
+ * Persists the schedule in the DB and restarts the in-process cron timer via the
+ * cron registry so the change takes effect immediately.
+ *
+ * @param input.id — UUID of the workflow to schedule
+ * @param input.cron_schedule — cron expression (e.g. "0 * * * *")
+ * @param input.cron_envelope — optional payload passed to each scheduled invocation
+ * @param input.execute_as — optional identity override for scheduled executions
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields set
+ */
+async function setCronSchedule(input) {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(input.id);
+        if (!wf) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        if (!input.cron_schedule || typeof input.cron_schedule !== 'string') {
+            return { status: 400, error: 'cron_schedule is required' };
+        }
+        const updated = await yamlDb.updateCronSchedule(wf.id, input.cron_schedule.trim(), input.cron_envelope ?? null, input.execute_as ?? null);
+        if (updated) {
+            await cron_1.cronRegistry.restartYamlCron(updated);
+        }
+        return { status: 200, data: updated };
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Remove the cron schedule from a YAML workflow.
+ *
+ * Stops the in-process cron timer first, then clears the schedule fields in the DB.
+ *
+ * @param input.id — UUID of the workflow to unschedule
+ * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields cleared
+ */
+async function clearCronSchedule(input) {
+    try {
+        const wf = await yamlDb.getYamlWorkflow(input.id);
+        if (!wf) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        await cron_1.cronRegistry.stopYamlCron(wf.id);
+        const updated = await yamlDb.clearCronSchedule(wf.id);
+        return { status: 200, data: updated };
+    }
+    catch (err) {
+        if ((0, helpers_1.isNotFoundError)(err)) {
+            return { status: 404, error: 'YAML workflow not found' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * List all YAML workflows that have a cron schedule, with their live timer status.
+ *
+ * Fetches all cron-scheduled workflows from the DB and cross-references with the
+ * in-process cron registry to determine which timers are actually running.
+ *
+ * @returns `{ status: 200, data: { schedules: Array<{ id, name, graph_topic, app_id, cron_schedule, execute_as, active }> } }`
+ */
+async function getCronStatus() {
+    try {
+        const workflows = await yamlDb.getCronScheduledWorkflows();
+        const activeTypes = cron_1.cronRegistry.activeWorkflowTypes;
+        const schedules = workflows.map((wf) => ({
+            id: wf.id,
+            name: wf.name,
+            graph_topic: wf.graph_topic,
+            app_id: wf.app_id,
+            cron_schedule: wf.cron_schedule,
+            execute_as: wf.execute_as,
+            active: activeTypes.includes(`yaml:${wf.id}`),
+        }));
+        return { status: 200, data: { schedules } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/{yaml-workflows.d.ts → yaml-workflows/crud.d.ts}

@@ -1,4 +1,4 @@
-import type { LTApiResult, LTApiAuth } from '../types/sdk';
+import type { LTApiResult } from '../../types/sdk';
 /**
  * List YAML workflows with optional filtering and pagination.
  *
@@ -140,143 +140,28 @@ export declare function deleteYamlWorkflow(input: {
     id: string;
 }): Promise<LTApiResult>;
 /**
- * Deploy a YAML workflow and all sibling workflows sharing its app_id namespace.
+ * Compile a durable TypeScript workflow into a YAML DAG.
  *
- * Merges and deploys the full app_id YAML, registers HotMesh workers for every
- * non-archived sibling, transitions draft/deployed siblings to active, and marks
- * the app_id content as deployed. Uses the app_version declared in the workflow record.
+ * Accepts inline source code or a file path. The LLM translates the procedural
+ * orchestration into an equivalent HotMesh YAML DAG that runs without replay.
  *
- * @param input.id — UUID of the workflow to deploy
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after deployment
- */
-export declare function deployYamlWorkflow(input: {
-    id: string;
-}): Promise<LTApiResult>;
-/**
- * Activate a previously deployed YAML workflow and its app_id siblings.
- *
- * Calls the deployer to activate the app_id at its current version, then registers
- * HotMesh workers for all sibling workflows. Siblings in "deployed" status are
- * transitioned to "active". The workflow must already be in deployed or active status.
- *
- * @param input.id — UUID of the workflow to activate
- * @returns `{ status: 200, data: YamlWorkflow }` the refreshed workflow record after activation
- */
-export declare function activateYamlWorkflow(input: {
-    id: string;
-}): Promise<LTApiResult>;
-/**
- * Invoke an active YAML workflow, executing its DAG pipeline.
- *
- * The workflow must be in "active" status. Delegates to the invoke service which
- * starts the HotMesh execution. Supports both synchronous (wait for result) and
- * asynchronous (fire-and-forget) invocation modes.
- *
- * @param input.id — UUID of the workflow to invoke
- * @param input.data — input payload passed to the workflow's entry point
- * @param input.sync — when true, block until the workflow completes and return its output
- * @param input.timeout — max milliseconds to wait when sync is true
- * @param input.execute_as — override identity for the execution context
- * @param auth — authenticated user context; userId is forwarded to the invoke service
- * @returns `{ status: 200, data: ... }` workflow execution result (sync) or job metadata (async)
- */
-export declare function invokeYamlWorkflow(input: {
-    id: string;
-    data?: any;
-    sync?: boolean;
-    timeout?: number;
-    execute_as?: string;
-}, auth?: LTApiAuth): Promise<LTApiResult>;
-/**
- * Archive a YAML workflow, removing it from active service.
- *
- * If the workflow is currently active, its HotMesh engine is stopped before
- * transitioning the status to "archived". Archived workflows cannot be invoked
- * or regenerated but can still be viewed or deleted.
- *
- * @param input.id — UUID of the workflow to archive
- * @returns `{ status: 200, data: YamlWorkflow }` the updated record with status "archived"
- */
-export declare function archiveYamlWorkflow(input: {
-    id: string;
-}): Promise<LTApiResult>;
-/**
- * Retrieve the version history for a YAML workflow.
- *
- * Returns a paginated list of version snapshots ordered by version number.
- *
- * @param input.id — UUID of the workflow
- * @param input.limit — max versions to return (defaults to 20)
- * @param input.offset — pagination offset (defaults to 0)
- * @returns `{ status: 200, data: VersionSnapshot[] }` paginated version history
- */
-export declare function getVersionHistory(input: {
-    id: string;
-    limit?: number;
-    offset?: number;
-}): Promise<LTApiResult>;
-/**
- * Retrieve a specific version snapshot of a YAML workflow.
- *
- * Validates that the version number is a positive integer before querying.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — 1-based version number to retrieve
- * @returns `{ status: 200, data: VersionSnapshot }` the snapshot at the requested version, or 404
- */
-export declare function getVersionSnapshot(input: {
-    id: string;
-    version: number;
-}): Promise<LTApiResult>;
-/**
- * Retrieve the raw YAML content for a workflow, optionally at a specific version.
- *
- * When a version is provided, fetches from the version snapshot table. Otherwise
- * returns the current yaml_content from the live workflow record.
- *
- * @param input.id — UUID of the workflow
- * @param input.version — optional version number; when omitted, returns the current content
- * @returns `{ status: 200, data: string }` the raw YAML string
- */
-export declare function getYamlContent(input: {
-    id: string;
-    version?: number;
-}): Promise<LTApiResult<string>>;
-/**
- * Set or update the cron schedule for a YAML workflow.
- *
- * Persists the schedule in the DB and restarts the in-process cron timer via the
- * cron registry so the change takes effect immediately.
- *
- * @param input.id — UUID of the workflow to schedule
- * @param input.cron_schedule — cron expression (e.g. "0 * * * *")
- * @param input.cron_envelope — optional payload passed to each scheduled invocation
- * @param input.execute_as — optional identity override for scheduled executions
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields set
- */
-export declare function setCronSchedule(input: {
-    id: string;
-    cron_schedule: string;
-    cron_envelope?: any;
-    execute_as?: string;
-}): Promise<LTApiResult>;
-/**
- * Remove the cron schedule from a YAML workflow.
- *
- * Stops the in-process cron timer first, then clears the schedule fields in the DB.
- *
- * @param input.id — UUID of the workflow to unschedule
- * @returns `{ status: 200, data: YamlWorkflow }` the updated workflow record with cron fields cleared
+ * @param input.source — TypeScript source code or file path
+ * @param input.is_file_path — whether source is a file path (default: false)
+ * @param input.workflow_name — name of the exported workflow function
+ * @param input.name — name for the generated YAML workflow
+ * @param input.description — optional description
+ * @param input.app_id — target namespace (defaults to "longtail")
+ * @param input.subscribes — graph topic override
+ * @param input.tags — additional tags
+ * @returns `{ status: 201, data: YamlWorkflow }` the newly created draft record
  */
-export declare function clearCronSchedule(input: {
-    id: string;
+export declare function createYamlWorkflowFromDurable(input: {
+    source: string;
+    is_file_path?: boolean;
+    workflow_name: string;
+    name: string;
+    description?: string;
+    app_id?: string;
+    subscribes?: string;
+    tags?: string[];
 }): Promise<LTApiResult>;
-/**
- * List all YAML workflows that have a cron schedule, with their live timer status.
- *
- * Fetches all cron-scheduled workflows from the DB and cross-references with the
- * in-process cron registry to determine which timers are actually running.
- *
- * @returns `{ status: 200, data: { schedules: Array<{ id, name, graph_topic, app_id, cron_schedule, execute_as, active }> } }`
- */
-export declare function getCronStatus(): Promise<LTApiResult>;