@fungi.computer/braid 0.0.0-stage → 0.0.1

package/dist/runtime/git-pass-contract.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import type { GitWriter } from "@fungi.computer/agar/git";
+/** Non-secret Team-issued authority for one stored Workflow step on its pinned Computer. */
+export declare const workflowGitPassGrantSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    computerId: z.ZodString;
+    memberId: z.ZodString;
+    workflow: import("zod/mini").ZodMiniObject<{
+        workflowId: import("zod/mini").ZodMiniString<string>;
+        runId: import("zod/mini").ZodMiniString<string>;
+        nodeId: import("zod/mini").ZodMiniString<string>;
+        armedBy: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+            kind: import("zod/mini").ZodMiniLiteral<"member">;
+            memberId: import("zod/mini").ZodMiniString<string>;
+        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+            kind: import("zod/mini").ZodMiniLiteral<"agent">;
+            agentId: import("zod/mini").ZodMiniString<string>;
+        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+            kind: import("zod/mini").ZodMiniLiteral<"team-key">;
+            keyId: import("zod/mini").ZodMiniString<string>;
+        }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    runId: z.ZodString;
+    graphId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodString;
+    iteration: z.ZodString;
+    scope: z.ZodEnum<{
+        write: "write";
+        read: "read";
+    }>;
+    gitAccess: z.ZodUnion<readonly [z.ZodObject<{
+        repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"installation">;
+            installationId: z.ZodString;
+            repository: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"team-source">;
+            repository: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        branches: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"installation">;
+            installationId: z.ZodString;
+            repository: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"team-source">;
+            repository: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        access: z.ZodLiteral<"read">;
+    }, z.core.$strict>]>;
+    triggerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkflowGitPassGrant = z.output<typeof workflowGitPassGrantSchema>;
+/** Run cleanup remains valid after the Computer's product data is erased. */
+export declare const workflowGitPassRevocationSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strict>;
+/** Project a stored, admitted pass; projection alone never admits authority. */
+export declare function workflowGitPassWriter(grant: WorkflowGitPassGrant): Extract<GitWriter, {
+    kind: "actor";
+}>;

package/dist/runtime/git-pass-contract.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { workflowAttestationSchema } from "@fungi.computer/puffball/app-method-runtime";
+import { gitAccessScope, resolvedGitAccessSchema } from "../git-access.js";
+const id = z.string().min(1).max(256);
+/** Non-secret Team-issued authority for one stored Workflow step on its pinned Computer. */
+export const workflowGitPassGrantSchema = z
+    .strictObject({
+    teamId: id,
+    computerId: id,
+    memberId: id,
+    workflow: workflowAttestationSchema,
+    runId: id,
+    graphId: id.optional(),
+    nodeId: id,
+    iteration: id,
+    scope: z.enum(["read", "write"]),
+    gitAccess: resolvedGitAccessSchema,
+    triggerId: id.optional(),
+})
+    .refine((grant) => grant.scope === gitAccessScope(grant.gitAccess), "A pass's scope is its admitted Git access");
+/** Run cleanup remains valid after the Computer's product data is erased. */
+export const workflowGitPassRevocationSchema = z.strictObject({
+    teamId: id,
+    runId: id,
+});
+/** Project a stored, admitted pass; projection alone never admits authority. */
+export function workflowGitPassWriter(grant) {
+    // A read pass never writes, so it carries no branch ceiling to attest.
+    return "branches" in grant.gitAccess
+        ? {
+            kind: "actor",
+            actor: grant.workflow.armedBy,
+            workflow: { ...grant.workflow, branches: grant.gitAccess.branches },
+        }
+        : { kind: "actor", actor: grant.workflow.armedBy };
+}

package/dist/runtime/git-pass-store.d.ts

@@ -0,0 +1,32 @@
+import { type RepositoryRef } from "@fungi.computer/agar/git";
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type WorkflowGitPassGrant } from "./git-pass-contract.js";
+/** Scoped pass state shared by both Computer hosts; credentials never enter the grant. */
+export declare function createWorkflowGitPassStore(options: Readonly<{
+    sql: WatchdogSqliteOwner["sql"];
+    transactionSync: <T>(body: () => T) => T;
+    ownerId(): string | null;
+    computerId(): string | undefined;
+    mintPassId(): string;
+    remote(passId: string, repository: RepositoryRef): string;
+    denied(): Error;
+    now?: () => number;
+}>): Readonly<{
+    openWorkflowPass(raw: WorkflowGitPassGrant): {
+        passId: string;
+        remote: string;
+        expiresAt: number;
+        bearer?: string;
+    };
+    /** Retain a tombstone so a delayed mint cannot resurrect a terminal run. */
+    revokeWorkflowRunGitPasses(input: {
+        teamId: string;
+        runId: string;
+    }): void;
+    /** Re-admit the stored scope for every Git request; an expired pass grants nothing. */
+    admit(input: {
+        passId: string;
+        repository: RepositoryRef;
+        scope: "read" | "write";
+    }): WorkflowGitPassGrant | null;
+}>;

