@fungi.computer/oyster 0.2.0 → 0.3.1

package/dist/page/mount.js

@@ -1,19 +1,23 @@
 import { appOpenInputSchema, appsCall, appsOpen, } from "@fungi.computer/agar/apps";
 import { appApiMethodNameSchema } from "@fungi.computer/puffball/app";
 import { appIdSchema } from "@fungi.computer/puffball/effect";
-import { createBrowserActionHandler } from "../shell/browser-actions.js";
-import { createAppSurfaceCommandHost } from "../shell/command-host.js";
+import { createBrowserActionHandler } from "@fungi.computer/nacre";
+import { createAppSurfaceCommandHost } from "@fungi.computer/nacre/command-host";
 // App page: mounts one installed App's sandboxed frame and gives it the
 // capabilities this Oyster host provides. Bundled into `shellScript`.
-import { RpcTarget } from "@fungi.computer/capnweb";
+import { RpcTarget, RpcStub } from "@fungi.computer/capnweb";
+import { EventSource } from "eventsource";
+import { connectBrowser, UiBrowserError, } from "@fungi.computer/knapsack/ui/browser";
 import { createPageLifetime } from "./lifetime.js";
+import { computerTargetUrl } from "./computer-target.js";
 import * as Schema from "effect/Schema";
-import { AppError } from "@fungi.computer/agar";
+import { AppError, createCapabilityRegistry, } from "@fungi.computer/agar";
 import { appStorage } from "@fungi.computer/agar/storage";
+import { approvals } from "@fungi.computer/agar/approvals";
 import { oysterStorageHandle } from "./storage.js";
 import { appBackend, appMethods } from "@fungi.computer/agar/backend";
 import { computerList, computerPorts, computerProcesses, computerReadFile, computerTerminal, computerWriteFile, } from "@fungi.computer/agar/computer";
-import { agentList, agentManage, agentSessionRead, agentSessionWrite, } from "@fungi.computer/agar/agents";
+import { agentList, agentManage, agentSessionRead, agentSessionWrite, openAppAgent, } from "@fungi.computer/agar/agents";
 import { mediaGeneration } from "@fungi.computer/agar/media";
 import { MediaGeneration, mediaGenerationDescriptionSchema, } from "@fungi.computer/agar/media-json";
 import { registeredCapabilityHandle, } from "./capabilities.js";
@@ -23,6 +27,105 @@ import { parseJsonValue } from "@fungi.computer/whistle/wire";
 import { appDeclaredCommandSchema } from "@fungi.computer/puffball/app";
 import { TerminalCapability } from "./terminal.js";
 import { ComputerPortsHandle, ComputerProcessesHandle, } from "./computer-handles.js";
