@fungi.computer/oyster 0.2.0 → 0.3.0

package/dist/standalone/builds.js

@@ -2,29 +2,39 @@
  * Owner routes for App builds on the standalone's Computer. They run after
  * the host's owner guard; the build owner is the registry.
  *
- * - `PUT /api/apps/:appId/build-source` records an installation repository
- *   and recipe an App builds from (the recipe is normalized and pinned here).
- *   Publishing an App's source (`PUT /api/apps/:appId/source`) instead makes
- *   its template the build source, buildable at the returned seed revision.
+ * 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 * as Schema from "effect/Schema";
-import { capturedPinnedRecipeSchema, normalizeAppPublisherRecipe, pinnedRecipeSchema, } from "../build-contract.js";
-import { oysterBuildSourceSchema } from "../app-builds.js";
+import { oysterBuildStartMessages, } from "../app-builds.js";
 import { oysterPrincipalIsOwner } from "../host.js";
 import { appIdSchema, releaseSchema, sourceRevisionSchema, } from "@fungi.computer/puffball/effect";
-const sourceInput = Schema.Struct({
-    installationId: Schema.String,
-    repository: Schema.String,
-    recipe: pinnedRecipeSchema,
-});
 const buildInput = Schema.Struct({
     appId: appIdSchema,
     sourceRevision: sourceRevisionSchema,
 });
