@fungi.computer/oyster 0.6.0 → 0.8.0

package/dist/apps/gate.js

@@ -59,9 +59,15 @@ export const gateRefusalSchema = z.lazy(() => z.strictObject({
         "approval_required",
         "requires_not_granted",
         "invalid_input",
-        "visitor_read_only",
     ]),
 }));
+/** Availability uses "any"; a selected target must match both its kind and identity. */
+function grantsResource(resources, resource) {
+    return (resources === "tenant-scope" ||
+        (resource === "any"
+            ? resources.length > 0
+            : resources.some((ref) => ref.kind === resource.kind && ref.id === resource.id)));
+}
 /** Intersect stored approvals with the current verified Release without widening resource selectors. */
 export function grantsFor(installation, declaration, snapshot, capability, resource = "any") {
     if (installation.status !== "enabled" ||
@@ -73,17 +79,14 @@ export function grantsFor(installation, declaration, snapshot, capability, resou
     const declared = snapshot.capabilities.find((row) => row.capability === capability)
         ?.operations ?? [];
     if (!approved?.capabilityApproved ||
-        (approved.resources !== "tenant-scope" &&
-            (resource === "any"
-                ? approved.resources.length === 0
-                : !approved.resources.some((ref) => ref.kind === resource.kind && ref.id === resource.id))))
+        !grantsResource(approved.resources, resource))
         return null;
     const operations = approved.operations.filter((operation) => declared.includes(operation));
     return { ...approved, operations };
 }
 /** Approved binding operations from an already verified declaration. Hosts still pin
  * the selection/version/artifact and compare running frame grants as a subset. */
-export function approvedBindingGrants(installation, declaration) {
+export function approvedBindingGrants(installation, declaration, resource = "any") {
     if (installation.status !== "enabled")
         return [];
     const bindings = [];
@@ -96,8 +99,7 @@ export function approvedBindingGrants(installation, declaration) {
                     const approved = installation.authority.approvedGrants.find((grant) => grant.capability === capability);
                     return (declaration.capabilities.includes(capability) &&
                         approved?.capabilityApproved &&
-                        (approved.resources === "tenant-scope" ||
-                            approved.resources.length > 0) &&
+                        grantsResource(approved.resources, resource) &&
                         approved.operations.includes(bindingOperationKey(binding.name, name)));
                 }));
         });
