@fungi.computer/braid 0.0.0-stage → 0.1.0

package/dist/runtime/trigger-plans.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import * as S from "effect/Schema";
+import { canonicalJson, executionPlanSchema, } from "../index.js";
+import { armedWorkflowTriggerSchema, } from "./trigger-owner.js";
+const rowSchema = S.Struct({
+    binding: S.String,
+    plan: S.String,
+    refusal: S.NullOr(S.String),
+});
+/** Immutable published plans survive Team owner recreation; only arm writes plans. */
+export function createTriggerPlans(sql) {
+    sql.exec(`CREATE TABLE IF NOT EXISTS hub_workflow_trigger_plans (
+    binding TEXT PRIMARY KEY, installation_id TEXT NOT NULL,
+    plan TEXT NOT NULL, refusal TEXT
+  ) STRICT`);
+    const key = (binding) => canonicalJson(z.json().parse(armedWorkflowTriggerSchema.parse(binding)));
+    const decode = (raw) => {
+        const row = S.decodeUnknownSync(rowSchema)(raw);
+        return {
+            binding: armedWorkflowTriggerSchema.parse(JSON.parse(row.binding)),
+            plan: S.decodeUnknownSync(executionPlanSchema)(JSON.parse(row.plan), {
+                onExcessProperty: "error",
+            }),
+            refusal: row.refusal,
+        };
+    };
+    return {
+        put(binding, plan) {
+            sql.exec("INSERT INTO hub_workflow_trigger_plans(binding,installation_id,plan,refusal) VALUES(?,?,?,NULL) ON CONFLICT(binding) DO UPDATE SET plan=excluded.plan,refusal=NULL", key(binding), binding.installationId, JSON.stringify(S.decodeUnknownSync(executionPlanSchema)(plan)));
+        },
+        read(binding) {
+            const row = sql
+                .exec("SELECT binding,plan,refusal FROM hub_workflow_trigger_plans WHERE binding=?", key(binding))
+                .toArray()[0];
+            return row === undefined ? null : decode(row);
+        },
+        refusal(binding) {
+            const row = sql
+                .exec("SELECT refusal FROM hub_workflow_trigger_plans WHERE binding=?", key(binding))
+                .toArray()[0];
+            return row === undefined
+                ? "Compiled Workflow unavailable; re-arm required"
+                : S.decodeUnknownSync(S.Struct({ refusal: S.NullOr(S.String) }))(row)
+                    .refusal;
+        },
+        installation(installationId) {
+            return sql
+                .exec("SELECT binding,plan,refusal FROM hub_workflow_trigger_plans WHERE installation_id=?", installationId)
+                .toArray()
+                .map(decode);
+        },
+        refuse(binding, reason) {
+            sql.exec("UPDATE hub_workflow_trigger_plans SET refusal=? WHERE binding=?", reason, key(binding));
+        },
+        remove(binding) {
+            sql.exec("DELETE FROM hub_workflow_trigger_plans WHERE binding=?", key(binding));
+        },
+        invalidateInstallation(installationId) {
+            sql.exec("DELETE FROM hub_workflow_trigger_plans WHERE installation_id=?", installationId);
+        },
+    };
+}

package/dist/runtime/trigger-router.d.ts

@@ -0,0 +1,34 @@
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type AppEventFact } from "@fungi.computer/puffball/app-event-facts";
+import { type WorkflowArmer, type WorkflowInstallationAuthority, type WorkflowTriggerPrincipal, type WorkflowTriggerTarget, type createTeamWorkflowTriggers } from "./trigger-owner.js";
+/** The Team's one App-event index; admission and execution belong to the shared trigger owner. */
+export declare function createWorkflowEventRouter(options: {
+    sql: WatchdogSqliteOwner["sql"];
+    triggers: ReturnType<typeof createTeamWorkflowTriggers>;
+    teamId(): string;
+    commit<A>(body: () => A): Promise<A>;
+    authorize(memberId: string, installationId: string): Promise<void>;
+}): {
+    arm(armer: WorkflowArmer, target: WorkflowTriggerTarget, computerId: string, installationAuthority: WorkflowInstallationAuthority): Promise<{
+        kind: "refused";
+        reason: string;
+    } | {
+        kind: "armed";
+        eventTriggerId: string;
+    }>;
+    disarm(principal: WorkflowTriggerPrincipal, installationId: string, eventTriggerId: string): Promise<{
+        kind: "disarmed";
+    } | {
+        kind: "not_found";
+    }>;
+    list(principal: WorkflowTriggerPrincipal, installationId: string): Promise<{
+        eventTriggerId: string;
+        workflowId: string;
+        triggerId: string;
+        emitterInstallationId: string;
+        event: string;
+        state: "active" | "paused";
+        lastError: string | null;
+    }[]>;
+    deliver(raw: AppEventFact): Promise<"accepted">;
+};

