gesso-electrobun 0.6.12 → 0.6.14

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # gesso-electrobun
 
+## 0.6.14
+
+### Patch Changes
+
+- b9ddff5: A desktop window's screen tools can be offered to agents beside its channels: `relayScreenAgent` (`gesso-electrobun/view`) relays the render worker's agent port over the window's RPC, `createScreenAgent` (`gesso-electrobun/desktop`) holds the other end, and `serveDesktopAgent` takes it as `screen`. Only the screen tools cross. Meant for development, since pressing the screen's buttons is everything the person can do.
+- gesso-framework@0.6.14
+
+## 0.6.13
+
+### Patch Changes
+
+- Updated dependencies [0020afa]
+  - gesso-framework@0.6.13
+
 ## 0.6.12
 
 ### Patch Changes

package/dist/desktop.d.ts

@@ -1,8 +1,28 @@
 import { r as GessoFrame } from "./frames-CsYW_e7F.js";
-import { n as withWindowRoute } from "./route-CNeMnj_6.js";
+import { r as ScreenAgentMessage, s as withWindowRoute } from "./view-Cw282TuC.js";
+import { AgentConfirmation, AgentSurface, AgentSurfaceLike, McpHandlerOptions } from "gesso-framework/agent";
 import { ChannelToken, ServedChannel } from "gesso-framework";
 import { Observable } from "rxjs";
-import { AgentConfirmation, AgentSurface, McpHandlerOptions } from "gesso-framework/agent";
+//#region src/screen.d.ts
+/** The main process's half. */
+interface ScreenAgent {
+  /**
+   * The screen tools of the window attached last, or none while no
+   * window is. For `serveDesktopAgent`'s `screen`.
+   */
+  readonly surface: AgentSurfaceLike;
+  /**
+   * Attaches a window: `send` posts a message to its page's relay, and
+   * the window's messages are handed to `receive`. Detach it when the
+   * window closes. The window attached last is the one agents operate.
+   */
+  attach(send: (message: ScreenAgentMessage) => void): {
+    receive(message: ScreenAgentMessage): void;
+    detach(): void;
+  };
+}
+declare function createScreenAgent(): ScreenAgent;
+//#endregion
 //#region src/agent.d.ts
 /**
  * A desktop application's channels, served to AI agents over MCP.
@@ -21,9 +41,10 @@ import { AgentConfirmation, AgentSurface, McpHandlerOptions } from "gesso-framew
  * `createDesktopApp` takes them per window, and the per-window ones
  * (`windowsChannel`) are about a window an agent does not have.
  *
- * What it offers is the channel tools only. The screen is in each
- * window's render worker, out of the main process's reach, so the
- * screen tools a web app offers are not here.
+ * What it offers is the channel tools, and the screen tools of a window
+ * when it is given `screen`: the screen is in each window's render
+ * worker, out of the main process's reach, so the window relays it
+ * (`createScreenAgent`).
  *
  * The descriptions come from `channelSchema`. A main process is bundled
  * by Electrobun's own build, which `gesso-vite-plugin` never sees, so
@@ -55,6 +76,12 @@ interface DesktopAgentOptions extends Omit<McpHandlerOptions, 'allowedOrigins'>
   confirm?: (request: AgentConfirmation) => boolean | Promise<boolean>;
   /** The server to start. Defaults to the runtime's `Bun.serve`. */
   serve?: DesktopServe;
