@fungi.computer/oyster 0.6.0 → 0.8.0

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

@@ -1,6 +1,6 @@
-import { Hono } from "hono";
 import { z } from "zod";
 import { type OysterAuth, type OysterEnv } from "../host.js";
+import { type Routes } from "../authorization.js";
 import type { StandaloneRegistry } from "./registry.js";
 export declare const standaloneFleetRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operation: z.ZodLiteral<"create">;
@@ -20,10 +20,10 @@ export declare const standaloneFleetRequestSchema: z.ZodDiscriminatedUnion<[z.Zo
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodEnum<{
         read: "read";
-        resolve: "resolve";
         select: "select";
-        start: "start";
         state: "state";
+        resolve: "resolve";
+        start: "start";
     }>;
     computerId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
@@ -41,4 +41,4 @@ export declare function standaloneComputerSelection(registry: Pick<StandaloneReg
     auth: OysterAuth;
 }>): Promise<string>;
 /** Tenant-owner management controls over the same durable fleet as Hub. */
-export declare function standaloneComputerFleetRoutes(registryFor: () => DurableObjectStub<StandaloneRegistry>): Hono<OysterEnv>;
+export declare function standaloneComputerFleetRoutes(registryFor: () => DurableObjectStub<StandaloneRegistry>): Routes<OysterEnv>;

package/dist/standalone/computer-fleet.js

@@ -1,9 +1,9 @@
-import { Hono } from "hono";
 import { endTime, startTime } from "hono/timing";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
 import { computerCreateRequestSchema, computerPageSchema, } from "@fungi.computer/computer/fleet";
-import { oysterPrincipalIsOwner, } from "../host.js";
+import {} from "../host.js";
+import { oysterPrincipalIsOwner, owner as ownerRoute, routes as routeTable, } from "../authorization.js";
 import { computerTargetParam } from "../computer-target.js";
 /** Fleet controls never accept an actor from the request body. */
 const fleetComputerId = z.string().min(1).max(256);
@@ -79,19 +79,14 @@ export async function standaloneComputerSelection(registry, incoming) {
 }
 /** Tenant-owner management controls over the same durable fleet as Hub. */
 export function standaloneComputerFleetRoutes(registryFor) {
-    const routes = new Hono();
-    routes.use("/api/computers/*", async (context, next) => oysterPrincipalIsOwner(context.get("principal"))
-        ? next()
-        : context.json({ error: "Owner only" }, 403));
+    const routes = routeTable();
+    const owner = ownerRoute("direct-or-app");
     routes.onError((error, context) => {
         if (error instanceof z.ZodError || error instanceof SyntaxError)
             return context.json({ error: "invalid_input" }, 400);
         throw error;
     });
-    routes.get("/api/workbench/directory", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.get("/api/workbench/directory", owner, async (context, { principal }) => {
         const registry = registryFor();
         startTime(context, "fleet");
         const admitted = await registry.computerFleet(principal.actor.memberId, {
@@ -113,10 +108,7 @@ export function standaloneComputerFleetRoutes(registryFor) {
             computerContext: "owner-fleet",
         });
     });
-    routes.get("/api/computers", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.get("/api/computers", owner, async (context, { principal }) => {
         const page = computerPageSchema.parse({
             limit: Number(context.req.query("limit") ?? 100),
             offset: Number(context.req.query("offset") ?? 0),
@@ -126,10 +118,7 @@ export function standaloneComputerFleetRoutes(registryFor) {
             page,
         }));
     });
-    routes.get("/api/workbench/computers", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.get("/api/workbench/computers", owner, async (context, { principal }) => {
         return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
             operation: "choices",
             page: computerPageSchema.parse({
@@ -138,39 +127,27 @@ export function standaloneComputerFleetRoutes(registryFor) {
             }),
         }));
     });
-    routes.post("/api/computers", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.post("/api/computers", owner, async (context, { principal }) => {
         const input = computerCreateRequestSchema.parse(await context.req.json());
         return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
             operation: "create",
             request: input,
         }));
     });
-    routes.post("/api/computers/:computerId/start", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.post("/api/computers/:computerId/start", owner, async (context, { principal }) => {
         const result = await registryFor().computerFleet(principal.actor.memberId, {
             operation: "start",
             computerId: context.req.param("computerId"),
         });
         return fleetResponse(result);
     });
-    routes.get("/api/computers/:computerId/internet-access", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.get("/api/computers/:computerId/internet-access", owner, async (context, { principal }) => {
         return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
             operation: "read-internet-access",
             computerId: context.req.param("computerId"),
         }));
     });