package/dist/runtime/trigger-router.js

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import { canonicalJson, contentDigest } from "../index.js";
+import { appEventFactSchema, } from "@fungi.computer/puffball/app-event-facts";
+import { armedWorkflowTriggerSchema, workflowArmerKey, workflowTriggerControlledBy, workflowTriggerPrincipalMember, } from "./trigger-owner.js";
+import { storedTriggerRows } from "./stored-trigger-rows.js";
+const recordSchema = armedWorkflowTriggerSchema.extend({
+    id: z.string(),
+    emitterInstallationId: appEventFactSchema.shape.installationId,
+    appId: appEventFactSchema.shape.appId,
+    event: appEventFactSchema.shape.type,
+    state: z.enum(["active", "paused"]),
+    lastError: z.string().nullable(),
+});
+/** The Team's one App-event index; admission and execution belong to the shared trigger owner. */
+export function createWorkflowEventRouter(options) {
+    const { sql } = options;
+    sql.exec(`CREATE TABLE IF NOT EXISTS hub_workflow_event_triggers (
+    id TEXT PRIMARY KEY, record TEXT NOT NULL
+  ) STRICT`);
+    sql.exec(`CREATE INDEX IF NOT EXISTS hub_workflow_event_trigger_source
+    ON hub_workflow_event_triggers(json_extract(record,'$.emitterInstallationId'),json_extract(record,'$.event'))`);
+    const rows = storedTriggerRows(sql, {
+        table: "hub_workflow_event_triggers",
+        key: "id",
+        record: recordSchema,
+    });
+    const readable = (raw) => raw.flatMap((row) => {
+        const decoded = rows.read(z.strictObject({ id: z.string() }).parse(row).id);
+        return decoded === null ? [] : [decoded];
+    });
+    return {
+        async arm(armer, target, computerId, installationAuthority) {
+            await options.authorize(armer.armedBy, target.installationId);
+            const armed = await options.triggers.arm(armer, target, computerId, installationAuthority);
+            if (armed.kind === "refused")
+                return armed;
+            if (armed.trigger.on !== "event")
+                return {
+                    kind: "refused",
+                    reason: "Workflow trigger is not an App event",
+                };
+            const emitterInstallationId = armed.binding.bindings[armed.trigger.app];
+            const appId = armed.definition.apps[armed.trigger.app]?.appId;
+            if (emitterInstallationId === undefined || appId === undefined)
+                return {
+                    kind: "refused",
+                    reason: "Event App installation is not bound",
+                };
+            const id = await contentDigest([
+                "workflow-event",
+                ...workflowArmerKey(armer),
+                target.installationId,
+                target.workflowId,
+                target.triggerId,
+            ]);
+            const record = recordSchema.parse({
+                ...armed.binding,
+                id,
+                emitterInstallationId,
+                appId,
+                event: armed.trigger.event,
+                state: "active",
+                lastError: null,
+            });
+            await options.commit(() => {
+                const previous = rows.read(id);
+                if (previous !== null) {
+                    const binding = armedWorkflowTriggerSchema.strip().parse(previous);
+                    if (canonicalJson(z.json().parse(binding)) !==
+                        canonicalJson(z.json().parse(armed.binding)))
+                        options.triggers.disarm(binding);
+                }
+                sql.exec("INSERT INTO hub_workflow_event_triggers(id,record) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET record=excluded.record", id, JSON.stringify(record));
+            });
+            return { kind: "armed", eventTriggerId: id };
+        },
+        async disarm(principal, installationId, eventTriggerId) {
+            const memberId = workflowTriggerPrincipalMember(principal);
+            await options.authorize(memberId, installationId);
+            const record = rows.read(eventTriggerId);
+            if (record === null)
+                return { kind: "not_found" };
+            if (record.installationId !== installationId ||
+                !workflowTriggerControlledBy(principal, record))
+                return { kind: "not_found" };
+            return options.commit(() => {
+                // Re-read inside the commit; a concurrent change may have replaced the row.
+                const current = rows.read(eventTriggerId);
+                if (current === null ||
+                    !workflowTriggerControlledBy(principal, current))
+                    return { kind: "not_found" };
+                options.triggers.disarm(armedWorkflowTriggerSchema.strip().parse(current));
+                rows.remove(eventTriggerId);
+                return { kind: "disarmed" };
+            });
+        },
+        async list(principal, installationId) {
+            await options.authorize(workflowTriggerPrincipalMember(principal), installationId);
+            const stored = readable(sql
+                .exec("SELECT id FROM hub_workflow_event_triggers WHERE json_valid(record) AND json_extract(record,'$.installationId')=? ORDER BY id", installationId)
+                .toArray()).map((record) => {
+                const refusal = options.triggers.refusal(armedWorkflowTriggerSchema.strip().parse(record));
+                return {
+                    eventTriggerId: record.id,
+                    workflowId: record.workflowId,
+                    triggerId: record.triggerId,
+                    emitterInstallationId: record.emitterInstallationId,
+                    event: record.event,
+                    state: refusal === null ? record.state : "paused",
+                    lastError: record.lastError ?? refusal,
+                };
+            });
+            return stored;
+        },
+        async deliver(raw) {
+            const fact = appEventFactSchema.parse(raw);
+            const records = readable(sql
+                .exec("SELECT id FROM hub_workflow_event_triggers WHERE json_valid(record) AND json_extract(record,'$.emitterInstallationId')=? AND json_extract(record,'$.event')=? ORDER BY id", fact.installationId, fact.type)
+                .toArray());
+            for (const record of records) {
+                if (record.appId !== fact.appId || record.state !== "active")
+                    continue;
+                const result = await options.triggers.fire(armedWorkflowTriggerSchema.strip().parse(record), canonicalJson([
+                    options.teamId(),
+                    "app-event",
+                    record.id,
+                    fact.installationId,
+                ]), { payload: fact.payload, eventId: fact.eventId });
+                if (result.kind === "refused") {
+                    await options.commit(() => {
+                        // A concurrent disarm or re-arm owns the newer record.
+                        sql.exec("UPDATE hub_workflow_event_triggers SET record=? WHERE id=? AND record=?", JSON.stringify({
+                            ...record,
+                            state: "paused",
+                            lastError: result.reason,
+                        }), record.id, JSON.stringify(record));
+                    });
+                }
+            }
+            return "accepted";
+        },
+    };
+}

