@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/standalone/machine-link.js

@@ -0,0 +1,368 @@
+import { machineAgentReservations } from "@fungi.computer/shiitake/delegation";
+import { createMachineEnrollment, MachineEnrollmentRefused, MachineLinkRefused, } from "../machine-link/index.js";
+import { keyAllowsMachineEnroll, } from "../keys.js";
+import { agentIds, createAgentDirectory, } from "@fungi.computer/shiitake/fleet";
+import { DurableObject } from "cloudflare:workers";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { validator } from "hono/validator";
+import { machineEnrollmentSchema, machineLinkName, } from "../machine-link/index.js";
+import { createMachineLink } from "../machine-link/workers.js";
+import { defaultTenant, tenantScope } from "../tenant.js";
+import { presentedGitKey } from "../git-auth.js";
+import { standaloneTenancy } from "./tenancy.js";
+/** Standalone's fresh directory projection for the shared hosted client. */
+export function standaloneMachineAgentHome(options) {
+    return async (agentId) => {
+        const actor = options.identity();
+        if (actor === null)
+            throw new MachineLinkRefused("actor_not_allowed");
+        const directory = options.directory.getByName(actor.teamId);
+        const home = await directory.agentHome(agentId);
+        if (home === null)
+            throw new MachineLinkRefused("actor_not_allowed");
+        if (home.kind === "hosted")
+            return home;
+        // Admit the source and live device before the client addresses its link.
+        return (await directory.machineTarget({ kind: "hosted", agentId: actor.agentId }, agentId, null)).targetHome;
+    };
+}
+/** Machine-link teamId is the existing owner's Agent directory scope. */
+const scopeFor = (env) => tenantScope(defaultTenant, env.OYSTER_ORIGIN);
+async function liveOwner(env) {
+    const tenant = await env.TENANTS.getByName("registry").get(defaultTenant);
+    // A mesh request cannot provision a missing owner scope or cold-start
+    // tenancy's seed path while that scope is held inactive.
+    if (tenant?.status !== "active")
+        return null;
+    return (await standaloneTenancy(env)).owner();
+}
+/** Fresh host authority; no answer is retained by the adapter or the link. */
+export function standaloneMachineLinkAuthority(env) {
+    const scope = scopeFor(env);
+    const teamId = scope.durableName("agents");
+    const directory = () => env.AGENT_DIRECTORY.getByName(teamId);
+    const authority = {
+        admitDevice: async (id) => {
+            if (id.teamId !== teamId || (await liveOwner(env)) === null)
+                return { live: false };
+            return directory().machineDevice(id);
+        },
+        currentFence: async (id) => id.teamId !== teamId ? null : directory().machineFence(id),
+        directory: async (id) => {
+            if (!(await authority.admitDevice(id)).live)
+                throw new MachineLinkRefused("actor_not_allowed");
+            return directory().machineDirectory(id);
+        },
+        resolveTarget: async (id, caller, agentId, requester) => {
+            if (!(await authority.admitDevice(id)).live)
+                throw new MachineLinkRefused("actor_not_allowed");
+            return directory().machineTarget(caller, agentId, requester);
+        },
+        deliverHome: async (id, caller, target, envelope) => {
+            // The projection used to prepare this delivery lends no later authority.
+            const facts = await authority.resolveTarget(id, caller, target.targetAgentId, null);
+            if (facts.targetHome.kind === "hosted")
+                return env.AGENTS.getByName(facts.targetAgentId).deliver(envelope);
+            const next = { teamId, deviceId: facts.targetHome.deviceId };
+            if (!(await authority.admitDevice(next)).live)
+                throw new MachineLinkRefused("actor_not_allowed");
+            return env.MACHINE_LINK.getByName(machineLinkName(next)).deliver(next, caller, facts.targetAgentId, envelope);
+        },
+        canErase: async (id) => {
+            if (id.teamId !== teamId)
+                return false;
+            const tenant = await env.TENANTS.getByName("registry").get(defaultTenant);
+            // Losing a login or a failed owner read is not erasure permission.
+            // Like the Hub: the owner scope is held inactive AND the device key is
+            // irreversibly retired in its retained enrollment owner.
+            return (tenant !== null &&
+                tenant.origin === scope.origin &&
+                (tenant.status === "suspended" || tenant.status === "deleting") &&
+                (await directory().machineKeyRetired(id.deviceId)));
+        },
+        deliverControlFact: async (fact) => {
+            const tenant = await env.TENANTS.getByName("registry").get(defaultTenant);
+            if (fact.teamId !== teamId ||
+                tenant?.origin !== scope.origin ||
+                (await authority.currentFence(fact)) === null)
+                throw new MachineLinkRefused("actor_not_allowed");
+            return env.MACHINE_LINK.getByName(machineLinkName(fact)).applyFence(fact);
+        },
+    };
+    return authority;
+}
+/** HTTP enrollment over the existing live KEYS and directory owners. */
+export function standaloneMachineJoinRoutes(options) {
+    const { scope } = options;
+    const teamId = scope.durableName("agents");
+    return new Hono().post("/local/mesh/join", bodyLimit({ maxSize: 512 * 1024 }), validator("json", (value, context) => {
+        const parsed = machineEnrollmentSchema.safeParse(value);
+        return parsed.success
+            ? parsed.data
+            : context.json({ error: "invalid_enrollment" }, 400);
+    }), async (context) => {
+        if (new URL(context.req.url).origin !== scope.origin)
+            return context.body(null, 403);
+        const ownerId = await options.ownerId();
+        if (ownerId === null)
+            return context.body(null, 403);
+        const presented = presentedGitKey(context.req.raw);
+        if (presented.kind !== "key")
+            return context.body(null, 401);
+        const keys = options.keys();
+        const verified = await keys.verify(presented.value);
+        if (verified.kind !== "ok")
+            return context.body(null, 401);
+        const live = await keys.live(verified.value.keyId);
+        if (live?.owner !== ownerId || !keyAllowsMachineEnroll(live))
+            return context.body(null, 403);
+        const joined = await options.enroll(live.keyId, context.req.valid("json"));
+        // Domain refusals cross RPC as data, not an instanceof claim about a
+        // platform-reconstructed Error.
+        if (joined.kind === "refused") {
+            if (joined.error === "request_conflict" || joined.error === "capacity")
+                return context.json({ error: joined.error }, 409);
+            if (joined.error === "invalid_enrollment")
+                return context.json({ error: "invalid_enrollment" }, 400);
+            return context.body(null, 403);
+        }
+        return context.json({ kind: "joined", scopeId: teamId, ...joined.value }, 200);
+    });
+}
+/** Only join accepts an oyk credential; every subsequent dial uses Seam. */
+export function standaloneMachineLinkRoutes(env) {
+    const scope = scopeFor(env);
+    const teamId = scope.durableName("agents");
+    return standaloneMachineJoinRoutes({
+        scope,
+        ownerId: async () => (await liveOwner(env))?.actor.memberId ?? null,
+        keys: () => env.KEYS.getByName(scope.durableName("keys")),
+        enroll: (keyId, input) => env.AGENT_DIRECTORY.getByName(teamId).enrollMachine(keyId, input),
+    }).get("/api/teams/:teamId/local/mesh/:deviceId/connect", async (context) => {
+        const id = {
+            teamId: context.req.param("teamId"),
+            deviceId: context.req.param("deviceId"),
+        };
+        if (new URL(context.req.url).origin !== scope.origin ||
+            id.teamId !== teamId ||
+            !(await standaloneMachineLinkAuthority(env).admitDevice(id)).live)
+            return context.body(null, 403);
+        // F1: never address an unknown scope/device, even for a refused dial.
+        // The shared link independently rereads admission and verifies Seam.
+        return env.MACHINE_LINK.getByName(machineLinkName(id)).fetch(context.req.raw);
+    });
+}
+const erasedKey = "machine-link:erased";
+/** One device's link; directory, credentials and owner state remain elsewhere. */
+export class MachineLinkDO extends DurableObject {
+    link = createMachineLink(this.ctx, {
+        authority: standaloneMachineLinkAuthority(this.env),
+        addressed: (identity) => this.ctx.id.equals(this.env.MACHINE_LINK.idFromName(machineLinkName(identity))),
+        erasure: {
+            erased: async () => (await this.ctx.storage.get(erasedKey)) === true,
+            read: async () => ({
+                erased: (await this.ctx.storage.get(erasedKey)) === true,
+            }),
+            erase: async () => {
+                // Only this retired device's socket/replay owner, never an Agent,
+                // directory or KEYS store. The shared factory checks canErase first.
+                await this.ctx.storage.deleteAll();
+                await this.ctx.storage.put(erasedKey, true);
+                return { erased: true };
+            },
+        },
+        report: (operation, cause) => {
+            console.error(operation, cause);
+        },
+    });
+    fetch(request) {
+        return this.link.fetch(request);
+    }
+    deliver(id, caller, agentId, envelope) {
+        return this.link.deliver(id, caller, agentId, envelope);
+    }
+    operation(id, caller, agentId, operation) {
+        return this.link.operation(id, caller, agentId, operation);
+    }
+    applyFence(fact) {
+        return Promise.resolve(this.link.applyFence(fact));
+    }
+    preflightErasure(teamId, deviceId) {
+        return this.link.preflightErasure(teamId, deviceId);
+    }
+    eraseForTeam(teamId, deviceId) {
+        return this.link.eraseForTeam(teamId, deviceId);
+    }
+    readErasure() {
+        return this.link.readErasure();
+    }
+    webSocketMessage(socket, message) {
+        return this.link.webSocketMessage(socket, message);
+    }
+    webSocketClose(socket, code, reason) {
+        this.link.webSocketClose(socket, code, reason);
+    }
+    webSocketError(socket) {
+        this.link.webSocketError(socket);
+    }
+}
+/** Enrollment and the ordinary directory share this one SQLite owner. */
+export function createStandaloneMachineEnrollment(options) {
+    options.owner.sql.exec("CREATE TABLE IF NOT EXISTS standalone_machine_enroll_keys (key_id TEXT PRIMARY KEY, request_id TEXT NOT NULL) STRICT");
+    const configured = {
+        // Retained host's private storage/representation ceilings, not plan quotas.
+        limits: { machines: 256, agentsPerMachine: 256 },
+        authorizeMember: async (memberId) => {
+            if ((await options.ownerId()) !== memberId)
+                throw new MachineLinkRefused("actor_not_allowed");
+        },
+        // Enrollment keys buy identity once; they are not ongoing device credentials.
+        authorizeLogin: async ({ memberId }) => (await options.ownerId()) === memberId,
+        onAgentCreated: options.onAgentCreated,
+        agents: machineAgentReservations,
+    };
+    const enrollment = createMachineEnrollment({
+        ...configured,
+        owner: options.owner,
+    });
+    // A view of the ordinary directory in this same store, not another catalog.
+    const directory = createAgentDirectory(options.owner.sql);
+    const grant = (memberId) => ({
+        agents: "all",
+        actions: ["read"],
+        expiresAt: Date.now() + 60_000,
+        provenance: { actor: memberId },
+    });
+    const owner = async () => {
+        const memberId = await options.ownerId();
+        if (memberId === null)
+            throw new MachineLinkRefused("actor_not_allowed");
+        return memberId;
+    };
+    const admitDevice = async (id) => {
+        if (id.teamId !== options.scopeId || (await options.ownerId()) === null)
+            return { live: false };
+        try {
+            const device = await enrollment.authorizeDevice(id.deviceId);
+            return {
+                live: true,
+                teamId: options.scopeId,
+                deviceId: device.deviceId,
+                memberId: device.memberId,
+                publicKey: device.publicKey,
+                fenceEpoch: device.fenceEpoch,
+            };
+        }
+        catch (cause) {
+            if (cause instanceof MachineEnrollmentRefused ||
+                cause instanceof MachineLinkRefused)
+                return { live: false };
+            throw cause;
+        }
+    };
+    const currentFence = async (id) => {
+        if (id.teamId !== options.scopeId)
+            return null;
+        const memberId = await options.ownerId();
+        const device = enrollment
+            .retainedDevices()
+            .find((row) => row.deviceId === id.deviceId);
+        return device === undefined
+            ? null
+            : {
+                ...id,
+                fenceEpoch: device.fenceEpoch,
+                live: memberId === device.memberId && !device.revoked,
+            };
+    };
+    const target = async (caller, agentId, requester) => {
+        const memberId = await owner();
+        const exists = (id) => {
+            const parsed = agentIds.agent.parse(id);
+            return (parsed.ok && directory.read(grant(memberId), parsed.value) !== null);
+        };
+        if (!exists(caller.agentId) ||
+            !exists(agentId) ||
+            (requester !== null &&
+                (!exists(requester) ||
+                    (caller.agentId !== agentId && caller.agentId !== requester))))
+            throw new MachineLinkRefused("actor_not_allowed");
+        const source = enrollment.home(caller.agentId);
+        if (caller.kind === "device"
+            ? source?.kind !== "machine" || source.deviceId !== caller.deviceId
+            : source !== null)
+            throw new MachineLinkRefused("actor_not_allowed");
+        if (source?.kind === "machine")
+            await enrollment.authorizeDevice(source.deviceId);
+        const targetHome = enrollment.home(agentId) ?? {
+            kind: "hosted",
+        };
+        if (targetHome.kind === "machine")
+            await enrollment.authorizeDevice(targetHome.deviceId);
+        return {
+            teamId: options.scopeId,
+            callerAgentId: caller.agentId,
+            targetAgentId: agentId,
+            actorAgentId: requester ?? caller.agentId,
+            callerHome: source ?? { kind: "hosted" },
+            targetHome,
+        };
+    };
+    return {
+        ...enrollment,
+        admitDevice,
+        currentFence,
+        target,
+        async publicDirectory(id) {
+            if (!(await admitDevice(id)).live)
+                throw new MachineLinkRefused("actor_not_allowed");
+            const memberId = await owner();
+            return directory
+                .list(grant(memberId))
+                .map(({ agentId, name }) => ({ agentId, name }));
+        },
+        async enrollWithKey(keyId, input) {
+            const memberId = await options.ownerId();
+            const key = await options.liveKey(keyId);
+            if (memberId === null ||
+                key?.owner !== memberId ||
+                !keyAllowsMachineEnroll(key))
+                throw new MachineLinkRefused("actor_not_allowed");
+            // This wrapper is per call: concurrent joins never share a mutable key
+            // slot. createMachineEnrollment invokes it only around its synchronous
+            // identity/directory commit, after awaited validation and authority reads.
+            const consumingOwner = {
+                sql: options.owner.sql,
+                transactionSync: (body) => options.owner.transactionSync(() => {
+                    const consumed = options.owner.sql
+                        .exec("SELECT key_id FROM standalone_machine_enroll_keys WHERE key_id=?", keyId)
+                        .toArray().length !== 0;
+                    if (consumed) {
+                        // Replay is an ordinary enrollment receipt, not another spend.
+                        // The shared owner checks canonical body, member, login and
+                        // retirement before returning its original directory identities.
+                        if (options.owner.sql
+                            .exec("SELECT 1 FROM standalone_machine_enroll_keys WHERE key_id=? AND request_id=?", keyId, input.requestId)
+                            .toArray().length === 0)
+                            throw new MachineLinkRefused("actor_not_allowed");
+                    }
+                    else {
+                        options.owner.sql.exec("INSERT INTO standalone_machine_enroll_keys (key_id, request_id) VALUES (?, ?)", keyId, input.requestId);
+                    }
+                    return body();
+                }),
+            };
+            return createMachineEnrollment({
+                ...configured,
+                owner: consumingOwner,
+                authorizeMember: async (member) => {
+                    await configured.authorizeMember(member);
+                    const current = await options.liveKey(keyId);
+                    if (current?.owner !== member || !keyAllowsMachineEnroll(current))
+                        throw new MachineLinkRefused("actor_not_allowed");
+                },
+            }).enroll({ memberId, clientId: "oyster-key", loginId: key.keyId }, input);
+        },
+    };
+}