-    routes.put("/api/computers/:computerId/internet-access", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.put("/api/computers/:computerId/internet-access", owner, async (context, { principal }) => {
         const input = z
             .strictObject({ enabled: z.boolean() })
             .parse(await context.req.json());
@@ -180,20 +157,14 @@ export function standaloneComputerFleetRoutes(registryFor) {
             enabled: input.enabled,
         }));
     });
-    routes.get("/api/computers/:computerId", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.get("/api/computers/:computerId", owner, async (context, { principal }) => {
         const result = await registryFor().computerFleet(principal.actor.memberId, {
             operation: "read",
             computerId: context.req.param("computerId"),
         });
         return fleetResponse(result);
     });
-    routes.put("/api/computers/selected", async (context) => {
-        const principal = context.get("principal");
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner only" }, 403);
+    routes.put("/api/computers/selected", owner, async (context, { principal }) => {
         const input = z
             .strictObject({ computerId: fleetComputerId })
             .parse(await context.req.json());

package/dist/standalone/computer.d.ts

@@ -109,6 +109,7 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
             exitCode: number | null;
             stderr: string;
         } | null;
+        log: import("../build/job-log.js").BuildJobLog;
     }>>;
     /** Issue preview tickets for every exposed port, or refuse typed. */
     portPreviews(authority: ComputerGrant, selectorInput: PreviewSelector): Promise<ComputerPortPreviewsReply>;
@@ -160,10 +161,10 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
 export declare function standaloneWorkspace(env: StandaloneComputerEnv, keysLive?: OysterKeysLivePort, selectedComputerId?: string): OysterWorkspace;
 /**
  * Owner/key capability routes over the selected Computer's native
- * namespace. `keysLive` is the same owner-checked port `standaloneWorkspace`
- * takes; a caller with none fails every team-key request closed.
+ * namespace. Each route declares the Computer requirement, so a key reaches
+ * it only with its own `computer.use` grant (`authorization.ts`).
  */
-export declare function standaloneComputerCapabilities(env: StandaloneComputerEnv, workspace: OysterWorkspace, keysLive?: OysterKeysLivePort): readonly OysterCapability[];
+export declare function standaloneComputerCapabilities(env: StandaloneComputerEnv, workspace: OysterWorkspace): readonly OysterCapability[];
 /** The COMPUTER row's codecs, as the standalone Instance joins them. */
 export type ComputerFrameMethods = Readonly<{
     COMPUTER: OysterBindingRow<OysterWorkerEnv>["methods"];

package/dist/standalone/computer.js

@@ -1,10 +1,10 @@
-import { Hono } from "hono";
 import { attachedBackendId, hostedBackingSchema, } from "@fungi.computer/computer/backing";
 import { appMethodRefusalStatus, appMethodRefusedReplySchema, } from "@fungi.computer/agar/backend";
 import * as Schema from "effect/Schema";
 import { computerPortsSchema, } from "@fungi.computer/agar/computer";
 import { verifyRelease } from "../host.js";
 import { r2ArtifactStore } from "../workers.js";
+import { createBuildJobLog } from "../build/job-log.js";
 import { createStandalonePreview, previewOrigins, previewSelectorSchema, PreviewRefused, } from "./preview.js";
 import { standaloneTenancy } from "./tenancy.js";
 import { Base64 } from "effect/encoding";
@@ -18,8 +18,8 @@ import { checkComputerGrant, computerActionSchema, computerGrantSchema, createFl
 import { AppInstanceError, selectionOf } from "../index.js";
 import {} from "../cloudflare.js";
 import { computerSlots } from "../computer.js";
-import { oysterPrincipalId, oysterPrincipalIsOwner, } from "../host.js";
-import { keyAllowsComputerUse } from "../keys.js";
+import { oysterPrincipalId, } from "../host.js";
+import { authorityOf, computer as computerRoute, owner, reachesComputer, routes as routeTable, } from "../authorization.js";
 import { oysterAppBuildTimeoutMs, } from "../app-builds.js";
 import { workflowGitStepGrant, } from "./workflow-binding.js";
 const missingFile = z.lazy(() => z.object({ code: z.literal("ENOENT") }));
@@ -66,24 +66,18 @@ function grant(computerId, actor) {
     };
 }
 /**
- * The Computer grant actor for an admitted owner or member; null for an
- * Agent or visitor. A key only when its own `computer.use` grant allows it
- * -- off by default, so an unknown, revoked, expired or suspended key, or
- * one issued with no Computer grant, is also null. `keysLive` is the one
- * owner-checked port every caller reaches a key's liveness through (the
- * same one `host.keys.live` is); a caller with none -- the Media binding's
- * own workspace selection never calls through to a principal at all --
- * fails every team-key closed rather than falling back to an unchecked read.
+ * The Computer grant actor for a principal `authorization.ts` lets reach the
+ * Computer; null otherwise. `keysLive` is the one owner-checked port every
+ * caller reaches a key's liveness through (the same one `host.keys.live`
+ * is); a caller with none -- the Media binding's own workspace selection
+ * never calls through to a principal at all -- fails every key closed.
  */
 async function computerActor(principal, keysLive) {
-    if (principal.actor.kind === "visitor" || principal.actor.kind === "agent")
-        return null;
-    if (principal.actor.kind === "team-key") {
-        const key = keysLive === undefined ? null : await keysLive(principal.actor.keyId);
-        if (key === null || !keyAllowsComputerUse(key))
-            return null;
-    }
-    return JSON.stringify(principal);
+    const authority = await authorityOf(principal, {
+        liveKey: keysLive ?? (() => Promise.resolve(null)),
+        appToolPolicy: () => null,
+    });
+    return reachesComputer(authority) ? JSON.stringify(principal) : null;
 }
 /** Each advertised Computer tool, the grant action that accepts it, and its result. */
 const computerTools = {
@@ -243,16 +237,25 @@ export class ComputerDO extends NativeComputerDO {
         const admitted = await this.previewBindings.REGISTRY.getByName("registry").admitBuildExecution(input.jobId, this.state.id.toString());
         if (!admitted)
             throw new AppInstanceError("revoked");
+        const log = createBuildJobLog();
         const result = await this.executeOperationAfterAcceptance({
             command: input.command,
             cwd: "/workspace",
             timeoutMs: input.timeoutMs,
             requestId: mintComputerRequestId(),
-        }, () => undefined, "hosted", { maximumTimeMs: oysterAppBuildTimeoutMs });
+        }, () => undefined, "hosted", { maximumTimeMs: oysterAppBuildTimeoutMs }, undefined, undefined, {
+            onEvent(event) {
+                if (event.name === "stdout" || event.name === "stderr")
+                    log.append(event.value);
+            },
+        });
         const output = z
             .object({ exitCode: z.number().nullable(), stderr: z.string() })
             .safeParse(result.output);
-        return { output: output.success ? output.data : null };
+        return {
+            output: output.success ? output.data : null,
+            log: log.finish(),
+        };
     }
     /** Issue preview tickets for every exposed port, or refuse typed. */
     async portPreviews(authority, selectorInput) {
@@ -538,30 +541,26 @@ export function standaloneWorkspace(env, keysLive, selectedComputerId = env.OYST
 }
 /**
  * Owner/key capability routes over the selected Computer's native
- * namespace. `keysLive` is the same owner-checked port `standaloneWorkspace`
- * takes; a caller with none fails every team-key request closed.
+ * namespace. Each route declares the Computer requirement, so a key reaches
+ * it only with its own `computer.use` grant (`authorization.ts`).
  */
-export function standaloneComputerCapabilities(env, workspace, keysLive) {
-    const routes = new Hono();
-    routes.use("*", async (context, next) => {
-        const actor = await computerActor(context.env.principal, keysLive);
-        if (actor === null)
-            return context.json({ error: "Computer access requires an owner or key" }, 403);
-        context.set("authority", grant(workspace.computerId, actor));
-        return next();
-    });
+export function standaloneComputerCapabilities(env, workspace) {
+    const routes = routeTable();
+    const reach = computerRoute();
+    const authority = (principal) => grant(workspace.computerId, JSON.stringify(principal));
     const computer = () => env.COMPUTER.getByName(workspace.computerId);
-    routes.get("/ports", async (context) => {
+    routes.get("/ports", owner("direct-or-app"), async (context, { principal }) => {
         if (previewOrigins(env) === null)
             return context.json({ error: "port_previews_not_configured" });
-        const { principal, installation } = context.env;
-        if (!oysterPrincipalIsOwner(principal))
-            return context.json({ error: "Owner preview access required" }, 403);
+        const { installation } = context.env;
         const ownerId = oysterPrincipalId(principal);
-        const authority = context.get("authority");
+        const ownerAuthority = authority(principal);
         const reply = await computer().portPreviews({
-            ...authority,
-            provenance: { ...authority.provenance, actor: `owner:${ownerId}` },
+            ...ownerAuthority,
+            provenance: {
+                ...ownerAuthority.provenance,
+                actor: `owner:${ownerId}`,
+            },
         }, {
             ownerId,
             installationId: installation.installationId,
@@ -573,47 +572,47 @@ export function standaloneComputerCapabilities(env, workspace, keysLive) {
             : context.json({ error: reply.code, message: reply.message }, appMethodRefusalStatus[reply.code]);
     });
     // The host wire body is `{ port }`, as on Hub; it is parsed here.
-    routes.post("/ports/expose", async (context) => {
+    routes.post("/ports/expose", reach, async (context, { principal }) => {
         const input = computerPortInputSchema.safeParse(await context.req.json());
         if (!input.success)
             return context.json({ error: "invalid_input" }, 400);
-        return Response.json(await computer().value(context.get("authority"), "exposePort", input.data));
+        return Response.json(await computer().value(authority(principal), "exposePort", input.data));
     });
     // The host wire body is `{ port }`, as on Hub; it is parsed here.
-    routes.post("/ports/unexpose", async (context) => {
+    routes.post("/ports/unexpose", reach, async (context, { principal }) => {
         const input = computerPortInputSchema.safeParse(await context.req.json());
         if (!input.success)
             return context.json({ error: "invalid_input" }, 400);
-        return Response.json(await computer().value(context.get("authority"), "unexposePort", input.data));
+        return Response.json(await computer().value(authority(principal), "unexposePort", input.data));
     });
-    routes.get("/processes", async (context) => Response.json(await computer().value(context.get("authority"), "processList", {})));
-    routes.post("/processes/start", async (context) => {
+    routes.get("/processes", reach, async (_context, { principal }) => Response.json(await computer().value(authority(principal), "processList", {})));
+    routes.post("/processes/start", reach, async (context, { principal }) => {
         const input = processStartHttpBody.safeParse(await context.req.json());
         if (!input.success)
             return context.json({ error: "invalid_input" }, 400);
-        const result = processStartReply.parse(await computer().value(context.get("authority"), "processStart", computerValueSchema.parse({
+        const result = processStartReply.parse(await computer().value(authority(principal), "processStart", computerValueSchema.parse({
             ...input.data,
             requestScope: `owner:${env.OYSTER_OWNER_NAME ?? "owner"}`,
         })));
         return Response.json(result, { status: "error" in result ? 409 : 200 });
     });
     // The host wire body is `{ id }`, as on Hub; it is parsed here.
-    routes.post("/processes/kill", async (context) => {
+    routes.post("/processes/kill", reach, async (context, { principal }) => {
         const input = processIdInputSchema.safeParse(await context.req.json());
         if (!input.success)
             return context.json({ error: "invalid_input" }, 400);
-        return Response.json(await computer().value(context.get("authority"), "processKill", input.data));
+        return Response.json(await computer().value(authority(principal), "processKill", input.data));
     });
-    routes.get("/terminal", async (context) => {
-        const authority = context.get("authority");
+    routes.get("/terminal", reach, async (context, { principal }) => {
+        const terminal = authority(principal);
         const url = new URL(context.req.url);
         url.pathname = "/_oyster/terminal";
         return computer().fetch(new Request(url, {
             headers: {
                 Upgrade: "websocket",
                 [terminalGrantHeader]: JSON.stringify({
-                    ...authority,
-                    actions: [...authority.actions],
+                    ...terminal,
+                    actions: [...terminal.actions],
                 }),
             },
         }));
@@ -621,7 +620,7 @@ export function standaloneComputerCapabilities(env, workspace, keysLive) {
     return Object.values(computerSlots).map((slot) => ({
         ...slot,
         permission: "computer.execute",
-        routes: new Hono().route("/", routes),
+        routes,
     }));
 }
 /** Closed COMPUTER binding codecs, joined into the standalone Instance. */

package/dist/standalone/dashboard-approval.d.ts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+import { type Installation } from "../apps/installation.js";
+import type { InstallationOperation } from "../installation-operations.js";
+/**
+ * An owner choosing a freshly installed dashboard approves its declared shell
+ * operations only. Replacements and tombstone remints never replay consent.
+ */
+export declare function approveChosenDashboard(operation: Extract<InstallationOperation, {
+    state: "succeeded";
+}>, owner: (method: "GET" | "PUT", path: string, body?: Schema.Json) => Promise<Response>): Promise<Installation | undefined>;

package/dist/standalone/dashboard-approval.js

@@ -0,0 +1,66 @@
+import * as Schema from "effect/Schema";
+import { grantCommandSchema, installationSchema, } from "../apps/installation.js";
+import { appPermissionPageSchema } from "../apps/permissions.js";
+/**
+ * An owner choosing a freshly installed dashboard approves its declared shell
+ * operations only. Replacements and tombstone remints never replay consent.
+ */
+export async function approveChosenDashboard(operation, owner) {
+    if (operation.creation !== "fresh")
+        return;
+    const installed = operation.installation;
+    const name = operation.installationId;
+    if (installed === null)
+        throw new Error(`${name} completed installation version is unavailable`);
+    if (installed.status !== "enabled")
+        throw new Error(`${name} fresh installation is not enabled`);
+    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 !== operation.reference.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`);
+    return receipt;
+}