@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/shell/app-directory.js

@@ -1,196 +0,0 @@
-import * as Schema from "effect/Schema";
-import { appDeclaredCommandSchema, appCallsSchema, } from "@fungi.computer/puffball/app";
-import { appDeclaredGillSchema, appGillParamsSchema, } from "@fungi.computer/gills";
-import * as z from "zod";
-/** An App address selects a host default or a specific installation. */
-export const appAddressSchema = z.lazy(() => z.union([
-    z.strictObject({
-        kind: z.literal("default"),
-        appId: z.string().min(1),
-    }),
-    z.strictObject({
-        kind: z.literal("installation"),
-        installationId: z.string().min(1),
-    }),
-]));
-/** Host-reported progress of applying a revised App authority version. */
-export const appAuthorityEnforcementSchema = z.lazy(() => z.strictObject({
-    requestId: z.string().min(1),
-    address: appAddressSchema,
-    authorityVersion: z.number().int().positive(),
-    state: z.enum(["unaffected", "pending", "applied", "expired"]),
-    outstanding: z.number().int().nonnegative(),
-}));
-/** Stable identity of one App address across directory and settings views. */
-export const addressKey = (address) => address.kind === "default"
-    ? `default:${address.appId}`
-    : `installation:${address.installationId}`;
-/** Reusable App metadata supplied by an embedding host; it conveys no permissions. */
-export const appDirectoryEntrySchema = z.strictObject({
-    address: appAddressSchema,
-    installationId: z.string().min(1).nullable(),
-    surfaceId: z.string().min(1),
-    appId: z.string().min(1),
-    displayName: z.string().trim().min(1).optional(),
-    icon: z.string().min(1).nullable().optional(),
-    releaseId: z.string().min(1).nullable(),
-    authorityVersion: z.number().int().nonnegative(),
-    enforcement: appAuthorityEnforcementSchema.nullable(),
-    handlers: z.array(z.literal("file.open")),
-    roles: z.array(z.string().min(1)),
-    /** Capabilities the Release declares: the ceiling for host consent, never a grant. */
-    declaredCapabilities: z.array(z.string().min(1)),
-    calls: z
-        .unknown()
-        .transform((value) => Schema.decodeUnknownSync(appCallsSchema)(value))
-        .optional(),
-    commands: z
-        .array(z.unknown())
-        .transform((values) => values.map((value) => Schema.decodeUnknownSync(appDeclaredCommandSchema)(value))),
-    gills: z.array(z.unknown()).transform((values) => values.map((value) => Schema.decodeUnknownSync(appDeclaredGillSchema, {
-        onExcessProperty: "error",
-    })(value))),
-    availability: z.enum(["available", "unavailable"]),
-    surface: z
-        .strictObject({
-        stableRoute: z.string().min(1),
-    })
-        .nullable(),
-    surfacePath: z.string().startsWith("/"),
-});
-/** A host-resolved role selection; a surface address is not launch authority. */
-export const appRoleSelectionSchema = z.strictObject({
-    surfaceId: z.string().min(1).nullable(),
-    chosen: z.boolean(),
-});
-const appComputerOperationSchema = z.enum([
-    "computer.list",
-    "computer.readFile",
-    "computer.writeFile",
-    "computer.execute",
-]);
-const selectedComputerPermissionSchema = z.lazy(() => z.strictObject({
-    kind: z.literal("selected-computers"),
-    computers: z.array(z.strictObject({
-        computerId: z.string().min(1),
-        operations: z.array(appComputerOperationSchema),
-    })),
-}));
-const allTeamComputersPermissionSchema = z.lazy(() => z.strictObject({
-    kind: z.literal("all-team-computers"),
-    operations: z.array(appComputerOperationSchema),
-}));
-/** App Computer permissions limited to selected Computers or the Team's Computers. */
-export const appComputerPermissionSchema = z.discriminatedUnion("kind", [
-    selectedComputerPermissionSchema,
-    allTeamComputersPermissionSchema,
-]);
-const agentDirectoryOperationSchema = z.enum(["agent.list"]);
-const agentSessionOperationSchema = z.enum([
-    "agent.read",
-    "agent.send",
-    "agent.manage",
-]);
-/** Agent directory and session operations an App may request from its host. */
-export const appAgentPermissionSchema = z.discriminatedUnion("kind", [
-    z.strictObject({
-        kind: z.literal("all-team-agents"),
-        directoryOperations: z.array(agentDirectoryOperationSchema),
-        sessionOperations: z.array(agentSessionOperationSchema),
-    }),
-    z.strictObject({
-        kind: z.literal("selected-agents"),
-        directoryOperations: z.array(agentDirectoryOperationSchema),
-        agents: z.array(z.strictObject({
-            agentId: z.string().min(1).max(256),
-            sessionOperations: z.array(agentSessionOperationSchema),
-        })),
-    }),
-]);
-/** Whether an App may use language-model and media generation services. */
-export const appGenerationPermissionsSchema = z.strictObject({
-    llm: z.boolean(),
-    media: z.boolean(),
-});
-/** Whether an App may browse, buy, or install free marketplace entries. */
-export const appMarketplacePermissionsSchema = z.strictObject({
-    browse: z.boolean(),
-    purchase: z.boolean(),
-    installFree: z.boolean(),
-});
-/**
- * A host's Team App directory with its permission projection, parsed strictly
- * by every consumer: an unknown field is a contract change both sides make.
- */
-export const appDirectoryResponseSchema = z.lazy(() => z.strictObject({
-    actorIsTeamOwner: z.boolean(),
-    needsUpdate: z
-        .array(z.strictObject({
-        installationId: z.string().min(1).nullable(),
-        appId: z.string().min(1).nullable(),
-        displayName: z.string().min(1),
-    }))
-        .optional(),
-    apps: z.array(appDirectoryEntrySchema.extend({
-        override: z
-            .strictObject({
-            appId: z.string().min(1).optional(),
-            releaseId: z.string().min(1),
-            surfaceRoute: z.string().min(1).nullable(),
-        })
-            .nullable(),
-        grants: z.array(z.strictObject({
-            operation: z.string().min(1),
-            resourceId: z.string().min(1),
-        })),
-        computerPermission: appComputerPermissionSchema.nullable().optional(),
-        generationPermissions: appGenerationPermissionsSchema,
-        marketplacePermissions: appMarketplacePermissionsSchema,
-        agentPermission: appAgentPermissionSchema,
-    })),
-    /** The Team's effective App per role, owned and resolved by the host. */
-    roles: z.record(z.string().min(1), appRoleSelectionSchema),
-}));
-/** Desktop metadata is a method result, distinct from the full Release Gill declaration. */
-const catalogGillParamsSchema = z.lazy(() => z
-    .array(z.strictObject({
-    key: z.string().max(64),
-    label: z.string().max(256),
-    kind: z.enum(["computer", "repository", "branch"]),
-    required: z.boolean(),
-    options: z.string().max(256).optional(),
-}))
-    .max(4)
-    // The wire shape is representable; Gill owns its domain refinements.
-    .refine(Schema.is(appGillParamsSchema), "Invalid Gill placement parameters"));
-const catalogGillSchema = z.strictObject({
-    id: z.string().trim().min(1).max(256),
-    title: z.string().trim().min(1).max(256),
-    params: catalogGillParamsSchema.optional(),
-    desktop: z
-        .strictObject({
-        sizes: z
-            .array(z.enum(["S", "M", "L"]))
-            .min(1)
-            .max(3)
-            .refine((sizes) => new Set(sizes).size === sizes.length, "Repeated Gill size"),
-    })
-        .optional(),
-});
-/** Read-only catalog metadata for one App, without host-specific role policy. */
-export const appCatalogEntrySchema = appDirectoryEntrySchema
-    .pick({
-    surfaceId: true,
-    appId: true,
-    displayName: true,
-})
-    .extend({ gills: z.array(catalogGillSchema).max(16) });
-/** Read-only desktop metadata; identities are surface addresses, never launch authority. */
-export const appCatalogResponseSchema = z.lazy(() => z.strictObject({
-    apps: z.array(appCatalogEntrySchema).max(50),
-    roles: z.strictObject({
-        inbox: appRoleSelectionSchema.optional(),
-    }),
-}));
-/** Complete APPS.catalog reply, including broker admission failures. */
-export const appCatalogBrokerResultSchema = z.lazy(() => z.union([appCatalogResponseSchema, z.strictObject({ error: z.string() })]));

