@fungi.computer/oyster 0.6.0 → 0.8.0

package/dist/standalone/agents.js

@@ -2,12 +2,11 @@ import { isRetryableProviderRejection, normalizeModel, observeProviderStatus, st
 import { standaloneTenancy, } from "./tenancy.js";
 import { AcceptedSchema } from "@fungi.computer/shiitake/client";
 import { createShiitakeClient } from "@fungi.computer/shiitake/client";
-import { AgentCreateRefused, } from "@fungi.computer/shiitake/agent-control";
+import { ShiitakeError } from "@fungi.computer/shiitake";
+import { AgentArchiveRefused, AgentCreateRefused, } from "@fungi.computer/shiitake/agent-control";
 import { AgentDelegation, AgentDisclosureRefused, machineAgentCodecs, } from "@fungi.computer/shiitake/delegation";
 import { FungiMessageMetaSchema } from "@fungi.computer/agar/agents";
 import { agentMail } from "./agent-mail.js";
-import { createChannelConversations, } from "../channels/conversations.js";
-import { channelSessionDoor } from "./channel-session-door.js";
 import { createStandaloneMachineEnrollment, standaloneMachineAgentHome, standaloneMachineLinkAuthority, } from "./machine-link.js";
 import { createMachineLinkFences, MachineEnrollmentRefused, MachineLinkRefused, createMachineAgentClient, } from "../machine-link/index.js";
 import { memberInboxItemSchema } from "@fungi.computer/puffball/inbox";
@@ -28,6 +27,8 @@ import { homeContract } from "@fungi.computer/shiitake-extensions/home";
 import { DurableObject } from "cloudflare:workers";
 import { ShiitakeDO } from "@fungi.computer/shiitake/cloudflare";
 import { agentStoreKeeping } from "./agent-store.js";
+import { agentArchiveOwner } from "./agent-archive-owner.js";
+import { agentArchiveProjection } from "../agent-archive-projection.js";
 import { standaloneBrowserSource } from "./browser.js";
 import { configuredProviderEgress, providerFetch, } from "@fungi.computer/veil/gatekeeper";
 import { createAssistantMessageEventStream } from "@earendil-works/pi-ai/utils/event-stream";
@@ -38,13 +39,18 @@ import * as Schema from "effect/Schema";
 import { z } from "zod";
 import {} from "../cloudflare.js";
 import { AppInstanceError } from "../index.js";
+import { agentScheduleBindingArgs, appAgentScheduleListInputSchema, agentSchedulePageSchema, agentScheduleControlReceiptSchema, } from "../agent-schedules.js";
+import { readAgentSchedulePage, controlAgentSchedule, } from "@fungi.computer/shiitake-extensions/schedules/client";
+import { agentScheduleTargetSchema } from "@fungi.computer/shiitake-extensions/schedules";
 import { createAgentAvatarStore, } from "../agent-avatars.js";
 import { defineIdFamily } from "@fungi.computer/cairn";
 import { agentIds, createAgentDirectory, createFleetSessions, commandSettlementSchema, DirectoryError, } from "@fungi.computer/shiitake/fleet";
 import { appToolPolicySchema } from "../apps/index.js";
-import { oysterPrincipalIsOwner, oysterPrincipalId, } from "../host.js";
+import { oysterPrincipalId } from "../host.js";
+import { oysterPrincipalIsOwner } from "../authorization.js";
 import { defaultTenant, tenantIdSchema, tenantScope, } from "../tenant.js";
 import { createCodemodeSandbox } from "@fungi.computer/mycelium/workers";
+import { forageDiscoveryInstructions } from "@fungi.computer/mycelium/effect";
 import { maxAgentMcpServers, } from "../agents.js";
 /** Own transport evidence and exact-message decisions for one model lease. */
 function observedModels(model, defaults) {
@@ -219,6 +225,7 @@ const toMcpServer = (stored) => ({
     hasBearer: stored.bearer !== null,
 });
 const instructions = [
+    forageDiscoveryInstructions,
     "Attached Computers are independent env.computers.<name> modules, including their Files and execute operations; no App is needed. Discover their exact operations before calling.",
     "You are an agent on a personal Oyster: a small, self-hosted home for Apps.",
     "Your tool is execute: it runs JavaScript in an isolated sandbox. Each installed App is an env.<APP> module; dotted method names are nested properties, e.g. `return await env.BONSAI.repos.list({})`.",
@@ -229,22 +236,29 @@ const instructions = [
 ].join("\n");
 /** One agent: Shiitake's Cloudflare host over this Durable Object; its root supplies `hostFor`. */
 export class StandaloneAgentBase extends ShiitakeDO {
-    /**
-     * Compose Oyster's channel owner on this Agent's real store and Shiitake.
-     * A host must supply its own binding lookup after authenticating its edge;
-     * this does not install an inbound route or mint provider credentials.
-     */
-    channelConversations(binding) {
-        const owner = createChannelConversations({
-            sql: this.ctx.storage.sql,
-            transactionSync: (body) => this.ctx.storage.transactionSync(body),
-            binding,
-            door: channelSessionDoor(() => this.shiitake(), () => {
-                // Standalone Agents have no Hub Team grants to deliver.
-            }, () => owner),
-            now: () => Date.now(),
-        });
-        return owner;
+    archiveControlOwner;
+    archiveControl() {
+        return (this.archiveControlOwner ??= agentArchiveOwner({
+            storage: this.ctx.storage,
+            agentId: () => this.ctx.id.name,
+            agent: () => this.shiitake(),
+            scheduledExtensions: true,
+            refreshOutstanding: (agentId) => this.delegation().refreshOutstanding((target, sessionId, commandId) => this.machineClient().then((client) => client.settlement(target, sessionId, commandId, agentId))),
+            record: async (agentId, archived, revision) => {
+                const pin = await this.policyDirectory();
+                if (pin === null)
+                    return false;
+                return this.env.AGENT_DIRECTORY.getByName(pin.directoryName).recordArchive(agentId, archived, revision);
+            },
+            wake: () => this.wakeRuntime(),
+            waitUntil: (task) => {
+                this.ctx.waitUntil(task);
+            },
+        }));
+    }
+    /** Owner-local atomic transition. The caller checks human/creator authority. */
+    setArchived(archived) {
+        return this.archiveControl().setArchived(archived);
     }
     /** Each installed Release's verified catalog surface, built once per Release for this Agent's lifetime. */
     #appSurfaces;
@@ -389,17 +403,40 @@ export class StandaloneAgentBase extends ShiitakeDO {
         }
     }
     controlDirectory() {
-        const list = async (signal) => {
+        const list = async (signal, options) => {
             signal.throwIfAborted();
             const pin = await this.policyDirectory();
             if (pin === null)
                 throw new Error("Agent directory is unavailable");
-            const agents = await this.env.AGENT_DIRECTORY.getByName(pin.directoryName).list();
-            if (!agents.some((agent) => agent.agentId === this.ctx.id.name))
+            const directory = this.env.AGENT_DIRECTORY.getByName(pin.directoryName);
+            const agents = await directory.list(options);
+            if (this.ctx.id.name === undefined ||
+                !(await directory.has(this.ctx.id.name)))
                 throw new Error("Agent is outside this scope");
             signal.throwIfAborted();
             return agents;
         };
+        const changeArchive = async (targetId, archived, signal) => {
+            await list(signal);
+            const caller = this.ctx.id.name;
+            const pin = await this.policyDirectory();
+            if (caller === undefined || pin === null)
+                throw new AgentArchiveRefused("unreadable", "Agent scope is unavailable");
+            if (targetId === caller)
+                throw new AgentArchiveRefused("self", "An Agent cannot archive or restore itself");
+            const directory = this.env.AGENT_DIRECTORY.getByName(pin.directoryName);
+            if ((await directory.createdBy(targetId)) !== caller)
+                throw new AgentArchiveRefused("not_creator", "An Agent can change only one it created");
+            const target = this.env.AGENTS.getByName(targetId);
+            const targetPin = await target.policyDirectory();
+            if (targetPin?.directoryName !== pin.directoryName ||
+                targetPin.tenantId !== pin.tenantId)
+                throw new AgentArchiveRefused("unreadable", "Agent archive scope does not match");
+            signal.throwIfAborted();
+            const result = await target.setArchived(archived);
+            if ("error" in result)
+                throw new AgentArchiveRefused(result.error, result.message ?? `Agent archive refused: ${result.error}`);
+        };
         return {
             list,
             create: async (input, signal) => {
@@ -420,10 +457,17 @@ export class StandaloneAgentBase extends ShiitakeDO {
             },
             send: (input, sessionId, signal, invocation) => this.delegation().send(input, sessionId, signal, invocation),
             recall: (input, sessionId, signal) => this.delegation().recall(input, sessionId, signal),
+            archive: (input, signal) => changeArchive(input.agentId, true, signal),
+            unarchive: (input, signal) => changeArchive(input.agentId, false, signal),
             open: async (agentId, signal) => {
                 const admit = async () => {
-                    if (!(await list(signal)).some((agent) => agent.agentId === agentId))
+                    if (!(await list(signal)).some((agent) => agent.agentId === agentId)) {
+                        const pin = await this.policyDirectory();
+                        if (pin !== null &&
+                            (await this.env.AGENT_DIRECTORY.getByName(pin.directoryName).archived(agentId)))
+                            throw new ShiitakeError("contract", "archived", "Agent is archived");
                         throw new Error("Agent is outside this scope");
+                    }
                 };
                 await admit();
                 const agent = createShiitakeClient({
@@ -454,7 +498,19 @@ export class StandaloneAgentBase extends ShiitakeDO {
                     ? null
                     : { scopeId: pin.directoryName, agentId };
             },
-            directory: () => this.controlDirectory(),
+            // Delegation custody and settlement still see archived identities;
+            // Agent-control discovery keeps its active-only default. New sends
+            // reach the recipient's admission door and get contract/archived.
+            directory: () => {
+                const control = this.controlDirectory();
+                return {
+                    ...control,
+                    list: async (signal) => [
+                        ...(await control.list(signal)),
+                        ...(await control.list(signal, { archived: true })),
+                    ],
+                };
+            },
             deliver: (mail) => this.mail().deliver(mail),
             prepare: () => Promise.resolve(),
             stageAcceptedNotice: (mail, scopeId) => {
@@ -632,6 +688,28 @@ export class StandaloneAgentBase extends ShiitakeDO {
             ? null
             : Schema.decodeUnknownSync(policyDirectorySchema)(stored);
     }
+    /** Borrow the native owner only after matching its real initialization pin. */
+    async scheduleOwner(expected, agentId) {
+        const directory = Schema.decodeUnknownSync(policyDirectorySchema)(expected);
+        const pin = await this.policyDirectory();
+        if (agentId !== this.ctx.id.name ||
+            pin?.directoryName !== directory.directoryName ||
+            pin.tenantId !== directory.tenantId)
+            throw new AppInstanceError("revoked");
+        return this.shiitake();
+    }
+    /** One admitted Agent's bounded native schedule page; this is not a directory scan. */
+    async readSchedules(directory, input) {
+        const { agentId, ...page } = appAgentScheduleListInputSchema.parse(input);
+        const owner = await this.scheduleOwner(directory, agentId);
+        return readAgentSchedulePage(agentId, owner, page);
+    }
+    /** Manage authority returns native identity/state only, never schedule content. */
+    async controlSchedule(directory, input, action) {
+        const target = agentScheduleTargetSchema.parse(input);
+        const owner = await this.scheduleOwner(directory, target.agentId);
+        return controlAgentSchedule(owner, target, action);
+    }
     /** Listeners from live codemode acquisitions, told when the server list changes. */
     mcpInvalidations = new Set();
     async storedMcpServers() {
@@ -697,7 +775,13 @@ export class StandaloneAgentBase extends ShiitakeDO {
             meta: { schema: FungiMessageMetaSchema },
             ...this.mail().host,
             instructions: {
-                load: () => Promise.resolve({ revision: "oyster-5", text: instructions }),
+                load: async () => {
+                    const { appApprovalInstructions } = await import("../mcp.js");
+                    return {
+                        revision: "oyster-7",
+                        text: instructions + "\n" + appApprovalInstructions,
+                    };
+                },
             },
             tools: {
                 sources: [
@@ -777,7 +861,16 @@ export class StandaloneAgentBase extends ShiitakeDO {
                 grants: [...extensions.grants, homeGrant],
             },
             ...keeping,
-            hostWork: [...this.mail().host.hostWork, ...keeping.hostWork],
+            admission: {
+                assertOpen: () => {
+                    this.archiveControl().assertOpen();
+                },
+            },
+            hostWork: [
+                ...this.mail().host.hostWork,
+                ...keeping.hostWork,
+                this.archiveControl().work,
+            ],
         };
     }
     /** Send an installation-admitted message through fleet Session operations. */
@@ -841,6 +934,27 @@ const visitRow = Schema.Struct({
 const counterRow = Schema.Struct({ value: Schema.Number });
 /** Names this Oyster's agents and remembers which Sessions the member opened. */
 export class AgentDirectory extends DurableObject {
+    archiveProjectionOwner;
+    archiveProjection() {
+        return (this.archiveProjectionOwner ??= agentArchiveProjection(this.ctx.storage.sql));
+    }
+    /** Apply the Agent DO's revisioned fact; an older repair cannot undo a newer one. */
+    recordArchive(agentId, archived, revision) {
+        const projection = this.archiveProjection();
+        return this.ctx.storage.transactionSync(() => {
+            if (!this.has(agentId))
+                return false;
+            const result = projection.record(agentId, archived, revision);
+            if (result === "advanced")
+                this.bump();
+            // A replay after projection but before the Agent's ack still succeeds.
+            return result !== "stale";
+        });
+    }
+    /** Directory's bounded-stale projection, never the Agent's flag authority. */
+    archived(agentId) {
+        return this.archiveProjection().archived(agentId);
+    }
     computers;
     computerNames = new Map();
     directory;
@@ -1172,10 +1286,14 @@ export class AgentDirectory extends DurableObject {
             provenance: { actor: oysterPrincipalId(owner), via: captured.agentId },
         };
     }
-    list() {
+    list(options) {
+        const archived = this.archiveProjection().archivedIds();
         return this.directory
             .list(this.grant())
             .toReversed()
+            .filter(({ agentId }) => options?.archived === true
+            ? archived.has(agentId)
+            : !archived.has(agentId))
             .map(({ agentId, name, createdBy }) => ({
             agentId,
             createdBy,
@@ -1191,6 +1309,13 @@ export class AgentDirectory extends DurableObject {
     readCreator(agentId) {
         return this.directory.readCreator(this.grant(), agentId);
     }
+    /** Immutable creating Agent, distinct from the human credential owner. */
+    createdBy(agentId) {
+        const id = agentIds.agent.parse(agentId);
+        return id.ok
+            ? (this.directory.read(this.grant(), id.value)?.createdBy ?? null)
+            : null;
+    }
     /** Owner-only rename; refuses a name already held by another Agent. */
     rename(agentId, name, principal) {
         if (!oysterPrincipalIsOwner(principal))
@@ -1453,7 +1578,19 @@ export function standaloneAgents(env, scope) {
         sessionOperations: everyOperation,
     });
     return {
-        list: async () => (await directory().list()).map(toAgent),
+        list: async (options) => (await directory().list(options)).map(toAgent),
+        setArchived: async (agentId, archived, principal) => {
+            if (!oysterPrincipalIsOwner(principal))
+                return { error: "not_granted" };
+            if (!(await directory().has(agentId)))
+                return { error: "not_found" };
+            const agent = env.AGENTS.getByName(agentId);
+            const pin = await agent.policyDirectory();
+            if (pin?.directoryName !== directoryName ||
+                pin.tenantId !== (scope?.tenantId ?? defaultTenant))
+                return { error: "not_found" };
+            return agent.setArchived(archived);
+        },
         create: async (name, requestId, principal, actor, avatar) => {
             const entry = await directory().create(name, requestId, principal, actor, avatar);
             await env.AGENTS.getByName(entry.agentId).usePolicyDirectory({
@@ -1624,10 +1761,58 @@ export const agentFrameMethods = {
         },
     },
     AGENTS: {
+        schedules: {
+            decodeArgs: (raw) => agentScheduleBindingArgs.schedules.parse(raw),
+            decodeResult: Schema.decodeUnknownSync(agentSchedulePageSchema, {
+                onExcessProperty: "error",
+            }),
+            requiredOperations: () => ["schedules"],
+            requestedResource: (raw) => ({
+                kind: "agent",
+                id: agentScheduleBindingArgs.schedules.parse(raw)[0].agentId,
+            }),
+        },
+        pauseSchedule: {
+            decodeArgs: (raw) => agentScheduleBindingArgs.pauseSchedule.parse(raw),
+            decodeResult: Schema.decodeUnknownSync(agentScheduleControlReceiptSchema, {
+                onExcessProperty: "error",
+            }),
+            requiredOperations: () => ["pauseSchedule"],
+            requestedResource: (raw) => ({
+                kind: "agent",
+                id: agentScheduleBindingArgs.pauseSchedule.parse(raw)[0].agentId,
+            }),
+        },
+        resumeSchedule: {
+            decodeArgs: (raw) => agentScheduleBindingArgs.resumeSchedule.parse(raw),
+            decodeResult: Schema.decodeUnknownSync(agentScheduleControlReceiptSchema, {
+                onExcessProperty: "error",
+            }),
+            requiredOperations: () => ["resumeSchedule"],
+            requestedResource: (raw) => ({
+                kind: "agent",
+                id: agentScheduleBindingArgs.resumeSchedule.parse(raw)[0].agentId,
+            }),
+        },
+        deleteSchedule: {
+            decodeArgs: (raw) => agentScheduleBindingArgs.deleteSchedule.parse(raw),
+            decodeResult: Schema.decodeUnknownSync(agentScheduleControlReceiptSchema, {
+                onExcessProperty: "error",
+            }),
+            requiredOperations: () => ["deleteSchedule"],
+            requestedResource: (raw) => ({
+                kind: "agent",
+                id: agentScheduleBindingArgs.deleteSchedule.parse(raw)[0].agentId,
+            }),
+        },
         send: {
             decodeArgs: (raw) => agentBindingArgs.AGENTS.send.parse(raw),
             decodeResult: decodeAgentAccepted,
             requiredOperations: () => ["send"],
+            requestedResource: (raw) => ({
+                kind: "agent",
+                id: agentBindingArgs.AGENTS.send.parse(raw)[0].agentId,
+            }),
         },
     },
 };
@@ -1669,9 +1854,45 @@ export async function dispatchAgentBinding(env, scope, frame, props, method, arg
         });
         result = { status: accepted.status, commandId: accepted.commandId };
     }
+    else if (props.binding === "AGENTS" &&
+        (method === "schedules" ||
+            method === "pauseSchedule" ||
+            method === "resumeSchedule" ||
+            method === "deleteSchedule")) {
+        const [input] = agentScheduleBindingArgs[method].parse(args);
+        if (!(await directory.has(input.agentId)))
+            throw new Error("No such agent");
+        const home = await directory.agentHome(input.agentId);
+        if (home?.kind === "machine")
+            throw new MachineLinkRefused("actor_not_allowed");
+        if (home === null)
+            throw new AppInstanceError("revoked");
+        frame.signal.throwIfAborted();
+        const agent = env.AGENTS.getByName(input.agentId);
+        const pin = {
+            directoryName: scope.durableName("agents"),
+            tenantId: scope.tenantId,
+        };
+        if (method === "schedules") {
+            result = await agent.readSchedules(pin, agentScheduleBindingArgs.schedules.parse(args)[0]);
+        }
+        else {
+            result = await agent.controlSchedule(pin, agentScheduleBindingArgs[method].parse(args)[0], method === "pauseSchedule"
+                ? "pause"
+                : method === "resumeSchedule"
+                    ? "resume"
+                    : "delete");
+        }
+    }
     else {
         throw new AppInstanceError("revoked");
     }
     frame.signal.throwIfAborted();
-    return Schema.decodeUnknownSync(Schema.Union([inboxPageSchema, inboxVisitSchema, AcceptedSchema]), { onExcessProperty: "error" })(result);
+    return Schema.decodeUnknownSync(Schema.Union([
+        inboxPageSchema,
+        inboxVisitSchema,
+        AcceptedSchema,
+        agentSchedulePageSchema,
+        agentScheduleControlReceiptSchema,
+    ]), { onExcessProperty: "error" })(result);
 }

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

@@ -9,7 +9,7 @@ import { z } from "zod";
 import { buildStartFailureReply } from "./builds.js";
 import * as Schema from "effect/Schema";
 import { AppInstanceError } from "../index.js";
-import { installOrSelect, verifyRelease, } from "../host.js";
+import { installOrSelect, verifyRelease } from "../host.js";
 import { repositoryWorkflowSourceSchema } from "@fungi.computer/workflows-wire";
 import { installationIdSchema } from "../apps/index.js";
 import { appIdSchema, releaseSchema } from "@fungi.computer/puffball/effect";

package/dist/standalone/app-set.js

@@ -9,8 +9,7 @@ import { publishSource } from "../pack.js";
 import { appBuildRecipe, readBuildManifest } from "../build/workspace-build.js";
 import { parseSourceRevision } from "@fungi.computer/puffball";
 import { releaseSchema } from "@fungi.computer/puffball/effect";
-import { grantCommandSchema, installationSchema, } from "../apps/installation.js";
-import { appPermissionPageSchema } from "../apps/permissions.js";
+import { approveChosenDashboard } from "./dashboard-approval.js";
 import { installOnOyster, InstallationObservationError, } from "../installation-client.js";
 export const standaloneAppSet = [
     {
@@ -141,57 +140,6 @@ export async function installStandaloneAppSet(options) {
             init.signal = signal;
         return fetch(new URL(path, options.url), init);
     };
-    const approveChosenDashboard = async (installed, generation) => {
-        const name = installed.installationId;
-        const path = `/api/installations/${encodeURIComponent(name)}/grants`;
-        const projectionResponse = await owner("GET", path);
-        if (!projectionResponse.ok)
-            throw new Error(`${name} approval read failed (${String(projectionResponse.status)})`);
-        const projection = appPermissionPageSchema.parse(await projectionResponse.json());
-        const { permissions } = projection;
-        const digest = installed.release.artifact.artifactDigest;
-        if (projection.storeGeneration !== generation ||
-            projection.installationId !== name ||
-            projection.artifactDigest !== digest ||
-            permissions.declaredOperations.artifactDigest !== digest ||
-            permissions.authority.authorityVersion !==
-                installed.authority.authorityVersion ||
-            permissions.authority.declaredOperationsDigest !==
-                installed.authority.declaredOperationsDigest ||
-            permissions.declaredOperations.digest !==
-                installed.authority.declaredOperationsDigest)
-            throw new Error(`${name} approval snapshot changed`);
-        const shell = permissions.declaredOperations.capabilities.find((row) => row.capability === "team.workbenchHost");
-        if (shell === undefined)
-            return;
-        const command = grantCommandSchema.parse({
-            kind: "change-grants",
-            changes: [
-                {
-                    capability: shell.capability,
-                    grant: { operations: shell.operations, resources: "tenant-scope" },
-                },
-            ],
-        });
-        const saved = await owner("PUT", path, Schema.decodeUnknownSync(Schema.Json)({
-            storeGeneration: projection.storeGeneration,
-            authorityVersion: installed.authority.authorityVersion,
-            artifactDigest: digest,
-            command,
-        }));
-        if (!saved.ok)
-            throw new Error(`${name} approval failed (${String(saved.status)})`);
-        const receipt = installationSchema.parse(await saved.json());
-        if (receipt.installationId !== name ||
-            receipt.instanceId !== installed.instanceId ||
-            receipt.release.artifact.artifactDigest !== digest ||
-            receipt.authority.authorityVersion !==
-                installed.authority.authorityVersion + 1 ||
-            !receipt.authority.approvedGrants.some((grant) => grant.capability === "team.workbenchHost" &&
-                grant.resources === "tenant-scope" &&
-                shell.operations.every((operation) => grant.operations.includes(operation))))
-            throw new Error(`${name} approval incomplete`);
-    };
     const idle = options.idle ??
         ((ms, signal) => sleep(ms, undefined, { signal }));
     /** Start one build and wait for its terminal outcome within the build
@@ -392,7 +340,7 @@ export async function installStandaloneAppSet(options) {
                     if (record.status !== "enabled")
                         throw new Error(`${name} fresh installation is not enabled`);
                     if (next.app.dashboard === true)
-                        await approveChosenDashboard(record, operation.reference.generation);
+                        await approveChosenDashboard(operation, owner);
                 }
                 options.report(`${operation.creation === "replacement" ? "Replaced" : "Installed"} ${name} from its build ${build.jobId}`);
                 // Report-only UI check: never blocks, but the owner sees it here.

package/dist/standalone/app-source.d.ts

@@ -1,4 +1,4 @@
-import { Hono } from "hono";
+import { type Routes } from "../authorization.js";
 import type { TenantScope } from "../tenant.js";
 import type { OysterBindingResult } from "../workers.js";
 import type { OysterEnv } from "../host.js";
@@ -34,8 +34,7 @@ export declare const appSourceFrameMethods: {
  * re-checked here (never trusted from a stale captured frame). */
 export declare function dispatchAppSourceBinding(env: AppSourceBindingEnv, scope: TenantScope, frame: InvocationFrame, method: string, args: readonly unknown[]): Promise<OysterBindingResult>;
 /** Operator-only: seed one App's editable source template (`install-apps.mjs`).
- * Mounted under `host.ownerRoutes`, already owner-key-gated for every `/api/*`
- * path before this handler runs (`host.ts`'s `oysterPrincipalIsOwner` check).
+ * Each route declares the owner requirement (`authorization.ts`).
  * The operator `git push`es the projected source to
  * `/api/apps/:appId/source.git`, then claims that head here. */
-export declare function appSourceOwnerRoutes(env: AppSourceBindingEnv, scope: TenantScope): Hono<OysterEnv>;
+export declare function appSourceOwnerRoutes(env: AppSourceBindingEnv, scope: TenantScope): Routes<OysterEnv>;

package/dist/standalone/app-source.js

@@ -1,4 +1,4 @@
-import { Hono } from "hono";
+import { owner, routes as routeTable } from "../authorization.js";
 import { bodyLimit } from "hono/body-limit";
 import * as Schema from "effect/Schema";
 import { AppInstanceError } from "../index.js";
@@ -32,18 +32,14 @@ export async function dispatchAppSourceBinding(env, scope, frame, method, args)
     return Schema.decodeUnknownSync(appForkResultSchema)(result);
 }
 /** Operator-only: seed one App's editable source template (`install-apps.mjs`).
- * Mounted under `host.ownerRoutes`, already owner-key-gated for every `/api/*`
- * path before this handler runs (`host.ts`'s `oysterPrincipalIsOwner` check).
+ * Each route declares the owner requirement (`authorization.ts`).
  * The operator `git push`es the projected source to
  * `/api/apps/:appId/source.git`, then claims that head here. */
 export function appSourceOwnerRoutes(env, scope) {
-    const routes = new Hono();
+    const routes = routeTable();
     const registry = () => env.REGISTRY.getByName(scope.durableName("registry"));
-    routes.on(["GET", "POST"], "/api/apps/:appId/source.git/:suffix{info/refs|git-upload-pack|git-receive-pack}", (context) => registry().exchangeTemplateSource(context.req.param("appId"), context.req.param("suffix"), context.req.raw));
-    routes.put("/api/apps/:appId/source", bodyLimit({
-        maxSize: TEMPLATE_SEED_CLAIM_MAX_BYTES,
-        onError: (context) => context.json({ kind: "invalid" }, 413),
-    }), async (context) => {
+    routes.on(["GET", "POST"], "/api/apps/:appId/source.git/:suffix{info/refs|git-upload-pack|git-receive-pack}", owner("direct-or-app"), (context) => registry().exchangeTemplateSource(context.req.param("appId"), context.req.param("suffix"), context.req.raw));
+    routes.put("/api/apps/:appId/source", owner("direct-or-app"), async (context) => {
         const claim = parseTemplateSeedClaim(await context.req.text());
         if (claim === null)
             return context.json({ kind: "invalid" }, 400);
@@ -54,6 +50,13 @@ export function appSourceOwnerRoutes(env, scope) {
                 ? 409
                 : 503;
         return Response.json(result, { status });
+    }, {
+        middleware: [
+            bodyLimit({
+                maxSize: TEMPLATE_SEED_CLAIM_MAX_BYTES,
+                onError: (context) => context.json({ kind: "invalid" }, 413),
+            }),
+        ],
     });
     return routes;
 }

package/dist/standalone/builds.d.ts

@@ -1,18 +1,6 @@
-/**
- * Owner routes for App builds on the standalone's Computer. They run after
- * the host's owner guard; the build owner is the registry.
- *
- * Repository Apps register through APPS.register from their committed root
- * metadata. Publishing an App's source (PUT /api/apps/:appId/source) instead
- * makes its template the build source at the returned seed revision.
- *
- * - `POST /api/builds` starts a build of that source at one exact commit.
- * - `GET /api/builds/:jobId` reads it; a finished build carries its Release,
- *   which the owner installs or selects through the installation routes.
- */
-import { Hono } from "hono";
 import { type OysterBuildStartReason } from "../app-builds.js";
 import { type OysterEnv } from "../host.js";
+import { type Routes } from "../authorization.js";
 import type { StandaloneRegistry } from "./registry.js";
 /** Both HTTP and APPS expose the same closed preflight reason. */
 export declare function buildStartFailureReply(reason: OysterBuildStartReason | "unavailable"): {
@@ -24,4 +12,4 @@ export declare function buildStartFailureReply(reason: OysterBuildStartReason |
 };
 /** The build routes over the tenant registry that owns builds, resolved per
  * request so mounting the routes reaches no registry. */
-export declare function standaloneBuildRoutes(registryFor: () => DurableObjectStub<StandaloneRegistry>): Hono<OysterEnv>;
+export declare function standaloneBuildRoutes(registryFor: () => Pick<StandaloneRegistry, "startBuild" | "readBuild" | "readBuildLog">): Routes<OysterEnv>;

package/dist/standalone/builds.js

@@ -7,13 +7,14 @@
  * makes its template the build source at the returned seed revision.
  *
  * - `POST /api/builds` starts a build of that source at one exact commit.
- * - `GET /api/builds/:jobId` reads it; a finished build carries its Release,
- *   which the owner installs or selects through the installation routes.
+ * - `GET /api/builds/:jobId` reads it; `?log` reads its combined raw output.
+ *   Both require the same owner admission. A finished build carries its
+ *   Release, which the owner installs or selects through the installation routes.
  */
-import { Hono } from "hono";
 import * as Schema from "effect/Schema";
 import { oysterBuildStartMessages, } from "../app-builds.js";
-import { oysterPrincipalIsOwner } from "../host.js";
+import {} from "../host.js";
+import { owner as ownerRoute, routes as routeTable, } from "../authorization.js";
 import { appIdSchema, releaseSchema, sourceRevisionSchema, } from "@fungi.computer/puffball/effect";
 const buildInput = Schema.Struct({
     appId: appIdSchema,
@@ -38,14 +39,9 @@ export function buildStartFailureReply(reason) {
 /** The build routes over the tenant registry that owns builds, resolved per
  * request so mounting the routes reaches no registry. */
 export function standaloneBuildRoutes(registryFor) {
-    const routes = new Hono();
-    routes.use("/api/builds/*", async (context, next) => oysterPrincipalIsOwner(context.get("principal"))
-        ? next()
-        : Response.json({ error: "Owner only" }, { status: 403 }));
-    routes.post("/api/builds", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return Response.json({ error: "Owner only" }, { status: 403 });
+    const routes = routeTable();
+    const owner = ownerRoute("direct-or-app");
+    routes.post("/api/builds", owner, async (context, { principal }) => {
         let input;
         try {
             input = Schema.decodeUnknownSync(buildInput, {
@@ -70,7 +66,13 @@ export function standaloneBuildRoutes(registryFor) {
             return Response.json(reply.body, { status: reply.status });
         }
     });
-    routes.get("/api/builds/:jobId", async (context) => {
+    routes.get("/api/builds/:jobId", owner, async (context) => {
+        if (context.req.query("log") !== undefined) {
+            const log = await registryFor().readBuildLog(context.req.param("jobId"));
+            return log === null
+                ? Response.json({ error: "Not found" }, { status: 404 })
+                : Response.json(log);
+        }
         const build = await registryFor().readBuild(context.req.param("jobId"));
         return build === null
             ? Response.json({ error: "Not found" }, { status: 404 })