@fungi.computer/trellis 0.0.0-stage → 0.0.1

package/dist/backend/methods.js

@@ -0,0 +1,141 @@
+import { workflowLibraryGill } from "./gills.js";
+import * as z from "zod";
+import { memberInboxItemSchema } from "@fungi.computer/agar/inbox";
+import { catalogReplySchema as catalogReply } from "./catalog.js";
+import { scheduleMethods } from "./schedule-methods.js";
+import { toolFamilyMethods } from "./tool-family.js";
+import { libraryMethods } from "./library-methods.js";
+import * as Schema from "effect/Schema";
+import { reviewAnswerSchema } from "@fungi.computer/braid";
+import { defineAppBackend, defineAppMethod, } from "@fungi.computer/agar/backend-definition";
+import { chatsReplySchema, answerReviewReply, cancelReplySchema, catalogInputSchema, runListItemSchema, runsReplySchema, statusReply, viewerReplySchema, } from "@fungi.computer/workflows-wire";
+import { workflowIdSchema } from "@fungi.computer/braid";
+const identity = z.string().min(1).max(256);
+const inboxPage = z.object({ items: z.array(z.json()).max(200) });
+const granted = (context) => {
+    if (!context.env.WORKFLOWS)
+        throw new Error("Workflow access is not granted");
+    return context.env.WORKFLOWS;
+};
+export const appBackend = defineAppBackend({
+    sync: { method: "continuePublication" },
+    gills: [workflowLibraryGill],
+    toolFamily: { name: "flows", list: "listWorkflowTools", call: "runWorkflow" },
+    methods: {
+        ...libraryMethods,
+        ...toolFamilyMethods,
+        listRuns: defineAppMethod({
+            description: "List up to fifty runs from this installation, newest first.",
+            effect: "read",
+            requires: ["workflow.run"],
+            input: z.strictObject({ workflowId: workflowIdSchema.optional() }),
+            output: z.array(runListItemSchema).max(50),
+            handler: async (input, context) => {
+                const indexes = context.indexes;
+                if (!indexes)
+                    throw new Error("Workflow indexes unavailable");
+                const reply = runsReplySchema.parse(await granted(context).runs(input.workflowId === undefined
+                    ? {}
+                    : { workflowId: input.workflowId }));
+                if ("error" in reply)
+                    throw new Error("Workflow run list unavailable");
+                return reply.runs.map((row) => {
+                    const copied = indexes.publications.read(`${row.workflowId}:${row.commit}`);
+                    const published = copied.kind === "ready" &&
+                        copied.head === row.commit &&
+                        copied.value.commit === row.commit
+                        ? copied.value
+                        : null;
+                    return {
+                        ...row,
+                        title: published?.definition.title ?? null,
+                        version: published?.version ?? null,
+                    };
+                });
+            },
+        }),
+        viewerId: defineAppMethod({
+            description: "The calling member's own id, so the Runs UI can tell its own runs from a teammate's.",
+            effect: "read",
+            requires: [],
+            input: z.strictObject({}),
+            output: viewerReplySchema,
+            handler: (_input, _context, caller) => caller.actor.kind === "member"
+                ? { memberId: caller.actor.memberId }
+                : { error: "not_granted" },
+        }),
+        ...scheduleMethods,
+        listChats: defineAppMethod({
+            description: "List your existing chats (Agent Sessions) that a run or trigger may report its result to.",
+            effect: "read",
+            requires: ["agent.read"],
+            input: z.strictObject({}),
+            output: chatsReplySchema,
+            handler: async (_input, context) => {
+                if (!context.env.INBOX)
+                    return { error: "not_granted" };
+                const page = inboxPage.parse(await context.env.INBOX.page({ after: null }));
+                return {
+                    chats: page.items.flatMap((raw) => {
+                        const item = Schema.decodeUnknownSync(memberInboxItemSchema)(raw);
+                        return "kind" in item || !("title" in item)
+                            ? []
+                            : [
+                                {
+                                    agentId: item.agentId,
+                                    sessionId: item.sessionId,
+                                    title: item.title,
+                                },
+                            ];
+                    }),
+                };
+            },
+        }),
+        catalog: defineAppMethod({
+            description: "List your installed Apps' methods: a palette index with no port schemas, or one installation's full ports when `installationId` is given.",
+            effect: "read",
+            requires: ["workflow.run"],
+            input: catalogInputSchema,
+            output: catalogReply,
+            handler: async (input, context) => catalogReply.parse(await granted(context).catalog(input)),
+        }),
+        runStatus: defineAppMethod({
+            description: "Read one of your Workflow runs: per-node events, open reviews and the engine's status.",
+            effect: "read",
+            requires: ["workflow.run"],
+            input: z.strictObject({ runId: identity }),
+            output: statusReply,
+            handler: async (input, context) => statusReply.parse(await granted(context).graphStatus(input)),
+        }),
+        cancel: defineAppMethod({
+            description: "Cancel a run you started or administer as the current Team owner. Completed runs remain terminal.",
+            effect: "write",
+            requires: ["workflow.run"],
+            input: z.strictObject({ runId: identity }),
+            output: cancelReplySchema,
+            handler: async (input, context) => cancelReplySchema.parse(await granted(context).cancel(input)),
+        }),
+        answerReview: defineAppMethod({
+            description: "Answer one of your Workflow runs' reviews: approve or reject, or pick one of the review's named choices. Only a person can answer; Agents cannot.",
+            effect: "write",
+            requires: ["workflow.run"],
+            input: z.strictObject({
+                runId: identity,
+                nodeId: identity,
+                iteration: identity,
+                answer: z.fromJSONSchema(Schema.toJsonSchemaDocument(reviewAnswerSchema).schema),
+            }),
+            output: answerReviewReply,
+            handler: async (input, context, caller) => {
+                if (caller.actor.kind !== "member")
+                    return { error: "not_granted" };
+                return answerReviewReply.parse(await granted(context).answerReview({
+                    ...input,
+                    answer: Schema.decodeUnknownSync(reviewAnswerSchema)(input.answer, {
+                        onExcessProperty: "error",
+                    }),
+                }));
+            },
+        }),
+    },
+});

