@fungi.computer/oyster 0.0.0-stage → 0.1.0

package/dist/standalone/tenancy.js

@@ -0,0 +1,241 @@
+import { TenancyRegistryDO, admittedRegistry, durableObjectRegistry, } from "../tenancy/cloudflare.js";
+import { createTenancy, } from "../tenancy/index.js";
+import { ownerKey } from "../tenancy/owner-key.js";
+import { hosts } from "../tenancy/resolve.js";
+import { ownerOrKeyAuth } from "../auth.js";
+import { defaultTenant, tenantScope, } from "../tenant.js";
+import * as Schema from "effect/Schema";
+const seedSchema = Schema.Struct({
+    origin: Schema.String,
+    owner: Schema.Struct({
+        provider: Schema.NonEmptyString,
+        subject: Schema.NonEmptyString,
+    }),
+});
+const seedKey = "standalone-owner-seed";
+/** A fresh registry namespace with one host-provisioned standalone tenant. */
+export class StandaloneTenants extends TenancyRegistryDO {
+    #state;
+    constructor(state) {
+        super(state);
+        this.#state = state;
+    }
+    /** Reuse only the exact configured tenant and its current canonical owner. */
+    seed(input) {
+        return this.#state.blockConcurrencyWhile(async () => {
+            input = Schema.decodeUnknownSync(seedSchema)(input);
+            const scope = tenantScope(defaultTenant, input.origin);
+            const domain = new URL(scope.origin).host;
+            const raw = await this.#state.storage.get(seedKey);
+            if (raw !== undefined) {
+                const marker = Schema.decodeUnknownSync(seedSchema)(raw);
+                if (marker.origin !== scope.origin ||
+                    marker.owner.provider !== input.owner.provider ||
+                    marker.owner.subject !== input.owner.subject)
+                    throw new Error("Standalone seed configuration changed");
+            }
+            let tenant = await this.get(defaultTenant);
+            if (tenant === null) {
+                if (raw !== undefined)
+                    throw new Error("Previously seeded standalone tenant is missing");
+                // Persist the attempt first: a crash must never turn removal into creation.
+                await this.#state.storage.put(seedKey, {
+                    origin: scope.origin,
+                    owner: input.owner,
+                });
+                tenant = await this.create({
+                    handle: defaultTenant,
+                    origin: scope.origin,
+                    domains: [domain],
+                    owner: input.owner,
+                });
+            }
+            const owner = await this.membershipOf(defaultTenant, input.owner);
+            if (tenant.handle !== defaultTenant ||
+                tenant.origin !== scope.origin ||
+                tenant.domains.length !== 1 ||
+                tenant.domains[0] !== domain ||
+                tenant.status !== "active" ||
+                owner?.role !== "owner" ||
+                tenant.owners.length !== 1 ||
+                tenant.owners[0] !== owner.memberId)
+                throw new Error("Standalone tenant does not match its configured owner");
+            if (raw === undefined)
+                await this.#state.storage.put(seedKey, {
+                    origin: scope.origin,
+                    owner: input.owner,
+                });
+            return tenant;
+        });
+    }
+}
+const environments = new WeakMap();
+/** Seed once per environment, then admit every entry from one fresh registry read. */
+export function standaloneTenancy(env) {
+    let pending = environments.get(env);
+    if (pending === undefined) {
+        pending = composeTenancy(env).catch((cause) => {
+            if (environments.get(env) === pending)
+                environments.delete(env);
+            throw cause;
+        });
+        environments.set(env, pending);
+    }
+    return pending;
+}
+async function composeTenancy(env) {
+    const scope = tenantScope(defaultTenant, env.OYSTER_ORIGIN);
+    const domain = new URL(scope.origin).host;
+    const identity = {
+        provider: "standalone-owner",
+        subject: env.OYSTER_OWNER_NAME ?? "owner",
+    };
+    await env.TENANTS.getByName("registry").seed({
+        origin: scope.origin,
+        owner: identity,
+    });
+    const registry = durableObjectRegistry(env.TENANTS, { readonly: true });
+    /** The canonical owner, only while the one admitted record still proves it. */
+    const ownerOf = ({ tenant, membership, }) => tenant.id !== defaultTenant ||
+        tenant.status !== "active" ||
+        tenant.origin !== scope.origin ||
+        tenant.handle !== defaultTenant ||
+        tenant.domains.length !== 1 ||
+        tenant.domains[0] !== domain ||
+        membership?.role !== "owner" ||
+        tenant.owners.length !== 1 ||
+        tenant.owners[0] !== membership.memberId
+        ? null
+        : {
+            actor: { kind: "member", memberId: membership.memberId },
+            role: "owner",
+            membershipVersion: membership.membershipVersion,
+        };
+    const admitted = (admission) => {
+        const view = admittedRegistry(admission);
+        const owner = ownerOf(admission);
+        const ownerAuth = ownerKey({
+            registry: view,
+            keys: {
+                get: () => Promise.resolve(owner === null
+                    ? null
+                    : { key: env.OYSTER_OWNER_KEY, memberId: owner.actor.memberId }),
+            },
+            login: { resolveTenant: (request) => tenancy.resolve(request) },
+        });
+        const resolver = hosts(view);
+        const tenancy = createTenancy({
+            registry: view,
+            resolve: {
+                kind: "origin",
+                resolve: (url, current) => url.origin === scope.origin
+                    ? resolver.resolve(url, current)
+                    : Promise.resolve(null),
+            },
+            auth: [
+                ownerAuth,
+                {
+                    id: "standalone-named-key",
+                    async authenticate(request) {
+                        if (owner === null)
+                            return { kind: "refused", status: 403 };
+                        const admission = await ownerOrKeyAuth(env.OYSTER_OWNER_KEY, owner.actor.memberId, () => env.KEYS.getByName(scope.durableName("keys"))).authenticate(request);
+                        // This entry admits only named keys; the owner key has its own entry.
+                        return admission.kind === "admitted" &&
+                            admission.principal.actor.kind === "team-key"
+                            ? { kind: "principal", principal: admission.principal }
+                            : { kind: "refused", status: 401 };
+                    },
+                },
+            ],
+        });
+        const routes = ownerAuth.routes;
+        return {
+            tenancy,
+            owner,
+            login: async (request) => routes === undefined
+                ? new Response("Sign-in is not available", { status: 404 })
+                : await routes.fetch(request),
+        };
+    };
+    /**
+     * The registry only ever stores a tenant's creation-time owner membership,
+     * and `ownerOf` proved this admission names exactly one owner. So the
+     * admitted owner is the tenant's only member: attest it on that principal.
+     */
+    const soleOwner = (current, principal) => principal.actor.kind === "member" &&
+        current.owner?.actor.memberId === principal.actor.memberId
+        ? { ...principal, soleMember: true }
+        : principal;
+    /** The one TENANTS read for an entry at `url`; another origin never reads. */
+    const admit = async (url) => {
+        if (url.origin !== scope.origin)
+            return null;
+        const admission = await registry.admission(url.host, identity);
+        return admission === null ? null : admitted(admission);
+    };
+    const atRoot = () => admit(new URL(scope.origin));
+    const owner = async () => (await atRoot())?.owner ?? null;
+    const tenancy = {
+        resolve: async (request) => (await (await admit(new URL(request.url)))?.tenancy.resolve(request)) ??
+            null,
+        authenticate: async (request, tenant) => {
+            const current = await admit(new URL(request.url));
+            return current === null
+                ? { kind: "refused", status: 404 }
+                : current.tenancy.authenticate(request, tenant);
+        },
+        member: async (tenantId, member) => (await (await atRoot())?.tenancy.member(tenantId, member)) ?? null,
+        memberById: async (tenantId, memberId) => (await (await atRoot())?.tenancy.memberById(tenantId, memberId)) ?? null,
+        middleware: (options) => async (context, next) => {
+            const current = await admit(new URL(context.req.url));
+            return current === null
+                ? context.json({ error: "not_found" }, 404)
+                : current.tenancy.middleware(options)(context, next);
+        },
+        oyster: () => oyster,
+    };
+    const oyster = {
+        async resolve(request) {
+            const current = await admit(new URL(request.url));
+            const tenant = (await current?.tenancy.resolve(request)) ?? null;
+            if (current === null || tenant === null)
+                return null;
+            // This request's authentication consumes the admission read above.
+            // Any other request is its own entry and is admitted afresh.
+            const forRequest = (incoming) => incoming === request
+                ? Promise.resolve(current)
+                : admit(new URL(incoming.url));
+            return {
+                scope: tenantScope(tenant.id, tenant.origin),
+                auth: {
+                    resolve: async (actor) => {
+                        if (actor.kind !== "member")
+                            return null;
+                        const current = await atRoot();
+                        const member = (await current?.tenancy.memberById(tenant.id, actor.memberId)) ??
+                            null;
+                        return current === null || member === null
+                            ? null
+                            : soleOwner(current, member);
+                    },
+                    authenticate: async (incoming) => {
+                        const admittedFor = await forRequest(incoming);
+                        if (admittedFor === null)
+                            return { kind: "refused", status: 404 };
+                        const result = await admittedFor.tenancy.authenticate(incoming, tenant);
+                        return result.kind === "admitted"
+                            ? {
+                                kind: "admitted",
+                                principal: soleOwner(admittedFor, result.principal),
+                            }
+                            : result;
+                    },
+                    login: async (incoming) => (await (await forRequest(incoming))?.login(incoming)) ??
+                        new Response("Not found", { status: 404 }),
+                },
+            };
+        },
+    };
+    return { tenantId: defaultTenant, tenancy, oyster, owner };
+}

