@fungi.computer/oyster 0.0.1 → 0.2.0

package/dist/standalone/workflow-node-capture.d.ts

@@ -0,0 +1,13 @@
+import { type WorkflowCeilingCapturePorts } from "@fungi.computer/braid/runtime";
+import { type OysterHost } from "../host.js";
+import type { StandaloneWorkflowAuthorityReaders } from "./workflow-authority-readers.js";
+/** Live host readers and approvals; a compile catalog is deliberately not a grant port. */
+export type StandaloneWorkflowNodeCaptureOptions = Readonly<{
+    host: Pick<OysterHost, "artifacts" | "computerId" | "capabilities"> & Readonly<{
+        auth: Pick<OysterHost["auth"], "resolve">;
+        installations: Pick<OysterHost["installations"], "get">;
+    }>;
+    readers: Pick<StandaloneWorkflowAuthorityReaders, "member" | "memberComputer">;
+}>;
+/** Capture one compiled node through the same metadata admission as ordinary App calls. */
+export declare function createStandaloneWorkflowNodeCapture(options: StandaloneWorkflowNodeCaptureOptions): WorkflowCeilingCapturePorts["node"];

package/dist/standalone/workflow-node-capture.js

@@ -0,0 +1,72 @@
+import * as Schema from "effect/Schema";
+import { appBackendBindingsSchema } from "@fungi.computer/puffball/app";
+import { catalogMethods } from "@fungi.computer/braid";
+import { workflowMethodRequiresComputer, } from "@fungi.computer/braid/runtime";
+import { admitMethodMetadata, appInvocationCeiling, approvedBindingGrants, deriveDeclaredOperations, scopedBindings, } from "../apps/index.js";
+import { oysterPrincipalIsOwner, verifyRelease, } from "../host.js";
+import { invocationCallerContext } from "../invocation.js";
+/** Capture one compiled node through the same metadata admission as ordinary App calls. */
+export function createStandaloneWorkflowNodeCapture(options) {
+    const { host, readers } = options;
+    return async (actor, member, target) => {
+        const before = await readers.member(actor.memberId);
+        if (before?.membershipVersion !== member.membershipVersion ||
+            (target.computerId !== null &&
+                (target.computerId !== host.computerId ||
+                    !(await readers.memberComputer(actor.memberId, target.computerId)))))
+            return null;
+        const principal = await host.auth.resolve(actor);
+        if (principal === null || !oysterPrincipalIsOwner(principal))
+            return null;
+        const caller = invocationCallerContext(principal, target.computerId);
+        if (caller.actor.kind !== "member" ||
+            caller.actor.memberId !== actor.memberId)
+            return null;
+        const installation = await host.installations.get(target.installationId);
+        if (installation?.status !== "enabled" ||
+            installation.appId !== target.appId)
+            return null;
+        const verified = await verifyRelease(host.artifacts, installation.release, undefined, false);
+        if (verified.declaration === null || verified.api === null)
+            return null;
+        const facts = {
+            principal: { actor: caller.actor, role: caller.role ?? null },
+            installation,
+            declaration: verified.declaration,
+            declaredOperations: await deriveDeclaredOperations(installation.release, verified.declaration, host.capabilities ?? []),
+            api: verified.api,
+            access: null,
+        };
+        const decision = admitMethodMetadata(facts, target.method);
+        if (decision.kind !== "admitted")
+            return null;
+        const { method } = decision;
+        if (method.effect !== "read" && method.effect !== "write")
+            return null;
+        if (target.computerId === null &&
+            workflowMethodRequiresComputer(method.requires))
+            return null;
+        const pinned = await catalogMethods({ [target.method]: method });
+        if (pinned.methods[target.method]?.digest !== target.methodDigest)
+            return null;
+        const bindings = Schema.decodeUnknownSync(appBackendBindingsSchema)(scopedBindings(approvedBindingGrants(installation, verified.declaration), method, appInvocationCeiling(facts)).map((binding) => ({
+            name: binding.binding,
+            operations: binding.operations,
+        })));
+        const latest = await host.installations.get(target.installationId);
+        const after = await readers.member(actor.memberId);
+        if (latest?.status !== "enabled" ||
+            latest.instanceId !== installation.instanceId ||
+            latest.authorityVersion !== installation.authorityVersion ||
+            latest.declaredOperationsDigest !==
+                installation.declaredOperationsDigest ||
+            latest.release.releaseId !== installation.release.releaseId ||
+            latest.release.artifact.artifactDigest !==
+                installation.release.artifact.artifactDigest ||
+            after?.membershipVersion !== member.membershipVersion ||
+            (target.computerId !== null &&
+                !(await readers.memberComputer(actor.memberId, target.computerId))))
+            return null;
+        return { level: method.effect, capabilities: method.requires, bindings };
+    };
+}

package/dist/standalone/workflow-root-authority.d.ts

