@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/workflow-control.test-fixture.ts

@@ -1,42 +0,0 @@
-import { afterEach } from "bun:test";
-import { Database } from "bun:sqlite";
-import { createSqliteModuleHost, createControllableClock } from "./index";
-import { workflow } from "./workflow.pilot";
-import { parseWorkflowDefinition } from "./workflow-definition";
-
-const identity = { actor: "fixture", grants: ["workflow:admin" as const] };
-const dbs: Database[] = [];
-afterEach(() => { for (const db of dbs.splice(0)) db.close(); });
-export async function fixture(items: unknown[], policy = "continue", action?: Record<string, unknown>, raw?: Record<string, unknown>) {
-  const db = new Database(":memory:"); dbs.push(db);
-  const clock = createControllableClock(1000);
-  const host = createSqliteModuleHost({ db, clock }); host.register(workflow);
-  const call = (op: string, input: Record<string, unknown> = {}): Promise<any> => host.invoke(workflow, op, identity, input);
-  const definition = parseWorkflowDefinition(raw ?? { version: 2,
-    outputs: { type: "object", additionalProperties: false, properties: { fleet: { type: "object", additionalProperties: true } } },
-    return: { fleet: "${{ steps.fleet.outputs }}" },
-    steps: { fleet: { timeout: "1m", "for-each": { items, concurrency: 2, "on-failure": policy, do: action ?? { script: { run: "fixture-host", timeout: "1m" }, inputs: { host: "${{ item }}", index: "${{ index }}" }, on: { 0: "next", default: "fail" } } } } } });
-  const { run } = await call("start", { workflow: "fleet", taskId: 1, coordinator: "fixture", cwd: "/fixture", orchestratorId: "fixture", sha: "a".repeat(40), ref: "origin/main", definition, afterEventId: 0 });
-  const driver = host.workflowDriver(workflow, identity);
-  async function pump() {
-    for (let pass = 0; pass < 8; pass++) {
-      const tick = await call("tickItems");
-      for (const runId of tick.cancel) await call("cancel", { runId, by: "fixture", reason: "fail-fast" });
-      await driver.recover(); await driver.wakeup();
-      for (const effect of (await call("pendingEffects")).items) {
-        if (effect.kind === "script") continue;
-        await call("settleEffect", { id: effect.id, status: "done", result: {} });
-        if (effect.kind === "cancel-children") await call("cleanup", { runId: effect.runId, complete: true });
-        if (effect.kind === "reap" && effect.waitKey) await call("signal", { runId: effect.runId, key: effect.waitKey, kind: "cleanup", payload: {} });
-      }
-    }
-  }
-  async function scripts() { return (await call("pendingEffects")).items.filter((effect: any) => effect.kind === "script"); }
-  async function finish(effect: any, exitCode = 0, output: Record<string, unknown> = { host: effect.payload.inputs.host }) {
-    await call("settleEffect", { id: effect.id, status: "done", result: {} });
-    await call("signal", { runId: effect.runId, key: effect.waitKey, kind: "script", payload: { step: effect.payload.step, round: 1, attempt: effect.payload.attempt, timerId: `wfs-${effect.id}`, exitCode, timedOut: false, output, at: 1 } });
-    await pump();
-  }
-  await pump();
-  return { call, pump, scripts, finish, runId: run.id, clock, host };
-}

package/node_modules/@humwick/kernel/workflow-control.ts

