@fungi.computer/oyster 0.3.2 → 0.4.0

package/dist/machine-link/host.js

@@ -1,51 +1,126 @@
 import { Hono } from "hono";
 import { z } from "zod";
+import * as Schema from "effect/Schema";
 import { correlationKey } from "@fungi.computer/cairn";
-import { createMachineLinkPostChannel, MachineLinkPostUnavailable, machineLinkAudience, } from "@fungi.computer/seam/machine-link-protocol";
+import { createMachineLinkPostChannel, MachineLinkPostUnavailable, machineLinkAudience, machineLinkProtocolVersion, } from "@fungi.computer/seam/machine-link-protocol";
 import { importSeamVerifiers, seamHeader, verifySeamRequest, } from "@fungi.computer/seam";
-import { createLocalBackendReplayStore } from "@fungi.computer/computer";
+import { createPost, definePostRoute, PostDeliveryResultSchema, } from "@fungi.computer/carrier/post";
+import { BirdDogMailSchema } from "@fungi.computer/bird-dog/effect";
+import { machineAgentOperationSchema } from "@fungi.computer/seam/machine-link-protocol";
+import { Watchdog, } from "@fungi.computer/watchdog";
 import { createMachineLinkSockets } from "./presence.js";
 const attachmentSchema = z.strictObject({
     deviceId: z.string().min(1).max(256),
     fenceEpoch: z.int().nonnegative(),
 });
 const maximumInFlight = 32;