@@ -0,0 +1,27 @@
+import { type WorkflowRunAuthority } from "@fungi.computer/braid/runtime";
+import type { RepositoryRef } from "@fungi.computer/agar/git";
+import type { AppToolPolicy } from "../apps/index.js";
+import { type LiveOysterKey } from "../keys.js";
+import type { StandaloneTenancy } from "./tenancy.js";
+import { type StandaloneWorkflowNodeCaptureOptions } from "./workflow-node-capture.js";
+import type { StandaloneWorkflowAuthorityReaderOptions } from "./workflow-authority-readers.js";
+/** The tenant, host and library a standalone Workflow root admits through. */
+export type StandaloneWorkflowRootOptions = Readonly<{
+    shared: Pick<StandaloneTenancy, "tenantId" | "tenancy" | "owner">;
+    host: StandaloneWorkflowNodeCaptureOptions["host"];
+    libraryInstallationId: string;
+    catalogHost: StandaloneWorkflowAuthorityReaderOptions["catalogHost"];
+}>;
+/** One live kit registry and its configured canonical owner back every start. */
+export declare function createStandaloneWorkflowRootAuthority(options: StandaloneWorkflowRootOptions & Readonly<{
+    /** The Agent's current App tool approval from its policy owner. */
+    agentToolPolicy(agentId: string): Promise<AppToolPolicy | null>;
+    /** A key's live Ear Tag facts, read fresh at every admission and recheck. */
+    keyLive(keyId: string): Promise<LiveOysterKey | null>;
+}>): WorkflowRunAuthority;
+/**
+ * The same live installation-Git admission the start ceiling captured, re-run
+ * for a Workflow Git pass: the member must still be the canonical owner and the
+ * repository's installation must still grant this Git scope.
+ */
+export declare function createStandaloneWorkflowGitAccess(options: StandaloneWorkflowRootOptions): (memberId: string, repository: RepositoryRef, scope: "read" | "write") => Promise<boolean>;

package/dist/standalone/workflow-root-authority.js

@@ -0,0 +1,87 @@
+import { createWorkflowRunAuthority, createWorkflowCeilingCapture, planInstallationLevels, } from "@fungi.computer/braid/runtime";
+import { AppInstanceError } from "../index.js";
+import { keyAppAccess } from "../keys.js";
+import { createStandaloneWorkflowAuthorityReaders } from "./workflow-authority-readers.js";
+import { createStandaloneWorkflowNodeCapture, } from "./workflow-node-capture.js";
+import { createStandaloneWorkflowInstallationGitCapture } from "./workflow-git-capture.js";
+/** The configured canonical owner, re-read around the kit registry's member row. */
+function rootReaders(options) {
+    const base = createStandaloneWorkflowAuthorityReaders({
+        tenantId: options.shared.tenantId,
+        tenancy: options.shared.tenancy,
+        host: options.host,
+        libraryInstallationId: options.libraryInstallationId,
+        catalogHost: options.catalogHost,
+    });
+    const member = async (id) => {
+        const before = await options.shared.owner();
+        if (before?.actor.memberId !== id)
+            return null;
+        const current = await base.member(id);
+        const after = await options.shared.owner();
+        return current !== null &&
+            after?.actor.memberId === id &&
+            before.membershipVersion === current.membershipVersion &&
+            after.membershipVersion === current.membershipVersion
+            ? current
+            : null;
+    };
+    return { ...base, member };
+}
+/** One live kit registry and its configured canonical owner back every start. */
+export function createStandaloneWorkflowRootAuthority(options) {
+    const readers = rootReaders(options);
+    return createWorkflowRunAuthority({
+        ...readers,
+        // An Agent run stays admitted only while its grantor's write approval lasts.
+        async admitAgent(preparation) {
+            const policy = await options.agentToolPolicy(preparation.initiatedBy.agentId);
+            return (policy?.level === "write" &&
+                policy.grantedBy === preparation.initiatedBy.grantorMemberId);
+        },
+        // A key run stays admitted only while the key is still live, its owner
+        // still matches the run's grantor, `apps.use` still reaches this
+        // Workflows library, and every installation the plan touches is still
+        // inside the key's own grants -- a key never widens past what it was
+        // issued, even when the plan's binding set has not changed.
+        async admitKey(preparation) {
+            const key = await options.keyLive(preparation.initiatedBy.keyId);
+            if (key?.owner !== preparation.initiatedBy.grantorMemberId)
+                return false;
+            if (keyAppAccess(key, options.libraryInstallationId)?.level !== "write")
+                return false;
+            return planInstallationLevels(preparation.plan).every(({ installationId, level }) => {
+                const access = keyAppAccess(key, installationId);
+                return (access !== null && (level !== "write" || access.level === "write"));
+            });
+        },
+        capture: createWorkflowCeilingCapture({
+            node: createStandaloneWorkflowNodeCapture({
+                host: options.host,
+                readers,
+            }),
+            git: createStandaloneWorkflowInstallationGitCapture({
+                host: options.host,
+                readers,
+            }),
+        }),
+        denied: () => new AppInstanceError("revoked"),
+    });
+}
+/**
+ * The same live installation-Git admission the start ceiling captured, re-run
+ * for a Workflow Git pass: the member must still be the canonical owner and the
+ * repository's installation must still grant this Git scope.
+ */
+export function createStandaloneWorkflowGitAccess(options) {
+    const readers = rootReaders(options);
+    const capture = createStandaloneWorkflowInstallationGitCapture({
+        host: options.host,
+        readers,
+    });
+    return async (memberId, repository, scope) => {
+        const member = await readers.member(memberId);
+        return (member !== null &&
+            (await capture({ kind: "member", memberId }, member, repository, scope)));
+    };
+}