package/dist/standalone/worker.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bonsai on a standalone Oyster: the whole Worker is Oyster's own git-enabled
+ * entry, plus agents on Workers AI. Bonsai is installed into it as an App
+ * Release (scripts/release.mjs); nothing here is specific to Bonsai.
+ */
+import { type OysterGitWorkerEnv } from "../workers-git.js";
+import { type TenantScope } from "../tenant.js";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import { type StandaloneComputerEnv } from "./computer.js";
+import { StandaloneAgentBase, type StandaloneAgentsEnv } from "./agents.js";
+import { type OysterMediaEnv } from "./media.js";
+import { StandaloneInstance as ComputerInstance } from "./instance.js";
+export { OysterBinding } from "./instance.js";
+import { StandaloneWorkflowRunsBase, type StandaloneWorkflowEnv } from "./workflows.js";
+import { type StandaloneTenancyEnv } from "./tenancy.js";
+export { StandaloneTenants } from "./tenancy.js";
+import { type OysterComputerEgressProps } from "./computer-egress.js";
+import { type AppSourceBindingEnv } from "./app-source.js";
+export { StandaloneGraphWorkflow } from "./workflows.js";
+export { MediaOperationDO } from "@fungi.computer/darkroom/cloudflare";
+/** Every binding the standalone Bonsai root receives. */
+export type StandaloneEnv = OysterGitWorkerEnv & StandaloneTenancyEnv & StandaloneComputerEnv & StandaloneAgentsEnv & OysterMediaEnv & StandaloneWorkflowEnv & AppSourceBindingEnv & {
+    OYSTER_HOME_INSTALLATION: string;
+    /** `disabled` closes the Computer's public download lane. */
+    COMPUTER_PUBLIC_EGRESS?: string;
+};
+export { ComputerDO } from "./computer.js";
+export { WorkspaceProxy, WorkspaceServiceProxy, } from "@fungi.computer/computer";
+export { StandaloneRegistry as OysterRegistry } from "./registry.js";
+export { OysterKeys } from "../workers-git.js";
+export { StandaloneEventDelivery as OysterWebhooks } from "./instance.js";
+export { AgentDirectory } from "./agents.js";
+declare const OysterMcp_base: new (ctx: DurableObjectState, env: StandaloneEnv) => import("../mcp-owner.js").OysterMcpOwner<StandaloneEnv>;
+export declare class OysterMcp extends OysterMcp_base {
+}
+/** Background wakes readmit members through this root's tenancy, as HTTP and MCP do. */
+export declare class StandaloneInstance extends ComputerInstance<StandaloneEnv> {
+    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+}
+/** Agent App tools derive the same catalog as HTTP and MCP for the Agent's pinned tenant. */
+export declare class StandaloneAgent extends StandaloneAgentBase<StandaloneEnv> {
+    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+}
+/** Workflow runs admit through the same root composition as HTTP. */
+export declare class StandaloneWorkflowRuns extends StandaloneWorkflowRunsBase<StandaloneEnv> {
+    protected hostFor(scope: TenantScope): import("../workers-git.js").OysterGitWorkerHost;
+}
+/** The Computer's egress gateway: its own HTTPS Git back into this Worker. */
+export declare class OysterComputerEgress extends WorkerEntrypoint<StandaloneEnv, OysterComputerEgressProps> {
+    fetch(request: Request): Promise<Response>;
+}
+declare const _default: {
+    fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: StandaloneEnv, context: ExecutionContext<unknown>): Promise<Response>;
+};
+export default _default;