+const custodyDeadlineMs = 7 * 24 * 60 * 60 * 1_000;
+const recipientOffline = {
+    status: "accepted",
+    receipt: {
+        status: "held",
+        reason: "recipient_offline",
+        message: "waiting: recipient offline",
+    },
+};
+// Carrier persists the nested application receipt, not the Post result wrapper.
+const custodyReceipt = (status, receipt) => Schema.decodeUnknownSync(PostDeliveryResultSchema)({ status, receipt });
+const previousCustodyReceipt = (existing) => {
+    if (existing.state === "delivered")
+        return existing.receipt === undefined
+            ? "accepted"
+            : custodyReceipt("accepted", existing.receipt);
+    if (existing.state === "dead" && existing.receipt !== undefined)
+        return custodyReceipt("refused", existing.receipt);
+    return recipientOffline;
+};
+const custodyAddress = Schema.Struct({
+    scopeId: Schema.String,
+    agentId: Schema.String,
+});
+const machineAgentEvent = Schema.Struct({
+    actorAgentId: Schema.String,
+    operation: machineAgentOperationSchema,
+});
+const machineMailEnvelope = Schema.Struct({
+    key: Schema.String,
+    kind: Schema.Literal("agentMail"),
+    address: custodyAddress,
+    event: BirdDogMailSchema,
+});
+const machineAgentEnvelope = Schema.Struct({
+    key: Schema.String,
+    kind: Schema.Literal("machineAgent"),
+    address: custodyAddress,
+    event: machineAgentEvent,
+});
 /**
  * Native device socket I/O. Pins/member authority and mail admission are supplied
- * by their existing owners. Native attachments survive hibernation; pending
- * Post I/O does not claim durable custody and is retried by Carrier.
+ * by their existing owners. Native attachments survive hibernation; Carrier
+ * owns durable custody and per-Agent ordering across socket lifetimes.
  */
 export class MachineLinkHost {
     context;
+    owner;
     options;
     channels = new Map();
-    replay;
-    routes;
+    replayRuntime;
+    router;
+    custodyRoutes;
+    deviceId;
+    custodyRuntime;
+    receipts = new Map();
     constructor(context, owner, options) {
         this.context = context;
+        this.owner = owner;
         this.options = options;
-        this.replay = createLocalBackendReplayStore(owner);
+        this.custodyRoutes = {
+            agentMail: definePostRoute({
+                addressKind: "machineLinkAgent",
+                deadlineMs: custodyDeadlineMs,
+                address: custodyAddress,
+                event: BirdDogMailSchema,
+                name: ({ agentId }) => agentId,
+                namespace: {
+                    getByName: () => ({
+                        deliver: (envelope) => this.deliverToSocket(envelope),
+                    }),
+                },
+            }),
+        };
         context.setWebSocketAutoResponse(new WebSocketRequestResponsePair("ping", "pong"));
-        this.routes = new Hono().get("/api/teams/:teamId/local/mesh/:deviceId/connect", async (context) => {
+        this.router = new Hono().get("/api/teams/:teamId/local/mesh/:deviceId/connect", async (context) => {
             if (context.req.param("teamId") !== options.teamId)
                 return context.body(null, 403);
             const request = context.req.raw;
-            if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket")
-                return context.body(null, 426);
             const deviceId = context.req.param("deviceId");
             try {
                 const device = await options.authorize(deviceId);
-                const keyId = await verifySeamRequest(await importSeamVerifiers({ [deviceId]: device.publicKey }), machineLinkAudience(options.teamId, deviceId), request.method, request.url, request.headers.get(seamHeader), null, this.replay);
+                const keyId = await verifySeamRequest(await importSeamVerifiers({ [deviceId]: device.publicKey }), machineLinkAudience(options.teamId, deviceId), request.method, request.url, request.headers.get(seamHeader), null, await this.replayStore());
                 if (keyId !== deviceId)
                     return context.body(null, 403);
+                // Seam verifies the signed path and query before we decide whether
+                // this client speaks the one supported wire contract.
+                const versions = new URL(request.url).searchParams.getAll("version");
+                if (versions.length !== 1 ||
+                    versions[0] !== machineLinkProtocolVersion)
+                    return context.body("upgrade fungi", 426, {
+                        "x-fungi-machine-link-action": "upgrade fungi",
+                    });
+                if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket")
+                    return context.body(null, 426);
                 const pair = new WebSocketPair();
                 pair[1].serializeAttachment({
                     deviceId,
                     fenceEpoch: device.fenceEpoch,
                 });
                 createMachineLinkSockets(this.context, deviceId).accept(pair[1]);
-                await this.publishDirectory(pair[1], deviceId);
-                return new Response(null, { status: 101, webSocket: pair[0] });
+                const response = new Response(null, {
+                    status: 101,
+                    webSocket: pair[0],
+                });
+                this.context.waitUntil(this.connected(pair[1], deviceId));
+                return response;
             }
             catch (cause) {
                 this.options.report("machine-link.dial", cause);
@@ -54,9 +129,21 @@ export class MachineLinkHost {
         });
     }
     fetch(request) {
-        return Promise.resolve(this.routes.fetch(request));
+        return Promise.resolve(this.router.fetch(request));
+    }
+    replayStore() {
+        this.replayRuntime ??= this.options.replay();
+        return this.replayRuntime;
+    }
+    /** Start the fresh socket and then hand durable rows to its live channel. */
+    async connected(socket, deviceId) {
+        this.deviceId = deviceId;
+        await this.publishDirectory(socket, deviceId);
+        await this.releaseCustody();
+        await this.drainCustody();
     }
     async publishDirectory(socket, deviceId) {
+        this.deviceId = deviceId;
         // Ordered before the addressed operation, but its metadata ACK is not a
         // prerequisite for work admission (including the deliberately lost ACK).
         const agents = await this.options.directory();
@@ -109,19 +196,127 @@ export class MachineLinkHost {
         return channel;
     }
     async deliver(deviceId, envelope) {
+        this.deviceId = deviceId;
         await this.options.authorize(deviceId);
         const links = createMachineLinkSockets(this.context, deviceId);
         const socket = this.context
             .getWebSockets(`machine-link:${deviceId}`)
             .find((candidate) => links.isCurrent(candidate));
+        const typedEnvelope = Schema.decodeUnknownSync(Schema.Union([machineMailEnvelope, machineAgentEnvelope]))(envelope);
+        if (typedEnvelope.kind === "machineAgent")
+            return await this.deliverLiveOperation(deviceId, socket, typedEnvelope);
+        return await this.deliverCustodyMail(deviceId, socket, typedEnvelope);
+    }
+    async deliverLiveOperation(deviceId, socket, envelope) {
         if (socket === undefined)
             throw new MachineLinkPostUnavailable({ reason: "closed" });
         await this.publishDirectory(socket, deviceId);
         return await this.channel(socket, deviceId).deliver(envelope);
     }
+    async deliverCustodyMail(deviceId, socket, envelope) {
+        const { post } = await this.custody();
+        const existing = post.read(envelope.key);
+        if (existing !== undefined) {
+            this.owner.transactionSync(() => {
+                post.send(envelope);
+            });
+            return previousCustodyReceipt(existing);
+        }
+        this.owner.transactionSync(() => {
+            post.send(envelope);
+        });
+        await this.options.scheduleWake(post.nextWake() ?? Date.now());
+        if (socket === undefined)
+            return recipientOffline;
+        await this.publishDirectory(socket, deviceId);
+        await this.drainCustody();
+        const receipt = this.receipts.get(envelope.key);
+        this.receipts.delete(envelope.key);
+        return receipt ?? recipientOffline;
+    }
+    /** Run due Carrier work; expired rows remain visible as Carrier dead letters. */
+    async alarm() {
+        await this.drainCustody();
+    }
+    /** Expose terminal custody rows so S9 can stage its own disposition reply. */
+    async deadLetters(afterKey) {
+        const { post } = await this.custody();
+        return post.deadLetters(64, afterKey);
+    }
+    async deliverToSocket(envelope) {
+        const deviceId = this.deviceId;
+        if (deviceId === undefined)
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        const links = createMachineLinkSockets(this.context, deviceId);
+        const socket = this.context
+            .getWebSockets(`machine-link:${deviceId}`)
+            .find((candidate) => links.isCurrent(candidate));
+        if (socket === undefined)
+            throw new MachineLinkPostUnavailable({ reason: "closed" });
+        const result = await this.channel(socket, deviceId).deliver(envelope);
+        this.receipts.set(envelope.key, result);
+        return result;
+    }
+    async custody() {
+        this.custodyRuntime ??= this.createCustody();
+        return await this.custodyRuntime;
+    }
+    async createCustody() {
+        const postRef = { current: undefined };
+        const watchdog = await Watchdog.make({
+            owner: this.owner,
+            isAlive: () => Promise.resolve(false),
+            execute: (job) => {
+                const post = postRef.current;
+                if (post === undefined)
+                    throw new Error("Carrier Post runtime is not initialized");
+                return post.execute(job);
+            },
+            wake: {
+                recompute: async () => {
+                    const at = postRef.current?.nextWake();
+                    if (at !== null && at !== undefined)
+                        await this.options.scheduleWake(at);
+                },
+            },
+        });
+        const post = createPost({
+            routes: this.custodyRoutes,
+            owner: this.owner,
+            transactional: watchdog.transactional,
+            readJob: watchdog.read,
+            now: Date.now,
+            scheduleWake: this.options.scheduleWake,
+        });
+        postRef.current = post;
+        return { post, watchdog };
+    }
+    async releaseCustody() {
+        const { post } = await this.custody();
+        let cursor;
+        do {
+            cursor = await post.releaseNow(64, cursor);
+        } while (cursor !== undefined);
+    }
+    async drainCustody() {
+        const { post, watchdog } = await this.custody();
+        let cursor;
+        do {
+            cursor = await post.enqueueDue(64, cursor);
+        } while (cursor !== undefined);
+        for (let count = 0; count < 64; count += 1) {
+            const tick = await watchdog.tick();
+            if (tick.status !== "settled")
+                break;
+        }
+        const at = post.nextWake();
+        if (at !== null)
+            await this.options.scheduleWake(at);
+    }
     async message(socket, message) {
         try {
             const { deviceId } = attachmentSchema.parse(socket.deserializeAttachment());
+            this.deviceId = deviceId;
             if (!createMachineLinkSockets(this.context, deviceId).isCurrent(socket)) {
                 socket.close(4001, "replaced");
                 return;

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

@@ -5,7 +5,7 @@ import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
 import { type MachineLinkAuthority, type MachineLinkCaller, type MachineLinkFenceFact, type MachineLinkFenceResult, type MachineLinkIdentity } from "./authority.js";
 /** The Durable Object state a machine link needs from its host class. */
 export type MachineLinkState = Pick<DurableObjectState, "getWebSockets" | "acceptWebSocket" | "setWebSocketAutoResponse" | "waitUntil"> & Readonly<{
-    storage: WatchdogSqliteOwner & Pick<DurableObjectStorage, "get" | "put">;
+    storage: WatchdogSqliteOwner & Pick<DurableObjectStorage, "get" | "put" | "setAlarm">;
 }>;
 /** The host's own storage erasure, so readback matches its other owners. */
 export type MachineLinkStorageErasure<Readback> = Readonly<{
@@ -41,6 +41,18 @@ export declare function createMachineLink<Readback>(state: MachineLinkState, opt
     preflightErasure: (teamId: string, deviceId: string) => Promise<void>;
     eraseForTeam(teamId: string, deviceId: string): Promise<Readback>;
     readErasure: () => Promise<Readback>;
+    /** Carrier terminal rows, including expired custody, remain observable for S9. */
+    deadLetters(input: MachineLinkIdentity, afterKey?: string): Promise<Readonly<{
+        letters: readonly Readonly<{
+            key: string;
+            reason: "refused" | "exhausted" | "expired";
+            envelope: PostEnvelope;
+            attempts: number;
+        }>[];
+        nextCursor: string | undefined;
+    }>>;
+    /** Reconcile durable Carrier custody after a DO alarm or physical restart. */
+    alarm(): Promise<void>;
     webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): Promise<void>;
     webSocketClose(socket: WebSocket, code: number, reason: string): void;
     webSocketError(socket: WebSocket): void;

package/dist/machine-link/link.js

@@ -6,7 +6,6 @@ import { agentMailAddressSchema, machineAgentOperationSchema, MachineLinkPostUna
 import { machineLinkFenceFactSchema, machineLinkIdentitySchema, machineLinkName, MachineLinkRefused, } from "./authority.js";
 import { MachineLinkHost } from "./host.js";
 const pinKey = "machine-link:identity";
-const maximumMailBytes = 256 * 1024;
 /**
  * One device's link inside its own Durable Object. The host's DO class
  * delegates every entry point here. Identity is pinned on the first live
@@ -16,6 +15,11 @@ const maximumMailBytes = 256 * 1024;
 export function createMachineLink(state, options) {
     const { authority } = options;
     let host;
+    let replayStore;
+    const openReplayStore = () => {
+        replayStore ??= import("@fungi.computer/computer").then(({ createLocalBackendReplayStore }) => createLocalBackendReplayStore(state.storage));
+        return replayStore;
+    };
     const match = (identity) => {
         if (!options.addressed(identity))
             throw new MachineLinkRefused("actor_not_allowed");
@@ -98,9 +102,7 @@ export function createMachineLink(state, options) {
         const target = await checkedTarget(identity, caller, address.agentId, null);
         if (envelope.key !== body.key ||
             address.scopeId !== target.teamId ||
-            address.agentId !== body.to.agentId ||
-            new TextEncoder().encode(JSON.stringify(body)).byteLength >
-                maximumMailBytes)
+            address.agentId !== body.to.agentId)
             return "refused";
         return await authority.deliverHome(identity, caller, target, envelope);
     };
@@ -113,8 +115,10 @@ export function createMachineLink(state, options) {
                     throw new MachineLinkRefused("actor_not_allowed");
                 return await current(identity);
             },
+            replay: openReplayStore,
             directory: () => authority.directory(identity),
             receive: (_device, envelope) => receive(identity, envelope),
+            scheduleWake: (at) => state.storage.setAlarm(at),
             report: options.report,
         }));
     };
@@ -151,9 +155,7 @@ export function createMachineLink(state, options) {
                 address.scopeId !== facts.teamId ||
                 address.agentId !== facts.targetAgentId ||
                 body.to.agentId !== facts.targetAgentId ||
-                body.from.agentId !== facts.callerAgentId ||
-                new TextEncoder().encode(JSON.stringify(body)).byteLength >
-                    maximumMailBytes)
+                body.from.agentId !== facts.callerAgentId)
                 return "refused";
             return await hostFor(device).deliver(device.deviceId, envelope);
         },
@@ -203,6 +205,17 @@ export function createMachineLink(state, options) {
             return await options.erasure.erase();
         },
         readErasure: () => options.erasure.read(),
+        /** Carrier terminal rows, including expired custody, remain observable for S9. */
+        async deadLetters(input, afterKey) {
+            const device = await current(input);
+            return await hostFor(device).deadLetters(afterKey);
+        },
+        /** Reconcile durable Carrier custody after a DO alarm or physical restart. */
+        async alarm() {
+            const identity = await savedIdentity();
+            if (identity !== null)
+                await hostFor(identity).alarm();
+        },
         async webSocketMessage(socket, message) {
             const identity = await savedIdentity();
             if (identity === null) {

package/dist/mcp.d.ts

@@ -1,7 +1,12 @@
+import { z } from "zod";
 import { type AppToolPolicy } from "./apps/tools.js";
 import type { DeclaredOperations, Installation } from "./apps/installation.js";
 import { type CapabilitySource, type Grants, type ModuleRegistration } from "@fungi.computer/mycelium";
 import { appToolSchemas } from "@fungi.computer/forage";
+import { computerPageSchema } from "@fungi.computer/computer/fleet/inventory-wire";
+import type { InvocationContext } from "@fungi.computer/mycelium";
+import type { ComputerControlPort } from "./computer-control-port.js";
+export type { ComputerControlPort } from "./computer-control-port.js";
 import type { OysterHost, OysterPrincipal } from "./host.js";
 import type { TenantPrincipal } from "./tenant.js";
 import { type VerifiedRelease } from "./release.js";
@@ -12,6 +17,135 @@ export type OysterMcpCatalogSnapshot = Readonly<{
     /** An omitted module has no grant. */
     grants: Grants;
 }>;
+declare const fleetComputerId: z.ZodObject<{
+    computerId: z.ZodString;
+}, z.core.$strict>;
+declare const fleetCreate: z.ZodObject<{
+    name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    requestId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+declare const fleetCreation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"created">;
+    requestId: z.ZodString;
+    computer: z.ZodObject<{
+        computerId: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        denied: "denied";
+        uncertain: "uncertain";
+        conflict: "conflict";
+        invalid: "invalid";
+    }>;
+    requestId: z.ZodString;
+}, z.core.$strict>], "kind">;
+/** One set of schemas and operations for MCP and direct broker invocation. */
+export declare function computerControlSpecs(port: ComputerControlPort): {
+    list: {
+        replay: "safe";
+        access: "read";
+        description: string;
+        input: z.ZodObject<{
+            limit: z.ZodDefault<z.ZodNumber>;
+            offset: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+        output: z.ZodObject<{
+            computers: z.ZodArray<z.ZodObject<{
+                computerId: z.ZodString;
+                name: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strict>>;
+            nextOffset: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>;
+        /** Return an admitted inventory page to MCP or the retained broker. */
+        execute: (input: z.output<typeof computerPageSchema>, context: InvocationContext) => Promise<{
+            computers: {
+                computerId: string;
+                name: string;
+                createdAt: number;
+                updatedAt: number;
+            }[];
+            nextOffset: number | null;
+        }>;
+    };
+    state: {
+        replay: "safe";
+        access: "read";
+        description: string;
+        input: z.ZodObject<{
+            computerId: z.ZodString;
+        }, z.core.$strict>;
+        output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodEnum<{
+                running: "running";
+                sleeping: "sleeping";
+                starting: "starting";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"queued">;
+            position: z.ZodNumber;
+        }, z.core.$strict>], "state">;
+        /** Return liveness without waking the runtime. */
+        execute: (input: z.output<typeof fleetComputerId>, context: InvocationContext) => Promise<{
+            state: "running" | "sleeping" | "starting";
+        } | {
+            state: "queued";
+            position: number;
+        }>;
+    };
+    start: {
+        replay: "unsafe";
+        description: string;
+        input: z.ZodObject<{
+            computerId: z.ZodString;
+        }, z.core.$strict>;
+        output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodEnum<{
+                running: "running";
+                sleeping: "sleeping";
+                starting: "starting";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            state: z.ZodLiteral<"queued">;
+            position: z.ZodNumber;
+        }, z.core.$strict>], "state">;
+        /** Admit and start this Computer. */
+        execute: (input: z.output<typeof fleetComputerId>, context: InvocationContext) => Promise<{
+            state: "running" | "sleeping" | "starting";
+        } | {
+            state: "queued";
+            position: number;
+        }>;
+    };
+    create: {
+        replay: "unsafe";
+        description: string;
+        input: z.ZodObject<{
+            name: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            requestId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>;
+        output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"created">;
+            requestId: z.ZodString;
+            computer: z.ZodObject<{
+                computerId: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                denied: "denied";
+                uncertain: "uncertain";
+                conflict: "conflict";
+                invalid: "invalid";
+            }>;
+            requestId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        /** Mint one identity or preserve the requestId for an uncertain retry. */
+        execute: (input: z.output<typeof fleetCreate>, context: InvocationContext) => Promise<z.output<typeof fleetCreation>>;
+    };
+};
 /** An installation ID as a guest binding name: `spawn-git` becomes `SPAWN_GIT`. */
 export declare function appBindingName(installationId: string): string;
 /** Why an App method call from the MCP catalog was refused. */
@@ -86,9 +220,9 @@ export declare function oysterAppMethods(host: Pick<OysterHost, "installations"
 }>;
 /**
  * Capture the host's fixed Computer for one caller as a Knapsack source.
- * The host decides whether the caller holds Computer access; the Computer
- * owner accepts every call. Null when the host has no Computer or the caller
- * has no access. Grants name exactly the one captured module.
+ * The host decides whether the caller holds Computer access; the ComputerDO
+ * still checks its host-issued grant on every call. Null when the host has no
+ * Computer or the caller has no access. Grants name the captured module.
  */
 export declare function oysterComputerTools(host: Pick<OysterHost, "computerId" | "computer">, principal: OysterPrincipal): Promise<(CapabilitySource & {
     readonly grants: Grants;
@@ -98,11 +232,11 @@ export declare function oysterComputerTools(host: Pick<OysterHost, "computerId"
  * methods, plus the host's Computer when the caller holds Computer access.
  * A key sees exactly the installations and levels its own grants admit, and
  * the Computer only with its own `computer.use` grant; each App retains its
- * own caller checks regardless. The owner's stored write approval of an
- * Agent's App tools is that principal's confirmation for App writes, so a
- * headless client can write; the shared MCP server asks the client to
- * approve every other write (an owner's own calls, the Computer). Each call
- * still re-admits the key, rechecks that same stored approval, and passes
- * the App's gate.
+ * own caller checks regardless. App writes use the host's approval record;
+ * stored approval of an Agent's App tools can permit headless App writes.
+ * The shared MCP server elicits consent for explicitly confirmed operations,
+ * including every advertised Workspace Computer call, even reads. Each call
+ * still re-admits the key, checks current App approval and passes the App's
+ * gate.
  */
-export declare function oysterMcpCatalogLoad(host: Pick<OysterHost, "installations" | "instances" | "artifacts" | "guestLimits" | "backgroundOriginKey" | "computerId" | "computer" | "capabilities" | "appToolPolicy" | "keys" | "workflows">): (principal: TenantPrincipal) => Promise<OysterMcpCatalogSnapshot>;
+export declare function oysterMcpCatalogLoad(host: Pick<OysterHost, "installations" | "instances" | "artifacts" | "guestLimits" | "backgroundOriginKey" | "computerId" | "computer" | "computerControl" | "capabilities" | "appToolPolicy" | "keys" | "workflows">): (principal: TenantPrincipal) => Promise<OysterMcpCatalogSnapshot>;