package/dist/shell/browser-actions.d.ts

@@ -1,7 +0,0 @@
-import type { AppBrowserAction, AppBrowserActionOutcome } from "@fungi.computer/agar";
-/** Browser effects stay in the trusted host, bound to one mounted App frame. */
-export declare function createBrowserActionHandler(options: {
-    frame: HTMLIFrameElement;
-    hostWindow: Window;
-    signal: AbortSignal;
-}): (request: AppBrowserAction) => Promise<AppBrowserActionOutcome>;

package/dist/shell/browser-actions.js

@@ -1,56 +0,0 @@
-import { APP_BROWSER_SAVE_MAX_BYTES, APP_BROWSER_COPY_MAX_BYTES, } from "@fungi.computer/agar";
-/** Browser effects stay in the trusted host, bound to one mounted App frame. */
-export function createBrowserActionHandler(options) {
-    let pending = false;
-    return async (request) => {
-        const { frame, hostWindow, signal } = options;
-        if (signal.aborted || !frame.isConnected)
-            return { kind: "refused", reason: "unavailable" };
-        if (!hostWindow.navigator.userActivation.isActive ||
-            hostWindow.document.activeElement !== frame)
-            return { kind: "refused", reason: "no-user-gesture" };
-        if (request.kind === "saveFile"
-            ? request.bytes.byteLength > APP_BROWSER_SAVE_MAX_BYTES
-            : new TextEncoder().encode(request.text).byteLength >
-                APP_BROWSER_COPY_MAX_BYTES)
-            return { kind: "refused", reason: "too-large" };
-        if (pending)
-            return { kind: "refused", reason: "busy" };
-        pending = true;
-        try {
-            if (request.kind === "copyText") {
-                await hostWindow.navigator.clipboard.writeText(request.text);
-                return { kind: "copied" };
-            }
-            const blob = new Blob([new Uint8Array(request.bytes)], {
-                type: request.mime,
-            });
-            const url = URL.createObjectURL(blob);
-            try {
-                const link = hostWindow.document.createElement("a");
-                link.href = url;
-                link.download = request.name;
-                link.click();
-            }
-            finally {
-                // Keep the bytes alive until the browser handles the navigation task.
-                hostWindow.setTimeout(() => {
-                    URL.revokeObjectURL(url);
-                }, 0);
-            }
-            // The browser accepted a download; this does not attest a disk write.
-            return { kind: "saved" };
-        }
-        catch (cause) {
-            return {
-                kind: "refused",
-                reason: cause instanceof DOMException && cause.name === "NotAllowedError"
-                    ? "denied"
-                    : "unavailable",
-            };
-        }
-        finally {
-            pending = false;
-        }
-    };
-}