+/** One page-wide selected Session, using only its reporting App's admitted view. */
+export class OysterAgentBrowserHost {
+    #active;
+    #disposed = false;
+    /** End the selected connection with the page's own lifetime. */
+    constructor(signal) {
+        if (signal.aborted)
+            this.dispose();
+        else
+            signal.addEventListener("abort", () => {
+                this.dispose();
+            }, { once: true });
+    }
+    /** A departing or deselecting mount cannot close a different active mount. */
+    release(frame) {
+        if (this.#active?.frame !== frame)
+            return;
+        const previous = this.#active;
+        this.#active = undefined;
+        previous.close();
+    }
+    /** Release the page's current selection; later reports cannot reconnect it. */
+    dispose() {
+        this.#disposed = true;
+        if (this.#active !== undefined)
+            this.release(this.#active.frame);
+    }
+    /** Bind the reporting mount's current command view to its explicitly selected Session. */
+    async report(frame, selection, capabilities, whistle) {
+        if (this.#disposed)
+            return;
+        if (selection === null) {
+            this.release(frame);
+            return;
+        }
+        if (this.#active !== undefined)
+            this.release(this.#active.frame);
+        // Read-only Apps may observe Sessions, but cannot claim or settle UI work.
+        if (!capabilities.has(agentSessionWrite) && !capabilities.has(agentManage))
+            return;
+        let transport;
+        let connection;
+        const failure = () => {
+            console.warn("Oyster Agent browser connection failed");
+        };
+        const active = {
+            frame,
+            close: () => {
+                connection?.close();
+                if (transport !== undefined)
+                    void transport.close().catch(failure);
+            },
+        };
+        this.#active = active;
+        try {
+            transport = await openAppAgent(capabilities, {
+                agentId: selection.agentId,
+            });
+            if (this.#active !== active) {
+                await transport.close();
+                return;
+            }
+            const admitted = transport;
+            connection = connectBrowser({
+                baseUrl: `${admitted.baseUrl}/browser/sessions/${encodeURIComponent(selection.sessionId)}`,
+                whistle,
+                transport: {
+                    fetch: admitted.fetch,
+                    openEvents: (url) => new EventSource(url, { fetch: admitted.fetch }),
+                },
+            });
+            void connection.closed.catch((cause) => {
+                if (this.#active === active)
+                    this.release(frame);
+                console.warn("Oyster Agent browser connection failed", cause instanceof UiBrowserError
+                    ? cause.message
+                    : "Transport unavailable");
+            });
+        }
+        catch (cause) {
+            if (this.#active === active)
+                this.release(frame);
+            throw cause;
+        }
+    }
+}
+function agentDirectory(capabilities) {
+    const directory = createCapabilityRegistry();
+    const read = capabilities.find(({ id, version }) => id === agentSessionRead.id && version === agentSessionRead.version);
+    const write = capabilities.find(({ id, version }) => id === agentSessionWrite.id && version === agentSessionWrite.version);
+    const manage = capabilities.find(({ id, version }) => id === agentManage.id && version === agentManage.version);
+    if (read !== undefined)
+        directory.provide(agentSessionRead, agentSessionRead.schema.parse(new RpcStub(read.handle)));
+    if (write !== undefined)
+        directory.provide(agentSessionWrite, agentSessionWrite.schema.parse(new RpcStub(write.handle)));
+    if (manage !== undefined)
+        directory.provide(agentManage, agentManage.schema.parse(new RpcStub(manage.handle)));
+    return directory;
+}
 /** Current server-admitted configuration for one installed App page. */
 export const oysterAppConfigSchema = Schema.Struct({
     workbench: Schema.Boolean,
@@ -59,15 +162,17 @@ async function answer(response) {
 }
 /** The App's typed methods, reached through this host's method route. */
 class Methods extends RpcTarget {
+    computerTarget;
     #url;
-    constructor(url) {
+    constructor(url, computerTarget) {
         super();
+        this.computerTarget = computerTarget;
         this.#url = url;
     }
     async call(method, input) {
         const name = Schema.decodeUnknownSync(Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_.]{0,79}$/u)))(method);
         const body = Schema.decodeUnknownSync(Schema.String)(input);
-        return answer(await fetch(`${this.#url}${name}`, {
+        return answer(await fetch(computerTargetUrl(`${this.#url}${name}`, this.computerTarget), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body,
@@ -81,10 +186,12 @@ class Methods extends RpcTarget {
 class Calls extends RpcTarget {
     base;
     signal;
-    constructor(base, signal) {
+    computerTarget;
+    constructor(base, signal, computerTarget) {
         super();
         this.base = base;
         this.signal = signal;
+        this.computerTarget = computerTarget;
     }
     async call(appId, method, input) {
         const target = Schema.decodeUnknownSync(appIdSchema)(appId);
@@ -96,7 +203,7 @@ class Calls extends RpcTarget {
                 retryable: false,
             });
         Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Json))(body);
-        return answer(await fetch(`${this.base}${encodeURIComponent(target)}/${encodeURIComponent(name)}`, {
+        return answer(await fetch(computerTargetUrl(`${this.base}${encodeURIComponent(target)}/${encodeURIComponent(name)}`, this.computerTarget), {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body,
@@ -205,11 +312,14 @@ export async function mountOysterPage() {
     // The App's commands are still admitted against its Release declaration.
     const commands = createAppSurfaceCommandHost();
     const mount = commands.mount(config.installationId, config.commands);
+    const agentBrowser = new OysterAgentBrowserHost(lifetime.signal);
     lifetime.own(() => {
         commands.dispose();
     });
     return connectOysterApp({
         config,
+        agentBrowser,
+        agentCommands: mount.agentCommands,
         frame,
         signal: lifetime.signal,
         reservedChords: [],
@@ -234,6 +344,11 @@ export async function connectOysterApp(options) {
     if (frame.contentWindow === null)
         throw new Error("App frame is unavailable");
     const capabilities = await oysterAppCapabilities(options);
+    const agents = agentDirectory(capabilities);
+    const releaseBrowser = () => {
+        options.agentBrowser.release(frame);
+    };
+    options.signal.addEventListener("abort", releaseBrowser, { once: true });
     const host = await connectAppHost({
         appWindow: frame.contentWindow,
         expectedAppOrigin: "null",
@@ -261,6 +376,14 @@ export async function connectOysterApp(options) {
         },
         handlers: {
             ...options.handlers,
+            reportAgentSessionSelection: async (selection) => {
+                await options.agentBrowser.report(frame, selection, agents, options.agentCommands);
+                await options.handlers.reportAgentSessionSelection(selection);
+            },
+            onDisconnect: async () => {
+                releaseBrowser();
+                await options.handlers.onDisconnect();
+            },
             requestBrowserAction: createBrowserActionHandler({
                 frame,
                 hostWindow: window,
@@ -305,11 +428,11 @@ export async function oysterAppCapabilities(options) {
                 let leaseExpiresAt = 0;
                 return new TerminalCapability((input) => transport("open", input), {
                     computerId: config.computerId,
-                    terminalUrl: selected.terminalUrl,
+                    terminalUrl: computerTargetUrl(selected.terminalUrl, options.computerTarget),
                     hostWindow: window,
                     mountSignal: options.signal,
                     ensureAccess: Object.assign(async (signal) => {
-                        const response = await fetch(`/apps/${encodeURIComponent(config.installationId)}/`, {
+                        const response = await fetch(computerTargetUrl(`/apps/${encodeURIComponent(config.installationId)}/`, options.computerTarget), {
                             headers: { Accept: "application/json" },
                             credentials: "same-origin",
                             cache: "no-store",
@@ -325,11 +448,18 @@ export async function oysterAppCapabilities(options) {
                                 retryable: false,
                             });
                         leaseExpiresAt = Date.now() + 60_000;
-                        return terminalSelection(current);
+                        const selected = terminalSelection(current);
+                        return {
+                            ...selected,
+                            terminalUrl: selected.terminalUrl === null
+                                ? null
+                                : computerTargetUrl(selected.terminalUrl, options.computerTarget),
+                        };
                     }, { leaseExpiresAt: () => leaseExpiresAt }),
                 });
             },
         },
+        { contract: approvals },
         { contract: agentList },
         { contract: agentManage },
         { contract: agentSessionRead },
@@ -357,7 +487,7 @@ export async function oysterAppCapabilities(options) {
             return [
                 Promise.resolve({
                     ...appsCall,
-                    handle: new Calls(base, options.signal),
+                    handle: new Calls(base, options.signal, options.computerTarget),
                 }),
             ];
         }
@@ -368,14 +498,20 @@ export async function oysterAppCapabilities(options) {
             return [];
         }
         return [
-            registeredCapabilityHandle(registration, descriptor, config.installationId).then((handle) => ({ ...registration.contract, handle })),
+            registeredCapabilityHandle(registration, descriptor, config.installationId, options.computerTarget).then((handle) => ({ ...registration.contract, handle })),
         ];
     }));
     if (unknownCapabilities.length > 0)
         document.body.dataset.oysterCapability = unknownCapabilities.join(", ");
     const resolved = [
-        { ...appBackend, handle: new Backend(config.backendUrl) },
-        { ...appMethods, handle: new Methods(config.methodsUrl) },
+        {
+            ...appBackend,
+            handle: new Backend(computerTargetUrl(config.backendUrl, options.computerTarget)),
+        },
+        {
+            ...appMethods,
+            handle: new Methods(config.methodsUrl, options.computerTarget),
+        },
         ...capabilities,
         ...(config.appsOpen && options.appOpen
             ? [{ ...appsOpen, handle: new AppOpen(options.appOpen) }]

package/dist/page-assets.d.ts

@@ -0,0 +1,22 @@
+import { HTTPException } from "hono/http-exception";
+/**
+ * Project the generated module's fields without exposing its private module name.
+ * The generated module remains the sole page-source contract.
+ * @inline
+ */
+export type PageAssetSources = {
+    [Key in keyof typeof import("#page-script")]: (typeof import("#page-script"))[Key];
+};
+/**
+ * Acquire page sources only when a host page or asset request needs them.
+ */
+export type PageAssetLoader = () => Promise<PageAssetSources>;
+/** A failed acquisition refuses this request without exposing loader details. */
+export declare class PageAssetsLoadError extends HTTPException {
+    constructor(cause: unknown);
+    getResponse(): Response;
+}
+/**
+ * Missing page sources must fail the request, never produce an empty script.
+ */
+export declare const loadPageAssets: PageAssetLoader;

package/dist/page-assets.js

@@ -0,0 +1,28 @@
+import { HTTPException } from "hono/http-exception";
+/** A failed acquisition refuses this request without exposing loader details. */
+export class PageAssetsLoadError extends HTTPException {
+    constructor(cause) {
+        super(503, { message: "Host page assets unavailable", cause });
+    }
+    getResponse() {
+        // Concurrent callers share the failure, not a one-use response body.
+        return new Response(this.message, {
+            status: this.status,
+            headers: {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Cache-Control": "no-store",
+            },
+        });
+    }
+}
+/**
+ * Missing page sources must fail the request, never produce an empty script.
+ */
+export const loadPageAssets = async () => {
+    try {
+        return await import("#page-script");
+    }
+    catch (cause) {
+        throw new PageAssetsLoadError(cause);
+    }
+};

package/dist/page-script.d.ts

@@ -7,6 +7,9 @@ export declare const publicHomeScript: string;
 /** Shared host fonts, served once as a digest-pinned stylesheet. */
 export declare const fontStyles: string;
 
+/** The sans family alone, for the sign-in page. */
+export declare const loginFontStyles: string;
+
 /** Caps styles for server-rendered host pages. */
 export declare const shellStyles: string;