package/dist/runtime/git-pass-store.js

@@ -0,0 +1,82 @@
+import { repositoryRefsEqual, } from "@fungi.computer/agar/git";
+import { workflowGitPassResultSchema } from "@fungi.computer/agar/computer-contracts";
+import { z } from "zod";
+import { workflowGitPassGrantSchema, workflowGitPassRevocationSchema, } from "./git-pass-contract.js";
+/** Scoped pass state shared by both Computer hosts; credentials never enter the grant. */
+export function createWorkflowGitPassStore(options) {
+    const { sql } = options;
+    const now = options.now ?? Date.now;
+    sql.exec(`CREATE TABLE IF NOT EXISTS computer_workflow_git_passes (
+    pass_id TEXT PRIMARY KEY, node_key TEXT NOT NULL UNIQUE, run_id TEXT NOT NULL,
+    grant_json TEXT NOT NULL, expires_at INTEGER NOT NULL
+  ) STRICT`);
+    sql.exec(`CREATE TABLE IF NOT EXISTS computer_workflow_git_ended_runs (run_id TEXT PRIMARY KEY) STRICT`);
+    return Object.freeze({
+        openWorkflowPass(raw) {
+            const grant = workflowGitPassGrantSchema.parse(raw);
+            if (grant.teamId !== options.ownerId() ||
+                grant.computerId !== options.computerId() ||
+                grant.workflow.runId !== grant.runId ||
+                grant.workflow.nodeId !== grant.nodeId ||
+                grant.workflow.armedBy.kind !== "member" ||
+                grant.workflow.armedBy.memberId !== grant.memberId)
+                throw options.denied();
+            return options.transactionSync(() => {
+                if (sql
+                    .exec("SELECT 1 FROM computer_workflow_git_ended_runs WHERE run_id=?", grant.runId)
+                    .toArray().length > 0)
+                    throw options.denied();
+                const key = JSON.stringify([
+                    grant.runId,
+                    grant.graphId ?? null,
+                    grant.nodeId,
+                    grant.iteration,
+                    grant.scope,
+                ]);
+                const row = sql
+                    .exec("SELECT pass_id,grant_json,expires_at FROM computer_workflow_git_passes WHERE node_key=?", key)
+                    .toArray()[0];
+                if (row !== undefined &&
+                    z.string().parse(row.grant_json) !== JSON.stringify(grant))
+                    throw options.denied();
+                const passId = row === undefined
+                    ? options.mintPassId()
+                    : z.string().parse(row.pass_id);
+                const expiresAt = now() + 60_000;
+                sql.exec(`INSERT INTO computer_workflow_git_passes VALUES(?,?,?,?,?)
+          ON CONFLICT(node_key) DO UPDATE SET expires_at=excluded.expires_at`, passId, key, grant.runId, JSON.stringify(grant), expiresAt);
+                return workflowGitPassResultSchema.parse({
+                    passId,
+                    expiresAt,
+                    remote: options.remote(passId, grant.gitAccess.repository),
+                });
+            });
+        },
+        /** Retain a tombstone so a delayed mint cannot resurrect a terminal run. */
+        revokeWorkflowRunGitPasses(input) {
+            const { teamId, runId } = workflowGitPassRevocationSchema.parse(input);
+            if (teamId !== options.ownerId())
+                throw options.denied();
+            options.transactionSync(() => {
+                sql.exec("INSERT OR IGNORE INTO computer_workflow_git_ended_runs VALUES(?)", runId);
+                sql.exec("DELETE FROM computer_workflow_git_passes WHERE run_id=?", runId);
+            });
+        },
+        /** Re-admit the stored scope for every Git request; an expired pass grants nothing. */
+        admit(input) {
+            const at = now();
+            const row = sql
+                .exec("SELECT grant_json,expires_at FROM computer_workflow_git_passes WHERE pass_id=?", input.passId)
+                .toArray()[0];
+            if (row === undefined || z.number().parse(row.expires_at) <= at)
+                return null;
+            const grant = workflowGitPassGrantSchema.parse(JSON.parse(z.string().parse(row.grant_json)));
+            if (grant.teamId !== options.ownerId() ||
+                grant.computerId !== options.computerId() ||
+                !repositoryRefsEqual(grant.gitAccess.repository, input.repository) ||
+                (input.scope === "write" && grant.scope !== "write"))
+                return null;
+            return grant;
+        },
+    });
+}

package/dist/runtime/git-pass.d.ts