package/dist/runtime/trigger-run-reservations.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+declare const triggerRunScopeSchema: z.ZodLazy<z.ZodObject<{
+    installationId: z.ZodString;
+    workflowId: z.ZodString;
+    commit: z.ZodString;
+    triggerId: z.ZodString;
+}, z.core.$strict>>;
+export type TriggerRunScope = z.output<typeof triggerRunScopeSchema>;
+/** The enclosing Team owner supplies SQLite; callers never select the Team. */
+export declare function createTriggerRunReservations(options: Pick<WatchdogSqliteOwner, "sql" | "transactionSync">): {
+    reserveTriggerRun(raw: {
+        scope: TriggerRunScope;
+        requestId: string;
+    }): {
+        kind: "reserved" | "replay";
+        reservationId: string;
+        runId: string | null;
+    } | {
+        kind: "refused";
+        reason: "limit";
+    };
+    countActiveTriggerRuns(scope: TriggerRunScope): number;
+    releaseTriggerRun(rawReservationId: string): void;
+    bindTriggerRun(rawReservationId: string, rawRunId: string): "bound" | "replay" | "conflict";
+    terminalTriggerRun(rawRunId: string): void;
+};
+export {};

package/dist/runtime/trigger-run-reservations.js

@@ -0,0 +1,114 @@
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+import { z } from "zod";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { workflowIdSchema } from "../index.js";
+const reservationIds = defineIdFamily({
+    family: "workflow-trigger-reservation",
+    version: 1,
+    kinds: { reservation: { prefix: "wf_trigger_reservation" } },
+});
+const identity = z.string().min(1).max(256);
+const triggerRunScopeSchema = z.lazy(() => z.strictObject({
+    installationId: identity,
+    workflowId: workflowIdSchema,
+    commit: gitSha1Schema,
+    triggerId: z.string().min(1).max(80),
+}));
+const reservationInputSchema = z.lazy(() => z.strictObject({
+    scope: triggerRunScopeSchema,
+    requestId: z.string().min(1).max(1024),
+}));
+const rowSchema = z.lazy(() => z.object({
+    reservation_id: identity,
+    run_id: identity.nullable(),
+    status: z.enum(["active", "released", "terminal"]),
+}));
+const countSchema = z.lazy(() => z.object({ count: z.number().int().nonnegative() }));
+const scopeKey = (scope) => {
+    const parsed = triggerRunScopeSchema.parse(scope);
+    return JSON.stringify([
+        parsed.installationId,
+        parsed.workflowId,
+        parsed.commit,
+        parsed.triggerId,
+    ]);
+};
+/** The enclosing Team owner supplies SQLite; callers never select the Team. */
+export function createTriggerRunReservations(options) {
+    const { sql } = options;
+    sql.exec(`CREATE TABLE IF NOT EXISTS hub_trigger_run_reservations (
+    reservation_id TEXT PRIMARY KEY, scope TEXT NOT NULL, request_id TEXT NOT NULL,
+    run_id TEXT UNIQUE, status TEXT NOT NULL CHECK(status IN ('active','released','terminal')),
+    UNIQUE(scope,request_id)
+  ) STRICT`);
+    return {
+        reserveTriggerRun(raw) {
+            const input = reservationInputSchema.parse(raw);
+            const scope = scopeKey(input.scope);
+            return options.transactionSync(() => {
+                const stored = sql
+                    .exec("SELECT reservation_id,run_id,status FROM hub_trigger_run_reservations WHERE scope=? AND request_id=?", scope, input.requestId)
+                    .toArray()[0];
+                const prior = stored === undefined ? null : rowSchema.parse(stored);
+                if (prior !== null && prior.status !== "released")
+                    return {
+                        kind: "replay",
+                        reservationId: prior.reservation_id,
+                        runId: prior.run_id,
+                    };
+                const active = countSchema.parse(sql
+                    .exec("SELECT count(*) AS count FROM hub_trigger_run_reservations WHERE status='active'")
+                    .toArray()[0]).count;
+                if (active >= 20)
+                    return { kind: "refused", reason: "limit" };
+                const reservationId = prior?.reservation_id ?? reservationIds.reservation.generate();
+                if (prior === null)
+                    sql.exec("INSERT INTO hub_trigger_run_reservations(reservation_id,scope,request_id,run_id,status) VALUES(?,?,?,NULL,'active')", reservationId, scope, input.requestId);
+                else
+                    sql.exec("UPDATE hub_trigger_run_reservations SET status='active' WHERE reservation_id=?", reservationId);
+                return {
+                    kind: "reserved",
+                    reservationId,
+                    runId: prior?.run_id ?? null,
+                };
+            });
+        },
+        countActiveTriggerRuns(scope) {
+            return countSchema.parse(sql
+                .exec("SELECT count(*) AS count FROM hub_trigger_run_reservations WHERE scope=? AND status='active'", scopeKey(scope))
+                .toArray()[0]).count;
+        },
+        releaseTriggerRun(rawReservationId) {
+            const reservationId = identity.parse(rawReservationId);
+            options.transactionSync(() => {
+                sql.exec("UPDATE hub_trigger_run_reservations SET status='released' WHERE reservation_id=? AND status='active'", reservationId);
+            });
+        },
+        bindTriggerRun(rawReservationId, rawRunId) {
+            const reservationId = identity.parse(rawReservationId);
+            const runId = identity.parse(rawRunId);
+            return options.transactionSync(() => {
+                const stored = sql
+                    .exec("SELECT reservation_id,run_id,status FROM hub_trigger_run_reservations WHERE reservation_id=?", reservationId)
+                    .toArray()[0];
+                if (stored === undefined)
+                    return "conflict";
+                const prior = rowSchema.parse(stored);
+                if (prior.run_id === runId)
+                    return "replay";
+                if (prior.run_id !== null || prior.status !== "active")
+                    return "conflict";
+                if (sql
+                    .exec("SELECT reservation_id FROM hub_trigger_run_reservations WHERE run_id=?", runId)
+                    .toArray().length > 0)
+                    return "conflict";
+                sql.exec("UPDATE hub_trigger_run_reservations SET run_id=? WHERE reservation_id=?", runId, reservationId);
+                return "bound";
+            });
+        },
+        terminalTriggerRun(rawRunId) {
+            const runId = identity.parse(rawRunId);
+            sql.exec("UPDATE hub_trigger_run_reservations SET status='terminal' WHERE run_id=?", runId);
+        },
+    };
+}