@mazjq/zhiro 0.0.0-stage → 0.1.2

package/dist/chunk-LUKCNS5M.js

@@ -0,0 +1,180 @@
+import {
+  json,
+  now
+} from "./chunk-5KCN32HQ.js";
+import {
+  __name
+} from "./chunk-2SSYR7VW.js";
+
+// apps/daemon/src/service/workflow.ts
+import { ulid } from "ulid";
+var WorkflowEngine = class {
+  constructor(db, pollMs = 15e3) {
+    this.db = db;
+    this.pollMs = pollMs;
+  }
+  db;
+  pollMs;
+  static {
+    __name(this, "WorkflowEngine");
+  }
+  defs = /* @__PURE__ */ new Map();
+  timer = null;
+  /** told when a run of some kind finishes or gives up (a research report filed, a lead looked up): the pages hear of it */
+  onEnded;
+  register(def) {
+    this.defs.set(def.kind, def);
+  }
+  /** Idempotent start: same idempotencyKey → existing workflow id. */
+  start(kind, subjectId, idempotencyKey, checkpoint = {}) {
+    const def = this.defs.get(kind);
+    if (!def) throw new Error(`unknown workflow ${kind}`);
+    const found = this.db.prepare("select id from workflow where idempotency_key = ?").get(idempotencyKey);
+    if (found) return found.id;
+    const id = ulid();
+    const t = now();
+    this.db.prepare("insert into workflow(id, kind, subject_id, state, current_step, idempotency_key, checkpoint_json, next_run_at, created_at, updated_at) values (?,?,?,?,?,?,?,?,?,?)").run(id, kind, subjectId, "running", def.order[0], idempotencyKey, json.str(checkpoint), t, t, t);
+    return id;
+  }
+  /**
+   * For work that must keep going as long as its subject exists (a subscription's daily pull): start it, or — when an
+   * earlier run of it ended (its subject was removed and has come back, or it gave up) — set it going again from the
+   * first step. `start` alone would hand back the ended run and nothing would ever run again.
+   */
+  ensure(kind, subjectId, idempotencyKey) {
+    const id = this.start(kind, subjectId, idempotencyKey);
+    const t = now();
+    this.db.prepare("update workflow set state = 'running', current_step = ?, attempts = 0, next_run_at = ?, lease_until = null, last_error = '', updated_at = ? where id = ? and state in ('completed', 'failed')").run(this.defs.get(kind).order[0], t, t, id);
+    return id;
+  }
+  /** Its subject is gone: the work ends now, wherever it was waiting. `ensure` sets it going again if the subject returns. */
+  end(idempotencyKey) {
+    this.db.prepare("update workflow set state = 'completed', next_run_at = null, lease_until = null, updated_at = ? where idempotency_key = ? and state in ('running', 'waiting')").run(now(), idempotencyKey);
+  }
+  /** Resume a waiting workflow (e.g. an external event arrived). */
+  signal(id, patch = {}) {
+    const r = this.db.prepare("select checkpoint_json from workflow where id = ?").get(id);
+    if (!r) return;
+    const cp = { ...json.parse(r.checkpoint_json, {}), ...patch };
+    this.db.prepare("update workflow set state = 'running', next_run_at = ?, checkpoint_json = ?, updated_at = ? where id = ?").run(now(), json.str(cp), now(), id);
+  }
+  list(state) {
+    const rows = state ? this.db.prepare("select * from workflow where state = ? order by updated_at desc").all(state) : this.db.prepare("select * from workflow order by updated_at desc limit 200").all();
+    return rows.map((r) => ({ id: r.id, kind: r.kind, subjectId: r.subject_id, state: r.state, currentStep: r.current_step, nextRunAt: r.next_run_at, lastError: r.last_error }));
+  }
+  startPolling() {
+    if (this.timer) return;
+    const loop = /* @__PURE__ */ __name(() => {
+      try {
+        this.pump();
+      } catch (e) {
+        console.error("[workflow] poll failed", e);
+      }
+      this.timer = setTimeout(loop, this.pollMs);
+    }, "loop");
+    loop();
+  }
+  stopPolling() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /**
+   * What each poll does: every kind of work that has something due, and is not already at it, is set going — kinds side by
+   * side, one kind's workflows one after another. One loop used to run everything in turn, so a career site that takes
+   * minutes to read held up a reminder, or a report that only needed filing (2026-10-13: a research answer waited behind a
+   * whole-site scan).
+   */
+  busy = /* @__PURE__ */ new Set();
+  pump() {
+    const t = now();
+    const kinds = this.db.prepare("select distinct kind from workflow where state = 'running' and (next_run_at is null or next_run_at <= ?) and (lease_until is null or lease_until < ?)").all(t, t);
+    for (const { kind } of kinds) {
+      if (this.busy.has(kind)) continue;
+      this.busy.add(kind);
+      void this.tick(now(), kind).catch((e) => console.error("[workflow] tick failed", kind, e)).finally(() => this.busy.delete(kind));
+    }
+  }
+  /** Run every due workflow once (of one kind, when given), one after another. Exposed for tests. */
+  async tick(nowIso = now(), kind) {
+    const due = this.db.prepare(`select * from workflow where state = 'running' and (next_run_at is null or next_run_at <= ?) and (lease_until is null or lease_until < ?)${kind ? " and kind = ?" : ""} order by next_run_at limit 20`).all(nowIso, nowIso, ...kind ? [kind] : []);
+    let ran = 0;
+    for (const w of due) {
+      const lease = new Date(Date.parse(nowIso) + 6e4).toISOString();
+      const claimed = this.db.prepare("update workflow set lease_until = ? where id = ? and (lease_until is null or lease_until < ?)").run(lease, w.id, nowIso);
+      if (claimed.changes === 0) continue;
+      await this.runOne(w);
+      ran++;
+    }
+    return ran;
+  }
+  async runOne(w) {
+    const def = this.defs.get(w.kind);
+    if (!def) {
+      this.finish(w.id, "failed", `no definition for ${w.kind}`);
+      return;
+    }
+    let step = w.current_step;
+    let checkpoint = json.parse(w.checkpoint_json, {});
+    let attempts = w.attempts;
+    for (let guard = 0; guard < 20; guard++) {
+      const handler = def.steps[step];
+      if (!handler) {
+        this.finish(w.id, "completed", "");
+        return;
+      }
+      let res;
+      try {
+        res = await handler({ subjectId: w.subject_id, checkpoint, attempts });
+      } catch (e) {
+        res = { type: "fail", error: String(e?.message ?? e), retryInMs: 5 * 6e4 };
+      }
+      if ("checkpoint" in res && res.checkpoint !== void 0) checkpoint = res.checkpoint;
+      if (res.type === "done") {
+        const i = def.order.indexOf(step);
+        const next = def.order[i + 1];
+        attempts = 0;
+        if (!next) {
+          this.update(w.id, { state: "completed", current_step: step, checkpoint, attempts, next_run_at: null, last_error: "" });
+          this.ended(w);
+          return;
+        }
+        step = next;
+        this.update(w.id, { state: "running", current_step: step, checkpoint, attempts, next_run_at: now(), last_error: "" });
+        continue;
+      }
+      if (res.type === "sleep") {
+        this.update(w.id, { state: "running", current_step: step, checkpoint, attempts, next_run_at: res.until, last_error: "" });
+        return;
+      }
+      if (res.type === "wait") {
+        this.update(w.id, { state: "waiting", current_step: step, checkpoint, attempts, next_run_at: null, last_error: "" });
+        return;
+      }
+      attempts++;
+      if (attempts >= 5) {
+        this.update(w.id, { state: "failed", current_step: step, checkpoint, attempts, next_run_at: null, last_error: res.error });
+        this.ended(w);
+        return;
+      }
+      this.update(w.id, { state: "running", current_step: step, checkpoint, attempts, next_run_at: new Date(Date.now() + (res.retryInMs ?? 6e4)).toISOString(), last_error: res.error });
+      return;
+    }
+  }
+  update(id, p) {
+    this.db.prepare("update workflow set state = ?, current_step = ?, checkpoint_json = ?, attempts = ?, next_run_at = ?, last_error = ?, lease_until = null, updated_at = ? where id = ?").run(p.state, p.current_step, json.str(p.checkpoint), p.attempts, p.next_run_at, p.last_error, now(), id);
+  }
+  ended(w) {
+    try {
+      this.onEnded?.(w.kind, w.subject_id);
+    } catch (e) {
+      console.error("[workflow] onEnded failed", e);
+    }
+  }
+  finish(id, state, err) {
+    this.db.prepare("update workflow set state = ?, last_error = ?, lease_until = null, next_run_at = null, updated_at = ? where id = ?").run(state, err, now(), id);
+  }
+};
+
+export {
+  WorkflowEngine
+};

package/dist/chunk-NNH4ZG6F.js

@@ -0,0 +1,6 @@
+// apps/daemon/src/version.ts
+var VERSION = true ? "0.1.2" : JSON.parse(readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version;
+
+export {
+  VERSION
+};

package/dist/chunk-OOHBM3BT.js

@@ -0,0 +1,6 @@
+// apps/daemon/src/env.ts
+for (const [k, v] of Object.entries(process.env)) {
+  if (!k.startsWith("ZHIRO_") || v === void 0 || k === "ZHIRO_DATA") continue;
+  const old = `JOBOS_${k.slice(6)}`;
+  if (process.env[old] === void 0) process.env[old] = v;
+}