@@ -0,0 +1,41 @@
+import type { RepositoryRef } from "@fungi.computer/agar/git";
+import { type WorkflowGitPassResult } from "@fungi.computer/agar/computer-contracts";
+import type { WorkflowRunContext } from "./graph-contract.js";
+import type { StoredWorkflowNode } from "./graph-dispatch.js";
+import { type WorkflowGitPassGrant } from "./git-pass-contract.js";
+/** Admitted stored-node identity; host resource admission remains outside the shared owner. */
+export type WorkflowGitPassNode = Pick<StoredWorkflowNode, "installationId" | "appId" | "method" | "methodDigest" | "computerId"> & {
+    teamId: string;
+    memberId: string;
+    context: WorkflowRunContext;
+};
+export type WorkflowGitScope = WorkflowGitPassGrant["scope"];
+/** Compose the sole stored-node admission and retained terminal cleanup owners. */
+export declare function createWorkflowGitPasses(ports: Readonly<{
+    /** The host preserves its own typed refusal vocabulary. */
+    denied(): Error;
+    admitNode(context: WorkflowRunContext, target: {
+        installationId: string;
+        method: string;
+    }): WorkflowGitPassNode | null;
+    admitMemberGitAccess(memberId: string, repository: RepositoryRef, scope: WorkflowGitScope): Promise<void>;
+    open(computerId: string, grant: WorkflowGitPassGrant): Promise<WorkflowGitPassResult>;
+    revoke(computerId: string, input: {
+        teamId: string;
+        runId: string;
+    }): Promise<void>;
+    pending(): {
+        teamId: string;
+        runId: string;
+        computerId: string;
+    }[];
+    acknowledge(runId: string): void;
+    wake?(due: number | null): Promise<void>;
+}>): {
+    cleanupWake: () => number | null;
+    openWorkflowPass(context: WorkflowRunContext, target: {
+        installationId: string;
+        method: string;
+    }): Promise<WorkflowGitPassResult>;
+    deliverCleanups(): Promise<void>;
+};

package/dist/runtime/git-pass.js

@@ -0,0 +1,72 @@
+import { workflowGitPassResultSchema, } from "@fungi.computer/agar/computer-contracts";
+import { canonicalJson } from "../index.js";
+import { gitAccessScope } from "../git-access.js";
+import { workflowGitPassGrantSchema, } from "./git-pass-contract.js";
+/** Compose the sole stored-node admission and retained terminal cleanup owners. */
+export function createWorkflowGitPasses(ports) {
+    const cleanupWake = () => ports.pending().length === 0 ? null : Date.now() + 5000;
+    return {
+        cleanupWake,
+        async openWorkflowPass(context, target) {
+            const admitted = ports.admitNode(context, target);
+            if (admitted?.computerId == null ||
+                admitted.context.gitAccess === undefined ||
+                admitted.context.armedBy.kind !== "member" ||
+                admitted.context.armedBy.memberId !== admitted.memberId)
+                throw ports.denied();
+            // The admitted node's own access decides the scope; no caller widens it.
+            const scope = gitAccessScope(admitted.context.gitAccess);
+            const grant = workflowGitPassGrantSchema.parse({
+                teamId: admitted.teamId,
+                computerId: admitted.computerId,
+                memberId: admitted.memberId,
+                workflow: {
+                    workflowId: admitted.context.workflowId,
+                    runId: admitted.context.runId,
+                    nodeId: admitted.context.nodeId,
+                    armedBy: admitted.context.armedBy,
+                },
+                runId: admitted.context.runId,
+                graphId: admitted.context.graphId,
+                nodeId: admitted.context.nodeId,
+                iteration: admitted.context.iteration,
+                scope,
+                gitAccess: admitted.context.gitAccess,
+                triggerId: admitted.context.trigger?.triggerId,
+            });
+            await ports.admitMemberGitAccess(grant.memberId, grant.gitAccess.repository, scope);
+            if (canonicalJson(ports.admitNode(context, target)) !==
+                canonicalJson(admitted))
+                throw ports.denied();
+            const pass = workflowGitPassResultSchema.parse(await ports.open(grant.computerId, grant));
+            try {
+                await ports.admitMemberGitAccess(grant.memberId, grant.gitAccess.repository, scope);
+                if (canonicalJson(ports.admitNode(context, target)) !==
+                    canonicalJson(admitted))
+                    throw ports.denied();
+            }
+            catch (cause) {
+                await ports.revoke(grant.computerId, {
+                    teamId: grant.teamId,
+                    runId: grant.runId,
+                });
+                throw cause;
+            }
+            return pass;
+        },
+        async deliverCleanups() {
+            try {
+                for (const cleanup of ports.pending()) {
+                    await ports.revoke(cleanup.computerId, {
+                        teamId: cleanup.teamId,
+                        runId: cleanup.runId,
+                    });
+                    ports.acknowledge(cleanup.runId);
+                }
+            }
+            finally {
+                await ports.wake?.(cleanupWake());
+            }
+        },
+    };
+}