package/dist/standalone/worker.js

@@ -0,0 +1,147 @@
+/**
+ * Bonsai on a standalone Oyster: the whole Worker is Oyster's own git-enabled
+ * entry, plus agents on Workers AI. Bonsai is installed into it as an App
+ * Release (scripts/release.mjs); nothing here is specific to Bonsai.
+ */
+import { createOysterGitWorker, createOysterGitMcpOwner, oysterGitRoot, } from "../workers-git.js";
+import { defaultTenant, tenantScope } from "../tenant.js";
+import { onBoxVmIngress } from "@fungi.computer/computer";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import { putContentObject } from "../build-contract.js";
+import { workflowGitPassPrefix } from "../git.js";
+import { z } from "zod";
+import { standaloneComputerCapabilities, standaloneWorkspace, } from "./computer.js";
+import { StandaloneAgentBase, standaloneAgents, } from "./agents.js";
+import { workersMedia } from "./media.js";
+import { StandaloneInstance as ComputerInstance } from "./instance.js";
+// Every guest binding in every frame is this one entrypoint, routed by props.
+export { OysterBinding } from "./instance.js";
+import { StandaloneWorkflowRunsBase, } from "./workflows.js";
+import { standaloneTenancy } from "./tenancy.js";
+export { StandaloneTenants } from "./tenancy.js";
+import { standalonePreviewRequest } from "./preview.js";
+import { standaloneBuildRoutes } from "./builds.js";
+import { serveOysterComputerEgress, } from "./computer-egress.js";
+import { appSourceOwnerRoutes, } from "./app-source.js";
+export { StandaloneGraphWorkflow } from "./workflows.js";
+export { MediaOperationDO } from "@fungi.computer/darkroom/cloudflare";
+/** A tenant's registry: it owns that tenant's installations and App builds. */
+const tenantRegistry = (env, scope) => env.REGISTRY.getByName(scope.durableName("registry"));
+/** The standalone's one Computer belongs to its default tenant, whose
+ * registry minted every build job that Computer runs. */
+const computerRegistry = (env) => tenantRegistry(env, tenantScope(defaultTenant, env.OYSTER_ORIGIN));
+export { ComputerDO } from "./computer.js";
+export { WorkspaceProxy, WorkspaceServiceProxy, } from "@fungi.computer/computer";
+export { StandaloneRegistry as OysterRegistry } from "./registry.js";
+export { OysterKeys } from "../workers-git.js";
+// WEBHOOKS keeps its deployed class name; the standalone owner also delivers to Workflows.
+export { StandaloneEventDelivery as OysterWebhooks } from "./instance.js";
+export { AgentDirectory } from "./agents.js";
+/** After Oyster's bearer prefix: `<library>.<pass>`, as the library minted it. */
+const workflowGitPassToken = z
+    .string()
+    .regex(/^([a-zA-Z0-9_-]{1,256})\.([0-9a-f]{64})$/u)
+    .transform((token) => {
+    const [libraryId = "", passId = ""] = token.split(".");
+    return [libraryId, passId];
+});
+/** The one composition root: every door reaches a tenant's host through `hostFor`. */
+const oysterRoot = oysterGitRoot({
+    tenancy: (env) => ({
+        resolve: async (request) => (await standaloneTenancy(env)).oyster.resolve(request),
+    }),
+    homeInstallationId: (env) => env.OYSTER_HOME_INSTALLATION,
+    agents: standaloneAgents,
+    workspace: standaloneWorkspace,
+    capabilities: (env, workspace, keysLive) => [
+        ...standaloneComputerCapabilities(env, workspace, keysLive),
+        ...workersMedia(env, workspace),
+    ],
+    // A presented pass names the library that minted it; only that library's
+    // run owner admits it, for one installation repository and scope.
+    workflowGitPass: async (env, _scope, pass, target) => {
+        const parsed = workflowGitPassToken.safeParse(pass.slice(workflowGitPassPrefix.length));
+        if (!parsed.success)
+            return null;
+        const [libraryId, passId] = parsed.data;
+        return env.WORKFLOW_RUNS.getByName(libraryId).admitWorkflowGitPass(passId, {
+            kind: "installation",
+            installationId: target.installationId,
+            repository: target.repository,
+        }, target.scope);
+    },
+    // A build job's clone reads one repository as the owner who started it.
+    buildGitPass: async (env, scope, pass, target) => {
+        const admitted = await tenantRegistry(env, scope).admitBuildGitPass(pass, target);
+        return admitted === null
+            ? null
+            : {
+                kind: "actor",
+                actor: { kind: "member", memberId: admitted.requestedBy },
+                role: "owner",
+            };
+    },
+    // Operator source seeding and owner builds share the one owner guard.
+    ownerRoutes: (env, scope) => appSourceOwnerRoutes(env, scope).route("/", standaloneBuildRoutes(() => tenantRegistry(env, scope))),
+});
+export class OysterMcp extends createOysterGitMcpOwner(oysterRoot) {
+}
+/** Background wakes readmit members through this root's tenancy, as HTTP and MCP do. */
+export class StandaloneInstance extends ComputerInstance {
+    hostFor(scope) {
+        return oysterRoot.hostFor(this.env, scope);
+    }
+}
+/** Agent App tools derive the same catalog as HTTP and MCP for the Agent's pinned tenant. */
+export class StandaloneAgent extends StandaloneAgentBase {
+    hostFor(scope) {
+        return oysterRoot.hostFor(this.env, scope);
+    }
+}
+/** Workflow runs admit through the same root composition as HTTP. */
+export class StandaloneWorkflowRuns extends StandaloneWorkflowRunsBase {
+    hostFor(scope) {
+        return oysterRoot.hostFor(this.env, scope);
+    }
+}
+const oyster = createOysterGitWorker(oysterRoot);
+/** The Computer's egress gateway: its own HTTPS Git back into this Worker. */
+export class OysterComputerEgress extends WorkerEntrypoint {
+    fetch(request) {
+        const computerObjectId = this.ctx.props.computerObjectId;
+        const registry = computerRegistry(this.env);
+        return serveOysterComputerEgress(request, {
+            origin: this.env.OYSTER_ORIGIN,
+            computerId: computerObjectId,
+            publicEgress: this.env.COMPUTER_PUBLIC_EGRESS,
+            build: {
+                gitPassFor: (target) => registry.buildGitPassFor(computerObjectId, target),
+                exchangeTemplate: (repository, request) => registry.exchangeBuildTemplate(computerObjectId, repository, request),
+                admitBuild: (jobId) => registry.admitBuildReport(jobId, computerObjectId),
+                admitObject: (jobId, grant) => registry.admitBuildObject(jobId, computerObjectId, grant),
+                // The bytes stream from the Computer to R2, which checks the digest;
+                // the registry only admits the upload and later reads the facts.
+                storeObject: (object, body, mediaType) => putContentObject(this.env.RELEASES, object, 
+                // R2 takes a stream of known length; the stated length is exact.
+                body?.pipeThrough(new FixedLengthStream(object.byteLength)) ?? null, mediaType),
+                submitCandidate: (jobId, manifest, grant, credentialId) => registry.submitBuildCandidate(jobId, manifest, grant, credentialId),
+                record: (event) => registry.recordBuildEvent(event),
+            },
+            // Back through this Worker's own default export, the way every other client arrives.
+            forward: (admitted) => this.ctx.exports.default.fetch(admitted),
+        });
+    }
+}
+export default {
+    async fetch(request, env, context) {
+        const preview = await standalonePreviewRequest(request, env, env.OYSTER_COMPUTER_ID, (signature, port, service) => env.COMPUTER.getByName(env.OYSTER_COMPUTER_ID).portPreview(signature, port, service));
+        if (preview !== null)
+            return preview;
+        const ingress = onBoxVmIngress(request, env, env.COMPUTER);
+        if (ingress !== undefined)
+            return ingress;
+        if (oyster.fetch === undefined)
+            throw new Error("Oyster fetch handler is missing");
+        return oyster.fetch(request, env, context);
+    },
+};

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