package/dist/standalone/workflow-schedules.d.ts

@@ -0,0 +1,52 @@
+import { createWorkflowSchedules, type WorkflowInstallationAuthority } from "@fungi.computer/braid/runtime";
+import type { AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
+import { type TriggerArmTarget, type ScheduleDisarmInput } from "./workflow-binding.js";
+/** The host supplies this result only after reopening the protected invocation. */
+export type TriggerAdmission = Readonly<{
+    libraryId: string;
+    context: AppMethodCallContext;
+    /** The admitted frame's selection and verified artifact, pinned on arm. */
+    installationAuthority: WorkflowInstallationAuthority;
+}>;
+export type ScheduleOperation = "armSchedule" | "disarmSchedule" | "schedules";
+/** Host controls and alarm delivery compose the shared schedule owner unchanged. */
+export declare function createStandaloneWorkflowSchedules<Frame>(options: Parameters<typeof createWorkflowSchedules>[0] & {
+    admitInvocation(frame: Frame, operation: ScheduleOperation): Promise<TriggerAdmission>;
+}): {
+    nextWake: () => number | null;
+    /** Native DO alarm delivery enters the same shared occurrence/fire path. */
+    alarm: () => Promise<void>;
+    arm(frame: Frame, raw: TriggerArmTarget): Promise<{
+        kind: "armed";
+        scheduleId: string;
+    } | {
+        error: string;
+        kind?: undefined;
+        reason?: undefined;
+    } | {
+        kind: "refused";
+        reason: string;
+        readonly error?: undefined;
+    }>;
+    disarm(frame: Frame, raw: ScheduleDisarmInput): Promise<{
+        kind: "not_found";
+    } | {
+        kind: "disarmed";
+    } | {
+        error: string;
+    }>;
+    list(frame: Frame): 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;
+    }>;
+};

package/dist/standalone/workflow-schedules.js

@@ -0,0 +1,40 @@
+import { createWorkflowSchedules, } from "@fungi.computer/braid/runtime";
+import { scheduleDisarmInputSchema } from "@fungi.computer/workflows-wire";
+import { triggerArmTargetSchema, } from "./workflow-binding.js";
+/** Host controls and alarm delivery compose the shared schedule owner unchanged. */
+export function createStandaloneWorkflowSchedules(options) {
+    const schedules = createWorkflowSchedules(options);
+    return {
+        nextWake: schedules.nextWake,
+        /** Native DO alarm delivery enters the same shared occurrence/fire path. */
+        alarm: () => schedules.fireDue(),
+        async arm(frame, raw) {
+            const target = triggerArmTargetSchema.parse(raw);
+            const { libraryId, context, installationAuthority } = await options.admitInvocation(frame, "armSchedule");
+            if (context.actor.kind !== "member")
+                return { error: "not_granted" };
+            if (context.computerId === null)
+                return {
+                    kind: "refused",
+                    reason: "Select a Computer before arming a schedule",
+                };
+            // Standalone has no Agent arming source: the owner arms as themself.
+            return schedules.arm({ armedBy: context.actor.memberId, armedVia: null }, { ...target, installationId: libraryId }, context.computerId, installationAuthority);
+        },
+        async disarm(frame, raw) {
+            const { scheduleId } = scheduleDisarmInputSchema.parse(raw);
+            const { libraryId, context } = await options.admitInvocation(frame, "disarmSchedule");
+            if (context.actor.kind !== "member")
+                return { error: "not_granted" };
+            return schedules.disarm({ kind: "member", memberId: context.actor.memberId }, libraryId, scheduleId);
+        },
+        async list(frame) {
+            const { libraryId, context } = await options.admitInvocation(frame, "schedules");
+            if (context.actor.kind !== "member")
+                return { error: "not_granted" };
+            return {
+                schedules: await schedules.list({ kind: "member", memberId: context.actor.memberId }, libraryId),
+            };
+        },
+    };
+}