package/dist/shell/command-host.d.ts

@@ -1,112 +0,0 @@
-/** An optional field a declaration may carry as explicitly undefined. */
-export type AppCommandOptional<T> = T | undefined;
-/**
- * The digest-covered command rows a mounted App's Release declares, as the
- * host receives them. Oyster compares and projects them; the Release
- * declaration grammar stays with its owner, which hands rows of this shape.
- */
-export type AppCommandDeclaration = Readonly<{
-    id: string;
-    title: string;
-    category: string;
-    description?: AppCommandOptional<string>;
-    projections?: AppCommandOptional<Readonly<{
-        bindings?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-            values: readonly string[];
-        }>>;
-        agent?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-            keybind?: AppCommandOptional<string>;
-        }>>;
-        help?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-        }>>;
-        menu?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-        }>>;
-        palette?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-        }>>;
-        slash?: AppCommandOptional<Readonly<{
-            order?: AppCommandOptional<number>;
-            aliases: readonly string[];
-        }>>;
-    }>>;
-}>;
-import type { AppHostHandlers, AppHostReservedChord } from "@fungi.computer/agar/host";
-import { type WhistleExecutionInput, type WhistleExecutionOutcome, type WhistleContributionLease, type WhistleCommand, type WhistleMenuProjection, type WhistleRuntime, type WhistleSnapshot } from "@fungi.computer/whistle";
-/** Select the shell command-palette chord for a Mac or non-Mac keyboard. */
-export declare function commandPaletteReservedChordForPlatform(mac: boolean): AppHostReservedChord;
-/** Select the shell command-palette chord from the embedding browser user agent. */
-export declare function commandPaletteReservedChordForUserAgent(userAgent: string): AppHostReservedChord;
-/** Whistle source of Release-advertised rows for Apps not yet mounted. */
-export declare const appDirectorySourceId = "app-directory";
-/** The command side of one mounted App's host handlers. */
-export type AppSurfaceCommandMount = Readonly<{
-    /** The narrow handler shape consumed by Agar's App host connection. */
-    readonly handlers: Pick<AppHostHandlers, "registerCommands" | "invokeReservedChord">;
-    /** Release this App's contribution and its mount identity. */
-    readonly dispose: () => void;
-}>;
-/** Commands owned by one pane, projected to globals plus its focus scope. */
-export type PaneCommands = Readonly<{
-    /** Qualify a locally contributed id in this pane's own namespace. */
-    commandId: (id: string) => string;
-    /** Contribute or replace commands owned by this pane through the returned lease. */
-    contribute: (commands: readonly WhistleCommand<never>[]) => WhistleContributionLease;
-    execute: WhistleRuntime["execute"];
-    snapshot: WhistleRuntime["snapshot"];
-    subscribe: WhistleRuntime["subscribe"];
-    /** Registered locally; only the focused pane presents human executions. */
-    present: WhistleRuntime["present"];
-}>;
-/** Closing a pane withdraws all its leases, presenters and subscriptions. */
-export type PaneCommandMount = PaneCommands & Readonly<{
-    /** Withdraw this pane's contributions, presenters and subscriptions. */
-    dispose: () => void;
-}>;
-/** The shell-owned Whistle graph and its focused menu projection. */
-export type AppSurfaceCommandHost = Readonly<{
-    /** Create the command scope for one locally rendered pane. */
-    readonly mountPane: (paneId: string) => PaneCommandMount;
-    /** Create one command admission scope for a mounted App. */
-    readonly mount: (mountId: string, declarations: readonly AppCommandDeclaration[]) => AppSurfaceCommandMount;
-    /** Select the App or pane whose commands are the active human-facing ones. */
-    readonly focus: (mountId: string | null) => void;
-    /** Register the shell's own global commands in the shared Whistle graph. */
-    readonly registerShellCommands: (commands: readonly WhistleCommand<never>[]) => () => void;
-    /** Publish verified Release command rows before their App is mounted. */
-    readonly registerDirectoryCommands: (commands: readonly Readonly<{
-        surfaceId: string;
-        appTitle: string;
-        command: AppCommandDeclaration;
-    }>[], run: (surfaceId: string, commandId: string) => Promise<void>) => () => void;
-    /** Read the menu rows belonging to the focused App. */
-    readonly menu: () => readonly WhistleMenuProjection[];
-    /**
-     * The human-facing commands for the current focus: shell rows plus the
-     * focused mount's rows, with its aliases and keys shadowing the shell's.
-     */
-    readonly active: () => WhistleSnapshot;
-    /** Execute an active row, an agent row, or an exact programmatic action. */
-    readonly execute: (commandId: string, input: WhistleExecutionInput) => Promise<WhistleExecutionOutcome>;
-    /** Read the complete renderer-neutral graph for host consumers. */
-    readonly snapshot: () => WhistleSnapshot;
-    /** Observe graph changes, including contribution replacement and disposal. */
-    readonly subscribe: (listener: () => void) => () => void;
-    /** Dispose all App contributions and close the shell runtime. */
-    readonly dispose: () => void;
-}>;
-/**
- * Own one shell's Whistle runtime for mounted Apps and local panes. The
- * embedding host supplies verified Release declarations and decides which
- * App or pane has focus.
- *
- * Agar invokes `registerCommands` once for the aggregate command set of a
- * mount. The adapter keeps that aggregate as one Whistle generation, so an
- * Agar update replaces the generation atomically and disposal releases only
- * that App. Command handlers remain the App's callback; the shell only adds
- * the Whistle identity and routes focused menu execution to it.
- */
-export declare function createAppSurfaceCommandHost(whistle?: WhistleRuntime): AppSurfaceCommandHost;