+/** Both HTTP and APPS expose the same closed preflight reason. */
+export function buildStartFailureReply(reason) {
+    return {
+        status: reason === "invalid_revision"
+            ? 400
+            : reason === "unavailable" || reason === "no_backend"
+                ? 503
+                : 409,
+        body: {
+            code: reason,
+            error: reason === "unavailable"
+                ? "Build is unavailable"
+                : oysterBuildStartMessages[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) {
@@ -32,36 +42,6 @@ export function standaloneBuildRoutes(registryFor) {
     routes.use("/api/builds/*", async (context, next) => oysterPrincipalIsOwner(context.get("principal"))
         ? next()
         : Response.json({ error: "Owner only" }, { status: 403 }));
-    routes.put("/api/apps/:appId/build-source", async (context) => {
-        if (!oysterPrincipalIsOwner(context.get("principal")))
-            return Response.json({ error: "Owner only" }, { status: 403 });
-        let source;
-        try {
-            const appId = Schema.decodeUnknownSync(appIdSchema)(context.req.param("appId"));
-            const input = Schema.decodeUnknownSync(sourceInput, {
-                onExcessProperty: "error",
-            })(await context.req.json());
-            const pinned = normalizeAppPublisherRecipe({
-                appId,
-                recipe: Schema.encodeSync(pinnedRecipeSchema)(input.recipe),
-            });
-            source = Schema.decodeUnknownSync(oysterBuildSourceSchema)({
-                appId,
-                location: {
-                    kind: "installation",
-                    installationId: input.installationId,
-                    repository: input.repository,
-                },
-                recipe: Schema.encodeSync(capturedPinnedRecipeSchema)(pinned.recipe),
-                buildRecipeDigest: pinned.buildRecipeDigest,
-            });
-        }
-        catch {
-            return Response.json({ error: "Invalid build source" }, { status: 400 });
-        }
-        await registryFor().registerBuildSource(source);
-        return new Response(null, { status: 204 });
-    });
     routes.post("/api/builds", async (context) => {
         const principal = context.get("principal");
         if (!oysterPrincipalIsOwner(principal))
@@ -76,14 +56,18 @@ export function standaloneBuildRoutes(registryFor) {
             return Response.json({ error: "Invalid build" }, { status: 400 });
         }
         try {
-            const build = await registryFor().startBuild({
+            const result = await registryFor().startBuild({
                 ...input,
                 requestedBy: principal.actor.memberId,
             });
-            return Response.json(build, { status: 202 });
+            if (result.kind === "started")
+                return Response.json(result.build, { status: 202 });
+            const reply = buildStartFailureReply(result.reason);
+            return Response.json(reply.body, { status: reply.status });
         }
         catch {
-            return Response.json({ error: "App has no build source" }, { status: 409 });
+            const reply = buildStartFailureReply("unavailable");
+            return Response.json(reply.body, { status: reply.status });
         }
     });
     routes.get("/api/builds/:jobId", async (context) => {

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

@@ -32,6 +32,8 @@ export declare function serveOysterComputerEgress(request: Request, options: Rea
     computerId: string;
     /** `COMPUTER_PUBLIC_EGRESS`; only `disabled` closes the public lane. */
     publicEgress: string | undefined;
+    /** Live setting from the Computer identified by the host's loopback props. */
+    internetAccess(): Promise<boolean>;
     build: OysterComputerBuildPort;
     forward(request: Request): Promise<Response>;
 }>): Promise<Response>;

package/dist/standalone/computer-egress.js

@@ -26,12 +26,12 @@ const templateRoute = /^\/([a-zA-Z0-9._-]{1,128}?)\.git\/(info\/refs|git-upload-
  * Worker's own fetch, whose door authenticates it as for any other client.
  */
 export async function serveOysterComputerEgress(request, options) {
-    const deny = (host, decision) => computerEgressDenied({
+    const deny = (host, decision, status = 403) => computerEgressDenied({
         computerId: options.computerId,
         teamId: null,
         host,
         method: request.method,
-        status: 403,
+        status,
         decision,
     });
     let url;
@@ -51,10 +51,19 @@ export async function serveOysterComputerEgress(request, options) {
     if (decision.kind === "origin-git")
         response = await options.forward(originGitRequest(request, url));
     else if (decision.kind === "public") {
+        let enabled;
+        let globalEnabled;
+        try {
+            globalEnabled = publicEgressEnabled(options.publicEgress);
+            enabled = globalEnabled ? await options.internetAccess() : true;
+        }
+        catch {
+            return deny(url.hostname, "policy-unavailable", 503);
+        }
         const lane = decidePublicLane({
-            publicEgressEnabled: publicEgressEnabled(options.publicEgress),
+            publicEgressEnabled: globalEnabled,
             teamDisabled: false,
-            computerInternetAccessEnabled: true,
+            computerInternetAccessEnabled: enabled,
         });
         if (lane.kind === "denied")
             return deny(url.hostname, lane.reason);

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

@@ -0,0 +1,43 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { type OysterAuth, type OysterEnv } from "../host.js";
+import type { StandaloneRegistry } from "./registry.js";
+export declare const standaloneFleetRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"create">;
+    request: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        list: "list";
+        choices: "choices";
+    }>;
+    page: z.ZodObject<{
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        read: "read";
+        resolve: "resolve";
+        select: "select";
+        start: "start";
+    }>;
+    computerId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"read-internet-access">;
+    computerId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"set-internet-access">;
+    computerId: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strict>], "operation">;
+export type StandaloneFleetRequest = z.input<typeof standaloneFleetRequestSchema>;
+/** A window's requested context is a hint, never authority or a default mutation. */
+export declare function standaloneComputerSelection(registry: Pick<StandaloneRegistry, "computerFleet" | "selectedComputer">, incoming?: Readonly<{
+    request: Request;
+    auth: OysterAuth;
+}>): Promise<string>;
+/** Tenant-owner management controls over the same durable fleet as Hub. */
+export declare function standaloneComputerFleetRoutes(registryFor: () => DurableObjectStub<StandaloneRegistry>): Hono<OysterEnv>;

package/dist/standalone/computer-fleet.js

@@ -0,0 +1,200 @@
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { computerCreateRequestSchema, computerPageSchema, } from "@fungi.computer/computer/fleet";
+import { oysterPrincipalIsOwner, } from "../host.js";
+/** Fleet controls never accept an actor from the request body. */
+const fleetComputerId = z.string().min(1).max(256);
+export const standaloneFleetRequestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({
+        operation: z.literal("create"),
+        request: computerCreateRequestSchema,
+    }),
+    z.strictObject({
+        operation: z.enum(["list", "choices"]),
+        page: computerPageSchema,
+    }),
+    z.strictObject({
+        operation: z.enum(["read", "resolve", "start", "select"]),
+        computerId: fleetComputerId,
+    }),
+    z.strictObject({
+        operation: z.literal("read-internet-access"),
+        computerId: fleetComputerId,
+    }),
+    z.strictObject({
+        operation: z.literal("set-internet-access"),
+        computerId: fleetComputerId,
+        enabled: z.boolean(),
+    }),
+]);
+function fleetStatus(result) {
+    if (result === null)
+        return 404;
+    if ("error" in result)
+        return result.error === "owner_required"
+            ? 403
+            : result.error === "partial_init"
+                ? 503
+                : 409;
+    return 200;
+}
+function fleetResponse(result) {
+    return Response.json(result ?? { error: "not_found" }, {
+        status: fleetStatus(result),
+    });
+}
+/** A window's requested context is a hint, never authority or a default mutation. */
+export async function standaloneComputerSelection(registry, incoming) {
+    if (incoming === undefined)
+        return registry.selectedComputer();
+    const requested = new URL(incoming.request.url).searchParams.getAll("computerId");
+    if (requested.length === 0)
+        return registry.selectedComputer();
+    const admission = await incoming.auth.authenticate(incoming.request);
+    if (admission.kind === "refused")
+        throw new HTTPException(admission.status, {
+            res: Response.json({ error: "Computer selection refused" }, {
+                status: admission.status,
+                headers: admission.retryAfter === undefined
+                    ? {}
+                    : { "Retry-After": String(admission.retryAfter) },
+            }),
+        });
+    if (!oysterPrincipalIsOwner(admission.principal))
+        throw new HTTPException(403, { message: "Owner only" });
+    const computerId = z.tuple([fleetComputerId]).safeParse(requested);
+    if (!computerId.success)
+        throw new HTTPException(400, { message: "Invalid Computer selection" });
+    const result = await registry.computerFleet(admission.principal.actor.memberId, {
+        operation: "resolve",
+        computerId: computerId.data[0],
+    });
+    const status = fleetStatus(result);
+    if (status !== 200)
+        throw new HTTPException(status, { res: fleetResponse(result) });
+    return computerId.data[0];
+}
+/** 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));
+    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);
+        const registry = registryFor();
+        const admitted = await registry.computerFleet(principal.actor.memberId, {
+            operation: "list",
+            page: { limit: 1, offset: 0 },
+        });
+        if (admitted === null || "error" in admitted)
+            return fleetResponse(admitted);
+        const [directory, computerId] = await Promise.all([
+            registry.directory(),
+            registry.selectedComputer(),
+        ]);
+        return context.json({
+            ...directory,
+            computer: { computerId, name: computerId },
+            computerContext: "owner-fleet",
+        });
+    });
+    routes.get("/api/computers", async (context) => {
+        const principal = context.get("principal");
+        if (!oysterPrincipalIsOwner(principal))
+            return context.json({ error: "Owner only" }, 403);
+        const page = computerPageSchema.parse({
+            limit: Number(context.req.query("limit") ?? 100),
+            offset: Number(context.req.query("offset") ?? 0),
+        });
+        return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
+            operation: "list",
+            page,
+        }));
+    });
+    routes.get("/api/workbench/computers", async (context) => {
+        const principal = context.get("principal");
+        if (!oysterPrincipalIsOwner(principal))
+            return context.json({ error: "Owner only" }, 403);
+        return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
+            operation: "choices",
+            page: computerPageSchema.parse({
+                limit: Number(context.req.query("limit") ?? 100),
+                offset: Number(context.req.query("offset") ?? 0),
+            }),
+        }));
+    });
+    routes.post("/api/computers", async (context) => {
+        const principal = context.get("principal");
+        if (!oysterPrincipalIsOwner(principal))
+            return context.json({ error: "Owner only" }, 403);
+        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);
+        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);
+        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);
+        const input = z
+            .strictObject({ enabled: z.boolean() })
+            .parse(await context.req.json());
+        return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
+            operation: "set-internet-access",
+            computerId: context.req.param("computerId"),
+            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);
+        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);
+        const input = z
+            .strictObject({ computerId: fleetComputerId })
+            .parse(await context.req.json());
+        return fleetResponse(await registryFor().computerFleet(principal.actor.memberId, {
+            operation: "select",
+            computerId: input.computerId,
+        }));
+    });
+    return routes;
+}

package/dist/standalone/computer.d.ts

@@ -1,17 +1,21 @@
 import { type AppMethodRefusedReply } from "@fungi.computer/agar/backend";
-import { type WorkflowGitPassResult } from "@fungi.computer/agar/computer-contracts";
 import { type ComputerPorts } from "@fungi.computer/agar/computer";
 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/operations";
-import { ComputerDO as NativeComputerDO, listOutputSchema, writeOutputSchema, mkdirOutputSchema, computerPortsOutputSchema, computerPortOutputSchema, computerPortRemovalOutputSchema, processListOutputSchema, processKillOutputSchema, computerOperationResultSchema, type AttachedBackend, type ComputerEnv, type ComputerValue } from "@fungi.computer/computer";
+import { computerProcessSchema, computerToolResultSchema, readOutputSchema } from "@fungi.computer/computer-contract";
+import { ComputerDO as NativeComputerDO, type AttachedBackend, type ComputerEnv } from "@fungi.computer/computer";
+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";
 import type { InvocationFrame } from "../invocation.js";
 import { type OysterCapability } from "../host.js";
 import type { OysterBindingRow, OysterInvocationHost, OysterWorkerEnv, OysterWorkspace } from "../workers.js";
 import type { OysterKeys, OysterKeysLivePort } from "../workers-git.js";
+import { type OysterBuildBackend } from "../app-builds.js";
 import type { StandaloneRegistry } from "./registry.js";
+import type { TenantScope } from "../tenant.js";
+import { type WorkflowGitStepEnv } from "./workflow-binding.js";
 /** Native bindings selected by the standalone composition, never by an App. */
 export type StandaloneComputerEnv = ComputerEnv & Pick<OysterWorkerEnv, "RELEASES"> & Readonly<{
     OYSTER_COMPUTER_ID: string;
@@ -25,7 +29,7 @@ export type StandaloneComputerEnv = ComputerEnv & Pick<OysterWorkerEnv, "RELEASE
     OYSTER_OWNER_NAME?: string;
 }>;
 /** Finite native results cross the Workers RPC mapping without recursive JSON types. */
-export type StandaloneComputerResult = WorkflowGitPassResult | z.output<typeof listOutputSchema> | Readonly<{
+export type StandaloneComputerResult = z.output<typeof listOutputSchema> | Readonly<{
     path: string;
     byteOffset: number;
     content: string;
@@ -46,12 +50,35 @@ export type ComputerPortPreviewsReply = Readonly<{
  * The Computer owner's bindings: the standalone Computer env plus the tenancy
  * registry that names the live canonical owner a port preview must belong to.
  */
-export type StandaloneComputerOwnerEnv = StandaloneComputerEnv & StandaloneTenancyEnv;
+export type StandaloneComputerOwnerEnv = StandaloneComputerEnv & StandaloneTenancyEnv & Readonly<{
+    /** Each Workflows library's run owner issues its own Git credentials. */
+    WORKFLOW_RUNS: Readonly<{
+        getByName(libraryId: string): StandaloneWorkflowGitIssuer;
+    }>;
+}>;
+/** The library run owner's per-invocation Workflow Git credential ports. */
+export type StandaloneWorkflowGitIssuer = Readonly<{
+    issueWorkflowGit(invocationId: string, grant: WorkflowGitPassGrant): Promise<WorkflowGitCredential>;
+    renewWorkflowGit(invocationId: string, grant: WorkflowGitPassGrant): Promise<void>;
+    closeWorkflowGit(invocationId: string, grant: WorkflowGitPassGrant): Promise<void>;
+}>;
+/** The Worker's terminal route reaches this native fetch through the stub. */
+export type ComputerFetch = {
+    fetch(request: Request): Promise<Response>;
+};
 /** Durable workspace and existing backings, with fleet checks at native acceptance. */
-export declare class ComputerDO extends NativeComputerDO {
+export declare class ComputerDO extends NativeComputerDO implements ComputerFetch {
     #private;
     private readonly previewBindings;
     constructor(state: DurableObjectState, previewBindings: StandaloneComputerOwnerEnv);
+    /** Install the fleet's creation projection before exposing its new identity. */
+    initializeFleetBackings(backings: readonly AttachedBackend[]): void;
+    /** An admitted fleet control starts exactly this Computer's hosted backend. */
+    startHostedComputer(authority: ComputerGrant): Promise<{
+        state: "running";
+    }>;
+    /** A read-only preflight over the maintained hosted-route selector. */
+    buildBackend(): OysterBuildBackend;
     /**
      * Run one App build job's fixed command, under the build budget. The
      * registry that minted the job re-admits it for this Computer first.
@@ -69,11 +96,17 @@ export declare class ComputerDO extends NativeComputerDO {
     /** Issue preview tickets for every exposed port, or refuse typed. */
     portPreviews(authority: ComputerGrant, selectorInput: PreviewSelector): Promise<ComputerPortPreviewsReply>;
     portPreview(signature: string, port: number, request: Request): Promise<Response>;
+    /**
+     * The host side of native execution (Computer ABI 0edb0e4a): the grant's
+     * library run owner issues one credential for the invocation and the
+     * Computer hands it only to that command's Git environment.
+     */
+    protected executionHooks(): ComputerExecutionHostHooks;
     protected attachedBackends(): readonly AttachedBackend[];
     /** One advertised Computer tool, accepted against the host-issued grant. */
     tool(authority: ComputerGrant, capabilityId: string, input: ComputerValue): Promise<StandaloneComputerResult>;
     /** JSON operations keep the Computer's maintained parsers and execution engine. */
-    value(authority: ComputerGrant, action: ComputerAction, input: ComputerValue): Promise<StandaloneComputerResult>;
+    value(authority: ComputerGrant, action: ComputerAction, input: ComputerValue, executionContext?: ComputerValue): Promise<StandaloneComputerResult>;
     fileList(authority: ComputerGrant, path: string, limit: number, offset: number): Promise<{
         path: string;
         entries: {
@@ -105,7 +138,7 @@ export declare class ComputerDO extends NativeComputerDO {
  * omit it, since a team-key principal then simply never reaches the
  * Computer, rather than reading `env.KEYS` directly and skipping the check.
  */
-export declare function standaloneWorkspace(env: StandaloneComputerEnv, keysLive?: OysterKeysLivePort): OysterWorkspace;
+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`
@@ -118,5 +151,7 @@ export type ComputerFrameMethods = Readonly<{
 }>;
 /** Closed COMPUTER binding codecs, joined into the standalone Instance. */
 export declare const computerFrameMethods: ComputerFrameMethods;
+/** Media and Computer bindings capture the same inventory-admitted workspace. */
+export declare function standaloneFrameWorkspace(env: StandaloneComputerEnv, scope: TenantScope, frame: InvocationFrame<OysterInvocationHost>): Promise<OysterWorkspace>;
 /** Dispatch one admitted COMPUTER operation under its captured frame. */
-export declare function computerInvocation(env: StandaloneComputerEnv, frame: InvocationFrame<OysterInvocationHost>, method: string, args: readonly unknown[]): Promise<StandaloneComputerResult>;
+export declare function computerInvocation(env: StandaloneComputerEnv & WorkflowGitStepEnv, scope: TenantScope, frame: InvocationFrame<OysterInvocationHost>, method: string, args: readonly unknown[]): Promise<StandaloneComputerResult>;