package/dist/backend/publication-job.js

@@ -0,0 +1,451 @@
+import * as z from "zod";
+import * as S from "effect/Schema";
+import { Watchdog, watchdogSqliteRowSchema, } from "@fungi.computer/watchdog";
+import { begin, GitStepMaterialError, runStep, gitStepSchema, sqliteGitStepMaterial, dropMaterial, } from "@fungi.computer/agar/git-steps";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { advertisedRefs } from "@fungi.computer/agar/git-wire";
+import { contentDigest, validate, workflowDefinitionSchema, } from "@fungi.computer/braid";
+import { actorLane, backgroundOriginSchema, backgroundSyncRefusalSchema, } from "@fungi.computer/puffball/background-replay";
+import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
+import { draftDocument, publicationIds, publishedDocument, publicationFailure, publicationComplete, publicationFailed, workflowIdSchema, } from "@fungi.computer/workflows-wire";
+import { versionRefs } from "@fungi.computer/workflows-wire";
+import { serializedDraft, retainedDraft } from "./library.js";
+import { definitionAppIds } from "./catalog.js";
+const cargo = z.strictObject({
+    publicationId: publicationIds.publication.schema,
+    step: z.number().int().nonnegative(),
+});
+const rowSchema = z.strictObject({
+    id: publicationIds.publication.schema,
+    workflow_id: workflowIdSchema,
+    revision: z.number().int().positive(),
+    lane: z.string(),
+    origin: z.string(),
+    body: z.string().nullable(),
+    epoch: z.number().int().nonnegative(),
+    step: z.number().int().nonnegative(),
+    attempts: z.number().int().min(0).max(2),
+    phase: z.enum(["inspect", "create", "prepare", "git"]),
+    checkpoint: z.string().nullable(),
+    version: z.number().int().positive().nullable(),
+    status: z.enum(["publishing", "published", "failed"]),
+    reason: publicationFailure.nullable(),
+    commit_oid: z.string().nullable(),
+    request_key: z.string().nullable(),
+    digest: z.string().refine(S.is(sha256DigestSchema)),
+});
+const queue = (id) => `publication:${id}`;
+/** StoredPublication cargo and status share the facet's existing SQLite owner with Watchdog. */
+export function createPublicationJobs(storage, store) {
+    const sql = {
+        exec(statement, ...bindings) {
+            const cursor = storage.sql.exec(statement, ...bindings);
+            return {
+                toArray: () => cursor
+                    .toArray()
+                    .map((row) => S.decodeUnknownSync(watchdogSqliteRowSchema)(row)),
+            };
+        },
+    };
+    const owner = {
+        sql,
+        transactionSync: (operation) => storage.transactionSync(operation),
+    };
+    const material = sqliteGitStepMaterial(sql);
+    sql.exec("CREATE TABLE IF NOT EXISTS workflow_publication_jobs (id TEXT PRIMARY KEY, workflow_id TEXT NOT NULL, revision INTEGER NOT NULL, lane TEXT NOT NULL, origin TEXT NOT NULL, body TEXT, epoch INTEGER NOT NULL, step INTEGER NOT NULL, attempts INTEGER NOT NULL, phase TEXT NOT NULL, checkpoint TEXT, version INTEGER, status TEXT NOT NULL, reason TEXT, commit_oid TEXT, request_key TEXT, digest TEXT NOT NULL)");
+    sql.exec("CREATE INDEX IF NOT EXISTS workflow_publication_pending ON workflow_publication_jobs(lane,status)");
+    const live = new Set();
+    function read(id) {
+        const raw = sql
+            .exec("SELECT * FROM workflow_publication_jobs WHERE id = ?", id)
+            .toArray()[0];
+        return raw === undefined ? null : rowSchema.parse(raw);
+    }
+    function status(row) {
+        if (row.status === "published")
+            return publicationComplete.parse({
+                kind: "published",
+                commit: row.commit_oid,
+                version: row.version,
+            });
+        if (row.status === "failed")
+            return publicationFailed.parse({ kind: "failed", reason: row.reason });
+        return { kind: "publishing", publicationId: row.id };
+    }
+    function forDraft(workflowId, revision) {
+        const raw = sql
+            .exec("SELECT * FROM workflow_publication_jobs WHERE workflow_id = ? AND revision = ? ORDER BY rowid DESC LIMIT 1", workflowId, revision)
+            .toArray()[0];
+        return raw === undefined ? null : rowSchema.parse(raw);
+    }
+    function existing(workflowId, revision, caller) {
+        const row = forDraft(workflowId, revision);
+        if (row === null)
+            return null;
+        const lane = caller?.actor.kind === "member" ? actorLane(caller.actor) : null;
+        if (row.status === "publishing" && row.lane !== lane)
+            return { kind: "publishing_elsewhere" };
+        if (row.status !== "failed" ||
+            (row.lane === lane &&
+                caller?.idempotencyKey !== undefined &&
+                row.request_key === caller.idempotencyKey))
+            return status(row);
+        return null;
+    }
+    const queued = (row) => ({
+        jobId: `${row.id}:${String(row.step)}`,
+        queue: queue(row.id),
+        lane: row.lane,
+        priority: 0,
+        state: "queued",
+        payload: { publicationId: row.id, step: row.step },
+        recovery: { maxRecoveries: 3 },
+    });
+    function storedOrigin(value) {
+        try {
+            const decoded = backgroundOriginSchema.safeParse(JSON.parse(value));
+            return decoded.success ? decoded.data : null;
+        }
+        catch (cause) {
+            if (cause instanceof SyntaxError)
+                return null;
+            throw cause;
+        }
+    }
+    const frameClosed = (signal) => signal.aborted;
+    async function runtime(lane, ports) {
+        const progress = new Map();
+        const terminal = new Set();
+        const claimed = new Set();
+        const retry = (jobId, row, interrupted = false) => {
+            if (!interrupted && row.attempts === 2)
+                return { kind: "failed", reason: "publication_failed" };
+            progress.set(jobId, {
+                checkpoint: row.checkpoint === null
+                    ? null
+                    : gitStepSchema.parse(JSON.parse(row.checkpoint)),
+                version: row.version,
+                attempts: interrupted ? row.attempts : row.attempts + 1,
+            });
+            return { kind: "completed" };
+        };
+        const runner = await Watchdog.make({
+            owner,
+            concurrentLane: lane,
+            isAlive: (job) => Promise.resolve(live.has(job.jobId)),
+            wake: { recompute: () => Promise.resolve() },
+            execute: async (job, signal) => {
+                const input = cargo.parse(job.payload);
+                const row = read(input.publicationId);
+                if (row?.status !== "publishing" ||
+                    row.lane !== lane ||
+                    job.lane !== lane ||
+                    row.step !== input.step)
+                    return { kind: "failed", reason: "publication_changed" };
+                if (!ports)
+                    throw new Error("StoredPublication transport unavailable");
+                live.add(job.jobId);
+                claimed.add(job.jobId);
+                try {
+                    if (frameClosed(signal))
+                        return retry(job.jobId, row, true);
+                    const origin = storedOrigin(row.origin);
+                    if (origin === null || !ports.background)
+                        return { kind: "failed", reason: "access_changed" };
+                    const admission = await ports.background.admit(origin);
+                    if (admission.kind === "refused")
+                        return { kind: "failed", reason: admission.code };
+                    const git = countingGit(ports.git, { limit: 1, signal }).git;
+                    if (row.body === null)
+                        return { kind: "failed", reason: "publication_changed" };
+                    const draft = draftDocument.parse(JSON.parse(row.body));
+                    const definition = S.decodeUnknownSync(workflowDefinitionSchema)(draft.definition);
+                    const catalog = await ports.catalog(definitionAppIds(definition));
+                    if (validate(definition, catalog).length) {
+                        progress.set(job.jobId, {
+                            checkpoint: null,
+                            version: row.version,
+                            result: { kind: "failed", reason: "publication_failed" },
+                        });
+                        return { kind: "completed" };
+                    }
+                    if (row.checkpoint === null) {
+                        if (frameClosed(signal))
+                            return retry(job.jobId, row, true);
+                        if (row.phase === "inspect") {
+                            const exists = await git.info("trellis");
+                            progress.set(job.jobId, {
+                                checkpoint: null,
+                                version: null,
+                                phase: exists ? "prepare" : "create",
+                            });
+                            return { kind: "completed" };
+                        }
+                        if (row.phase === "create") {
+                            await git.create("trellis", { defaultBranch: "main" });
+                            progress.set(job.jobId, {
+                                checkpoint: null,
+                                version: null,
+                                phase: "prepare",
+                            });
+                            return { kind: "completed" };
+                        }
+                        const refs = await git.refs("trellis");
+                        if (frameClosed(signal))
+                            return retry(job.jobId, row, true);
+                        const version = (versionRefs(row.workflow_id, refs)[0]?.version ?? 0) + 1;
+                        const checkpoint = await begin({
+                            kind: "commit",
+                            requestKey: row.id,
+                            request: {
+                                repository: "trellis",
+                                branch: "main",
+                                expectedHead: refs.find((ref) => ref.name === "refs/heads/main")?.hash ??
+                                    null,
+                                changes: [
+                                    {
+                                        path: `workflows/${row.workflow_id}.json`,
+                                        content: new TextEncoder().encode(serializedDraft(retainedDraft({ ...draft, definition }))),
+                                        mode: "100644",
+                                    },
+                                ],
+                                message: `Publish ${row.workflow_id}`,
+                                author: ports.author,
+                            },
+                            tags: [
+                                {
+                                    ref: `refs/tags/${row.workflow_id}@v${String(version)}`,
+                                    expected: null,
+                                },
+                            ],
+                        }, material);
+                        progress.set(job.jobId, { checkpoint, version, phase: "git" });
+                    }
+                    else {
+                        const checkpoint = gitStepSchema.parse(JSON.parse(row.checkpoint));
+                        let witnessedRefs;
+                        const witnessedGit = {
+                            exchange: async (repository, request) => {
+                                const response = await git.exchange(repository, request);
+                                if (request.service === "upload-pack" &&
+                                    request.phase === "advertise" &&
+                                    response.status === 200)
+                                    witnessedRefs = [...advertisedRefs(response.body)].map(([name, hash]) => ({ name, hash }));
+                                return response;
+                            },
+                        };
+                        const result = await runStep(checkpoint, { git: witnessedGit, material }, signal);
+                        if ("done" in result) {
+                            const done = result.done;
+                            // Reuse the helper's fresh confirmation witness. An extra read
+                            // after the tag lands could fail or observe a different main.
+                            const refs = done.kind === "committed" ? witnessedRefs : undefined;
+                            const tag = `refs/tags/${row.workflow_id}@v${String(row.version)}`;
+                            const final = done.kind === "committed" &&
+                                refs?.some((ref) => ref.name === tag && ref.hash === done.commit)
+                                ? publicationComplete.parse({
+                                    kind: "published",
+                                    commit: done.commit,
+                                    version: row.version,
+                                })
+                                : {
+                                    kind: "failed",
+                                    reason: done.kind === "too_large"
+                                        ? "too_large"
+                                        : "git_conflict",
+                                };
+                            const completed = {
+                                checkpoint,
+                                version: row.version,
+                                result: final,
+                            };
+                            if (refs === undefined)
+                                progress.set(job.jobId, completed);
+                            else
+                                progress.set(job.jobId, { ...completed, refs });
+                        }
+                        else
+                            progress.set(job.jobId, {
+                                checkpoint: "next" in result ? result.next : checkpoint,
+                                version: row.version,
+                            });
+                    }
+                    if (frameClosed(signal))
+                        return retry(job.jobId, row, true);
+                    return { kind: "completed" };
+                }
+                catch (cause) {
+                    if (frameClosed(signal) ||
+                        (cause instanceof Error && cause.name === "AbortError"))
+                        return retry(job.jobId, row, true);
+                    if (cause instanceof GitStepMaterialError)
+                        return { kind: "failed", reason: "publication_failed" };
+                    return retry(job.jobId, row);
+                }
+            },
+            project: (transition) => {
+                const settled = transition.settled;
+                if (!settled)
+                    return;
+                const input = cargo.parse(settled.payload);
+                const row = read(input.publicationId);
+                if (row?.status !== "publishing" || row.step !== input.step)
+                    return;
+                let next = settled.outcome === "completed"
+                    ? progress.get(settled.jobId)
+                    : undefined;
+                if (!next &&
+                    (settled.outcome === "cancelled" ||
+                        settled.failureReason === "execution_interrupted")) {
+                    retry(settled.jobId, row, true);
+                    next = progress.get(settled.jobId);
+                }
+                if (!next || next.result?.kind === "failed") {
+                    const reason = next?.result?.kind === "failed"
+                        ? next.result.reason
+                        : settled.failureReason === "access_changed"
+                            ? "access_changed"
+                            : "publication_failed";
+                    sql.exec("UPDATE workflow_publication_jobs SET status = 'failed', reason = ?, body = NULL WHERE id = ?", reason, row.id);
+                    terminal.add(row.id);
+                    return;
+                }
+                if (next.result?.kind === "published") {
+                    if (row.body === null)
+                        throw new Error("StoredPublication draft missing");
+                    const { revision, ...draft } = draftDocument.parse(JSON.parse(row.body));
+                    if (revision !== row.revision)
+                        throw new Error("StoredPublication revision mismatch");
+                    if (!next.refs)
+                        throw new Error("Confirmed publication refs missing");
+                    store.publish(publishedDocument.parse({
+                        ...draft,
+                        workflowId: row.workflow_id,
+                        commit: next.result.commit,
+                        version: next.result.version,
+                        digest: row.digest,
+                    }), row.epoch, next.refs);
+                    sql.exec("UPDATE workflow_publication_jobs SET status = 'published', commit_oid = ?, version = ?, body = NULL WHERE id = ?", next.result.commit, next.result.version, row.id);
+                    terminal.add(row.id);
+                    return;
+                }
+                const successor = {
+                    ...row,
+                    step: row.step + 1,
+                    attempts: next.attempts ?? 0,
+                    phase: next.phase ?? row.phase,
+                    version: next.version,
+                    checkpoint: next.checkpoint === null ? null : JSON.stringify(next.checkpoint),
+                };
+                sql.exec("UPDATE workflow_publication_jobs SET step = ?, attempts = ?, phase = ?, checkpoint = ?, version = ? WHERE id = ?", successor.step, successor.attempts, successor.phase, successor.checkpoint, successor.version, row.id);
+                runner.transactional.enqueueAcceptedJob(queued(successor));
+            },
+        });
+        return {
+            runner,
+            release: () => {
+                for (const id of claimed)
+                    live.delete(id);
+            },
+            cleanup: async () => {
+                for (const id of terminal) {
+                    const row = read(id);
+                    if (row && row.status !== "publishing" && row.checkpoint !== null)
+                        await dropMaterial(gitStepSchema.parse(JSON.parse(row.checkpoint)), material);
+                }
+                terminal.clear();
+            },
+        };
+    }
+    return {
+        existing,
+        async enqueue(workflowId, revision, caller) {
+            const lane = actorLane(caller.actor);
+            const draft = store.readDraft(workflowId);
+            if (draft?.revision !== revision)
+                return { kind: "conflict", head: null };
+            const { runner } = await runtime(lane);
+            const digest = S.decodeUnknownSync(sha256DigestSchema)(await contentDigest(S.decodeUnknownSync(S.Json)(draft.definition)));
+            return storage.transactionSync(() => {
+                if (store.readDraft(workflowId)?.revision !== revision)
+                    return { kind: "conflict", head: null };
+                const retained = existing(workflowId, revision, caller);
+                if (retained !== null)
+                    return retained;
+                const row = {
+                    id: publicationIds.publication.generate(),
+                    workflow_id: workflowId,
+                    revision,
+                    lane,
+                    origin: JSON.stringify(backgroundOriginSchema.parse(caller.backgroundOrigin)),
+                    body: JSON.stringify(draft),
+                    epoch: store.revision(),
+                    step: 0,
+                    attempts: 0,
+                    phase: "inspect",
+                    checkpoint: null,
+                    version: null,
+                    status: "publishing",
+                    reason: null,
+                    commit_oid: null,
+                    request_key: caller.idempotencyKey ?? null,
+                    digest,
+                };
+                sql.exec("INSERT INTO workflow_publication_jobs(id,workflow_id,revision,lane,origin,body,epoch,step,attempts,phase,checkpoint,version,status,reason,commit_oid,request_key,digest) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", row.id, workflowId, revision, lane, row.origin, row.body, row.epoch, row.step, row.attempts, row.phase, row.checkpoint, row.version, row.status, row.reason, row.commit_oid, row.request_key, row.digest);
+                runner.transactional.enqueueAcceptedJob(queued(row));
+                return status(row);
+            });
+        },
+        async continue(caller, ports) {
+            if (caller.actor.kind !== "member" || caller.workflow !== undefined)
+                return { more: false };
+            const lane = actorLane(caller.actor);
+            if (caller.backgroundLane !== undefined && caller.backgroundLane !== lane)
+                return { more: false };
+            // R0 strips enqueue markers on readmission. A sealed foreground write
+            // is still foreground, even if its host exposes a refusing binding.
+            if (caller.backgroundOrigin !== undefined ||
+                caller.backgroundLane !== undefined ||
+                !ports.background)
+                return {
+                    more: sql
+                        .exec("SELECT id FROM workflow_publication_jobs WHERE lane = ? AND status = 'publishing' LIMIT 1", lane)
+                        .toArray().length !== 0,
+                };
+            const { runner, cleanup, release } = await runtime(lane, ports);
+            try {
+                await runner.tickConcurrent();
+            }
+            finally {
+                release();
+            }
+            await cleanup();
+            return {
+                more: sql
+                    .exec("SELECT id FROM workflow_publication_jobs WHERE lane = ? AND status = 'publishing' LIMIT 1", lane)
+                    .toArray().length !== 0,
+            };
+        },
+        status(workflowId, publicationId, caller) {
+            const row = read(publicationId);
+            return caller.actor.kind === "member" &&
+                row?.workflow_id === workflowId &&
+                row.lane === actorLane(caller.actor)
+                ? status(row)
+                : { kind: "not_found" };
+        },
+        async refused(input) {
+            const refusal = backgroundSyncRefusalSchema.parse(input);
+            const { runner, cleanup } = await runtime(refusal.lane);
+            let more;
+            do {
+                const result = await runner.failLane({
+                    lane: refusal.lane,
+                    reason: refusal.code,
+                });
+                more = result.more;
+                await cleanup();
+            } while (more);
+        },
+    };
+}