+  /**
+   * A window's screen tools to offer beside the channels:
+   * `createScreenAgent().surface`. Pressing the screen's buttons is
+   * everything the person can do, so offer it in development.
+   */
+  screen?: AgentSurfaceLike;
 }
 interface DesktopAgent {
   /** Where an agent connects: `http://127.0.0.1:<port>/mcp`. */
@@ -231,5 +258,5 @@ declare const DesktopWindows: ChannelToken<DesktopWindowsView, DesktopWindowsCom
 /** Serves `DesktopWindows` to one window. Put it in `channels`. */
 declare function windowsChannel(app: DesktopApp, window: DesktopWindowHandle): ServedChannel;
 //#endregion
-export { type DesktopAgent, type DesktopAgentOptions, DesktopApp, DesktopAppOptions, type DesktopServe, DesktopWindowHandle, DesktopWindowOptions, DesktopWindowTransport, DesktopWindows, DesktopWindowsCommands, DesktopWindowsView, type ShowMessageBox, createDesktopApp, messageBoxConfirm, serveDesktopAgent, windowsChannel, withWindowRoute };
+export { type DesktopAgent, type DesktopAgentOptions, DesktopApp, DesktopAppOptions, type DesktopServe, DesktopWindowHandle, DesktopWindowOptions, DesktopWindowTransport, DesktopWindows, DesktopWindowsCommands, DesktopWindowsView, type ScreenAgent, type ShowMessageBox, createDesktopApp, createScreenAgent, messageBoxConfirm, serveDesktopAgent, windowsChannel, withWindowRoute };
 //# sourceMappingURL=desktop.d.ts.map

package/dist/desktop.js

@@ -1,8 +1,50 @@
 import { n as withWindowRoute } from "./route-B2qU38dY.js";
 import { serveChannelsToWindow } from "./main.js";
+import { agentSurface, combineSurfaces, mcpHandler, remoteSurface } from "gesso-framework/agent";
 import { channel } from "gesso-framework";
 import { BehaviorSubject } from "rxjs";
-import { agentSurface, mcpHandler } from "gesso-framework/agent";
+//#region src/screen.ts
+/** The screen tools, by name; what crosses from the render worker. */
+const SCREEN_TOOL = /^ui_/;
+const NO_WINDOW = {
+	content: [{
+		type: "text",
+		text: "No window is open to operate."
+	}],
+	isError: true
+};
+function createScreenAgent() {
+	const windows = [];
+	const current = () => windows.at(-1)?.surface;
+	return {
+		surface: {
+			tools: async () => (await current()?.tools() ?? []).filter((tool) => SCREEN_TOOL.test(tool.name)),
+			resources: () => [],
+			call: async (name, args) => {
+				const window = current();
+				if (window === void 0 || !SCREEN_TOOL.test(name)) return NO_WINDOW;
+				return window.call(name, args);
+			},
+			read: () => void 0
+		},
+		attach: (send) => {
+			const port = {
+				postMessage: (message) => send(message),
+				onmessage: null
+			};
+			const entry = { surface: remoteSurface(port, { confirm: () => false }) };
+			windows.push(entry);
+			return {
+				receive: (message) => port.onmessage?.({ data: message }),
+				detach: () => {
+					const at = windows.indexOf(entry);
+					if (at !== -1) windows.splice(at, 1);
+				}
+			};
+		}
+	};
+}
+//#endregion
 //#region src/agent.ts
 const DEFAULT_PORT = 7310;
 const PORTS_TRIED = 10;
@@ -11,7 +53,7 @@ function serveDesktopAgent(channels, options = {}) {
 	const hostname = options.hostname ?? "127.0.0.1";
 	const first = options.port ?? DEFAULT_PORT;
 	const surface = agentSurface(channels, options.confirm === void 0 ? {} : { confirm: options.confirm });
-	const fetch = mcpHandler(surface, {
+	const fetch = mcpHandler(options.screen === void 0 ? surface : combineSurfaces([surface, options.screen]), {
 		...options,
 		allowedOrigins: []
 	});
@@ -242,6 +284,6 @@ function windowsChannel(app, window) {
 	};
 }
 //#endregion
-export { DesktopWindows, createDesktopApp, messageBoxConfirm, serveDesktopAgent, windowsChannel, withWindowRoute };
+export { DesktopWindows, createDesktopApp, createScreenAgent, messageBoxConfirm, serveDesktopAgent, windowsChannel, withWindowRoute };
 
 //# sourceMappingURL=desktop.js.map

package/dist/desktop.js.map

@@ -1 +1 @@
-{"version":3,"file":"desktop.js","names":[],"sources":["../src/agent.ts","../src/desktop.ts"],"sourcesContent":["import type { ServedChannel } from 'gesso-framework';\nimport {\n  agentSurface,\n  mcpHandler,\n  type AgentConfirmation,\n  type AgentSurface,\n  type McpHandlerOptions\n} from 'gesso-framework/agent';\n\n/**\n * A desktop application's channels, served to AI agents over MCP.\n *\n * The main process already holds every channel's source: it is what\n * `createDesktopApp` serves to each window. So it is also where an\n * agent connects. This serves those same sources with MCP's HTTP\n * transport on the person's own machine, through `Bun.serve`, which\n * Cottontail provides as Bun does, and an agent such as Claude Code\n * connects by URL:\n *\n *   const agent = serveDesktopAgent([counter], { name: 'my-app', confirm: messageBoxConfirm(Utils.showMessageBox) });\n *   // claude mcp add --transport http my-app http://127.0.0.1:7310/mcp\n *\n * The channels are passed rather than read from the app, because\n * `createDesktopApp` takes them per window, and the per-window ones\n * (`windowsChannel`) are about a window an agent does not have.\n *\n * What it offers is the channel tools only. The screen is in each\n * window's render worker, out of the main process's reach, so the\n * screen tools a web app offers are not here.\n *\n * The descriptions come from `channelSchema`. A main process is bundled\n * by Electrobun's own build, which `gesso-vite-plugin` never sees, so\n * the template runs `gesso-channels` to write a module that describes\n * the contracts, and imports it.\n */\n\n/** A `Bun.serve`, as far as this uses one. */\nexport type DesktopServe = (options: {\n  hostname: string;\n  port: number;\n  fetch: (request: Request) => Promise<Response>;\n}) => { stop(closeActiveConnections?: boolean): void };\n\nexport interface DesktopAgentOptions extends Omit<McpHandlerOptions, 'allowedOrigins'> {\n  /**\n   * The port to listen on (default 7310). When it is taken, the next\n   * nine are tried in turn, so a second copy of the app still serves;\n   * `url` says which one it got.\n   */\n  port?: number;\n  /** Default `127.0.0.1`: reachable from this machine only. */\n  hostname?: string;\n  /**\n   * Asks the person whether a `@confirm` command may be sent. Without\n   * it such a command is refused. `messageBoxConfirm` makes one from\n   * Electrobun's native dialog.\n   */\n  confirm?: (request: AgentConfirmation) => boolean | Promise<boolean>;\n  /** The server to start. Defaults to the runtime's `Bun.serve`. */\n  serve?: DesktopServe;\n}\n\nexport interface DesktopAgent {\n  /** Where an agent connects: `http://127.0.0.1:<port>/mcp`. */\n  readonly url: string;\n  readonly surface: AgentSurface;\n  /** Stops serving and stops following the channels. */\n  stop(): void;\n}\n\nconst DEFAULT_PORT = 7310;\nconst PORTS_TRIED = 10;\n\nexport function serveDesktopAgent(channels: readonly ServedChannel[], options: DesktopAgentOptions = {}): DesktopAgent {\n  const serve = options.serve ?? bunServe();\n  const hostname = options.hostname ?? '127.0.0.1';\n  const first = options.port ?? DEFAULT_PORT;\n  const surface = agentSurface(channels, options.confirm === undefined ? {} : { confirm: options.confirm });\n  // A desktop app has no browser pages of its own to let in, so every\n  // request carrying an Origin is refused: that is a web page the person\n  // has open, reaching for their machine.\n  const fetch = mcpHandler(surface, { ...options, allowedOrigins: [] });\n\n  let lastError: unknown;\n  for (let port = first; port < first + PORTS_TRIED; port++) {\n    try {\n      const server = serve({ hostname, port, fetch });\n      return {\n        url: `http://${hostname}:${port}/mcp`,\n        surface,\n        stop: () => {\n          server.stop(true);\n          surface.dispose();\n        }\n      };\n    } catch (error) {\n      if (!isAddressInUse(error)) {\n        surface.dispose();\n        throw error;\n      }\n      lastError = error;\n    }\n  }\n  surface.dispose();\n  throw new Error(\n    `Ports ${first} to ${first + PORTS_TRIED - 1} are all in use, so agents cannot be served. ` +\n      `Pass another port to serveDesktopAgent. (${String(lastError)})`\n  );\n}\n\n/** The options Electrobun's `Utils.showMessageBox` takes, as far as this uses them. */\nexport type ShowMessageBox = (options: {\n  type?: 'info' | 'warning' | 'error' | 'question';\n  title?: string;\n  message?: string;\n  detail?: string;\n  buttons?: string[];\n  defaultId?: number;\n  cancelId?: number;\n}) => Promise<{ response: number }>;\n\n/**\n * A `confirm` that asks with the operating system's own dialog.\n *\n * Takes Electrobun's `Utils.showMessageBox` rather than importing it,\n * because Electrobun is a toolchain a project is projected into, not a\n * package this one can depend on.\n *\n * Everything the person needs to decide is in `message`, the command's\n * description and its arguments included, because macOS shows no\n * `detail`: a dialog that asked there showed only \"wants to\n * createBranch in workspace\", with nothing to say which branch.\n *\n * Decline is the first button. macOS makes the first button the\n * default, whatever `defaultId` says, so with Allow first, Enter\n * approved; first is also what `defaultId` and `cancelId` name, so\n * Enter, Escape and closing the dialog decline on every platform.\n */\nexport function messageBoxConfirm(showMessageBox: ShowMessageBox): (request: AgentConfirmation) => Promise<boolean> {\n  return async request => {\n    const argumentLines = Object.entries(request.arguments).map(([name, value]) => `${name}: ${JSON.stringify(value)}`);\n    const message = [\n      `An AI agent wants to ${request.command} in ${request.channel}.${request.destructive ? ' This cannot be undone.' : ''}`,\n      request.description,\n      argumentLines.join('\\n')\n    ]\n      .filter((part): part is string => part !== undefined && part !== '')\n      .join('\\n\\n');\n    const { response } = await showMessageBox({\n      type: request.destructive ? 'warning' : 'question',\n      title: 'An AI agent is asking',\n      message,\n      buttons: ['Decline', 'Allow'],\n      defaultId: 0,\n      cancelId: 0\n    });\n    return response === 1;\n  };\n}\n\nfunction bunServe(): DesktopServe {\n  const bun = (globalThis as { Bun?: { serve?: DesktopServe } }).Bun;\n  if (typeof bun?.serve !== 'function') {\n    throw new Error(\n      'serveDesktopAgent needs Bun.serve, which Cottontail and Bun provide. Pass serve to use another server.'\n    );\n  }\n  return options => bun.serve!(options);\n}\n\nfunction isAddressInUse(error: unknown): boolean {\n  const code = (error as { code?: unknown } | null)?.code;\n  return code === 'EADDRINUSE' || /in use|EADDRINUSE/i.test(String((error as Error | null)?.message ?? error));\n}\n","/**\n * An application in the main process: windows, and the channels each\n * one is served.\n *\n * Nothing here imports Electrobun, and that is not fastidiousness. The\n * SDK is projected into a project by Hutch rather than installed from\n * a registry, so a package in\n * this workspace could not import it even if it wanted to. What the\n * application supplies instead is one function that opens a window,\n * which is the only Electrobun-shaped thing this needs, and which is\n * five lines at the call site:\n *\n *   const app = createDesktopApp({\n *     channels: window => [\n *       { token: Catalogue, source: catalogue },\n *       windowsChannel(app, window)\n *     ],\n *     open: (receive, handle) => {\n *       const rpc = BrowserView.defineRPC<GessoWindowRPC>({\n *         handlers: { requests: {}, messages: { gessoFrame: receive } }\n *       });\n *       const window = new BrowserWindow({\n *         title: 'Notes',\n *         url: withWindowRoute('views://mainview/index.html', handle.route),\n *         rpc\n *       });\n *       return {\n *         send: frame => window.webview.rpc.send.gessoFrame(frame),\n *         close: () => window.close()\n *       };\n *     }\n *   });\n *   app.openWindow();\n *\n * The arrangement it buys: every\n * window is a replica of the same channels, so two windows agree by\n * construction rather than by synchronisation.\n */\nimport { channel, type ChannelToken, type ServedChannel } from 'gesso-framework';\nimport { BehaviorSubject, type Observable, type Subscription } from 'rxjs';\n\nimport type { GessoFrame } from './frames';\nimport { serveChannelsToWindow, type ChannelHost } from './main';\n\nexport { withWindowRoute } from './route';\n\n/** What the application does with the window it opened. */\nexport interface DesktopWindowTransport {\n  /** Sends one frame to this window, over its own RPC. */\n  send: (frame: GessoFrame) => void;\n  /** Closes the native window. The adapter calls this; the platform may also close it on its own. */\n  close: () => void;\n}\n\n/** A window this application opened. */\nexport interface DesktopWindowHandle {\n  /** Stable for the life of the window, and never reused. */\n  readonly id: number;\n  /**\n   * The application url the window was asked to open at, or null for\n   * wherever the application starts.\n   *\n   * Set by `openWindow({ route })`, which is what a Cmd-click on an\n   * in-app link comes to by default. The window cannot be told it\n   * through a frame in time to start there, so `open` puts it on the\n   * view's url, with `withWindowRoute`, and the window reads it back\n   * with `windowRoute` before its shell starts.\n   */\n  readonly route: string | null;\n  /** Closes the window and disposes the channels it was served. */\n  close(): void;\n}\n\n/** What `openWindow` may be told about the window it opens. */\nexport interface DesktopWindowOptions {\n  /**\n   * The application url to open at, `/epic/BUD-12?story=BUD-13`. Carried\n   * to `open` as `window.route`; see `DesktopWindowHandle.route`.\n   */\n  readonly route?: string;\n}\n\nexport interface DesktopAppOptions {\n  /**\n   * The channels each window is served.\n   *\n   * A function when a window needs a channel of its own, which is what\n   * `windowsChannel` uses to give a window a way to close itself. It\n   * is called once per window, and the observables it returns are\n   * ordinarily the same ones every time: `provide` keeps a separate\n   * record of what each client has seen, so sharing a source between\n   * windows is what makes them agree.\n   */\n  channels: readonly ServedChannel[] | ((window: DesktopWindowHandle) => readonly ServedChannel[]);\n  /**\n   * Opens a native window.\n   *\n   * `receive` is what the window's frames must be fed into: wire it to\n   * the RPC message the window sends frames on, before the window\n   * opens, or the first handshake is lost.\n   *\n   * `window.route` is the application url the window should start at,\n   * or null. Put it on the view's url with `withWindowRoute`, and read\n   * it in the window with `windowRoute`; an `open` that ignores it\n   * opens every window at the application's start, as before.\n   */\n  open: (receive: (frame: GessoFrame) => void, window: DesktopWindowHandle) => DesktopWindowTransport;\n  /**\n   * A url a window asked to have opened outside itself, with the\n   * window that asked. `Utils.openExternal(url)` is what an Electrobun\n   * application passes here.\n   */\n  onOpenUrl?: (url: string, window: DesktopWindowHandle) => void;\n  /**\n   * One of the application's own urls a window asked to have opened\n   * somewhere new (a Cmd-click or a Ctrl-click on an in-app link), with\n   * the window that asked.\n   *\n   * Defaults to `app.openWindow({ route: url })`: a new window of this\n   * application, at that route, which is what a new tab is in an\n   * application whose windows have none. An outbound url never comes\n   * here; it is `onOpenUrl`'s, and goes to the person's browser.\n   */\n  onOpenRoute?: (url: string, window: DesktopWindowHandle) => void;\n  /**\n   * The appearance the platform is in, pushed to every window as it\n   * changes and to a new window as it opens.\n   *\n   * The application supplies it because Electrobun does not: its SDK\n   * has no appearance API at all, and the webview's own\n   * `prefers-color-scheme` is wrong on WebKitGTK\n   *. On a platform that has a\n   * signal, this is where it goes; on one that does not, an\n   * application setting is a perfectly good source.\n   */\n  colorScheme?: Observable<'light' | 'dark'>;\n  /**\n   * Called when the last window closes. A desktop application usually\n   * stops here; one with a tray or a menu bar does not, which is why\n   * this is a callback rather than an exit.\n   */\n  onLastWindowClosed?: () => void;\n  /** Overrides the frame size messages are split at. Only a test should need to. */\n  chunkBytes?: number;\n}\n\nexport interface DesktopApp {\n  /**\n   * Opens a window, serves it every channel, and returns its handle;\n   * at `options.route` when one is given.\n   */\n  openWindow(options?: DesktopWindowOptions): DesktopWindowHandle;\n  /** The windows open now, in the order they were opened. */\n  readonly windows: readonly DesktopWindowHandle[];\n  /** How many windows are open, as something a channel can publish. */\n  readonly windowCount: Observable<number>;\n  /** Closes every window and stops serving. */\n  dispose(): void;\n}\n\nexport function createDesktopApp(options: DesktopAppOptions): DesktopApp {\n  interface Entry {\n    handle: DesktopWindowHandle;\n    transport: DesktopWindowTransport;\n    host: ChannelHost;\n  }\n  const entries = new Map<number, Entry>();\n  /** One appearance subscription per window, ended when it closes. */\n  const subscriptions = new Map<number, Subscription>();\n  const order: DesktopWindowHandle[] = [];\n  const count = new BehaviorSubject(0);\n  let nextId = 1;\n  let disposed = false;\n\n  const forget = (id: number, closeNative: boolean): void => {\n    const entry = entries.get(id);\n    if (entry === undefined) {\n      return;\n    }\n    entries.delete(id);\n    subscriptions.get(id)?.unsubscribe();\n    subscriptions.delete(id);\n    const at = order.indexOf(entry.handle);\n    if (at >= 0) {\n      order.splice(at, 1);\n    }\n    entry.host.dispose();\n    if (closeNative) {\n      entry.transport.close();\n    }\n    count.next(order.length);\n    if (order.length === 0 && !disposed) {\n      options.onLastWindowClosed?.();\n    }\n  };\n\n  const app: DesktopApp = {\n    openWindow(windowOptions: DesktopWindowOptions = {}): DesktopWindowHandle {\n      if (disposed) {\n        throw new Error('This desktop application has been disposed; it cannot open a window.');\n      }\n      const id = nextId++;\n      const handle: DesktopWindowHandle = {\n        id,\n        route: windowOptions.route ?? null,\n        close: () => forget(id, true)\n      };\n\n      // The host exists before the window does, because `open` may\n      // deliver a frame synchronously and a window whose first\n      // handshake was dropped never replicates anything.\n      let transport: DesktopWindowTransport | undefined;\n      const host = serveChannelsToWindow(\n        typeof options.channels === 'function' ? options.channels(handle) : options.channels,\n        {\n          send: frame => transport?.send(frame),\n          chunkBytes: options.chunkBytes,\n          onOpenUrl: url => options.onOpenUrl?.(url, handle),\n          onOpenRoute: url => {\n            if (options.onOpenRoute !== undefined) {\n              options.onOpenRoute(url, handle);\n            } else if (!disposed) {\n              app.openWindow({ route: url });\n            }\n          }\n        }\n      );\n      entries.set(id, { handle, transport: { send: () => {}, close: () => {} }, host });\n      order.push(handle);\n\n      // Anything pushed before the window has spoken is lost: a\n      // webview's RPC is not listening until its page has loaded, and\n      // the window opens well before that. Channels do not notice,\n      // because a channel starts with the window asking. The\n      // appearance is the one thing this side sends first, so it waits\n      // for the window's first frame, whatever that frame is. A native\n      // window found this; a spec with a transport that was live\n      // immediately could not.\n      let greeted = false;\n      let latest: 'light' | 'dark' | undefined;\n      transport = options.open(frame => {\n        if (!greeted) {\n          greeted = true;\n          if (latest !== undefined) {\n            host.setColorScheme(latest);\n          }\n        }\n        host.receive(frame);\n      }, handle);\n      entries.set(id, { handle, transport, host });\n      const appearance = options.colorScheme?.subscribe(scheme => {\n        latest = scheme;\n        if (greeted) {\n          host.setColorScheme(scheme);\n        }\n      });\n      if (appearance !== undefined) {\n        subscriptions.set(id, appearance);\n      }\n      count.next(order.length);\n      return handle;\n    },\n    get windows(): readonly DesktopWindowHandle[] {\n      return [...order];\n    },\n    windowCount: count.asObservable(),\n    dispose(): void {\n      disposed = true;\n      for (const id of new Set(entries.keys())) {\n        forget(id, true);\n      }\n      count.complete();\n    }\n  };\n\n  return app;\n}\n\n/** What a window can see and do about the windows of its application. */\nexport interface DesktopWindowsView {\n  /** How many windows this application has open. */\n  count: number;\n  /** Which one this is, so a screen can say \"window 2 of 3\" without asking. */\n  id: number;\n}\n\nexport interface DesktopWindowsCommands {\n  open: () => void;\n  closeThis: () => void;\n}\n\n/**\n * The channel a window opens another window through.\n *\n * It exists because opening a window is the one native act a screen\n * genuinely needs, and going through a channel keeps the view layer\n * from importing an adapter. the \"native menus bound to\n * store actions\" is the same idea from the other end, and on Linux it\n * is the only end: the runtime has no application menus there, so a\n * menu is a component and this is what it calls.\n */\nexport const DesktopWindows: ChannelToken<DesktopWindowsView, DesktopWindowsCommands> = channel<\n  DesktopWindowsView,\n  DesktopWindowsCommands\n>('gesso:windows', { count: 0, id: 0 });\n\n/** Serves `DesktopWindows` to one window. Put it in `channels`. */\nexport function windowsChannel(app: DesktopApp, window: DesktopWindowHandle): ServedChannel {\n  return {\n    token: DesktopWindows,\n    source: {\n      view: {\n        count: app.windowCount,\n        id: new BehaviorSubject(window.id)\n      },\n      commands: {\n        open: () => {\n          app.openWindow();\n        },\n        closeThis: () => {\n          window.close();\n        }\n      }\n    }\n  };\n}\n\nexport {\n  messageBoxConfirm,\n  serveDesktopAgent,\n  type DesktopAgent,\n  type DesktopAgentOptions,\n  type DesktopServe,\n  type ShowMessageBox\n} from './agent';\n"],"mappings":";;;;;;AAsEA,MAAM,eAAe;AACrB,MAAM,cAAc;AAEpB,SAAgB,kBAAkB,UAAoC,UAA+B,CAAC,GAAiB;CACrH,MAAM,QAAQ,QAAQ,SAAS,SAAS;CACxC,MAAM,WAAW,QAAQ,YAAY;CACrC,MAAM,QAAQ,QAAQ,QAAQ;CAC9B,MAAM,UAAU,aAAa,UAAU,QAAQ,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS,QAAQ,QAAQ,CAAC;CAIxG,MAAM,QAAQ,WAAW,SAAS;EAAE,GAAG;EAAS,gBAAgB,CAAC;CAAE,CAAC;CAEpE,IAAI;CACJ,KAAK,IAAI,OAAO,OAAO,OAAO,QAAQ,aAAa,QACjD,IAAI;EACF,MAAM,SAAS,MAAM;GAAE;GAAU;GAAM;EAAM,CAAC;EAC9C,OAAO;GACL,KAAK,UAAU,SAAS,GAAG,KAAK;GAChC;GACA,YAAY;IACV,OAAO,KAAK,IAAI;IAChB,QAAQ,QAAQ;GAClB;EACF;CACF,SAAS,OAAO;EACd,IAAI,CAAC,eAAe,KAAK,GAAG;GAC1B,QAAQ,QAAQ;GAChB,MAAM;EACR;EACA,YAAY;CACd;CAEF,QAAQ,QAAQ;CAChB,MAAM,IAAI,MACR,SAAS,MAAM,MAAM,QAAQ,cAAc,EAAE,wFACC,OAAO,SAAS,EAAE,EAClE;AACF;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,kBAAkB,gBAAkF;CAClH,OAAO,OAAM,YAAW;EACtB,MAAM,gBAAgB,OAAO,QAAQ,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,MAAM,WAAW,GAAG,KAAK,IAAI,KAAK,UAAU,KAAK,GAAG;EAClH,MAAM,UAAU;GACd,wBAAwB,QAAQ,QAAQ,MAAM,QAAQ,QAAQ,GAAG,QAAQ,cAAc,4BAA4B;GACnH,QAAQ;GACR,cAAc,KAAK,IAAI;EACzB,CAAC,CACE,QAAQ,SAAyB,SAAS,KAAA,KAAa,SAAS,EAAE,CAAC,CACnE,KAAK,MAAM;EACd,MAAM,EAAE,aAAa,MAAM,eAAe;GACxC,MAAM,QAAQ,cAAc,YAAY;GACxC,OAAO;GACP;GACA,SAAS,CAAC,WAAW,OAAO;GAC5B,WAAW;GACX,UAAU;EACZ,CAAC;EACD,OAAO,aAAa;CACtB;AACF;AAEA,SAAS,WAAyB;CAChC,MAAM,MAAO,WAAkD;CAC/D,IAAI,OAAO,KAAK,UAAU,YACxB,MAAM,IAAI,MACR,wGACF;CAEF,QAAO,YAAW,IAAI,MAAO,OAAO;AACtC;AAEA,SAAS,eAAe,OAAyB;CAE/C,OADc,OAAqC,SACnC,gBAAgB,qBAAqB,KAAK,OAAQ,OAAwB,WAAW,KAAK,CAAC;AAC7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACbA,SAAgB,iBAAiB,SAAwC;CAMvE,MAAM,0BAAU,IAAI,IAAmB;;CAEvC,MAAM,gCAAgB,IAAI,IAA0B;CACpD,MAAM,QAA+B,CAAC;CACtC,MAAM,QAAQ,IAAI,gBAAgB,CAAC;CACnC,IAAI,SAAS;CACb,IAAI,WAAW;CAEf,MAAM,UAAU,IAAY,gBAA+B;EACzD,MAAM,QAAQ,QAAQ,IAAI,EAAE;EAC5B,IAAI,UAAU,KAAA,GACZ;EAEF,QAAQ,OAAO,EAAE;EACjB,cAAc,IAAI,EAAE,CAAC,EAAE,YAAY;EACnC,cAAc,OAAO,EAAE;EACvB,MAAM,KAAK,MAAM,QAAQ,MAAM,MAAM;EACrC,IAAI,MAAM,GACR,MAAM,OAAO,IAAI,CAAC;EAEpB,MAAM,KAAK,QAAQ;EACnB,IAAI,aACF,MAAM,UAAU,MAAM;EAExB,MAAM,KAAK,MAAM,MAAM;EACvB,IAAI,MAAM,WAAW,KAAK,CAAC,UACzB,QAAQ,qBAAqB;CAEjC;CAEA,MAAM,MAAkB;EACtB,WAAW,gBAAsC,CAAC,GAAwB;GACxE,IAAI,UACF,MAAM,IAAI,MAAM,sEAAsE;GAExF,MAAM,KAAK;GACX,MAAM,SAA8B;IAClC;IACA,OAAO,cAAc,SAAS;IAC9B,aAAa,OAAO,IAAI,IAAI;GAC9B;GAKA,IAAI;GACJ,MAAM,OAAO,sBACX,OAAO,QAAQ,aAAa,aAAa,QAAQ,SAAS,MAAM,IAAI,QAAQ,UAC5E;IACE,OAAM,UAAS,WAAW,KAAK,KAAK;IACpC,YAAY,QAAQ;IACpB,YAAW,QAAO,QAAQ,YAAY,KAAK,MAAM;IACjD,cAAa,QAAO;KAClB,IAAI,QAAQ,gBAAgB,KAAA,GAC1B,QAAQ,YAAY,KAAK,MAAM;UAC1B,IAAI,CAAC,UACV,IAAI,WAAW,EAAE,OAAO,IAAI,CAAC;IAEjC;GACF,CACF;GACA,QAAQ,IAAI,IAAI;IAAE;IAAQ,WAAW;KAAE,YAAY,CAAC;KAAG,aAAa,CAAC;IAAE;IAAG;GAAK,CAAC;GAChF,MAAM,KAAK,MAAM;GAUjB,IAAI,UAAU;GACd,IAAI;GACJ,YAAY,QAAQ,MAAK,UAAS;IAChC,IAAI,CAAC,SAAS;KACZ,UAAU;KACV,IAAI,WAAW,KAAA,GACb,KAAK,eAAe,MAAM;IAE9B;IACA,KAAK,QAAQ,KAAK;GACpB,GAAG,MAAM;GACT,QAAQ,IAAI,IAAI;IAAE;IAAQ;IAAW;GAAK,CAAC;GAC3C,MAAM,aAAa,QAAQ,aAAa,WAAU,WAAU;IAC1D,SAAS;IACT,IAAI,SACF,KAAK,eAAe,MAAM;GAE9B,CAAC;GACD,IAAI,eAAe,KAAA,GACjB,cAAc,IAAI,IAAI,UAAU;GAElC,MAAM,KAAK,MAAM,MAAM;GACvB,OAAO;EACT;EACA,IAAI,UAA0C;GAC5C,OAAO,CAAC,GAAG,KAAK;EAClB;EACA,aAAa,MAAM,aAAa;EAChC,UAAgB;GACd,WAAW;GACX,KAAK,MAAM,MAAM,IAAI,IAAI,QAAQ,KAAK,CAAC,GACrC,OAAO,IAAI,IAAI;GAEjB,MAAM,SAAS;EACjB;CACF;CAEA,OAAO;AACT;;;;;;;;;;;AAyBA,MAAa,iBAA2E,QAGtF,iBAAiB;CAAE,OAAO;CAAG,IAAI;AAAE,CAAC;;AAGtC,SAAgB,eAAe,KAAiB,QAA4C;CAC1F,OAAO;EACL,OAAO;EACP,QAAQ;GACN,MAAM;IACJ,OAAO,IAAI;IACX,IAAI,IAAI,gBAAgB,OAAO,EAAE;GACnC;GACA,UAAU;IACR,YAAY;KACV,IAAI,WAAW;IACjB;IACA,iBAAiB;KACf,OAAO,MAAM;IACf;GACF;EACF;CACF;AACF"}
+{"version":3,"file":"desktop.js","names":[],"sources":["../src/screen.ts","../src/agent.ts","../src/desktop.ts"],"sourcesContent":["import type { AgentSurfaceLike, AgentToolResult } from 'gesso-framework/agent';\nimport { remoteSurface } from 'gesso-framework/agent';\n\n/**\n * A desktop window's screen, offered to agents beside its channels.\n *\n * The screen tools (`ui_snapshot`, `ui_press`, `ui_type`, `ui_focus`,\n * `ui_key`) are served by each window's render worker, on its agent port,\n * and the main process cannot reach a worker. The window's own page can,\n * and it already talks to the main process over Electrobun's RPC. So\n * the page relays the agent port's messages over the RPC\n * (`relayScreenAgent`, in `gesso-electrobun/view`), and the main process holds the other end as a\n * surface (`createScreenAgent`) that `serveDesktopAgent` offers beside\n * the channel tools.\n *\n * Only the screen tools cross. The render worker's surface also lists\n * the channels it replicates, which the main process serves itself, so\n * they would only be listed twice.\n *\n * Pressing the screen's buttons is everything the person can do, so an\n * application offers this in development, not to every agent with the\n * token: a confirmation an agent could click through on the screen is\n * no confirmation.\n */\n\nimport type { ScreenAgentMessage } from './view';\n\n/** The screen tools, by name; what crosses from the render worker. */\nconst SCREEN_TOOL = /^ui_/;\n\n/** The main process's half. */\nexport interface ScreenAgent {\n  /**\n   * The screen tools of the window attached last, or none while no\n   * window is. For `serveDesktopAgent`'s `screen`.\n   */\n  readonly surface: AgentSurfaceLike;\n  /**\n   * Attaches a window: `send` posts a message to its page's relay, and\n   * the window's messages are handed to `receive`. Detach it when the\n   * window closes. The window attached last is the one agents operate.\n   */\n  attach(send: (message: ScreenAgentMessage) => void): { receive(message: ScreenAgentMessage): void; detach(): void };\n}\n\nconst NO_WINDOW: AgentToolResult = {\n  content: [{ type: 'text', text: 'No window is open to operate.' }],\n  isError: true\n};\n\nexport function createScreenAgent(): ScreenAgent {\n  const windows: { surface: AgentSurfaceLike }[] = [];\n  const current = () => windows.at(-1)?.surface;\n  const surface: AgentSurfaceLike = {\n    tools: async () => ((await current()?.tools()) ?? []).filter(tool => SCREEN_TOOL.test(tool.name)),\n    resources: () => [],\n    call: async (name, args) => {\n      const window = current();\n      if (window === undefined || !SCREEN_TOOL.test(name)) return NO_WINDOW;\n      return window.call(name, args);\n    },\n    read: () => undefined\n  };\n  return {\n    surface,\n    attach: send => {\n      // A MessagePort's shape, over whatever carries the window's messages.\n      const port = {\n        postMessage: (message: unknown) => send(message),\n        onmessage: null as ((event: MessageEvent) => void) | null\n      };\n      // The screen tools ask the person nothing; a channel command they\n      // might reach is the main process's to confirm, not the window's.\n      const entry = { surface: remoteSurface(port, { confirm: () => false }) };\n      windows.push(entry);\n      return {\n        receive: message => port.onmessage?.({ data: message } as MessageEvent),\n        detach: () => {\n          const at = windows.indexOf(entry);\n          if (at !== -1) windows.splice(at, 1);\n        }\n      };\n    }\n  };\n}\n","import type { ServedChannel } from 'gesso-framework';\nimport {\n  agentSurface,\n  combineSurfaces,\n  mcpHandler,\n  type AgentSurfaceLike,\n  type AgentConfirmation,\n  type AgentSurface,\n  type McpHandlerOptions\n} from 'gesso-framework/agent';\n\n/**\n * A desktop application's channels, served to AI agents over MCP.\n *\n * The main process already holds every channel's source: it is what\n * `createDesktopApp` serves to each window. So it is also where an\n * agent connects. This serves those same sources with MCP's HTTP\n * transport on the person's own machine, through `Bun.serve`, which\n * Cottontail provides as Bun does, and an agent such as Claude Code\n * connects by URL:\n *\n *   const agent = serveDesktopAgent([counter], { name: 'my-app', confirm: messageBoxConfirm(Utils.showMessageBox) });\n *   // claude mcp add --transport http my-app http://127.0.0.1:7310/mcp\n *\n * The channels are passed rather than read from the app, because\n * `createDesktopApp` takes them per window, and the per-window ones\n * (`windowsChannel`) are about a window an agent does not have.\n *\n * What it offers is the channel tools, and the screen tools of a window\n * when it is given `screen`: the screen is in each window's render\n * worker, out of the main process's reach, so the window relays it\n * (`createScreenAgent`).\n *\n * The descriptions come from `channelSchema`. A main process is bundled\n * by Electrobun's own build, which `gesso-vite-plugin` never sees, so\n * the template runs `gesso-channels` to write a module that describes\n * the contracts, and imports it.\n */\n\n/** A `Bun.serve`, as far as this uses one. */\nexport type DesktopServe = (options: {\n  hostname: string;\n  port: number;\n  fetch: (request: Request) => Promise<Response>;\n}) => { stop(closeActiveConnections?: boolean): void };\n\nexport interface DesktopAgentOptions extends Omit<McpHandlerOptions, 'allowedOrigins'> {\n  /**\n   * The port to listen on (default 7310). When it is taken, the next\n   * nine are tried in turn, so a second copy of the app still serves;\n   * `url` says which one it got.\n   */\n  port?: number;\n  /** Default `127.0.0.1`: reachable from this machine only. */\n  hostname?: string;\n  /**\n   * Asks the person whether a `@confirm` command may be sent. Without\n   * it such a command is refused. `messageBoxConfirm` makes one from\n   * Electrobun's native dialog.\n   */\n  confirm?: (request: AgentConfirmation) => boolean | Promise<boolean>;\n  /** The server to start. Defaults to the runtime's `Bun.serve`. */\n  serve?: DesktopServe;\n  /**\n   * A window's screen tools to offer beside the channels:\n   * `createScreenAgent().surface`. Pressing the screen's buttons is\n   * everything the person can do, so offer it in development.\n   */\n  screen?: AgentSurfaceLike;\n}\n\nexport interface DesktopAgent {\n  /** Where an agent connects: `http://127.0.0.1:<port>/mcp`. */\n  readonly url: string;\n  readonly surface: AgentSurface;\n  /** Stops serving and stops following the channels. */\n  stop(): void;\n}\n\nconst DEFAULT_PORT = 7310;\nconst PORTS_TRIED = 10;\n\nexport function serveDesktopAgent(channels: readonly ServedChannel[], options: DesktopAgentOptions = {}): DesktopAgent {\n  const serve = options.serve ?? bunServe();\n  const hostname = options.hostname ?? '127.0.0.1';\n  const first = options.port ?? DEFAULT_PORT;\n  const surface = agentSurface(channels, options.confirm === undefined ? {} : { confirm: options.confirm });\n  // A desktop app has no browser pages of its own to let in, so every\n  // request carrying an Origin is refused: that is a web page the person\n  // has open, reaching for their machine.\n  const fetch = mcpHandler(options.screen === undefined ? surface : combineSurfaces([surface, options.screen]), {\n    ...options,\n    allowedOrigins: []\n  });\n\n  let lastError: unknown;\n  for (let port = first; port < first + PORTS_TRIED; port++) {\n    try {\n      const server = serve({ hostname, port, fetch });\n      return {\n        url: `http://${hostname}:${port}/mcp`,\n        surface,\n        stop: () => {\n          server.stop(true);\n          surface.dispose();\n        }\n      };\n    } catch (error) {\n      if (!isAddressInUse(error)) {\n        surface.dispose();\n        throw error;\n      }\n      lastError = error;\n    }\n  }\n  surface.dispose();\n  throw new Error(\n    `Ports ${first} to ${first + PORTS_TRIED - 1} are all in use, so agents cannot be served. ` +\n      `Pass another port to serveDesktopAgent. (${String(lastError)})`\n  );\n}\n\n/** The options Electrobun's `Utils.showMessageBox` takes, as far as this uses them. */\nexport type ShowMessageBox = (options: {\n  type?: 'info' | 'warning' | 'error' | 'question';\n  title?: string;\n  message?: string;\n  detail?: string;\n  buttons?: string[];\n  defaultId?: number;\n  cancelId?: number;\n}) => Promise<{ response: number }>;\n\n/**\n * A `confirm` that asks with the operating system's own dialog.\n *\n * Takes Electrobun's `Utils.showMessageBox` rather than importing it,\n * because Electrobun is a toolchain a project is projected into, not a\n * package this one can depend on.\n *\n * Everything the person needs to decide is in `message`, the command's\n * description and its arguments included, because macOS shows no\n * `detail`: a dialog that asked there showed only \"wants to\n * createBranch in workspace\", with nothing to say which branch.\n *\n * Decline is the first button. macOS makes the first button the\n * default, whatever `defaultId` says, so with Allow first, Enter\n * approved; first is also what `defaultId` and `cancelId` name, so\n * Enter, Escape and closing the dialog decline on every platform.\n */\nexport function messageBoxConfirm(showMessageBox: ShowMessageBox): (request: AgentConfirmation) => Promise<boolean> {\n  return async request => {\n    const argumentLines = Object.entries(request.arguments).map(([name, value]) => `${name}: ${JSON.stringify(value)}`);\n    const message = [\n      `An AI agent wants to ${request.command} in ${request.channel}.${request.destructive ? ' This cannot be undone.' : ''}`,\n      request.description,\n      argumentLines.join('\\n')\n    ]\n      .filter((part): part is string => part !== undefined && part !== '')\n      .join('\\n\\n');\n    const { response } = await showMessageBox({\n      type: request.destructive ? 'warning' : 'question',\n      title: 'An AI agent is asking',\n      message,\n      buttons: ['Decline', 'Allow'],\n      defaultId: 0,\n      cancelId: 0\n    });\n    return response === 1;\n  };\n}\n\nfunction bunServe(): DesktopServe {\n  const bun = (globalThis as { Bun?: { serve?: DesktopServe } }).Bun;\n  if (typeof bun?.serve !== 'function') {\n    throw new Error(\n      'serveDesktopAgent needs Bun.serve, which Cottontail and Bun provide. Pass serve to use another server.'\n    );\n  }\n  return options => bun.serve!(options);\n}\n\nfunction isAddressInUse(error: unknown): boolean {\n  const code = (error as { code?: unknown } | null)?.code;\n  return code === 'EADDRINUSE' || /in use|EADDRINUSE/i.test(String((error as Error | null)?.message ?? error));\n}\n","/**\n * An application in the main process: windows, and the channels each\n * one is served.\n *\n * Nothing here imports Electrobun, and that is not fastidiousness. The\n * SDK is projected into a project by Hutch rather than installed from\n * a registry, so a package in\n * this workspace could not import it even if it wanted to. What the\n * application supplies instead is one function that opens a window,\n * which is the only Electrobun-shaped thing this needs, and which is\n * five lines at the call site:\n *\n *   const app = createDesktopApp({\n *     channels: window => [\n *       { token: Catalogue, source: catalogue },\n *       windowsChannel(app, window)\n *     ],\n *     open: (receive, handle) => {\n *       const rpc = BrowserView.defineRPC<GessoWindowRPC>({\n *         handlers: { requests: {}, messages: { gessoFrame: receive } }\n *       });\n *       const window = new BrowserWindow({\n *         title: 'Notes',\n *         url: withWindowRoute('views://mainview/index.html', handle.route),\n *         rpc\n *       });\n *       return {\n *         send: frame => window.webview.rpc.send.gessoFrame(frame),\n *         close: () => window.close()\n *       };\n *     }\n *   });\n *   app.openWindow();\n *\n * The arrangement it buys: every\n * window is a replica of the same channels, so two windows agree by\n * construction rather than by synchronisation.\n */\nimport { channel, type ChannelToken, type ServedChannel } from 'gesso-framework';\nimport { BehaviorSubject, type Observable, type Subscription } from 'rxjs';\n\nimport type { GessoFrame } from './frames';\nimport { serveChannelsToWindow, type ChannelHost } from './main';\n\nexport { withWindowRoute } from './route';\n\n/** What the application does with the window it opened. */\nexport interface DesktopWindowTransport {\n  /** Sends one frame to this window, over its own RPC. */\n  send: (frame: GessoFrame) => void;\n  /** Closes the native window. The adapter calls this; the platform may also close it on its own. */\n  close: () => void;\n}\n\n/** A window this application opened. */\nexport interface DesktopWindowHandle {\n  /** Stable for the life of the window, and never reused. */\n  readonly id: number;\n  /**\n   * The application url the window was asked to open at, or null for\n   * wherever the application starts.\n   *\n   * Set by `openWindow({ route })`, which is what a Cmd-click on an\n   * in-app link comes to by default. The window cannot be told it\n   * through a frame in time to start there, so `open` puts it on the\n   * view's url, with `withWindowRoute`, and the window reads it back\n   * with `windowRoute` before its shell starts.\n   */\n  readonly route: string | null;\n  /** Closes the window and disposes the channels it was served. */\n  close(): void;\n}\n\n/** What `openWindow` may be told about the window it opens. */\nexport interface DesktopWindowOptions {\n  /**\n   * The application url to open at, `/epic/BUD-12?story=BUD-13`. Carried\n   * to `open` as `window.route`; see `DesktopWindowHandle.route`.\n   */\n  readonly route?: string;\n}\n\nexport interface DesktopAppOptions {\n  /**\n   * The channels each window is served.\n   *\n   * A function when a window needs a channel of its own, which is what\n   * `windowsChannel` uses to give a window a way to close itself. It\n   * is called once per window, and the observables it returns are\n   * ordinarily the same ones every time: `provide` keeps a separate\n   * record of what each client has seen, so sharing a source between\n   * windows is what makes them agree.\n   */\n  channels: readonly ServedChannel[] | ((window: DesktopWindowHandle) => readonly ServedChannel[]);\n  /**\n   * Opens a native window.\n   *\n   * `receive` is what the window's frames must be fed into: wire it to\n   * the RPC message the window sends frames on, before the window\n   * opens, or the first handshake is lost.\n   *\n   * `window.route` is the application url the window should start at,\n   * or null. Put it on the view's url with `withWindowRoute`, and read\n   * it in the window with `windowRoute`; an `open` that ignores it\n   * opens every window at the application's start, as before.\n   */\n  open: (receive: (frame: GessoFrame) => void, window: DesktopWindowHandle) => DesktopWindowTransport;\n  /**\n   * A url a window asked to have opened outside itself, with the\n   * window that asked. `Utils.openExternal(url)` is what an Electrobun\n   * application passes here.\n   */\n  onOpenUrl?: (url: string, window: DesktopWindowHandle) => void;\n  /**\n   * One of the application's own urls a window asked to have opened\n   * somewhere new (a Cmd-click or a Ctrl-click on an in-app link), with\n   * the window that asked.\n   *\n   * Defaults to `app.openWindow({ route: url })`: a new window of this\n   * application, at that route, which is what a new tab is in an\n   * application whose windows have none. An outbound url never comes\n   * here; it is `onOpenUrl`'s, and goes to the person's browser.\n   */\n  onOpenRoute?: (url: string, window: DesktopWindowHandle) => void;\n  /**\n   * The appearance the platform is in, pushed to every window as it\n   * changes and to a new window as it opens.\n   *\n   * The application supplies it because Electrobun does not: its SDK\n   * has no appearance API at all, and the webview's own\n   * `prefers-color-scheme` is wrong on WebKitGTK\n   *. On a platform that has a\n   * signal, this is where it goes; on one that does not, an\n   * application setting is a perfectly good source.\n   */\n  colorScheme?: Observable<'light' | 'dark'>;\n  /**\n   * Called when the last window closes. A desktop application usually\n   * stops here; one with a tray or a menu bar does not, which is why\n   * this is a callback rather than an exit.\n   */\n  onLastWindowClosed?: () => void;\n  /** Overrides the frame size messages are split at. Only a test should need to. */\n  chunkBytes?: number;\n}\n\nexport interface DesktopApp {\n  /**\n   * Opens a window, serves it every channel, and returns its handle;\n   * at `options.route` when one is given.\n   */\n  openWindow(options?: DesktopWindowOptions): DesktopWindowHandle;\n  /** The windows open now, in the order they were opened. */\n  readonly windows: readonly DesktopWindowHandle[];\n  /** How many windows are open, as something a channel can publish. */\n  readonly windowCount: Observable<number>;\n  /** Closes every window and stops serving. */\n  dispose(): void;\n}\n\nexport function createDesktopApp(options: DesktopAppOptions): DesktopApp {\n  interface Entry {\n    handle: DesktopWindowHandle;\n    transport: DesktopWindowTransport;\n    host: ChannelHost;\n  }\n  const entries = new Map<number, Entry>();\n  /** One appearance subscription per window, ended when it closes. */\n  const subscriptions = new Map<number, Subscription>();\n  const order: DesktopWindowHandle[] = [];\n  const count = new BehaviorSubject(0);\n  let nextId = 1;\n  let disposed = false;\n\n  const forget = (id: number, closeNative: boolean): void => {\n    const entry = entries.get(id);\n    if (entry === undefined) {\n      return;\n    }\n    entries.delete(id);\n    subscriptions.get(id)?.unsubscribe();\n    subscriptions.delete(id);\n    const at = order.indexOf(entry.handle);\n    if (at >= 0) {\n      order.splice(at, 1);\n    }\n    entry.host.dispose();\n    if (closeNative) {\n      entry.transport.close();\n    }\n    count.next(order.length);\n    if (order.length === 0 && !disposed) {\n      options.onLastWindowClosed?.();\n    }\n  };\n\n  const app: DesktopApp = {\n    openWindow(windowOptions: DesktopWindowOptions = {}): DesktopWindowHandle {\n      if (disposed) {\n        throw new Error('This desktop application has been disposed; it cannot open a window.');\n      }\n      const id = nextId++;\n      const handle: DesktopWindowHandle = {\n        id,\n        route: windowOptions.route ?? null,\n        close: () => forget(id, true)\n      };\n\n      // The host exists before the window does, because `open` may\n      // deliver a frame synchronously and a window whose first\n      // handshake was dropped never replicates anything.\n      let transport: DesktopWindowTransport | undefined;\n      const host = serveChannelsToWindow(\n        typeof options.channels === 'function' ? options.channels(handle) : options.channels,\n        {\n          send: frame => transport?.send(frame),\n          chunkBytes: options.chunkBytes,\n          onOpenUrl: url => options.onOpenUrl?.(url, handle),\n          onOpenRoute: url => {\n            if (options.onOpenRoute !== undefined) {\n              options.onOpenRoute(url, handle);\n            } else if (!disposed) {\n              app.openWindow({ route: url });\n            }\n          }\n        }\n      );\n      entries.set(id, { handle, transport: { send: () => {}, close: () => {} }, host });\n      order.push(handle);\n\n      // Anything pushed before the window has spoken is lost: a\n      // webview's RPC is not listening until its page has loaded, and\n      // the window opens well before that. Channels do not notice,\n      // because a channel starts with the window asking. The\n      // appearance is the one thing this side sends first, so it waits\n      // for the window's first frame, whatever that frame is. A native\n      // window found this; a spec with a transport that was live\n      // immediately could not.\n      let greeted = false;\n      let latest: 'light' | 'dark' | undefined;\n      transport = options.open(frame => {\n        if (!greeted) {\n          greeted = true;\n          if (latest !== undefined) {\n            host.setColorScheme(latest);\n          }\n        }\n        host.receive(frame);\n      }, handle);\n      entries.set(id, { handle, transport, host });\n      const appearance = options.colorScheme?.subscribe(scheme => {\n        latest = scheme;\n        if (greeted) {\n          host.setColorScheme(scheme);\n        }\n      });\n      if (appearance !== undefined) {\n        subscriptions.set(id, appearance);\n      }\n      count.next(order.length);\n      return handle;\n    },\n    get windows(): readonly DesktopWindowHandle[] {\n      return [...order];\n    },\n    windowCount: count.asObservable(),\n    dispose(): void {\n      disposed = true;\n      for (const id of new Set(entries.keys())) {\n        forget(id, true);\n      }\n      count.complete();\n    }\n  };\n\n  return app;\n}\n\n/** What a window can see and do about the windows of its application. */\nexport interface DesktopWindowsView {\n  /** How many windows this application has open. */\n  count: number;\n  /** Which one this is, so a screen can say \"window 2 of 3\" without asking. */\n  id: number;\n}\n\nexport interface DesktopWindowsCommands {\n  open: () => void;\n  closeThis: () => void;\n}\n\n/**\n * The channel a window opens another window through.\n *\n * It exists because opening a window is the one native act a screen\n * genuinely needs, and going through a channel keeps the view layer\n * from importing an adapter. the \"native menus bound to\n * store actions\" is the same idea from the other end, and on Linux it\n * is the only end: the runtime has no application menus there, so a\n * menu is a component and this is what it calls.\n */\nexport const DesktopWindows: ChannelToken<DesktopWindowsView, DesktopWindowsCommands> = channel<\n  DesktopWindowsView,\n  DesktopWindowsCommands\n>('gesso:windows', { count: 0, id: 0 });\n\n/** Serves `DesktopWindows` to one window. Put it in `channels`. */\nexport function windowsChannel(app: DesktopApp, window: DesktopWindowHandle): ServedChannel {\n  return {\n    token: DesktopWindows,\n    source: {\n      view: {\n        count: app.windowCount,\n        id: new BehaviorSubject(window.id)\n      },\n      commands: {\n        open: () => {\n          app.openWindow();\n        },\n        closeThis: () => {\n          window.close();\n        }\n      }\n    }\n  };\n}\n\nexport { createScreenAgent, type ScreenAgent } from './screen';\nexport {\n  messageBoxConfirm,\n  serveDesktopAgent,\n  type DesktopAgent,\n  type DesktopAgentOptions,\n  type DesktopServe,\n  type ShowMessageBox\n} from './agent';\n"],"mappings":"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"}

package/dist/{route-CNeMnj_6.d.ts → view-Cw282TuC.d.ts}

@@ -1,3 +1,4 @@
+import { RemoteBridge, RemoteBridgeOptions } from "gesso-framework/remote";
 //#region src/route.d.ts
 /**
  * How a new window learns the route it opens at.
@@ -40,5 +41,25 @@ declare function withWindowRoute(viewUrl: string, route: string | null | undefin
  */
 declare function windowRoute(hash?: string): string;
 //#endregion
-export { withWindowRoute as n, windowRoute as t };
-//# sourceMappingURL=route-CNeMnj_6.d.ts.map
+//#region src/view.d.ts
+type ElectrobunBridgeOptions = RemoteBridgeOptions;
+type ElectrobunBridge = RemoteBridge;
+/** `createRemoteBridge`, by the name the Electrobun template uses. */
+declare const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge;
+/** A message between a window's render worker agent port and the main process, as the port carries it. */
+type ScreenAgentMessage = unknown;
+/**
+ * The page's half: relays messages between the main process and the
+ * render worker's agent port, which it opens on the first one, since the
+ * render worker does not exist until the app mounts. Returns what to call
+ * with each message the main process sends.
+ *
+ *   const relay = relayScreenAgent(app, message => view.rpc?.send.screenAgent(message));
+ *   // in the RPC's handlers: screenAgent: message => relay(message)
+ */
+declare function relayScreenAgent(app: {
+  openRenderPort(key: string): MessagePort | undefined;
+}, send: (message: ScreenAgentMessage) => void): (message: ScreenAgentMessage) => void;
+//#endregion
+export { relayScreenAgent as a, createElectrobunBridge as i, ElectrobunBridgeOptions as n, windowRoute as o, ScreenAgentMessage as r, withWindowRoute as s, ElectrobunBridge as t };
+//# sourceMappingURL=view-Cw282TuC.d.ts.map

package/dist/view.d.ts

@@ -1,10 +1,2 @@
-import { t as windowRoute } from "./route-CNeMnj_6.js";
-import { RemoteBridge, RemoteBridgeOptions } from "gesso-framework/remote";
-//#region src/view.d.ts
-type ElectrobunBridgeOptions = RemoteBridgeOptions;
-type ElectrobunBridge = RemoteBridge;
-/** `createRemoteBridge`, by the name the Electrobun template uses. */
-declare const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge;
-//#endregion
-export { ElectrobunBridge, ElectrobunBridgeOptions, createElectrobunBridge, windowRoute };
-//# sourceMappingURL=view.d.ts.map
+import { a as relayScreenAgent, i as createElectrobunBridge, n as ElectrobunBridgeOptions, o as windowRoute, r as ScreenAgentMessage, t as ElectrobunBridge } from "./view-Cw282TuC.js";
+export { ElectrobunBridge, ElectrobunBridgeOptions, ScreenAgentMessage, createElectrobunBridge, relayScreenAgent, windowRoute };

package/dist/view.js

@@ -1,5 +1,6 @@
 import { t as windowRoute } from "./route-B2qU38dY.js";
 import { createRemoteBridge } from "gesso-framework/remote";
+import { AGENT_PORT } from "gesso-framework/agent";
 //#region src/view.ts
 /**
 * The webview's half of the bridge.
@@ -13,7 +14,27 @@ import { createRemoteBridge } from "gesso-framework/remote";
 */
 /** `createRemoteBridge`, by the name the Electrobun template uses. */
 const createElectrobunBridge = createRemoteBridge;
+/**
+* The page's half: relays messages between the main process and the
+* render worker's agent port, which it opens on the first one, since the
+* render worker does not exist until the app mounts. Returns what to call
+* with each message the main process sends.
+*
+*   const relay = relayScreenAgent(app, message => view.rpc?.send.screenAgent(message));
+*   // in the RPC's handlers: screenAgent: message => relay(message)
+*/
+function relayScreenAgent(app, send) {
+	let port;
+	return (message) => {
+		if (port === void 0) {
+			port = app.openRenderPort(AGENT_PORT);
+			if (port === void 0) return;
+			port.onmessage = (event) => send(event.data);
+		}
+		port.postMessage(message);
+	};
+}
 //#endregion
-export { createElectrobunBridge, windowRoute };
+export { createElectrobunBridge, relayScreenAgent, windowRoute };
 
 //# sourceMappingURL=view.js.map

package/dist/view.js.map

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":[],"sources":["../src/view.ts"],"sourcesContent":["/**\n * The webview's half of the bridge.\n *\n * The bridge is `createRemoteBridge` from `gesso-framework/remote`,\n * which carries a render worker's channels over any transport that\n * can carry a string. In a desktop window that transport is\n * Electrobun's RPC: pass `view.rpc.send.<name>` as `send`, and feed\n * every frame the main process sends to `receive`. This entry keeps the\n * names a desktop application has always used for it.\n */\nimport { createRemoteBridge, type RemoteBridge, type RemoteBridgeOptions } from 'gesso-framework/remote';\n\nexport { windowRoute } from './route';\n\nexport type ElectrobunBridgeOptions = RemoteBridgeOptions;\nexport type ElectrobunBridge = RemoteBridge;\n\n/** `createRemoteBridge`, by the name the Electrobun template uses. */\nexport const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge = createRemoteBridge;\n"],"mappings":";;;;;;;;;;;;;;AAkBA,MAAa,yBAAiF"}
+{"version":3,"file":"view.js","names":[],"sources":["../src/view.ts"],"sourcesContent":["/**\n * The webview's half of the bridge.\n *\n * The bridge is `createRemoteBridge` from `gesso-framework/remote`,\n * which carries a render worker's channels over any transport that\n * can carry a string. In a desktop window that transport is\n * Electrobun's RPC: pass `view.rpc.send.<name>` as `send`, and feed\n * every frame the main process sends to `receive`. This entry keeps the\n * names a desktop application has always used for it.\n */\nimport { AGENT_PORT } from 'gesso-framework/agent';\nimport { createRemoteBridge, type RemoteBridge, type RemoteBridgeOptions } from 'gesso-framework/remote';\n\nexport { windowRoute } from './route';\n\nexport type ElectrobunBridgeOptions = RemoteBridgeOptions;\nexport type ElectrobunBridge = RemoteBridge;\n\n/** `createRemoteBridge`, by the name the Electrobun template uses. */\nexport const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge = createRemoteBridge;\n\n/** A message between a window's render worker agent port and the main process, as the port carries it. */\nexport type ScreenAgentMessage = unknown;\n\n/**\n * The page's half: relays messages between the main process and the\n * render worker's agent port, which it opens on the first one, since the\n * render worker does not exist until the app mounts. Returns what to call\n * with each message the main process sends.\n *\n *   const relay = relayScreenAgent(app, message => view.rpc?.send.screenAgent(message));\n *   // in the RPC's handlers: screenAgent: message => relay(message)\n */\nexport function relayScreenAgent(\n  app: { openRenderPort(key: string): MessagePort | undefined },\n  send: (message: ScreenAgentMessage) => void\n): (message: ScreenAgentMessage) => void {\n  let port: MessagePort | undefined;\n  return message => {\n    if (port === undefined) {\n      port = app.openRenderPort(AGENT_PORT);\n      if (port === undefined) return;\n      port.onmessage = event => send(event.data as ScreenAgentMessage);\n    }\n    port.postMessage(message);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,MAAa,yBAAiF;;;;;;;;;;AAc9F,SAAgB,iBACd,KACA,MACuC;CACvC,IAAI;CACJ,QAAO,YAAW;EAChB,IAAI,SAAS,KAAA,GAAW;GACtB,OAAO,IAAI,eAAe,UAAU;GACpC,IAAI,SAAS,KAAA,GAAW;GACxB,KAAK,aAAY,UAAS,KAAK,MAAM,IAA0B;EACjE;EACA,KAAK,YAAY,OAAO;CAC1B;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gesso-electrobun",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "description": "Run a Gesso application in an Electrobun window, with its stores in the main process.",
   "license": "MIT",
   "author": "Kevin Baker",
@@ -54,7 +54,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "gesso-framework": "^0.6.12"
+    "gesso-framework": "^0.6.14"
   },
   "peerDependencies": {
     "rxjs": "^7.8.2"