@fungi.computer/oyster 0.3.1 → 0.4.0

package/dist/standalone/app-builds-binding.js

@@ -203,7 +203,7 @@ export async function dispatchAppsBuildsBinding(env, scope, frame, props, method
         const registry = buildRegistry(env, scope);
         const build = "repo" in input
             ? await registry.readRepositoryBuild(frame.facts.selection.owner.id, input.repo)
-            : await registry.readBuild(input.jobId);
+            : await registry.readInstallationBuild(frame.facts.selection.owner.id, input.jobId);
         frame.signal.throwIfAborted();
         const missingJob = build === null && "jobId" in input;
         return Schema.decodeUnknownSync(Schema.Json)({

package/dist/standalone/computer-control.d.ts

@@ -0,0 +1,4 @@
+import type { ComputerControlPort } from "../mcp.js";
+import type { StandaloneRegistryRpc } from "./registry.js";
+/** MCP control speaks to the same owner-admitted durable fleet as HTTP. */
+export declare function standaloneComputerControl(registry: Pick<StandaloneRegistryRpc, "computerFleet">, memberId: string): ComputerControlPort;

package/dist/standalone/computer-control.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { computerStateSchema, } from "@fungi.computer/computer/fleet";
+import { teamComputerDirectorySchema } from "@fungi.computer/nacre/workbench";
+const inventoryComputer = z.strictObject({
+    computerId: z.string(),
+    name: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const inventoryPage = z.strictObject({
+    computers: z.array(inventoryComputer),
+    nextOffset: z.number().int().nonnegative().nullable(),
+});
+const inventoryError = z.strictObject({
+    error: z.string(),
+});
+/** MCP control speaks to the same owner-admitted durable fleet as HTTP. */
+export function standaloneComputerControl(registry, memberId) {
+    const fleet = (request) => registry.computerFleet(memberId, request);
+    const available = (result) => {
+        if (result === null || inventoryError.safeParse(result).success)
+            throw new Error("Computer fleet refused the request");
+        return result;
+    };
+    return {
+        list: async (page) => teamComputerDirectorySchema.parse(inventoryPage.parse(available(await fleet({ operation: "list", page })))),
+        state: async (computerId) => computerStateSchema.parse(available(await fleet({ operation: "state", computerId }))),
+        start: async (computerId) => computerStateSchema.parse(available(await fleet({ operation: "start", computerId }))),
+        create: async (input) => {
+            let result;
+            try {
+                result = await fleet({ operation: "create", request: input });
+            }
+            catch {
+                // Creation may have persisted before the RPC failed. Surface its
+                // identity so the caller can retry, never silently mint another one.
+                return { kind: "uncertain" };
+            }
+            if (result === null)
+                return { kind: "denied" };
+            const error = inventoryError.safeParse(result);
+            if (error.success) {
+                switch (error.data.error) {
+                    case "owner_required":
+                        return { kind: "denied" };
+                    case "name_taken":
+                    case "request_conflict":
+                        return { kind: "conflict" };
+                    case "partial_init":
+                        return { kind: "uncertain" };
+                    default:
+                        return { kind: "invalid" };
+                }
+            }
+            const computer = inventoryComputer.parse(result);
+            return {
+                kind: "created",
+                computer: { computerId: computer.computerId, name: computer.name },
+            };
+        },
+    };
+}

package/dist/standalone/computer-fleet.d.ts

@@ -23,6 +23,7 @@ export declare const standaloneFleetRequestSchema: z.ZodDiscriminatedUnion<[z.Zo
         resolve: "resolve";
         select: "select";
         start: "start";
+        state: "state";
     }>;
     computerId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{

package/dist/standalone/computer-fleet.js

@@ -15,7 +15,7 @@ export const standaloneFleetRequestSchema = z.discriminatedUnion("operation", [
         page: computerPageSchema,
     }),
     z.strictObject({
-        operation: z.enum(["read", "resolve", "start", "select"]),
+        operation: z.enum(["read", "resolve", "state", "start", "select"]),
         computerId: fleetComputerId,
     }),
     z.strictObject({

package/dist/standalone/computer.d.ts

@@ -4,7 +4,8 @@ import { type PreviewSelector } from "./preview.js";
 import { type StandaloneTenancyEnv } from "./tenancy.js";
 import * as z from "zod";
 import { computerProcessSchema, computerToolResultSchema, readOutputSchema } from "@fungi.computer/computer-contract";
-import { ComputerDO as NativeComputerDO, type AttachedBackend, type ComputerEnv } from "@fungi.computer/computer";
+import { ComputerDO as NativeComputerDO, type AttachedBackend, type ComputerEnv, type ComputerFilesRpc } from "@fungi.computer/computer";
+import { patchInputSchema, patchOutputSchema } from "@fungi.computer/knapsack/files-patch";
 import { listOutputSchema, writeOutputSchema, mkdirOutputSchema, computerPortsOutputSchema, computerPortOutputSchema, computerPortRemovalOutputSchema, processListOutputSchema, processKillOutputSchema, computerOperationResultSchema, type ComputerExecutionHostHooks, type ComputerValue } from "@fungi.computer/computer-contract";
 import { type WorkflowGitCredential, type WorkflowGitPassGrant } from "@fungi.computer/braid/runtime";
 import { type ComputerAction, type ComputerGrant } from "@fungi.computer/computer/fleet";
@@ -66,8 +67,13 @@ export type StandaloneWorkflowGitIssuer = Readonly<{
 export type ComputerFetch = {
     fetch(request: Request): Promise<Response>;
 };
+/** The additional native doors an attached Agent may use on this Computer. */
+export type StandaloneAgentComputerRpc = ComputerFilesRpc & Readonly<{
+    tool(authority: ComputerGrant, capabilityId: string, input: ComputerValue): Promise<StandaloneComputerResult>;
+    filePatch(authority: ComputerGrant, input: z.output<typeof patchInputSchema>): Promise<z.output<typeof patchOutputSchema>>;
+}>;
 /** Durable workspace and existing backings, with fleet checks at native acceptance. */
-export declare class ComputerDO extends NativeComputerDO implements ComputerFetch {
+export declare class ComputerDO extends NativeComputerDO implements ComputerFetch, StandaloneAgentComputerRpc {
     #private;
     private readonly previewBindings;
     constructor(state: DurableObjectState, previewBindings: StandaloneComputerOwnerEnv);
@@ -77,6 +83,17 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
     startHostedComputer(authority: ComputerGrant): Promise<{
         state: "running";
     }>;
+    /** Observe an admitted fleet Computer without starting its backend. */
+    readHostedComputerState(authority: ComputerGrant): Promise<{
+        state: "queued";
+        position: number;
+    } | {
+        state: "running" | "starting";
+        position?: never;
+    } | {
+        state: "running" | "sleeping";
+        position?: never;
+    }>;
     /** A read-only preflight over the maintained hosted-route selector. */
     buildBackend(): OysterBuildBackend;
     /**
@@ -120,6 +137,8 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
     /** Binary files share the same native filesystem as commands and PTYs. */
     fileRead(authority: ComputerGrant, path: string): Promise<Uint8Array | null>;
     fileWrite(authority: ComputerGrant, path: string, bytes: Uint8Array): Promise<void>;
+    /** Patch is handled by the Computer's pinned native engine, not by the Agent. */
+    filePatch(authority: ComputerGrant, input: z.output<typeof patchInputSchema>): Promise<z.output<typeof patchOutputSchema>>;
     fileReplace(authority: ComputerGrant, path: string, expectedContent: string, content: string): Promise<{
         path: string;
         bytes: number;

package/dist/standalone/computer.js

@@ -11,6 +11,7 @@ import { Base64 } from "effect/encoding";
 import * as z from "zod";
 import { ComputerPortConflictError, computerByteReadReplySchema, computerProcessSchema, installationProcessScope, processStartInputSchema, processStartToolInputSchema, computerCapabilities, computerToolResultSchema, readOutputSchema, } from "@fungi.computer/computer-contract";
 import { ComputerDO as NativeComputerDO, ComputerOperationConflictError, } from "@fungi.computer/computer";
+import { patchInputSchema, patchOutputSchema, } from "@fungi.computer/knapsack/files-patch";
 import { ComputerFileConflict, computerExecutionRequestSchema, computerValueSchema, computerPortInputSchema, listInputSchema, listOutputSchema, readBytesInputSchema, writeInputSchema, replaceInputSchema, writeOutputSchema, mkdirOutputSchema, computerPortsOutputSchema, computerPortOutputSchema, computerPortRemovalOutputSchema, processListOutputSchema, processKillOutputSchema, computerOperationResultSchema, mintComputerRequestId, processIdInputSchema, } from "@fungi.computer/computer-contract";
 import { workflowGitExecutionEnvironment, workflowGitPassGrantSchema, } from "@fungi.computer/braid/runtime";
 import { checkComputerGrant, computerActionSchema, computerGrantSchema, createFleetBacking, FleetGrantRefused, FleetLifecycle, } from "@fungi.computer/computer/fleet";
@@ -173,6 +174,11 @@ export class ComputerDO extends NativeComputerDO {
             await run();
         });
     }
+    /** Observe an admitted fleet Computer without starting its backend. */
+    readHostedComputerState(authority) {
+        this.#accept(authority, "start");
+        return this.#fleetLifecycle().readComputerState();
+    }
     #previewGrant(ownerId) {
         return {
             computerId: this.#id(),
@@ -455,6 +461,12 @@ export class ComputerDO extends NativeComputerDO {
             this.#accept(authority, "files.writeBytes");
         });
     }
+    /** Patch is handled by the Computer's pinned native engine, not by the Agent. */
+    async filePatch(authority, input) {
+        return this.applyPatchAfterAcceptance(input, () => {
+            this.#accept(authority, "files.edit");
+        });
+    }
     async fileReplace(authority, path, expectedContent, content) {
         try {
             const result = await this.replaceFileIfUnchangedAfterAcceptance({ path, expectedContent, content }, () => {

package/dist/standalone/machine-link.d.ts

@@ -265,6 +265,7 @@ export declare function standaloneMachineLinkRoutes(env: StandaloneMachineLinkEn
 /** One device's link; directory, credentials and owner state remain elsewhere. */
 export declare class MachineLinkDO extends DurableObject<StandaloneMachineLinkEnv> {
     private readonly link;
+    alarm(): Promise<void>;
     fetch(request: Request): Promise<Response>;
     deliver(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, envelope: PostEnvelope): Promise<PostDeliveryResult>;
     operation(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, operation: MachineAgentOperation): Promise<import("effect/Schema").Json>;
@@ -276,6 +277,15 @@ export declare class MachineLinkDO extends DurableObject<StandaloneMachineLinkEn
     readErasure(): Promise<{
         erased: boolean;
     }>;
+    deadLetters(id: MachineLinkIdentity, afterKey?: string): Promise<Readonly<{
+        letters: readonly Readonly<{
+            key: string;
+            reason: "refused" | "exhausted" | "expired";
+            envelope: PostEnvelope;
+            attempts: number;
+        }>[];
+        nextCursor: string | undefined;
+    }>>;
     webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): Promise<void>;
     webSocketClose(socket: WebSocket, code: number, reason: string): void;
     webSocketError(socket: WebSocket): void;

package/dist/standalone/machine-link.js

@@ -176,6 +176,9 @@ export class MachineLinkDO extends DurableObject {
             console.error(operation, cause);
         },
     });
+    alarm() {
+        return this.link.alarm();
+    }
     fetch(request) {
         return this.link.fetch(request);
     }
@@ -197,6 +200,9 @@ export class MachineLinkDO extends DurableObject {
     readErasure() {
         return this.link.readErasure();
     }
+    deadLetters(id, afterKey) {
+        return this.link.deadLetters(id, afterKey);
+    }
     webSocketMessage(socket, message) {
         return this.link.webSocketMessage(socket, message);
     }

package/dist/standalone/registry.d.ts

@@ -37,6 +37,7 @@ export type StandaloneRegistryRpc = {
     registerRepositoryApp(input: Parameters<StandaloneRegistry["registerRepositoryApp"]>[0]): ReturnType<StandaloneRegistry["registerRepositoryApp"]>;
     repositoryBuildSource(installationId: string, repository: string): ReturnType<StandaloneRegistry["repositoryBuildSource"]>;
     readRepositoryBuild(installationId: string, repository: string): ReturnType<StandaloneRegistry["readRepositoryBuild"]>;
+    readInstallationBuild(installationId: string, jobId: string): ReturnType<StandaloneRegistry["readInstallationBuild"]>;
     installWorkflowBuild(jobId: string, target: string, release: Release, memberId: string, callerInstallationId: string): ReturnType<StandaloneRegistry["installWorkflowBuild"]>;
 };
 export declare abstract class StandaloneRegistry extends OysterRegistry implements StandaloneRegistryRpc {
@@ -60,6 +61,15 @@ export declare abstract class StandaloneRegistry extends OysterRegistry implemen
         }>[];
         readonly nextOffset: number | null;
     } | ({
+        state: "queued";
+        position: number;
+    } & Disposable) | ({
+        state: "running" | "starting";
+        position?: never | undefined;
+    } & Disposable) | ({
+        state: "running" | "sleeping";
+        position?: never | undefined;
+    } & Disposable) | ({
         state: "running";
     } & Disposable) | {
         error: string;
@@ -169,6 +179,8 @@ export declare abstract class StandaloneRegistry extends OysterRegistry implemen
         appId: import("@fungi.computer/puffball").AppId;
     } | null>;
     readBuild(jobId: string): Promise<OysterBuildView | null>;
+    /** A job ID alone never grants another installation access to its status. */
+    readInstallationBuild(installationId: string, jobId: string): Promise<OysterBuildView | null>;
     /** Repository status belongs to the same captured Git owner as registration. */
     readRepositoryBuild(installationId: string, repository: string): Promise<Readonly<{
         jobId: string;

package/dist/standalone/registry.js

@@ -129,6 +129,15 @@ export class StandaloneRegistry extends OysterRegistry {
                 await this.#fleetStorage.put("selected-computer", input.computerId);
                 return computer;
             }
+            case "state":
+                if (this.#computers.read(input.computerId) === null)
+                    return null;
+                return this.#env.COMPUTER.getByName(input.computerId).readHostedComputerState({
+                    computerId: input.computerId,
+                    actions: new Set(["start"]),
+                    expiresAt: Date.now() + 60_000,
+                    provenance: { actor: memberId },
+                });
             case "start":
                 if (this.#computers.read(input.computerId) === null)
                     return null;
@@ -363,6 +372,15 @@ export class StandaloneRegistry extends OysterRegistry {
     async readBuild(jobId) {
         return (await this.#appBuilds()).read(jobId);
     }
+    /** A job ID alone never grants another installation access to its status. */
+    async readInstallationBuild(installationId, jobId) {
+        const builds = await this.#appBuilds();
+        const build = builds.read(jobId);
+        return build !== null &&
+            sourceOwnedBy(builds.readSource(build.appId), installationId)
+            ? build
+            : null;
+    }
     /** Repository status belongs to the same captured Git owner as registration. */
     async readRepositoryBuild(installationId, repository) {
         const latest = (await this.#appBuilds()).latestRepositoryBuild(installationId, repository);

package/dist/standalone/tenancy.d.ts

@@ -7,12 +7,23 @@ export type StandaloneSeed = Readonly<{
     origin: string;
     owner: Identity;
 }>;
+export type StandaloneSeedRefusal = Readonly<{
+    kind: "refused";
+    code: "seed_configuration_changed";
+    seededOrigin: string;
+    configuredOrigin: string;
+    recovery: "fresh_worker_name_or_reset_worker_data";
+}>;
+export declare class StandaloneSeedConfigurationChanged extends Error {
+    readonly refusal: StandaloneSeedRefusal;
+    constructor(refusal: StandaloneSeedRefusal);
+}
 /** A fresh registry namespace with one host-provisioned standalone tenant. */
 export declare class StandaloneTenants extends TenancyRegistryDO {
     #private;
     constructor(state: DurableObjectState);
     /** Reuse only the exact configured tenant and its current canonical owner. */
-    seed(input: StandaloneSeed): Promise<Tenant>;
+    seed(input: StandaloneSeed): Promise<Tenant | StandaloneSeedRefusal>;
 }
 /** The same trusted bindings are used by HTTP, MCP and cold root readers. */
 export type StandaloneTenancyEnv = Pick<OysterGitWorkerEnv, "OYSTER_ORIGIN" | "OYSTER_OWNER_NAME" | "OYSTER_OWNER_KEY" | "KEYS"> & Readonly<{
@@ -38,5 +49,7 @@ export type StandaloneTenancy = Readonly<{
     oyster: OysterTenancy;
     owner(): Promise<StandaloneOwner | null>;
 }>;
+/** A request may seed the standalone tenant only at its configured origin. */
+export declare function standaloneTenancyForRequest(env: StandaloneTenancyEnv, request: Request): Promise<StandaloneTenancy>;
 /** Seed once per environment, then admit every entry from one fresh registry read. */
 export declare function standaloneTenancy(env: StandaloneTenancyEnv): Promise<StandaloneTenancy>;

package/dist/standalone/tenancy.js

@@ -3,6 +3,7 @@ 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 { HTTPException } from "hono/http-exception";
 import { defaultTenant, tenantScope, } from "../tenant.js";
 import * as Schema from "effect/Schema";
 const seedSchema = Schema.Struct({
@@ -13,6 +14,14 @@ const seedSchema = Schema.Struct({
     }),
 });
 const seedKey = "standalone-owner-seed";
+export class StandaloneSeedConfigurationChanged extends Error {
+    refusal;
+    constructor(refusal) {
+        super("Standalone seed configuration changed");
+        this.name = "StandaloneSeedConfigurationChanged";
+        this.refusal = refusal;
+    }
+}
 /** A fresh registry namespace with one host-provisioned standalone tenant. */
 export class StandaloneTenants extends TenancyRegistryDO {
     #state;
@@ -31,8 +40,15 @@ export class StandaloneTenants extends TenancyRegistryDO {
                 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");
+                    marker.owner.subject !== input.owner.subject) {
+                    return {
+                        kind: "refused",
+                        code: "seed_configuration_changed",
+                        seededOrigin: marker.origin,
+                        configuredOrigin: scope.origin,
+                        recovery: "fresh_worker_name_or_reset_worker_data",
+                    };
+                }
             }
             let tenant = await this.get(defaultTenant);
             if (tenant === null) {
@@ -69,6 +85,22 @@ export class StandaloneTenants extends TenancyRegistryDO {
         });
     }
 }
+/** A request may seed the standalone tenant only at its configured origin. */
+export async function standaloneTenancyForRequest(env, request) {
+    const configuredOrigin = tenantScope(defaultTenant, env.OYSTER_ORIGIN).origin;
+    const requestOrigin = new URL(request.url).origin;
+    if (requestOrigin !== configuredOrigin)
+        throw new HTTPException(404, {
+            res: Response.json({
+                kind: "refused",
+                code: "origin_mismatch",
+                configuredOrigin,
+                requestOrigin,
+                message: `Request origin ${requestOrigin} does not match configured OYSTER_ORIGIN ${configuredOrigin}. Set OYSTER_ORIGIN to this Worker's URL.`,
+            }, { status: 404 }),
+        });
+    return standaloneTenancy(env);
+}
 const environments = new WeakMap();
 /** Seed once per environment, then admit every entry from one fresh registry read. */
 export function standaloneTenancy(env) {
@@ -90,10 +122,12 @@ async function composeTenancy(env) {
         provider: "standalone-owner",
         subject: env.OYSTER_OWNER_NAME ?? "owner",
     };
-    await env.TENANTS.getByName("registry").seed({
+    const seeded = await env.TENANTS.getByName("registry").seed({
         origin: scope.origin,
         owner: identity,
     });
+    if ("kind" in seeded)
+        throw new StandaloneSeedConfigurationChanged(seeded);
     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 ||

package/dist/standalone/worker.js

@@ -5,6 +5,8 @@
  */
 import { createOysterGitWorker, createOysterGitMcpOwner, oysterGitRoot, } from "../workers-git.js";
 import { defaultTenant, tenantScope } from "../tenant.js";
+import { oysterPrincipalIsOwner } from "../host.js";
+import { standaloneComputerControl } from "./computer-control.js";
 import { onBoxVmIngress } from "@fungi.computer/computer";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import { installationWorkerEntrypoint } from "../installation-execution.js";
@@ -17,7 +19,7 @@ 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";
+import { standaloneTenancyForRequest, StandaloneSeedConfigurationChanged, } from "./tenancy.js";
 export { StandaloneTenants } from "./tenancy.js";
 import { standalonePreviewRequest } from "./preview.js";
 import { standaloneMachineLinkRoutes, } from "./machine-link.js";
@@ -25,8 +27,11 @@ export { MachineLinkDO } from "./machine-link.js";
 import { standaloneWorkflowControl } from "./workflow-control.js";
 import { standaloneWorkflowWebhookRoutes, standaloneWorkflowWebhookControls, } from "./workflow-webhooks.js";
 import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
 import { standaloneBuildRoutes } from "./builds.js";
 import { standaloneComputerFleetRoutes, standaloneComputerSelection, } from "./computer-fleet.js";
+import { standaloneAgentComputerRoutes } from "./agent-computers.js";
+import { agentDirectoryForScope } from "./agent-directory.js";
 import { serveOysterComputerEgress, } from "./computer-egress.js";
 import { appSourceOwnerRoutes, } from "./app-source.js";
 export { StandaloneGraphWorkflow } from "./workflows.js";
@@ -59,11 +64,14 @@ export { AgentDirectory } from "./agents.js";
 const standaloneRoot = (selectComputer) => {
     const root = oysterGitRoot({
         tenancy: (env) => ({
-            resolve: async (request) => (await standaloneTenancy(env)).oyster.resolve(request),
+            resolve: async (request) => (await standaloneTenancyForRequest(env, request)).oyster.resolve(request),
         }),
         homeInstallationId: (env) => env.OYSTER_HOME_INSTALLATION,
         agents: standaloneAgents,
         workflows: standaloneWorkflowControl,
+        computerControl: (env, scope) => (principal) => oysterPrincipalIsOwner(principal)
+            ? standaloneComputerControl(tenantRegistry(env, scope), principal.actor.memberId)
+            : null,
         workspace: async (env, keysLive, scope, request) => standaloneWorkspace(env, keysLive, await selectComputer(tenantRegistry(env, scope), request)),
         capabilities: (env, workspace, keysLive) => [
             ...standaloneComputerCapabilities(env, workspace, keysLive),
@@ -96,6 +104,11 @@ const standaloneRoot = (selectComputer) => {
         ownerRoutes: (env, scope) => appSourceOwnerRoutes(env, scope)
             .route("/", standaloneBuildRoutes(() => tenantRegistry(env, scope)))
             .route("/", standaloneComputerFleetRoutes(() => tenantRegistry(env, scope)))
+            .route("/", standaloneAgentComputerRoutes({
+            attach: (principal, command) => agentDirectoryForScope(env, scope).attachComputer(command, principal, scope.tenantId),
+            detach: (principal, command) => agentDirectoryForScope(env, scope).detachComputer(command, principal, scope.tenantId),
+            read: (principal, agentId) => agentDirectoryForScope(env, scope).readAgentComputers(agentId, principal, scope.tenantId),
+        }))
             .route("/", standaloneWorkflowWebhookControls(env, () => root.hostFor(env, scope))),
     });
     return root;
@@ -153,14 +166,21 @@ export class OysterComputerEgress extends WorkerEntrypoint {
         });
     }
 }
+const standaloneWorkerErrorHandler = (error, context) => {
+    if (error instanceof StandaloneSeedConfigurationChanged) {
+        const { refusal } = error;
+        return context.json({
+            ...refusal,
+            message: `Standalone seed/origin mismatch: existing data was seeded for ${refusal.seededOrigin}, but OYSTER_ORIGIN is ${refusal.configuredOrigin}. Deploy under a fresh Worker name or reset this Worker's data.`,
+        }, 409);
+    }
+    if (error instanceof HTTPException)
+        return error.getResponse();
+    console.error(error);
+    return context.text("Internal Server Error", 500);
+};
 export default {
     async fetch(request, env, context) {
-        const path = new URL(request.url).pathname;
-        if (path === "/local/mesh/join" ||
-            new URLPattern({
-                pathname: "/api/teams/:teamId/local/mesh/:deviceId/connect",
-            }).test(request.url))
-            return standaloneMachineLinkRoutes(env).fetch(request);
         const preview = await standalonePreviewRequest(request, env, (computerId) => computerRegistry(env).ownsComputer(computerId), (computerId, signature, port, service) => env.COMPUTER.getByName(computerId).portPreview(signature, port, service));
         if (preview !== null)
             return preview;
@@ -171,6 +191,13 @@ export default {
         if (fetchOyster === undefined)
             throw new Error("Oyster fetch handler is missing");
         return new Hono()
+            .onError(standaloneWorkerErrorHandler)
+            .all("/local/mesh/join", () => standaloneMachineLinkRoutes(env)
+            .onError(standaloneWorkerErrorHandler)
+            .fetch(request, env, context))
+            .all("/api/teams/:teamId/local/mesh/:deviceId/connect", () => standaloneMachineLinkRoutes(env)
+            .onError(standaloneWorkerErrorHandler)
+            .fetch(request, env, context))
             .route("/", standaloneWorkflowWebhookRoutes(env, async (incoming) => {
             const admitted = await oysterRoot.admit(env, incoming);
             return admitted === null
@@ -178,6 +205,6 @@ export default {
                 : oysterRoot.hostFor(env, admitted.scope);
         }))
             .all("*", () => fetchOyster(request, env, context))
-            .fetch(request);
+            .fetch(request, env, context);
     },
 };

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

@@ -72,10 +72,10 @@ export declare const workflowFrameMethods: {
                 readonly input: {
                     readonly [x: string]: S.Json;
                 };
+                readonly requestId: string;
                 readonly bindings: Record<string, string | {
                     kind: "team-source";
                 }>;
-                readonly requestId: string;
                 readonly definition: unknown;
                 readonly delivery?: {
                     readonly agentId: string;
@@ -86,10 +86,10 @@ export declare const workflowFrameMethods: {
                 readonly input: {
                     readonly [x: string]: S.Json;
                 };
+                readonly requestId: string;
                 readonly bindings: Record<string, string | {
                     kind: "team-source";
                 }>;
-                readonly requestId: string;
                 readonly definition: S.Json;
                 readonly published: {
                     workflowId: string;