lightflow-engine 0.2.0 → 0.2.2

package/dist/src/compat/api.js

@@ -29,51 +29,56 @@ export function getEngine() {
  * Register a workflow function under a stable id and start it. Mirrors
  * Vercel's start(workflowFn, args).
  */
-export async function start(fn, args) {
-    const engine = getEngine();
-    const id = workflowIdFor(fn);
-    registerWorkflow(id, fn);
-    const { runId } = await engine.start(id, args);
-    return makeRunHandle(runId);
-}
-export function getRun(runId) {
-    return makeRunHandle(runId);
-}
 function makeRunHandle(runId) {
     const engine = getEngine();
     const store = sharedStore;
-    let cachedStatus = null;
-    const statusPromise = (async () => {
-        if (cachedStatus)
-            return cachedStatus;
+    /** One DB read -> Vercel status vocabulary. */
+    const readStatus = async () => {
+        const row = await store.getRun(runId);
+        if (!row)
+            return "pending";
+        if (row.status === "completed")
+            return "completed";
+        if (row.status === "failed") {
+            return row.output?.error === "cancelled"
+                ? "cancelled"
+                : "failed";
+        }
+        return "running";
+    };
+    /** Promise resolving when the run reaches a terminal state. */
+    const terminal = (cache) => {
         const deadline = Date.now() + 10 * 60_000;
-        let delay = 5;
-        let seenRow = false;
-        while (Date.now() < deadline) {
-            const row = await store.getRun(runId);
-            if (row) {
-                seenRow = true;
-                if (row.status === "completed") {
-                    cachedStatus = "completed";
-                    return cachedStatus;
-                }
-                if (row.status === "failed") {
-                    // cancelled runs are 'failed' with error 'cancelled'
-                    cachedStatus =
-                        row.output?.error === "cancelled"
-                            ? "cancelled" : "failed";
-                    return cachedStatus;
+        let delay = 25;
+        const loop = async () => {
+            while (Date.now() < deadline) {
+                const st = await readStatus();
+                if (st === "completed" || st === "failed" || st === "cancelled") {
+                    cache.status = st;
+                    return st;
                 }
+                await new Promise((r) => setTimeout(r, delay));
+                delay = Math.min(delay * 1.4, 250);
             }
-            await new Promise((r) => setTimeout(r, delay));
-            delay = seenRow ? Math.min(delay * 1.6, 250) : 5;
-        }
-        throw new Error(`run status timeout: ${runId}`);
-    })();
+            throw new Error(`run status timeout: ${runId}`);
+        };
+        return loop();
+    };
+    const cache = {};
     const handle = {
         runId,
-        status: statusPromise,
-        returnValue: (async () => (await engine.getRun(runId)).returnValue)(),
+        get status() {
+            // Live snapshot: resolve immediately with the current state; the
+            // startStopMonitor poll loop relies on this re-reading each tick.
+            return readStatus().then((st) => {
+                cache.status = st;
+                return st;
+            });
+        },
+        returnValue: (async () => {
+            await terminal(cache);
+            return (await engine.getRun(runId)).returnValue;
+        })(),
         getReadable(opts) {
             const startIndex = opts?.startIndex ?? 0;
             let sent = startIndex;
@@ -109,19 +114,17 @@ function makeRunHandle(runId) {
                     }
                     const chunks = await collectChunks();
                     const hasDone = chunks.some((c) => c.done);
-                    // chunks carry a monotonic `index`; entries after startIndex
                     for (const c of chunks) {
-                        const p = c;
-                        if (p.done) {
+                        if (c.done) {
                             closed = true;
                             controller.close();
                             return;
                         }
-                        if (p.index < startIndex)
+                        if (c.index < startIndex)
                             continue;
-                        if (p.index >= sent) {
-                            controller.enqueue(p.value);
-                            sent = p.index + 1;
+                        if (c.index >= sent) {
+                            controller.enqueue(c.value);
+                            sent = c.index + 1;
                         }
                     }
                     if (hasDone) {
@@ -155,3 +158,13 @@ function makeRunHandle(runId) {
     };
     return handle;
 }
+export async function start(fn, args) {
+    const engine = getEngine();
+    const id = workflowIdFor(fn);
+    registerWorkflow(id, fn);
+    const { runId } = await engine.start(id, args);
+    return makeRunHandle(runId);
+}
+export function getRun(runId) {
+    return makeRunHandle(runId);
+}

package/dist/src/compat/workflow.js

@@ -8,6 +8,7 @@
  *    webpack loader (workflow/next) or explicit step() wrappers.
  */
 import { createHash } from "node:crypto";
+import { step, registerStep, } from "../index.js";
 import { current } from "../index.js";
 export { FatalError, CancelledError, sleep } from "../index.js";
 export { getWorkflowMetadata } from "../compat/metadata.js";
@@ -69,3 +70,27 @@ export function workflowIdFor(fn) {
     return "wf_" + createHash("sha256")
         .update(String(fn).slice(0, 512)).digest("hex").slice(0, 16);
 }
+/**
+ * makeStep — turns a plain async function into a durable step callable.
+ *
+ * Entry's "use step" functions take arguments; lightflow's step() takes a
+ * thunk. makeStep wraps both: the returned function is a drop-in for the
+ * original (same signature), but each call becomes a memoized, retrying,
+ * replayable step keyed by call position. Outside a workflow it degrades
+ * to a plain call, so tests and non-durable paths keep working.
+ */
+export function makeStep(fn, opts) {
+    const wrapped = async (...args) => step(() => fn(...args));
+    Object.defineProperty(wrapped, "__lightflowStepId", {
+        value: `step_${workflowIdFor(fn)}`,
+        enumerable: false,
+    });
+    if (opts?.retries !== undefined) {
+        Object.defineProperty(wrapped, "__lightflowRetries", {
+            value: opts.retries,
+            enumerable: false,
+        });
+    }
+    registerStep(wrapped.__lightflowStepId, fn);
+    return wrapped;
+}

package/dist/test/compat.js

@@ -52,7 +52,8 @@ test("compat: vercel-style agent chat workflow end-to-end", async () => {
         { messages: ["hello", "world"], chatId: "c1" },
     ]);
     assert.ok(run.runId.startsWith("lrun_"));
-    // status is a Promise, resolvable to a terminal state
+    // status is a live getter; await terminal state via returnValue
+    await run.returnValue;
     const status = await run.status;
     assert.equal(status, "completed");
     const ret = (await run.returnValue);
@@ -79,7 +80,7 @@ test("compat: vercel-style agent chat workflow end-to-end", async () => {
     // cancel semantics: getRun + status + cancel()
     const dup = await start(runAgentWorkflow, [{ messages: ["x"], chatId: "c2" }]);
     await dup.cancel();
-    assert.equal(await dup.status, "cancelled");
+    assert.equal(await dup.status, "cancelled"); // live getter reflects cancel
     await pool.end();
     engine.stopWorker();
     await workerPromise;

package/dist/test/dbg3.mjs

@@ -0,0 +1,23 @@
+
+import { Engine, step, sleep } from "/home/agentuser/lightflow/dist/src/index.js";
+import { createPostgresStore } from "/home/agentuser/lightflow/dist/src/pg-store.js";
+import { initWorkflowApi, start } from "/home/agentuser/lightflow/dist/src/compat/api.js";
+const store = await createPostgresStore(process.env.LIGHTFLOW_PG_URL);
+const engine = new Engine(store, { pollMs: 25 });
+initWorkflowApi(store, engine);
+const wp = engine.startWorker();
+setTimeout(() => engine.stopWorker(), 20000);
+const wf = async () => {
+  await sleep(new Date(Date.now() + 300));
+  await step(async () => "x");
+  return "ok";
+};
+const run = await start(wf, []);
+const s1 = await run.status;           // live snapshot (running/pending)
+const s2 = await run.status;           // fresh promise each access
+console.log("live status:", s1, s2);
+const t = await run.status && await (async()=>{ // wait terminal
+  for(;;){ const st = await run.status; if(st!=="running"&&st!=="pending") return st; await new Promise(r=>setTimeout(r,25)); }
+})();
+console.log("terminal:", t);
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightflow-engine",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "A tiny durable workflow engine for Node.js and Postgres \u2014 with a Vercel Workflow drop-in compat layer.",
   "license": "MIT",
   "type": "module",