@@ -124,10 +126,7 @@ export function scopedBindings(captured, method, ceiling = "write") {
 /** Principal ceiling for invocation and metadata capture. Captures must pass this
  * to scopedBindings; its default write ceiling does not encode caller access. */
 export function appInvocationCeiling(facts) {
-    return facts.access?.level === "read" ||
-        facts.principal.actor.kind === "visitor"
-        ? "read"
-        : "write";
+    return facts.access?.level === "read" ? "read" : "write";
 }
 function admittedBindings(facts, method) {
     return scopedBindings(approvedBindingGrants(facts.installation, facts.declaration), method, appInvocationCeiling(facts));
@@ -135,9 +134,7 @@ function admittedBindings(facts, method) {
 const refusal = (code) => ({ kind: "refused", code });
 function admissionRefusal(facts) {
     const { installation, principal } = facts;
-    const visitor = principal.actor.kind === "visitor";
-    if (installation.status !== "enabled" ||
-        (visitor && installation.visibility !== "public"))
+    if (installation.status !== "enabled")
         return refusal("unavailable");
     if (facts.declaredOperations.digest !==
         installation.authority.declaredOperationsDigest ||
@@ -153,8 +150,7 @@ function admissionRefusal(facts) {
     return null;
 }
 function methodMetadata(facts, name) {
-    const { installation, principal } = facts;
-    const visitor = principal.actor.kind === "visitor";
+    const { installation } = facts;
     if (installation.instanceId === null)
         return refusal("unavailable");
     if (!Schema.is(appApiMethodNameSchema)(name) ||
@@ -166,8 +162,6 @@ function methodMetadata(facts, name) {
         return refusal("not_declared");
     if (method.effect === "external")
         return refusal("approval_required");
-    if (visitor && method.effect !== "read")
-        return refusal("visitor_read_only");
     if (method.effect === "write" && facts.access?.level === "read")
         return refusal("level_too_low");
     return { kind: "admitted", method };
@@ -199,16 +193,13 @@ export function admits(facts, rawRequest) {
     if (!parsed.success)
         return refusal("invalid_input");
     const request = parsed.data;
-    const { installation, principal } = facts;
-    const visitor = principal.actor.kind === "visitor";
+    const { installation } = facts;
     const denied = admissionRefusal(facts);
     if (denied !== null)
         return denied;
     switch (request.kind) {
         case "backend":
             // Opaque App requests have no verified method selector; they require write authority.
-            if (visitor)
-                return refusal("visitor_read_only");
             if (installation.instanceId === null)
                 return refusal("unavailable");
             if (facts.access?.level === "read")
@@ -242,8 +233,6 @@ export function admits(facts, rawRequest) {
             };
         }
         case "capability": {
-            if (visitor)
-                return refusal("visitor_read_only");
             if (!facts.declaration.capabilities.includes(request.capability) ||
                 (request.operation !== undefined &&
                     facts.declaredOperations.capabilities
@@ -258,8 +247,6 @@ export function admits(facts, rawRequest) {
             return { kind: "admitted", grants: [] };
         }
         case "capability-route": {
-            if (visitor)
-                return refusal("visitor_read_only");
             if (request.effect === "write" && facts.access?.level === "read")
                 return refusal("level_too_low");
             if (!request.operation.startsWith("route:") ||
@@ -273,8 +260,6 @@ export function admits(facts, rawRequest) {
             return { kind: "admitted", grants: [] };
         }
         case "binding": {
-            if (visitor)
-                return refusal("visitor_read_only");
             if (installation.instanceId === null)
                 return refusal("unavailable");
             const operation = appBackendBindingOperation(request.binding, request.operation);

package/dist/apps/index.d.ts

@@ -1,6 +1,6 @@
 /** Installation records and pure admission rules; tenant state and commits stay host-owned. */
 export { applyGrantCommand, appAuthoritySchema, grantCommandSchema, type AppAuthority, type GrantCommand, type GrantContext, type GrantRefusal, applyInstallationCommand, approvedGrantSchema, declaredOperationsSchema, installationCommandSchema, installationIdSchema, installationRefusalSchema, installationSchema, type Approval, type ApprovedGrant, type CapabilityOperationDescriptor, type DeclaredOperations, grantChangeSchema, type GrantChange, type Installation, type InstallationCommand, type InstallationContext, type InstallationReader, type InstallationRefusal, type InstallationUpdate, type ResourceRef, } from "./installation.js";
-export { permissionPinsSchema, permissionSaveSchema, type PermissionPins, appPermissionsWireSchema, appPermissionPageSchema, permissionScreen, draftOf, editPermissions, planGrantChange, rebaseDraft, type PermissionDraft, type PermissionEdit, type PermissionScreen, type AppPermissionsWire, grantRequestFor, pendingCapabilities, type GrantRequestDecision, type ResourceOption, } from "./permissions.js";
+export { permissionPinsSchema, permissionSaveSchema, type PermissionPins, appPermissionsWireSchema, appPermissionPageSchema, permissionScreen, draftOf, editPermissions, planGrantChange, rebaseDraft, type PermissionDraft, type PermissionEdit, type PermissionScreen, type AppPermissionsWire, type AppPermissionsPort, type AppPermissionsViewData, grantRequestFor, pendingCapabilities, type GrantRequestDecision, type ResourceOption, } from "./permissions.js";
 export { admits, admitMethodMetadata, appInvocationCeiling, approvedBindingGrants, scopedBindings, grantsFor, gateRefusalSchema, gateRequestSchema, invocationGrantsSchema, type AppMethodDeclaration, type AppMethodMetadataDecision, type GateDecision, type GateFacts, type GateRequest, type HostPrincipal, type InvocationGrants, } from "./gate.js";
 export { deriveDeclaredOperations, appCallOperation } from "./operations.js";
 export { appToolPolicySchema, type AppToolAccess, type AppToolEntry, type AppToolPolicy, } from "./tools.js";

package/dist/apps/installation.d.ts

@@ -110,6 +110,8 @@ export type GrantContext = Readonly<{
     declaration: AppDeclaration;
     declaredOperations: DeclaredOperations;
     now: number;
+    /** Host-attested configured built-in Shell; never a manifest or command field. */
+    builtInShell?: boolean;
 }>;
 export type GrantRefusal = Readonly<{
     kind: "refused";
@@ -121,10 +123,6 @@ export declare function applyGrantCommand(current: AppAuthority | null, rawComma
 export declare const declaredOperationsSchema: z.ZodLazy<z.ZodObject<{
     artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
-        digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    }, z.core.$strict>>>>;
     capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
         capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
         operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
@@ -189,28 +187,6 @@ export declare const installationSchema: z.ZodObject<{
         disabled: "disabled";
         deleted: "deleted";
     }>;
-    visibility: z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>;
-    approvedAnonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
-        digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    }, z.core.$strict>>>>;
-    anonymousApproval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
-        by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
-            kind: import("zod/mini").ZodMiniLiteral<"member">;
-            memberId: import("zod/mini").ZodMiniString<string>;
-        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
-            kind: import("zod/mini").ZodMiniLiteral<"agent">;
-            agentId: import("zod/mini").ZodMiniString<string>;
-        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
-            kind: import("zod/mini").ZodMiniLiteral<"team-key">;
-            keyId: import("zod/mini").ZodMiniString<string>;
-        }, z.core.$strip>], "kind">;
-        at: z.ZodNumber;
-        authorityVersion: z.ZodLazy<z.ZodNumber>;
-    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 export type Installation = Readonly<z.output<typeof installationSchema>>;
 /** Host commands; floating targets have already been resolved to immutable Releases. */
@@ -259,12 +235,6 @@ export declare const installationCommandSchema: z.ZodLazy<z.ZodDiscriminatedUnio
         disabled: "disabled";
         deleted: "deleted";
     }>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"set-visibility">;
-    visibility: z.ZodEnum<{
-        private: "private";
-        public: "public";
-    }>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"change-grants">;
     changes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -277,12 +247,6 @@ export declare const installationCommandSchema: z.ZodLazy<z.ZodDiscriminatedUnio
             }, z.core.$strict>>>>>]>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"approve-anonymous">;
-    methods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
-        digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    }, z.core.$strict>>>>;
 }, z.core.$strict>], "kind">>;
 export type InstallationCommand = z.output<typeof installationCommandSchema>;
 /** Values captured by the host; identities and time are never generated by the reducer. */
@@ -294,10 +258,8 @@ export type InstallationContext = Readonly<{
     declaredOperations: DeclaredOperations;
     now: number;
     identity: Pick<Installation, "installationId" | "instanceId">;
-    /** Trusted interactive consent; never copied from a command or inferred from a key's owner role. */
-    anonymousConsent?: Readonly<{
-        memberId: string;
-    }>;
+    /** Operator-selected built-in Shell, attested by the executing host, not the App. */
+    builtInShell?: boolean;
 }>;
 /** Closed refusals: failed commands produce no installation update. */
 export declare const installationRefusalSchema: z.ZodLazy<z.ZodObject<{

package/dist/apps/installation.js

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import * as Schema from "effect/Schema";
 import * as Result from "effect/Result";
-import { appCapabilityIdSchema, appApiMethodNameSchema, } from "@fungi.computer/puffball/app";
+import { appCapabilityIdSchema, } from "@fungi.computer/puffball/app";
 import { hostActorSchema } from "@fungi.computer/puffball/app-method-runtime";
 import { appIdSchema, releaseSchema, sha256DigestSchema, } from "@fungi.computer/puffball/effect";
 import { instanceIdSchema } from "../instance-id.js";
@@ -119,7 +119,6 @@ export function applyGrantCommand(current, rawCommand, context) {
             current.declaredOperationsDigest !== context.declaredOperations.digest))
         return refuse("stale_authority");
     if (context.principal.role === null ||
-        context.principal.actor.kind === "visitor" ||
         (command.kind === "change-grants" && context.principal.role !== "owner"))
         return refuse("not_owner");
     const declared = (capability) => context.declaredOperations.capabilities.find((row) => row.capability === capability)?.operations ?? [];
@@ -131,7 +130,9 @@ export function applyGrantCommand(current, rawCommand, context) {
             grants =
                 context.principal.role === "owner"
                     ? context.declaration.capabilities
-                        .filter((capability) => permissionCatalog[capability].consent === "install")
+                        .filter((capability) => permissionCatalog[capability].consent === "install" ||
+                        (capability === "team.workbenchHost" &&
+                            context.builtInShell === true))
                         .map((capability) => ({
                         capability,
                         capabilityApproved: true,
@@ -190,23 +191,10 @@ export function applyGrantCommand(current, rawCommand, context) {
         approval,
     });
 }
-const anonymousMethodsSchema = z
-    .array(z
-    .strictObject({
-    name: ownerCodec(appApiMethodNameSchema),
-    digest: ownerCodec(sha256DigestSchema),
-})
-    .readonly())
-    .refine((methods) => methods.every((method, index) => {
-    const previous = methods[index - 1];
-    return previous === undefined || previous.name < method.name;
-}), "Anonymous method identities must have unique, sorted names")
-    .readonly();
 /** Immutable operation facts derived from descriptor methods and the binding registry. */
 export const declaredOperationsSchema = z.lazy(() => z.strictObject({
     artifactDigest: ownerCodec(sha256DigestSchema),
     digest: ownerCodec(sha256DigestSchema),
-    anonymousMethods: anonymousMethodsSchema,
     capabilities: z
         .array(z
         .strictObject({
@@ -226,20 +214,8 @@ export const installationSchema = z
     releasePin: z.enum(["pinned", "floating"]),
     authority: appAuthoritySchema,
     status: z.enum(["enabled", "disabled", "deleted"]),
-    visibility: z.enum(["private", "public"]),
-    approvedAnonymousMethods: anonymousMethodsSchema,
-    anonymousApproval: approvalSchema.nullable(),
 })
-    .refine((installation) => installation.appId === installation.release.appId, "Release must belong to the installation's App")
-    .refine((installation) => {
-    const approval = installation.anonymousApproval;
-    return approval === null
-        ? installation.approvedAnonymousMethods.length === 0
-        : installation.status !== "deleted" &&
-            installation.approvedAnonymousMethods.length > 0 &&
-            approval.by.kind === "member" &&
-            approval.authorityVersion <= installation.authority.authorityVersion;
-}, "Anonymous authority requires a retained human approval receipt");
+    .refine((installation) => installation.appId === installation.release.appId, "Release must belong to the installation's App");
 const releaseFields = {
     release: ownerCodec(releaseSchema),
     releasePin: installationSchema.shape.releasePin,
@@ -255,18 +231,10 @@ export const installationCommandSchema = z.lazy(() => z.discriminatedUnion("kind
         kind: z.literal("set-status"),
         status: installationSchema.shape.status,
     }),
-    z.strictObject({
-        kind: z.literal("set-visibility"),
-        visibility: installationSchema.shape.visibility,
-    }),
     z.strictObject({
         kind: z.literal("change-grants"),
         changes: grantChangesSchema,
     }),
-    z.strictObject({
-        kind: z.literal("approve-anonymous"),
-        methods: anonymousMethodsSchema,
-    }),
 ]));
 /** Closed refusals: failed commands produce no installation update. */
 export const installationRefusalSchema = z.lazy(() => z.strictObject({
@@ -301,13 +269,6 @@ export function applyInstallationCommand(current, rawCommand, context) {
     }
     if (command.kind === "change-grants" && context.role !== "owner")
         return refuse("not_owner");
-    const anonymousConsent = context.by.kind === "member" &&
-        context.anonymousConsent?.memberId === context.by.memberId;
-    if (command.kind === "approve-anonymous") {
-        const narrows = command.methods.every((method) => current?.approvedAnonymousMethods.some((approved) => approved.name === method.name && approved.digest === method.digest));
-        if (context.role !== "owner" || (!narrows && !anonymousConsent))
-            return refuse("not_owner");
-    }
     const release = command.kind === "install" || command.kind === "select-release"
         ? command.release
         : current?.release;
@@ -327,7 +288,7 @@ export function applyInstallationCommand(current, rawCommand, context) {
         ? { kind: command.kind }
         : command.kind === "change-grants"
             ? command
-            : command.kind === "set-status" && command.status === "deleted"
+            : command.status === "deleted"
                 ? { kind: "delete" }
                 : null;
     const authority = grantCommand === null
@@ -348,34 +309,10 @@ export function applyInstallationCommand(current, rawCommand, context) {
             declaration: context.declaration,
             declaredOperations: context.declaredOperations,
             now: context.now,
+            builtInShell: context.builtInShell === true,
         });
     if (Result.isFailure(authority))
         return refuse(authority.failure.code);
-    let anonymousMethods = current?.approvedAnonymousMethods ?? [];
-    let anonymousApproval = current?.anonymousApproval ?? null;
-    if (command.kind === "approve-anonymous") {
-        if (command.methods.some((method) => !context.declaredOperations.anonymousMethods.some((declared) => declared.name === method.name &&
-            declared.digest === method.digest)))
-            return refuse("not_declared");
-        anonymousMethods = command.methods;
-        if (command.methods.length === 0)
-            anonymousApproval = null;
-        else if (anonymousConsent)
-            anonymousApproval = {
-                by: context.by,
-                at: context.now,
-                authorityVersion: version,
-            };
-    }
-    if (command.kind === "select-release") {
-        anonymousMethods = anonymousMethods.filter((method) => context.declaredOperations.anonymousMethods.some((declared) => declared.name === method.name && declared.digest === method.digest));
-        if (anonymousMethods.length === 0)
-            anonymousApproval = null;
-    }
-    if (command.kind === "set-status" && command.status === "deleted") {
-        anonymousMethods = [];
-        anonymousApproval = null;
-    }
     const next = installationSchema.safeParse({
         installationId: current?.installationId ?? context.identity.installationId,
         instanceId: current === null ? context.identity.instanceId : current.instanceId,
@@ -387,12 +324,7 @@ export function applyInstallationCommand(current, rawCommand, context) {
         status: command.kind === "set-status"
             ? command.status
             : (current?.status ?? "enabled"),
-        visibility: command.kind === "set-visibility"
-            ? command.visibility
-            : (current?.visibility ?? "private"),
         authority: authority.success,
-        approvedAnonymousMethods: anonymousMethods,
-        anonymousApproval,
     });
     return next.success
         ? Result.succeed({ next: next.data, authorityChanged: true })

package/dist/apps/operations.js

@@ -1,6 +1,5 @@
 import { appBackendBindingOperation, } from "@fungi.computer/puffball/app";
 import { sha256 } from "../release.js";
-import canonicalJson from "fast-json-stable-stringify";
 import { declaredOperationsSchema, } from "./installation.js";
 /** Qualify backend operations so a same-named browser method grants no backend authority. */
 export function bindingOperationKey(binding, operation) {
@@ -75,24 +74,15 @@ export async function deriveDeclaredOperations(release, declaration, descriptors
         operations: [...operations].sort(),
     }));
     const artifactDigest = release.artifact.artifactDigest;
-    const anonymousMethods = await Promise.all(Object.entries(declaration.api?.methods ?? {})
-        .filter(([, method]) => method.anonymous === true)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-        .map(async ([name, method]) => ({
-        name,
-        digest: await sha256(new TextEncoder().encode(canonicalJson(method))),
-    })));
     const digest = await sha256(new TextEncoder().encode(JSON.stringify({
         artifactDigest,
         capabilities: rows,
         routes,
         bindings,
-        anonymousMethods,
     })));
     return declaredOperationsSchema.parse({
         artifactDigest,
         digest,
         capabilities: rows,
-        anonymousMethods,
     });
 }

package/dist/apps/permissions.d.ts

@@ -103,10 +103,6 @@ export declare const appPermissionsWireSchema: z.ZodObject<{
     declaredOperations: z.ZodLazy<z.ZodObject<{
         artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-        anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-            name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
-            digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-        }, z.core.$strict>>>>;
         capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
             capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
             operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
@@ -234,14 +230,28 @@ export declare const appPermissionPageSchema: z.ZodObject<{
         declaredOperations: z.ZodLazy<z.ZodObject<{
             artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
             digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-            anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-                name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
-                digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-            }, z.core.$strict>>>>;
             capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
                 capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
                 operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             }, z.core.$strict>>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
+    canEdit: z.ZodBoolean;
+    resources: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
+/** A host's live authority and resource directory, never browser-minted grants. */
+export type AppPermissionsViewData = z.output<typeof appPermissionPageSchema>;
+/**
+ * Hosts authenticate, fence and commit; the shared view owns the permission draft.
+ * @interface
+ */
+export type AppPermissionsPort = Readonly<{
+    /** Read the installation's current permissions, whether the caller can edit them, and the available resources. */
+    read(appKey: string): Promise<AppPermissionsViewData | "unavailable">;
+    /** Submit edited grants with the store generation, authority version and artifact digest. The host checks authorization and freshness before saving. */
+    submit(appKey: string, pins: PermissionPins, changes: readonly GrantChange[]): Promise<"accepted" | "stale" | "refused" | "unavailable" | "unconfirmed">;
+}>;

package/dist/apps/permissions.js

@@ -214,7 +214,7 @@ export function permissionScreen(input) {
                     ? []
                     : [
                         row("all", scope === "computer" ? "All Computers" : "All Agents"),
-                        ...[...resources.values()].map((resource) => row(resource, resource.label)),
+                        ...[...resources.values()].map((resource) => row({ kind: resource.kind, id: resource.id }, resource.label)),
                     ],
                 switches: capabilities
                     .filter((capability) => permissionCatalog[capability].scope === null)
@@ -252,4 +252,10 @@ export const appPermissionPageSchema = z.strictObject({
     appName: z.string(),
     artifactDigest: ownerCodec(sha256DigestSchema),
     permissions: appPermissionsWireSchema,
+    canEdit: z.boolean(),
+    resources: z.array(z.strictObject({
+        kind: z.string(),
+        id: z.string(),
+        label: z.string(),
+    })),
 });

package/dist/auth.d.ts

@@ -1,24 +1,7 @@
-import type { OysterAuth, OysterHost } from "./host.js";
+import type { OysterAuth } from "./host.js";
 import type { OysterKeyStore } from "./keys.js";
 /** Cookie emitted by ownerKeyAuth, for composing credential-specific adapters. */
 export declare const ownerKeyCookieName = "oyster_session";
-/** Host-minted opaque sessions for named keys, separate from the owner cookie. */
-export declare const keySessionCookieName = "oyster_key_session";
-/**
- * The host owns session minting, hashing/storage and expiry.
- * A session resolves only to a key id, never to owner or grant authority.
- * Hosts should use Path=/, HttpOnly, Secure and SameSite=Lax (or stricter)
- * as defense in depth; Oyster independently checks request provenance.
- * Cookie-only admission allows GET/HEAD navigation. Every other method requires
- * Origin to be present and equal the request URL's origin, and Sec-Fetch-Site
- * not to be cross-site. Missing Origin is refused.
- */
-export type OysterKeySessionResolver = Readonly<{
-    /** Resolve an opaque host session to its named key, or null when unavailable. */
-    resolve: (value: string) => Promise<Readonly<{
-        keyId: string;
-    }> | null>;
-}>;
 /**
  * Single-owner sign-in: a bearer token or a session cookie holding the
  * owner key's digest. The key itself is never stored in the browser.
@@ -26,9 +9,3 @@ export type OysterKeySessionResolver = Readonly<{
 export declare function ownerKeyAuth(ownerKey: string, ownerId?: string): OysterAuth;
 /** The owner key, or a named key admitted as its canonical Team-key actor. */
 export declare function ownerOrKeyAuth(ownerKey: string, ownerId: string, keys: () => Pick<OysterKeyStore, "verify">): OysterAuth;
-/**
- * Add host-owned browser sessions to ownerOrKeyAuth. Explicit credentials and
- * non-401 refusals keep their ordinary result; ambient cookies cannot undo them.
- * Every cookie admission rechecks the key's liveness and canonical owner.
- */
-export declare function keySessionAuth(auth: OysterAuth, ownerId: string, keys: () => NonNullable<OysterHost["keys"]>, sessions: OysterKeySessionResolver): OysterAuth;

package/dist/auth.js

@@ -1,13 +1,9 @@
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import { parse } from "hono/utils/cookie";
 import { presentedGitKey } from "./git-auth.js";
 import { sha256 } from "./release.js";
-import { sameOriginRequest } from "./request-origin.js";
 /** Cookie emitted by ownerKeyAuth, for composing credential-specific adapters. */
 export const ownerKeyCookieName = "oyster_session";
-/** Host-minted opaque sessions for named keys, separate from the owner cookie. */
-export const keySessionCookieName = "oyster_key_session";
 const loginFormSchema = Schema.Struct({ key: Schema.String });
 /** Compare two secrets through their fixed-length digests, in constant time. */
 async function constantTimeEqual(a, b) {
@@ -52,7 +48,15 @@ export function ownerKeyAuth(ownerKey, ownerId = "owner") {
             return { kind: "refused", status: 401 };
         },
         async login(request) {
-            const form = Schema.decodeUnknownOption(loginFormSchema)(Object.fromEntries(await request.formData()));
+            // A body that is not a form is a malformed sign-in, not a server fault.
+            const fields = await request.formData().catch((cause) => {
+                if (cause instanceof TypeError)
+                    return null;
+                throw cause;
+            });
+            if (fields === null)
+                return new Response("Expected a sign-in form", { status: 400 });
+            const form = Schema.decodeUnknownOption(loginFormSchema)(Object.fromEntries(fields));
             if (Option.isNone(form) ||
                 !(await constantTimeEqual(form.value.key, ownerKey)))
                 return new Response("Wrong key", { status: 401 });
@@ -95,37 +99,3 @@ export function ownerOrKeyAuth(ownerKey, ownerId, keys) {
             Promise.resolve(new Response("Sign-in is not available", { status: 404 })),
     };
 }
-/**
- * Add host-owned browser sessions to ownerOrKeyAuth. Explicit credentials and
- * non-401 refusals keep their ordinary result; ambient cookies cannot undo them.
- * Every cookie admission rechecks the key's liveness and canonical owner.
- */
-export function keySessionAuth(auth, ownerId, keys, sessions) {
-    return {
-        ...auth,
-        async authenticate(request) {
-            const result = await auth.authenticate(request);
-            if (result.kind === "admitted" ||
-                result.status !== 401 ||
-                request.headers.has("Authorization"))
-                return result;
-            if (request.method !== "GET" &&
-                request.method !== "HEAD" &&
-                !sameOriginRequest(request))
-                return result;
-            const value = parse(request.headers.get("Cookie") ?? "", keySessionCookieName)[keySessionCookieName];
-            if (value === undefined || value.length === 0)
-                return result;
-            const session = await sessions.resolve(value);
-            if (session === null)
-                return result;
-            const key = await keys().live(session.keyId);
-            return key !== null && key.owner === ownerId
-                ? {
-                    kind: "admitted",
-                    principal: { actor: { kind: "team-key", keyId: key.keyId } },
-                }
-                : result;
-        },
-    };
-}