@fungi.computer/oyster 0.0.0-stage → 0.1.0

package/dist/standalone/workflows.d.ts

@@ -0,0 +1,657 @@
+import type { GraphStartRequest } from "@fungi.computer/braid/runtime";
+import { DurableObject } from "cloudflare:workers";
+import * as S from "effect/Schema";
+import { GraphWorkflow, type GraphRunEnding, type GraphWorkflowBindings } from "@fungi.computer/braid/cloudflare";
+import { type GraphReview, type GraphParams, type NodeCall, type NodeEvent, type NodeDispatcher } from "@fungi.computer/braid";
+import { type StandaloneTenancyEnv } from "./tenancy.js";
+import type { AppEventFact } from "@fungi.computer/puffball/app-event-facts";
+import type { InvocationFacts } from "../invocation.js";
+import type { OysterGitWorkerEnv, OysterGitWorkerHost } from "../workers-git.js";
+import { type TenantScope } from "../tenant.js";
+import type { GitWriter, RepositoryRef } from "@fungi.computer/agar/git";
+import type { WorkflowGitPassResult } from "@fungi.computer/agar/computer-contracts";
+import { reviewKey, type EventDisarmInput, type WorkflowGitPassRequest, type TriggerArmTarget, type ScheduleDisarmInput } from "./workflow-binding.js";
+import type { StandaloneComputerEnv } from "./computer.js";
+import type { StandaloneAgentsEnv } from "./agents.js";
+import type { OysterMediaEnv } from "./media.js";
+export type StandaloneWorkflowEnv = OysterGitWorkerEnv & StandaloneComputerEnv & StandaloneAgentsEnv & OysterMediaEnv & StandaloneTenancyEnv & GraphWorkflowBindings & {
+    WORKFLOW_RUNS: DurableObjectNamespace<StandaloneWorkflowRunsBase>;
+};
+/** Schedule time and the native alarm instant that delivers a due time. */
+export type StandaloneScheduleClock = Readonly<{
+    now(): number;
+    alarmAt(due: number): number;
+}>;
+/** SQLite and the native Workflow binding belong to this standalone host; its root supplies `hostFor`. */
+export declare abstract class StandaloneWorkflowRunsBase<Env extends StandaloneWorkflowEnv = StandaloneWorkflowEnv> extends DurableObject<Env> {
+    private readonly composed;
+    /** Schedule time and its native alarm instant; production is the wall clock. */
+    protected readonly scheduleClock: StandaloneScheduleClock;
+    private readonly owner;
+    /** The deployable root's host for one tenant; Workflow runs use the default tenant. */
+    protected abstract hostFor(scope: TenantScope): OysterGitWorkerHost;
+    constructor(ctx: DurableObjectState, env: Env);
+    /** Record the library this object serves; another name is a revocation. */
+    private nameLibrary;
+    /**
+     * Mint (or renew) the Git pass for the Git step a node frame is executing.
+     * Null when this library dispatched no such step; a step that does not match
+     * the frame's attested Workflow, member and Computer is a revocation.
+     */
+    openWorkflowGitPass(raw: WorkflowGitPassRequest): Promise<WorkflowGitPassResult | null>;
+    /** The tenant Git door's per-request admission of a presented pass. */
+    admitWorkflowGitPass(passId: string, repository: RepositoryRef, scope: "read" | "write"): Promise<Extract<GitWriter, {
+        kind: "actor";
+    }> | null>;
+    /** A finished run's passes and recorded Git steps end with it. */
+    private endRunGit;
+    private libraryId;
+    /** Trigger controls open the library named by the admitted frame. */
+    private library;
+    /** Idempotently ensure a recorded run has its engine instance. */
+    private launch;
+    armSchedule(facts: InvocationFacts, input: TriggerArmTarget): Promise<{
+        kind: "armed";
+        scheduleId: string;
+    } | {
+        error: string;
+        kind?: undefined;
+        reason?: undefined;
+    } | {
+        kind: "refused";
+        reason: string;
+        readonly error?: undefined;
+    }>;
+    disarmSchedule(facts: InvocationFacts, input: ScheduleDisarmInput): Promise<{
+        kind: "not_found";
+    } | {
+        kind: "disarmed";
+    } | {
+        error: string;
+    }>;
+    schedules(facts: InvocationFacts): Promise<{
+        error: string;
+        schedules?: undefined;
+    } | {
+        schedules: {
+            scheduleId: string;
+            workflowId: string;
+            triggerId: string;
+            nextDueAt: number;
+            state: "active" | "finished" | "paused" | "cancelled";
+            lastError: string | null;
+        }[];
+        readonly error?: undefined;
+    }>;
+    armEventTrigger(facts: InvocationFacts, input: TriggerArmTarget): Promise<{
+        kind: "armed";
+        eventTriggerId: string;
+    } | {
+        error: string;
+        kind?: undefined;
+        reason?: undefined;
+    } | {
+        kind: "refused";
+        reason: string;
+        readonly error?: undefined;
+    }>;
+    disarmEventTrigger(facts: InvocationFacts, input: EventDisarmInput): Promise<{
+        kind: "disarmed";
+    } | {
+        kind: "not_found";
+    } | {
+        error: string;
+    }>;
+    eventTriggers(facts: InvocationFacts): Promise<{
+        error: string;
+        eventTriggers?: undefined;
+    } | {
+        eventTriggers: {
+            eventTriggerId: string;
+            workflowId: string;
+            triggerId: string;
+            emitterInstallationId: string;
+            event: string;
+            state: "active" | "paused";
+            lastError: string | null;
+        }[];
+        readonly error?: undefined;
+    }>;
+    /** Up to 50 runs of this library, newest first; this host has no per-member rule. */
+    runs(facts: InvocationFacts, input: {
+        workflowId?: string;
+    }): Promise<{
+        runs: ({
+            runId: string;
+            workflowId: string | undefined;
+            commit: string | undefined;
+            source: "manual" | "agent" | "key" | "event" | "schedule";
+            initiatedBy: Readonly<{
+                kind: "member";
+                memberId: string;
+            }> | Readonly<{
+                kind: "agent";
+                agentId: string;
+                grantorMemberId: string;
+            }> | Readonly<{
+                kind: "key";
+                keyId: string;
+                grantorMemberId: string;
+            }>;
+            startedAt: number;
+        } | {
+            triggerId: string;
+            runId: string;
+            workflowId: string | undefined;
+            commit: string | undefined;
+            source: "manual" | "agent" | "key" | "event" | "schedule";
+            initiatedBy: Readonly<{
+                kind: "member";
+                memberId: string;
+            }> | Readonly<{
+                kind: "agent";
+                agentId: string;
+                grantorMemberId: string;
+            }> | Readonly<{
+                kind: "key";
+                keyId: string;
+                grantorMemberId: string;
+            }>;
+            startedAt: number;
+        })[];
+    }>;
+    /** Native alarm delivery: fire every due schedule of this library. */
+    alarm(): Promise<void>;
+    /**
+     * The emitting App's Instance delivers each accepted event here. The
+     * emitter's live Release must declare the event and its payload schema
+     * must accept it before any armed trigger of this library fires.
+     */
+    deliverEvent(fact: AppEventFact): Promise<"accepted">;
+    catalog(facts: InvocationFacts, input?: Readonly<{
+        installationId?: string;
+    }>): Promise<Readonly<{
+        error: "too_large";
+    }> | Readonly<{
+        apps: readonly Readonly<{
+            installationId: string;
+            appId: string;
+            displayName: string;
+            icon?: string;
+            capabilities?: import("@fungi.computer/braid/runtime").WorkflowCatalogEntry["capabilities"];
+            workflowPublishGranted: boolean;
+            workflowRunGranted: boolean;
+            methods: Readonly<Record<string, Readonly<{
+                pending?: true;
+                description: string;
+                effect: import("@fungi.computer/braid").Catalog[string]["methods"][string]["effect"];
+                approval: import("@fungi.computer/braid").Catalog[string]["methods"][string]["approval"];
+                requires: import("@fungi.computer/braid").Catalog[string]["methods"][string]["requires"];
+                digest: string;
+            }>>>;
+            events?: Readonly<Record<string, Readonly<{
+                description: string;
+                digest: string;
+            }>>>;
+        }>[];
+    }> | {
+        app: Readonly<{
+            installationId: string;
+            appId: string;
+            displayName: string;
+            icon?: string;
+            capabilities?: import("@fungi.computer/braid/runtime").RunCeiling["nodes"][number]["capabilities"];
+            workflowPublishGranted?: boolean;
+            workflowRunGranted?: boolean;
+            methods: import("@fungi.computer/braid").Catalog[string]["methods"];
+            events?: NonNullable<import("@fungi.computer/braid").Catalog[string]["events"]>;
+        }>;
+    } | {
+        error: "not_found";
+    }>;
+    start(facts: InvocationFacts, input: GraphStartRequest): Promise<(Readonly<{
+        apps: readonly import("@fungi.computer/braid/runtime").WorkflowCatalogEntry[];
+    }> & Record<"error", unknown>) | Readonly<{
+        kind: "invalid";
+        issues: readonly import("@fungi.computer/braid").Issue[];
+    }> | {
+        error: "not_granted";
+        kind?: undefined;
+        runId?: undefined;
+        planDigest?: undefined;
+    } | {
+        error: "invalid_publication";
+        kind?: undefined;
+        runId?: undefined;
+        planDigest?: undefined;
+    } | {
+        error: "invalid_input";
+        kind?: undefined;
+        runId?: undefined;
+        planDigest?: undefined;
+    } | {
+        kind: "conflict" | "replay" | "started";
+        runId: string;
+        planDigest: string;
+        readonly error?: undefined;
+    }>;
+    loadRun(installationId: string, runId: string): Promise<{
+        plan: {
+            readonly planDigest: string;
+            readonly definition: {
+                readonly format: "fungi.workflow/v1";
+                readonly output: {
+                    readonly [x: string]: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                };
+                readonly input: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly title: string;
+                readonly apps: {
+                    readonly [x: string]: {
+                        readonly appId: string;
+                        readonly role?: string | undefined;
+                    };
+                };
+                readonly nodes: readonly ({
+                    readonly id: string;
+                    readonly kind: "code";
+                    readonly source: string;
+                    readonly input: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly output: {
+                        readonly [x: string]: S.Json;
+                    };
+                    readonly values: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    };
+                } | {
+                    readonly values: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    };
+                    readonly method: string;
+                    readonly kind: "app";
+                    readonly id: string;
+                    readonly app: string;
+                    readonly methodDigest: string;
+                    readonly retry?: {
+                        readonly attempts: number;
+                    } | undefined;
+                    readonly gitAccess?: {
+                        binding: string;
+                        repository: string;
+                        branches: string[];
+                    } | {
+                        binding: string;
+                        repository: string;
+                        access: "read";
+                    } | undefined;
+                } | {
+                    readonly kind: "review";
+                    readonly id: string;
+                    readonly title: string;
+                    readonly reviewers: "runner" | "owners";
+                    readonly show: readonly {
+                        readonly node: string;
+                        readonly port: string;
+                    }[];
+                    readonly timeout: number;
+                    readonly choices?: readonly {
+                        readonly id: string;
+                        readonly label: string;
+                    }[] | undefined;
+                } | {
+                    readonly id: string;
+                    readonly kind: "condition";
+                    readonly test: import("@fungi.computer/braid").Predicate;
+                } | {
+                    readonly id: string;
+                    readonly kind: "map";
+                    readonly over: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                    readonly body: string;
+                    readonly concurrency: number;
+                    readonly maxItems: number;
+                } | {
+                    readonly id: string;
+                    readonly kind: "repeat";
+                    readonly body: string;
+                    readonly maxRounds: number;
+                    readonly until: import("@fungi.computer/braid").Predicate;
+                } | {
+                    readonly id: string;
+                    readonly kind: "wait";
+                    readonly for: number;
+                } | {
+                    readonly id: string;
+                    readonly kind: "transform";
+                    readonly fields: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    };
+                })[];
+                readonly edges: readonly {
+                    readonly from: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                    readonly to: {
+                        readonly node: string;
+                        readonly port: string;
+                    };
+                }[];
+                readonly description?: string | undefined;
+                readonly subgraphs?: {
+                    readonly [x: string]: {
+                        readonly input: {
+                            readonly [x: string]: S.Json;
+                        };
+                        readonly nodes: readonly ({
+                            readonly id: string;
+                            readonly kind: "code";
+                            readonly source: string;
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly output: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly values: {
+                                readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                            };
+                        } | {
+                            readonly values: {
+                                readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                            };
+                            readonly method: string;
+                            readonly kind: "app";
+                            readonly id: string;
+                            readonly app: string;
+                            readonly methodDigest: string;
+                            readonly retry?: {
+                                readonly attempts: number;
+                            } | undefined;
+                            readonly gitAccess?: {
+                                binding: string;
+                                repository: string;
+                                branches: string[];
+                            } | {
+                                binding: string;
+                                repository: string;
+                                access: "read";
+                            } | undefined;
+                        } | {
+                            readonly kind: "review";
+                            readonly id: string;
+                            readonly title: string;
+                            readonly reviewers: "runner" | "owners";
+                            readonly show: readonly {
+                                readonly node: string;
+                                readonly port: string;
+                            }[];
+                            readonly timeout: number;
+                            readonly choices?: readonly {
+                                readonly id: string;
+                                readonly label: string;
+                            }[] | undefined;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "condition";
+                            readonly test: import("@fungi.computer/braid").Predicate;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "map";
+                            readonly over: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                            readonly body: string;
+                            readonly concurrency: number;
+                            readonly maxItems: number;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "repeat";
+                            readonly body: string;
+                            readonly maxRounds: number;
+                            readonly until: import("@fungi.computer/braid").Predicate;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "wait";
+                            readonly for: number;
+                        } | {
+                            readonly id: string;
+                            readonly kind: "transform";
+                            readonly fields: {
+                                readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                            };
+                        })[];
+                        readonly edges: readonly {
+                            readonly from: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                            readonly to: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                        }[];
+                        readonly output: {
+                            readonly [x: string]: {
+                                readonly node: string;
+                                readonly port: string;
+                            };
+                        };
+                    };
+                } | undefined;
+                readonly triggers?: readonly ({
+                    readonly id: string;
+                    readonly on: "webhook";
+                    readonly when?: import("@fungi.computer/braid").Predicate | undefined;
+                    readonly input?: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    } | undefined;
+                    readonly title?: string | undefined;
+                } | {
+                    readonly id: string;
+                    readonly on: "schedule";
+                    readonly cron: {
+                        readonly expression: string;
+                        readonly timeZone: string;
+                    };
+                    readonly input?: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    } | undefined;
+                    readonly title?: string | undefined;
+                } | {
+                    readonly id: string;
+                    readonly event: string;
+                    readonly on: "event";
+                    readonly app: string;
+                    readonly eventDigest: string;
+                    readonly repository?: import("@fungi.computer/braid").Mapping | undefined;
+                    readonly when?: import("@fungi.computer/braid").Predicate | undefined;
+                    readonly input?: {
+                        readonly [x: string]: import("@fungi.computer/braid").Mapping;
+                    } | undefined;
+                    readonly title?: string | undefined;
+                })[] | undefined;
+            };
+            readonly catalog: {
+                readonly [x: string]: {
+                    readonly methods: {
+                        readonly [x: string]: {
+                            readonly digest: string;
+                            readonly output: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly input: {
+                                readonly [x: string]: S.Json;
+                            };
+                            readonly approval: "none" | "queue" | "simulate";
+                            readonly description: string;
+                            readonly effect: "read" | "write" | "external";
+                            readonly requires: readonly string[];
+                            readonly pending?: true | undefined;
+                        };
+                    };
+                    readonly events?: {
+                        readonly [x: string]: {
+                            readonly digest: string;
+                            readonly description: string;
+                            readonly payload: {
+                                readonly [x: string]: S.Json;
+                            };
+                        };
+                    } | undefined;
+                };
+            };
+            readonly bindings: {
+                readonly [x: string]: {
+                    kind: "team-source";
+                } | {
+                    appId: string;
+                    installationId: string;
+                };
+            };
+            readonly estimatedSteps: number;
+            readonly requiredBindings: readonly {
+                readonly method: string;
+                readonly installationId: string;
+                readonly output: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly input: {
+                    readonly [x: string]: S.Json;
+                };
+                readonly approval: "none" | "queue" | "simulate";
+                readonly description: string;
+                readonly effect: "read" | "write" | "external";
+                readonly requires: readonly string[];
+                readonly app: string;
+                readonly pending?: true | undefined;
+            }[];
+        };
+        input: {
+            readonly [x: string]: S.Json;
+        };
+    }>;
+    beforeNode(event: NodeEvent): Promise<{
+        readonly kind: "admitted";
+    } | {
+        readonly kind: "refused";
+        readonly code: "invalid_input" | "revoked" | "not_granted" | "invalid_output" | "member_revoked" | "workflow_run_revoked" | "computer_revoked" | "budget_exhausted" | "unknown_method";
+    }>;
+    dispatch(call: NodeCall): Promise<{
+        readonly kind: "complete";
+        readonly output: S.Json;
+        readonly costMilliunits: number;
+    } | {
+        readonly kind: "refused";
+        readonly code: "invalid_input" | "revoked" | "not_granted" | "invalid_output" | "member_revoked" | "workflow_run_revoked" | "computer_revoked" | "budget_exhausted" | "unknown_method";
+    } | {
+        readonly kind: "pending_approval";
+        readonly actionId: string;
+    } | {
+        readonly kind: "pending";
+        readonly retryAfterMs: number;
+    }>;
+    recordEvent(event: NodeEvent): Promise<void>;
+    openReview(review: GraphReview): Promise<number>;
+    answerReview(facts: InvocationFacts, raw: typeof reviewKey.Type): Promise<{
+        result: string;
+    }>;
+    /** Record the engine's ending, then report it to the run's declared delivery. */
+    terminal(runId: string, ending: GraphRunEnding): Promise<void>;
+    /**
+     * One idempotent follow-up into the run's declared delivery Session, however
+     * the run started, through the same Session send that the AGENTS binding
+     * uses. Delivery never changes the run's recorded outcome.
+     */
+    private report;
+    status(facts: InvocationFacts, raw: {
+        runId: string;
+    }): Promise<{
+        error: string;
+        runId?: undefined;
+        planDigest?: undefined;
+        title?: undefined;
+        outcome?: undefined;
+        events?: undefined;
+        reviews?: undefined;
+        status?: undefined;
+        output?: undefined;
+    } | {
+        runId: string;
+        planDigest: string;
+        title: string;
+        outcome: "terminal" | "cancelled" | "active" | null;
+        events: readonly {
+            readonly state: "running" | "queued" | "failed" | "complete" | "waiting" | "skipped";
+            readonly runId: string;
+            readonly nodeId: string;
+            readonly iteration: string;
+            readonly attempt: number;
+            readonly output?: {
+                readonly [x: string]: S.Json;
+            } | undefined;
+            readonly costMilliunits?: number | undefined;
+            readonly graphId?: string | undefined;
+            readonly poll?: number | undefined;
+            readonly recordedAt?: number | undefined;
+            readonly durationMs?: number | undefined;
+            readonly outputDigest?: string | undefined;
+            readonly errorMessage?: string | undefined;
+            readonly refusal?: string | undefined;
+        }[];
+        reviews: {
+            review: {
+                readonly show: readonly S.Json[];
+                readonly title: string;
+                readonly timeout: number;
+                readonly runId: string;
+                readonly nodeId: string;
+                readonly reviewers: "runner" | "owners";
+                readonly iteration: string;
+                readonly instanceId: string;
+                readonly eventType: string;
+                readonly choices?: readonly string[];
+            };
+            status: "closed" | "pending" | "answered" | "delivered" | "timed_out";
+            openedAt: number;
+            expiresAt: number;
+        }[];
+        status: "unknown" | "running" | "queued" | "errored" | "complete" | "waiting" | "paused" | "terminated" | "waitingForPause";
+        output: {} | null;
+        error: {
+            name: string;
+            message: string;
+        } | null;
+    }>;
+    cancel(facts: InvocationFacts, raw: {
+        runId: string;
+    }): Promise<{
+        kind: string;
+        reason: string;
+    } | {
+        kind: string;
+        reason?: undefined;
+    }>;
+}
+/** The SAME extracted interpreter as Hub, with this host's owned ports. */
+export declare class StandaloneGraphWorkflow extends GraphWorkflow<StandaloneWorkflowEnv> {
+    protected codeExecution(): {
+        sandbox: Readonly<{
+            adapter?: string;
+            buildSha?: string;
+            execute: (request: import("@fungi.computer/mycelium").SandboxRequest, signal: AbortSignal) => Promise<import("@fungi.computer/mycelium").SandboxValue>;
+        }>;
+        timeoutMs: number;
+    };
+    protected dispatcher(params: GraphParams): NodeDispatcher;
+    protected terminalTriggerRun(params: GraphParams, ending: GraphRunEnding): Promise<void>;
+}