@@ -1,178 +0,0 @@
-import { z } from "zod";
-import { OpError, type ModuleCtx } from "./contract";
-import { workflowBackstop } from "./workflow-backstop";
-import { CI_MAIN_STEP, waitTimeoutMs, workflowCallPinSchema, workflowStations } from "./workflow-definition";
-import { landIntent } from "./workflow-transitions";
-import { retryItem, resumeContainer } from "./workflow-foreach";
-import { SIGNAL_TOPIC, ADMIN_GRANT, json, runSchema, stores, requireRun, writeEffect, usedEffects, workflowEffectId } from "./workflow-state";
-const alertInput = z.union([
-        // `waitKey` names the wait the fact was read for (red CI); without it the alert is about the land wait.
-        z.object({ runId: z.string().min(1), key: z.string().min(1), reason: z.string().min(1), waitKey: z.string().min(1).optional(), detail: json.optional() }),
-        // A timeout names the wait it read, so a run that moved on since is not alerted for its old step.
-        z.object({ runId: z.string().min(1), timeout: z.object({ waitKey: z.string().min(1), timeoutMs: z.number().int(), waitingFor: json }) }),
-      ]);
-const resumeInput = z.object({ runId: z.string().min(1), activationId: z.string().optional(), step: z.string().min(1).optional(), note: z.string().min(1).optional(), pins: z.record(z.string(), workflowCallPinSchema).optional(), workspaceId: z.string().optional(), by: z.string().min(1) });
-const cancelInput = z.object({ runId: z.string().min(1), reason: z.string().min(1), by: z.string().min(1) });
-export const workflowControlOps = {
-    alert: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Escalate once per key while the run keeps waiting: a stopped land, red CI on main, or a wait past its deadline (system-only).",
-      expose: { http: false, mcp: false, cli: false },
-      input: alertInput,
-      output: z.object({ created: z.boolean() }),
-      handler: async (ctx: ModuleCtx, input: z.output<typeof alertInput>) => {
-        const run = await requireRun(ctx, input.runId);
-        const wait = run.awaiting;
-        // A run leaving its land wait for a resumed step is not waiting on that land any more.
-        if (run.status !== "running" || !wait || run.resuming?.to) return { created: false };
-        if ("timeout" in input ? wait.key !== input.timeout.waitKey || wait.timedOutAt !== undefined : input.waitKey ? wait.key !== input.waitKey : wait.kind !== "landed") return { created: false };
-        // A resume at `land` renews the same wait's deadline, so a timeout alert is keyed by the deadline it passed.
-        const id = "timeout" in input ? `${run.id}:timeout:${wait.key}:${wait.deadline ?? wait.since}` : `${workflowEffectId(run.id, run.waitSeq, "escalate")}:${input.key}`;
-        if (await stores(ctx).effect.get(id)) return { created: false };
-        const now = ctx.clock.now();
-        const payload = "timeout" in input
-          ? { reason: "step-timeout", alert: true, step: run.step, round: run.round, waitingFor: input.timeout.waitingFor, timeoutMs: input.timeout.timeoutMs }
-          : { ...input.detail, reason: input.reason, alert: true };
-        await stores(ctx).effect.create({ id, runId: run.id, kind: "escalate", waitKey: wait.key, payload: { ...payload, wait }, status: "pending", attempts: 0, createdAt: now });
-        await stores(ctx).run.update(run.id, { ...("timeout" in input ? { awaiting: { ...wait, timedOutAt: now } } : {}), escalation: { id, at: now, waitKey: wait.key }, updatedAt: now });
-        return { created: true };
-      },
-    },
-    resume: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "Re-enter a run at its escalated step or a named one, once per escalation, with a fresh bound budget and step deadline (system-only).",
-      emits: [SIGNAL_TOPIC],
-      expose: { http: false, mcp: false, cli: false },
-      input: resumeInput,
-      output: z.object({ run: runSchema, resumed: z.boolean() }),
-      handler: async (ctx: ModuleCtx, input: z.output<typeof resumeInput>) => {
-        let run = await requireRun(ctx, input.runId);
-        const requested = run;
-        const treeRoot = run.rootRunId ? await requireRun(ctx, run.rootRunId) : undefined;
-        if (treeRoot?.cancel) throw new OpError("conflict", 409, "root tree is cancelled; it cannot resume");
-        if (treeRoot?.decisionChildRunId) {
-          if (input.step || input.pins) throw new OpError("invalid_input", 400, "resume a parked child without replacing its step or inputs");
-          run = await requireRun(ctx, treeRoot.decisionChildRunId);
-          if (run.itemContext && run.status === "failed") {
-            await retryItem(ctx, run, input.activationId);
-            return { run: await requireRun(ctx, requested.id), resumed: true };
-          }
-          if (run.status === "running" || run.status === "done") {
-            let ancestor = run.parentRunId ? await requireRun(ctx, run.parentRunId) : undefined;
-            const now = ctx.clock.now();
-            while (ancestor) {
-              await stores(ctx).run.update(ancestor.id, { status: "running", reason: undefined, decisionChildRunId: undefined, escalation: undefined, generation: (treeRoot.generation ?? 0) + 1,
-                ...(ancestor.awaiting ? { awaiting: { ...ancestor.awaiting, deadline: now + waitTimeoutMs(ancestor.definition, ancestor.step), timedOutAt: undefined } } : {}), updatedAt: now });
-              if (ancestor.activationId) await stores(ctx).activation.update(ancestor.activationId, { state: "waiting", error: undefined, generation: (treeRoot.generation ?? 0) + 1, updatedAt: now });
-              ancestor = ancestor.parentRunId ? await requireRun(ctx, ancestor.parentRunId) : undefined;
-            }
-            return { run: await requireRun(ctx, requested.id), resumed: true };
-          }
-        }
-
-        if (await resumeContainer(ctx, run)) return { run: await requireRun(ctx, requested.id), resumed: true };
-        const retryCi = run.status === "done" && run.step === CI_MAIN_STEP && !!run.landed && !!run.output?.ci && run.output.ci.status !== "pass" && (input.step ?? run.step) === CI_MAIN_STEP;
-        if ((run.status === "done" && !retryCi) || run.status === "cancelled" || run.status === "failed" || run.cancel) throw new OpError("conflict", 409, `workflow run '${run.id}' is ${run.cancel ? "cancelled" : run.status}; only a run that escalated resumes`);
-        // A run escalated before #3045 H2 has no escalation record; its end is the escalation.
-        const escalation = (retryCi ? `${run.id}:ci:${run.waitSeq}` : undefined) ?? run.escalation?.id ?? (run.status === "escalated" ? `${run.id}:escalated` : undefined);
-        if (escalation && run.resumes?.at(-1)?.escalation === escalation) return { run, resumed: false };
-        if (!escalation || (run.status === "running" && run.escalation?.waitKey !== run.awaiting?.key)) {
-          throw new OpError("conflict", 409, `workflow run '${run.id}' is running and has not escalated at its current step; there is nothing to resume`);
-        }
-        // The Task's newest run owns it (start re-links it), so an older run never comes back beside it.
-        const owner = await stores(ctx).link.get(String(run.taskId));
-        if (owner && owner.runId !== run.id) throw new OpError("conflict", 409, `T${run.taskId} has a newer workflow run '${owner.runId}'; resume that one`);
-        const step = input.step ?? run.step;
-        const stations = workflowStations(run.definition);
-        const postLand = run.definition.land?.then ? stations.slice(stations.indexOf(run.definition.land.then)) : [];
-        if (run.landed && step !== CI_MAIN_STEP && !postLand.includes(step)) {
-          throw new OpError("invalid_input", 400, `workflow run '${run.id}' already landed T${run.taskId} as ${run.landed.sha}; only ${CI_MAIN_STEP} or a post-land step can be resumed`);
-        }
-        if (step === CI_MAIN_STEP || step === "close" ? !run.landed : step !== "land" && !run.definition.steps[step]) {
-          throw new OpError("invalid_input", 400, `workflow run '${run.id}' has no step "${step}"; resume at ${[...Object.keys(run.definition.steps), "land"].join(", ")}`);
-        }
-        // A resume replaces the call pin of each step it names; the others keep theirs.
-        const pins = input.pins ? { pins: { ...run.pins, ...input.pins } } : {};
-        const wait = run.status === "running" ? run.awaiting : null;
-        if (run.status === "running" && (!wait || await stores(ctx).signal.get(wait.key))) {
-          throw new OpError("conflict", 409, `workflow run '${run.id}' is routing a step result that just arrived; relay_workflow_get shows where it went`);
-        }
-        const now = ctx.clock.now();
-        const note = input.note ? { note: input.note } : {};
-        const used = await usedEffects(ctx, run);
-        const round = step === "land" || step === CI_MAIN_STEP ? run.round : run.round + 1;
-        const resumes = [...(run.resumes ?? []), { escalation, from: run.step, step, round, ...note, by: input.by, at: now }];
-        // The bound that escalated already reached the coordinator: the resumed loop gets a fresh budget.
-        const base = { status: "running" as const, ...workflowBackstop({ ...run, step }, now), reason: undefined, round, counters: {}, feedback: null, scriptPoll: undefined, ...(step === "land" ? { landOperationId: workflowEffectId(run.id, used.seq + 1, "clear-hold") } : {}), resumes, ...pins, ...(input.workspaceId ? { deliveryWorkspaceId: input.workspaceId } : {}), updatedAt: now };
-        // The run goes on with its agents, so its end-of-run reap is void.
-        for (const id of used.runReaps) await stores(ctx).effect.update(id, { status: "done", result: { superseded: "resume" }, settledAt: now });
-        if (wait?.kind === "landed" && step === "land") {
-          // The same land wait goes on with a fresh deadline: a new one would miss a land that completed before it.
-          const seq = used.seq + 1;
-          const landOperationId = await writeEffect(ctx, run, seq, "clear-hold", landIntent({ ...run, ...base }, true), wait.key);
-          await stores(ctx).run.update(run.id, { ...base, landOperationId, awaiting: { ...wait, deadline: now + waitTimeoutMs(run.definition, "land"), timedOutAt: undefined } });
-        } else if (wait?.kind === "landed") {
-          // The run owns its land wait until the Task is held again, so a land that wins still ends it with its result.
-          const seq = used.seq + 1;
-          await writeEffect(ctx, run, seq, "hold", { step }, wait.key);
-          await stores(ctx).run.update(run.id, { ...base, waitSeq: seq, resuming: { ...note, to: step } });
-        } else if (wait) {
-          await stores(ctx).run.update(run.id, { ...base, step, waitSeq: used.seq, resuming: note });
-          await stores(ctx).signal.create({ id: wait.key, runId: run.id, kind: "resume", payload: { step }, createdAt: now });
-          await ctx.events.emit(SIGNAL_TOPIC, { runId: run.id, correlationId: wait.key });
-        } else {
-          await stores(ctx).run.update(run.id, { ...base, step, waitSeq: used.seq, resuming: note, awaiting: null });
-          await ctx.workflows.start("run", { runId: run.id }, { idempotencyKey: `${run.id}:resume:${resumes.length}`, enlist: "op-commit" });
-        }
-        if (treeRoot?.decisionChildRunId) {
-          let ancestor = run.parentRunId ? await requireRun(ctx, run.parentRunId) : undefined;
-          while (ancestor) {
-            await stores(ctx).run.update(ancestor.id, { status: "running", reason: undefined, decisionChildRunId: undefined, escalation: undefined, generation: (treeRoot.generation ?? 0) + 1, updatedAt: now });
-            if (ancestor.activationId) await stores(ctx).activation.update(ancestor.activationId, { state: "waiting", error: undefined, generation: (treeRoot.generation ?? 0) + 1, updatedAt: now });
-            ancestor = ancestor.parentRunId ? await requireRun(ctx, ancestor.parentRunId) : undefined;
-          }
-        }
-        return { run: await requireRun(ctx, requested.id), resumed: true };
-      },
-    },
-    cancel: {
-      kind: "mutation",
-      idempotent: true,
-      grant: ADMIN_GRANT,
-      summary: "End a run cancelled: a running one at its next routing (a parked wait wakes now), an escalated one at once; a done run refuses (system-only).",
-      emits: [SIGNAL_TOPIC, "workflow.finished"],
-      expose: { http: false, mcp: false, cli: false },
-      input: cancelInput,
-      output: z.object({ run: runSchema, cancelled: z.boolean() }),
-      handler: async (ctx: ModuleCtx, input: z.output<typeof cancelInput>) => {
-        const run = await requireRun(ctx, input.runId);
-        if (run.status === "done") throw new OpError("conflict", 409, `workflow run '${run.id}' is done${run.output ? `: T${run.taskId} landed as ${run.output.landedSha}` : ""}; there is nothing to cancel`);
-        if (run.status === "cancelled" || run.cancel) return { run, cancelled: false };
-        const now = ctx.clock.now();
-        if (run.status !== "running" && run.awaiting?.kind === "decision") await writeEffect(ctx, run, run.waitSeq + 1, "withdraw-decision", { effectId: run.awaiting.effectId });
-        if (run.rootRunId) {
-          await writeEffect(ctx, run, run.waitSeq + 1, "cancel-children", { scriptEffectId: run.awaiting?.kind === "script" ? run.awaiting.effectId : undefined });
-          if (run.activationId) await stores(ctx).activation.update(run.activationId, { state: "cancelled", updatedAt: now });
-        }
-        const cancel = { reason: input.reason, by: input.by, at: now };
-        if (run.status === "escalated" || run.status === "failed") {
-          await writeEffect(ctx, { ...run, cancel }, run.waitSeq + 1, "reap", { scope: "run" });
-          // Cancellation also shuts down agents retained by an escalation.
-          await stores(ctx).run.update(run.id, { cleanup: { status: "pending", deadline: now + 300000 }, status: "cancelled", reason: input.reason, cancel, updatedAt: now });
-          await ctx.events.emit("workflow.finished", { runId: run.id, status: "cancelled" });
-          return { run: await requireRun(ctx, run.id), cancelled: true };
-        }
-        await stores(ctx).run.update(run.id, { cancel, cleanup: { status: "pending", deadline: now + 300000 }, updatedAt: now });
-        const wait = run.awaiting;
-        if (wait && !(await stores(ctx).signal.get(wait.key))) {
-          await stores(ctx).signal.create({ id: wait.key, runId: run.id, kind: "cancel", payload: { reason: input.reason }, createdAt: now });
-          await ctx.events.emit(SIGNAL_TOPIC, { runId: run.id, correlationId: wait.key });
-        }
-        return { run: await requireRun(ctx, run.id), cancelled: true };
-      },
-    },
-} as const;