package/dist/standalone/media.d.ts

@@ -41,7 +41,7 @@ export declare const mediaFrameMethods: {
                     aspectRatio?: "16:9" | "4:3" | "1:1" | "3:4" | "9:16" | "21:9" | "9:21" | undefined;
                     references?: {
                         path: string;
-                        role?: "first-frame" | "last-frame" | "reference" | undefined;
+                        role?: "reference" | "first-frame" | "last-frame" | undefined;
                     }[] | undefined;
                     generateAudio?: boolean | undefined;
                     steps?: number | undefined;
@@ -60,7 +60,7 @@ export declare const mediaFrameMethods: {
                     generateAudio?: boolean | undefined;
                     references?: {
                         path: string;
-                        role: "first-frame" | "last-frame" | "reference";
+                        role: "reference" | "first-frame" | "last-frame";
                     }[] | undefined;
                 };
             }];

package/dist/standalone/media.js

@@ -53,21 +53,24 @@ export function workersMedia(env, workspace) {
         });
         if (!response.ok) {
             const failure = await readMediaFailure(response);
-            return context.json({
-                kind: "failed",
-                failure: failure === null
-                    ? {
-                        message: "Invalid media service response",
-                        code: "PROTOCOL",
-                        retryable: false,
-                    }
-                    : {
-                        message: failure.error,
-                        code: failure.code,
-                        stage: failure.stage,
-                        retryable: failure.retryable,
-                    },
-            });
+            const projected = failure === null
+                ? {
+                    message: "Invalid media service response",
+                    code: "PROTOCOL",
+                    retryable: false,
+                }
+                : {
+                    message: failure.error,
+                    code: failure.code,
+                    stage: failure.stage,
+                    retryable: failure.retryable,
+                };
+            if (failure?.provider !== undefined)
+                return context.json({
+                    kind: "failed",
+                    failure: { ...projected, provider: failure.provider },
+                });
+            return context.json({ kind: "failed", failure: projected });
         }
         if (response.status === 202) {
             const pending = mediaPendingSchema.parse(await response.json());
@@ -186,7 +189,7 @@ export async function dispatchMediaBinding(env, frame, props, method, args, work
     if (caller.computerId !== workspace.computerId ||
         caller.actor.kind === "team-key")
         throw new AppInstanceError("revoked");
-    const parsed = parseMediaBindingCall(Schema.decodeUnknownSync(Schema.Json)({
+    const parsed = parseMediaBindingCall(z.json().parse({
         operation: method,
         input: args[0],
     }));

package/dist/standalone/preview.d.ts

@@ -4,7 +4,7 @@ export declare const previewSelectorSchema: Schema.Struct<{
     readonly ownerId: Schema.NonEmptyString;
     readonly installationId: Schema.NonEmptyString;
     readonly selection: Schema.Struct<{
-        readonly instanceId: Schema.Codec<import("../index.js").InstanceId, string, never, never>;
+        readonly instanceId: Schema.Codec<import("../instance-id.js").InstanceId, string, never, never>;
         readonly owner: Schema.Struct<{
             readonly kind: Schema.Literals<readonly ["installation", "deployment"]>;
             readonly id: Schema.NonEmptyString;
@@ -48,4 +48,4 @@ export declare function createStandalonePreview(storage: ConstructorParameters<t
     fetch(signature: string, port: number, request: Request): Promise<Response>;
 };
 export declare function passivePreviewResponse(response: Response): Promise<Response>;
-export declare function standalonePreviewRequest(request: Request, env: StandalonePreviewEnv, computerId: string, forward: (signature: string, port: number, request: Request) => Promise<Response>): Promise<Response | null>;
+export declare function standalonePreviewRequest(request: Request, env: StandalonePreviewEnv, ownsComputer: (computerId: string) => Promise<boolean>, forward: (computerId: string, signature: string, port: number, request: Request) => Promise<Response>): Promise<Response | null>;

package/dist/standalone/preview.js

@@ -3,7 +3,7 @@ import * as z from "zod";
 import { ComputerPortPreview } from "@fungi.computer/computer/preview";
 import { selectionSchema } from "../index.js";
 import { sha256DigestSchema } from "@fungi.computer/puffball/effect";
-import { computerPortInputSchema } from "@fungi.computer/computer/operations";
+import { computerPortInputSchema } from "@fungi.computer/computer-contract";
 export const previewSelectorSchema = Schema.Struct({
     ownerId: Schema.NonEmptyString,
     installationId: Schema.NonEmptyString,
@@ -129,7 +129,7 @@ export async function passivePreviewResponse(response) {
     });
     return new Response(response.body, { status: response.status, headers });
 }
-export async function standalonePreviewRequest(request, env, computerId, forward) {
+export async function standalonePreviewRequest(request, env, ownsComputer, forward) {
     const incoming = new URL(request.url);
     const previewHost = configuredPreviewOrigin(env);
     // A host nothing configured as the preview tunnel is left to the caller's
@@ -143,23 +143,50 @@ export async function standalonePreviewRequest(request, env, computerId, forward
     if (!["GET", "HEAD"].includes(request.method) ||
         request.headers.has("Upgrade"))
         return new Response(null, { status: 404 });
-    const path = /^\/preview\/([^/]+)\/([0-9]{1,5})\/([a-z2-7]{20})(\/.*)$/u.exec(incoming.pathname);
-    if (path?.[1] !== encodeURIComponent(computerId) ||
-        path[3] === undefined ||
-        path[4] === undefined)
+    const path = new URLPattern({
+        pathname: "/preview/:computerId/:port/:signature/*",
+    }).exec(incoming)?.pathname.groups;
+    if (path === undefined)
         return new Response(null, { status: 404 });
     if (previewOrigins(env) === null)
         return new Response(null, { status: 404 });
-    const input = computerPortInputSchema.safeParse({ port: Number(path[2]) });
-    if (!input.success || String(input.data.port) !== path[2])
+    const ticket = z
+        .object({
+        computerId: z.string().min(1),
+        port: z.string().regex(/^[0-9]{1,5}$/u),
+        signature: z.string().regex(/^[a-z2-7]{20}$/u),
+        "0": z.string(),
+    })
+        .safeParse(path);
+    if (!ticket.success)
+        return new Response(null, { status: 404 });
+    let computerId;
+    try {
+        computerId = decodeURIComponent(ticket.data.computerId);
+    }
+    catch (cause) {
+        if (cause instanceof URIError)
+            return new Response(null, { status: 404 });
+        throw cause;
+    }
+    if (computerId.length === 0 ||
+        computerId.length > 256 ||
+        encodeURIComponent(computerId) !== ticket.data.computerId)
+        return new Response(null, { status: 404 });
+    const input = computerPortInputSchema.safeParse({
+        port: Number(ticket.data.port),
+    });
+    if (!input.success || String(input.data.port) !== ticket.data.port)
+        return new Response(null, { status: 404 });
+    if (!(await ownsComputer(computerId)))
         return new Response(null, { status: 404 });
     const service = new URL("http://localhost");
-    service.pathname = path[4];
+    service.pathname = `/${ticket.data["0"]}`;
     service.search = incoming.search;
     const headers = new Headers(request.headers);
     for (const name of ["cookie", "authorization", "proxy-authorization", "host"])
         headers.delete(name);
-    return forward(path[3], input.data.port, new Request(service, {
+    return forward(computerId, ticket.data.signature, input.data.port, new Request(service, {
         method: request.method,
         headers,
         signal: request.signal,