@@ -0,0 +1,16 @@
+import type { ReadonlyTenancy } from "../tenancy/index.js";
+import type { TenantId } from "../tenant.js";
+import type { OysterHost } from "../host.js";
+import type { WorkflowRunAuthorityPorts } from "@fungi.computer/braid/runtime";
+import type { createStandaloneWorkflowHost } from "./workflow-host.js";
+/** Host-selected tenant, Computer and library; none come from Workflow input. */
+export type StandaloneWorkflowAuthorityReaderOptions = Readonly<{
+    tenantId: TenantId;
+    tenancy: Pick<ReadonlyTenancy, "memberById">;
+    host: Pick<OysterHost, "computerId">;
+    libraryInstallationId: string;
+    catalogHost: Pick<ReturnType<typeof createStandaloneWorkflowHost>, "admitLibrary" | "catalogForLibrary">;
+}>;
+/** Live authority readers only: catalog entries do not establish node grants. */
+export type StandaloneWorkflowAuthorityReaders = Pick<WorkflowRunAuthorityPorts, "member" | "memberComputer" | "catalog">;
+export declare function createStandaloneWorkflowAuthorityReaders(options: StandaloneWorkflowAuthorityReaderOptions): StandaloneWorkflowAuthorityReaders;

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

@@ -0,0 +1,35 @@
+import { AppInstanceError } from "../index.js";
+export function createStandaloneWorkflowAuthorityReaders(options) {
+    const member = async (id) => {
+        const current = await options.tenancy.memberById(options.tenantId, id);
+        if (current?.actor.kind !== "member" ||
+            current.actor.memberId !== id ||
+            !("role" in current) ||
+            current.role !== "owner")
+            return null;
+        return { membershipVersion: current.membershipVersion };
+    };
+    return {
+        member,
+        async memberComputer(id, computerId) {
+            const before = await member(id);
+            if (before === null || computerId !== options.host.computerId)
+                return false;
+            const after = await member(id);
+            return after?.membershipVersion === before.membershipVersion;
+        },
+        async catalog(id) {
+            const before = await member(id);
+            if (before === null)
+                throw new AppInstanceError("revoked");
+            const selected = await options.catalogHost.admitLibrary(options.libraryInstallationId, "catalog");
+            const entries = await options.catalogHost.catalogForLibrary(selected, {
+                full: true,
+            });
+            const after = await member(id);
+            if (after?.membershipVersion !== before.membershipVersion)
+                throw new AppInstanceError("revoked");
+            return entries.apps;
+        },
+    };
+}