@agentorg/computer 0.0.22 → 0.0.24

package/README.md

@@ -50,14 +50,30 @@ This computer:
   - `apps`: the running apps and their windows, and bringing one forward. Each window's `app_name`, `title`, `pid`, `window_id`, `z_index` (higher in front) and `bounds` are also given as fields. The bounds are in the screen's points, not the pixels `act` aims in: to aim at a window, see it and use its picture.
   - On a machine the service only lends (`serve --lend`), the agent acts only in the background: `act` takes no `delivery_mode`, and `apps` takes no window to bring forward, which would take the person's front app and their typing. Where the driver's answer to `act` advises the foreground, the agent is told in plain words instead. What `see` and `apps` say of the screen is never rewritten.
   - The driver's hints and suggested next calls, which can name its own tools, aren't passed on with any of the three.
-- **The person installs Cua Driver once,** the signed app from cua.ai/download, and on macOS grants it Screen Recording and Accessibility once. AgentComputer never installs or ships it, nor its optional perception extension, which is AGPL. `info` says whether the screen is ready, at Cua Driver 0.49.7 or later, and if not, what to do; attaching with it is refused with 409 until then. `serve --screen-driver PATH` names the program; otherwise it is `cua-driver` on the path, in `~/.local/bin`, or inside `/Applications/CuaDriver.app`.
+- **The person installs Cua Driver once,** the signed app from cua.ai/download, and on macOS grants it Screen Recording and Accessibility once. AgentComputer never installs or ships it, nor its optional perception extension, which is AGPL. `info` says whether the screen is ready, at Cua Driver 0.49.7 or later, and if not, what to do; attaching with it is refused with 409 until then. Once attached, a computer doesn't rest on its screen: brought back as the service starts, or started again, while the screen can't be used, because the person switched it off or it isn't ready, it runs with its terminal, files and browser. Its screen's tools stay listed and say why, in the switch's words or the screen's. While the screen isn't ready, its `screen` surface is `unavailable` with the same words, and reading it checks the screen again; the switch is for agents, and leaves the person's own live view alone. The next call after the screen can be used works, with no restart. Cua Driver is looked for again at each connection, so one installed meanwhile is reached. `serve --screen-driver PATH` names the program; otherwise it is `cua-driver` on the path, in `~/.local/bin`, or inside `/Applications/CuaDriver.app`.
 - **An app can carry Cua Driver and host it,** as the driver's embedding guide describes, so that the grants are the app's.
   - The app runs `cua-driver serve --embedded --socket PATH` itself. The service, started with `serve --screen-driver DRIVER --screen-socket PATH`, where DRIVER is the driver inside the app, reaches it there through `cua-driver mcp --embedded`.
   - The grants are read from that driver, and listed under the outermost app the driver is inside.
-  - Asked for, they are asked for by the app: the service opens it through the system with `--args grant` and each grant to ask for, `screen-recording` or `accessibility`, which it asks for in turn.
-  - Once a grant changes, the app restarts its driver, which reads grants once. That ends the connections of computers using the screen, which then say Cua Driver has stopped.
+  - Asked for, they are asked for by the app: the service opens it through the system with `--args grant` and the grant to ask for, `screen-recording` or `accessibility`. The app's `grant` shows nothing of its own, no window and no Dock tile, since the switch opens it for Screen Recording's request, which shows nothing.
+  - Once a grant changes, the app restarts its driver, which reads grants once. A computer's connection to the driver ends with it, and its screen connects again at its next call: the computer runs on. The driver reads a point against the last picture its connection took, so after such a connection is made again, `act` aimed at a point is refused, saying so, until the screen is seen again.
 - **What the service starts of Cua Driver sends no telemetry and checks for no updates,** so no update notice reaches a computer's log. The person's own Cua Driver app follows its own settings: `cua-driver telemetry disable` turns its telemetry off.
 
+**Upgrading from 0.0.23:**
+
+- **A computer with the screen no longer stops working because of its screen.**
+  - Brought back as the service starts while the screen can't be used (switched off, or not ready), it is `running`, where it was `failed`. `start` on a stopped one is answered `running`, where it was refused with 409 and the computer stayed `stopped`. Its terminal, files and browser work.
+  - Its screen's tools are listed and say why, in the switch's words or the screen's. While the screen isn't ready, its `screen` surface has `unavailable` with the same words; switched off, it hasn't, as before. The next call after the screen can be used works, with no restart.
+  - Cua Driver stopping while it runs, as when an app hosting it starts it again for a grant, no longer fails the computer: the next screen call connects again. The surface's "Cua Driver has stopped. Stop the computer and start it again." and the screen endpoint's 502 "Cua Driver has stopped." are gone. After such a connection, `act` aimed at a point is refused until the screen is seen again.
+  - A client that showed a failed computer for its screen reads the surface's `unavailable`, or the tools' refusals, instead. Attaching with the screen while it can't be used is still refused with 409.
+
+**Upgrading from 0.0.22:**
+
+- **Turning a part on shows nothing.** `PUT /v1/setup/{capability}` with `{ "on": true }` makes only the requests that show nothing: from macOS 26, Screen Recording's for an app hosting Cua Driver. Accessibility's alert, Cua Driver's own grant window and a browser's inspect page come from `POST /v1/setup/{capability}/ask` with that need, which a client calls from a button the person presses for it. Before macOS 26 Screen Recording waits for its button too; that is untested. `ask` with no need makes only what turning the part on makes.
+  - A client that offered only `settings` for a missing grant, relying on the switch's requests, offers `ask` with the grant: the switch no longer has Accessibility list the app in its pane.
+  - Turning the browser on with neither Chrome nor Edge installed no longer answers 409; `GET /v1/setup` lists both as `missing`. Turning the screen on without Cua Driver no longer answers 409 either; the screen lists `install` as `missing`.
+- **Asking for a grant of an app hosting the driver now also opens the grant's pane,** a second later, except at the first request of a grant whose request may draw an alert, and it asks for that grant alone. A client that called `settings` after `ask` for the same click calls `ask` alone.
+  - Requests made before this version aren't counted. Where the person already answered Accessibility's alert, the first click after the upgrade makes the request alone, which shows nothing; the next opens the pane.
+
 **Upgrading from 0.0.21:**
 
 - **An agent's command keeps it acting on its terminal until the command ends,** and 10 seconds after, in `presence` and `GET /v1/acting`, where it was counted for 10 seconds from the command's start. One left running keeps it there, and its `at` can be older than 10 seconds: take the list as it is sent, and drop no one by their `at`.
@@ -216,13 +232,17 @@ These take the control token, kept in the data folder. A computer's own endpoint
   - The terminal and files need nothing, and are always ready; on macOS the Mac asks folder by folder.
   - The screen needs Cua Driver, and on macOS its `screen-recording` and `accessibility` grants, each `granted`, `not-granted` or `unknown`; it is ready once both are granted. While Cua Driver isn't installed, the one item is `{ "need": "install", "state": "missing" }`. `holder` names whom System Settings lists the grants under: the outermost app Cua Driver is inside, CuaDriver for its own app, or an app that carries the driver.
   - The browser lists Chrome, then Edge, each `on` (open, with remote debugging on), `off`, or `missing` (not installed); a service given one browser's folder, with `--own-browser-data`, lists just that one as `named`. It is ready with one on. With both on, the agent's is Chrome.
-- **`POST /v1/setup/{capability}/ask`**, with `{ "need": "..." }` or no body, asks the person, on the service's machine, macOS only, for one thing the part needs, or for everything it is missing. It answers once the steps have started, with each part then:
-  - `screen-recording` or `accessibility`, while it is missing: Cua Driver's own grant, its app started first, through the system, so the Mac names that app. Cua Driver asks in its own order, Accessibility first. For a driver an app hosts, the app asks, for that grant alone, in its own way. The service opens no pane of System Settings. macOS shows each request once: once it has been answered, asking again shows nothing and answers the same, so a client offers `settings` while a grant stays `not-granted`.
+- **`POST /v1/setup/{capability}/ask`**, with `{ "need": "..." }`, asks the person, on the service's machine, macOS only, for one thing the part needs, for a button they press for it. It answers once the steps have started, with each part then:
+  - `screen-recording` or `accessibility`, while it is missing, for a driver an app hosts: the app makes macOS's request each time, so macOS asks again whenever it would, such as after a reset of the app's privacy entries.
+    - That grant's pane of System Settings opens as well, a second later, by when macOS has listed the app there.
+    - Except at the first request the service has made, for that app's bundle identifier, of a grant whose request may draw an alert: `accessibility`, and `screen-recording` before macOS 26. macOS draws that alert until it has been answered, and the alert's own button opens the pane. Which requests were made is kept in the data folder, so it lasts across a restart. After a reset, the alert and the pane both come.
+    - From macOS 26 Screen Recording's request draws nothing, so its pane opens each time. Before 26 it is taken to draw an alert; that is untested.
+  - `screen-recording` or `accessibility`, while it is missing, for Cua Driver's own app: its own grant, its app started first, through the system, so the Mac names that app. Cua Driver asks in its own order, Accessibility first, in a window of its own.
   - `chrome` or `edge`: that browser opens at its inspect page, where remote debugging is switched on. One the service was given only the folder of, the person opens themselves.
-  - With none named: the screen's grant while either is missing; the first browser installed, Chrome before Edge, while none is on.
-  - What the part doesn't need, a browser that isn't installed, or steps that couldn't be started answer 409, saying why.
-- **`POST /v1/setup/{capability}/settings`**, with `{ "need": "screen-recording" }` or `{ "need": "accessibility" }`, opens that grant's pane of System Settings, under Privacy & Security, on the service's machine, macOS only, whether the grant is missing or not, for the person to switch it there. macOS lists an app there once it has asked, so this follows `ask`. It is for the person's own choice, such as a button they press: the service opens a pane nowhere else. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. A need the part doesn't have, one with no pane, a pane that couldn't be opened, or a machine other than a Mac answers 409, saying why.
-- **`PUT /v1/setup/{capability}`** with `{ "on": true }` or `{ "on": false }` sets a switch. Turning it on, or on again, also asks for everything the part is missing, as asking with no need does. Where that couldn't be started, it answers 409, saying why, and the switch stays on.
+  - With no body, or no need named, it makes only what turning the part on makes.
+  - What the part doesn't need, a browser that isn't installed, steps that couldn't be started, or a grant's pane that couldn't be opened once macOS's request was made answer 409, saying why.
+- **`POST /v1/setup/{capability}/settings`**, with `{ "need": "screen-recording" }` or `{ "need": "accessibility" }`, opens that grant's pane of System Settings, under Privacy & Security, on the service's machine, macOS only, whether the grant is missing or not, for the person to switch it there. macOS lists an app there once it has asked, so this follows `ask`. It is for the person's own choice, such as a button they press: the service opens a pane only here and from `ask`, each on the person's click. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. A need the part doesn't have, one with no pane, a pane that couldn't be opened, or a machine other than a Mac answers 409, saying why.
+- **`PUT /v1/setup/{capability}`** with `{ "on": true }` or `{ "on": false }` sets a switch. Turning it on, or on again, makes only the requests that show nothing, on the service's machine, macOS only: from macOS 26, Screen Recording's for an app hosting Cua Driver, while it is missing, which lists the app in its pane. Nothing that shows an alert or a window comes from the switch: each comes from `ask` with that need, on the person's click. Where a request it makes couldn't be started, it answers 409, saying why, and the switch stays on.
 - **`GET /v1/acting`** is who is acting now on every computer attached to this machine, in one list, as each one's `presence` surface has it. A computer in a container isn't included: its own `presence` surface has it.
 
 ## SDK

package/dist/agentcomputer.js

@@ -98140,27 +98140,87 @@ var Driver = class {
     return await this.#client.callTool({ name: tool, arguments: args });
   }
 };
-var Screen = class extends Driver {
+var Screen = class {
+  /** Cua Driver as it is found at each connection. */
+  #at;
+  #log;
   #noted;
   #refused;
+  /** The driver's connection, while there is one. */
+  #driver;
+  #stopped = false;
+  /** How many connections it has made, and whether the screen was seen on the one there is. */
+  #connections = 0;
+  #seen = false;
   /** On a lent machine: the agent acts only in the background, leaving the person's pointer. */
   #onlyBackground;
   /**
    * `noted` gives the line to add to each answer: who else acted on the screen. `refused` says why
-   * no call is answered now, while the person has it switched off. `onlyBackground`: whether the
-   * agent acts only in the background, as on a lent machine.
+   * no call is answered now: the person has it switched off, or it isn't ready. `onlyBackground`:
+   * whether the agent acts only in the background, as on a lent machine.
    */
-  constructor(driver, log, exited, noted, refused2, onlyBackground) {
-    super(driver, log, exited);
+  constructor(driver, log, noted, refused2, onlyBackground) {
+    this.#at = driver;
+    this.#log = log;
     this.#noted = noted;
     this.#refused = refused2;
     this.#onlyBackground = onlyBackground;
   }
+  /** The driver's connection: the one there is, or a new one, once it answers. */
+  async #connected() {
+    if (this.#stopped) throw new ApiError(409, "It has stopped.");
+    if (!this.#driver) {
+      const made = new Driver(this.#at(), this.#log, () => {
+        if (this.#driver === made) this.#driver = void 0;
+      });
+      this.#driver = made;
+      this.#connections += 1;
+      this.#seen = false;
+    }
+    const driver = this.#driver;
+    try {
+      await driver.ready();
+    } catch (error64) {
+      if (this.#driver === driver) this.#driver = void 0;
+      void driver.stop();
+      throw error64;
+    }
+    return driver;
+  }
+  /** Connect now, and wait until the driver answers, or say why it didn't. */
+  async ready() {
+    await this.#connected();
+  }
+  async call(tool, args) {
+    return (await this.#connected()).call(tool, args);
+  }
+  /**
+   * Why a call aimed at a point is refused now: the driver reads a point against the last picture
+   * its connection took, and a connection made again, as when the driver is started again for a
+   * grant, has taken none. Seen again, it aims as it should.
+   */
+  async #unseen(input3) {
+    if (input3.element_token !== void 0 || input3.x === void 0) return void 0;
+    await this.#connected();
+    if (this.#connections === 1 || this.#seen) return void 0;
+    return {
+      content: [
+        text3(
+          "Cua Driver was started again since the screen was last seen, as when a grant changes: see it again, then aim at its point."
+        )
+      ],
+      isError: true
+    };
+  }
+  async stop() {
+    this.#stopped = true;
+    await this.#driver?.stop();
+  }
   /** The agent's three tools, each answered with what the driver answers, and the line after it. */
   #server() {
     const server = new McpServer2({ name: "agentcomputer-screen", version: "1" });
     const answered2 = async (work) => {
-      const refusal = this.#refused();
+      const refusal = await this.#refused();
       if (refusal) return { content: [text3(refusal)], isError: true };
       const line = this.#noted();
       const answer = forAgent(await work().catch(failed));
@@ -98178,11 +98238,11 @@ var Screen = class extends Driver {
         inputSchema: Seen
       },
       ({ pid, window_id }) => answered2(async () => {
-        if (pid === void 0 && window_id === void 0)
-          return this.call("get_desktop_state", {});
-        if (pid === void 0 || window_id === void 0)
+        if (pid === void 0 !== (window_id === void 0))
           throw new ApiError(400, "A window is its pid and its window_id, from apps: give both.");
-        return this.call("get_window_state", { pid, window_id });
+        const seen = await (pid === void 0 ? this.call("get_desktop_state", {}) : this.call("get_window_state", { pid, window_id }));
+        if (!seen.isError) this.#seen = true;
+        return seen;
       })
     );
     server.registerTool(
@@ -98193,6 +98253,8 @@ var Screen = class extends Driver {
       },
       (input3) => answered2(async () => {
         const [tool, args] = driverCall(input3);
+        const unseen = await this.#unseen(input3);
+        if (unseen) return unseen;
         const answer = await this.call(tool, args).catch(failed);
         const said2 = (answer.content ?? []).map((part) => part.text ?? "").join("\n");
         if (this.#onlyBackground && /delivery_mode\W*foreground/i.test(said2))
@@ -98252,9 +98314,8 @@ var Screen = class extends Driver {
     );
     return server;
   }
-  /** Answer one MCP request, as the stateless transport does. */
+  /** Answer one MCP request, as the stateless transport does. Its tools are listed with no driver. */
   async handle(request2, response) {
-    await this.ready();
     const server = this.#server();
     const transport = new NodeStreamableHTTPServerTransport2({ sessionIdGenerator: void 0 });
     response.once("close", () => {
@@ -98313,6 +98374,7 @@ var said = (answer) => (answer.content ?? []).flatMap(
 ).join("\n") || "Cua Driver refused it.";
 var ScreenLive = class {
   /** Where Cua Driver is. */
+  /** Cua Driver as it is found at each connection. */
   #at;
   #log;
   /** Heard each time a person acts on the screen. */
@@ -98364,7 +98426,7 @@ var ScreenLive = class {
   /** The driver, connected once for everyone watching, and the frames it is taken for. */
   #begin() {
     if (this.#started) return this.#started;
-    const driver = new Driver(this.#at, this.#log, () => {
+    const driver = new Driver(this.#at(), this.#log, () => {
       if (this.#driver === driver) this.#leave(1011, "Cua Driver stopped.");
     });
     this.#driver = driver;
@@ -98591,6 +98653,35 @@ var ProcessRuntime = class {
     const { at: _, ...ready } = this.#screen;
     return ready;
   }
+  /**
+   * Why an agent's screen call is refused now: the person switched it off, or the screen wasn't
+   * ready at the last check. While it isn't, each call checks it afresh, so that a grant given is
+   * used at the next call; while it is, calls aren't held up by checks.
+   */
+  async #screenRefused() {
+    const off = this.#switches?.refused("screen");
+    if (off) return off;
+    if (this.#screen.ready) return void 0;
+    const { readiness: now } = await this.#checkScreen();
+    return now.ready ? void 0 : now.reason ?? "The screen isn't ready.";
+  }
+  /**
+   * Why the screen can't be opened live now: it isn't ready, as the last check says, which is
+   * checked again meanwhile, for the next to read. The person's switch is for agents, and leaves
+   * the person's own live view alone.
+   */
+  #screenUnavailable() {
+    if (this.#screen.ready) return void 0;
+    void this.#checkScreen();
+    return this.#screen.reason ?? "The screen isn't ready.";
+  }
+  /** Cua Driver as it is found now: where it was named or found, or where it was to be. */
+  #driverNow() {
+    return findDriver(this.#screenDriver) ?? {
+      ...this.#screenDriver,
+      program: this.#screenDriver.program ?? "cua-driver"
+    };
+  }
   /** Why the agent can't call this tool now: the person switched off what it reaches. */
   #toolRefused(tool) {
     const which = TOOL_SWITCH[tool];
@@ -98712,31 +98803,35 @@ var ProcessRuntime = class {
     }
     let screen;
     let screenLive;
-    let screenDown = false;
     if (spec.screen) {
       const { readiness: ready, driver } = await this.#checkScreen();
-      const refused2 = this.#switches?.refused("screen");
-      screen = ready.ready && driver && !refused2 ? new Screen(
-        driver,
+      const why = this.#switches?.refused("screen") ?? (ready.ready && driver ? void 0 : ready.reason ?? "The screen isn't ready.");
+      if (why && !spec.again) {
+        await Promise.all([exec2?.close(), browser?.stop()]);
+        throw new ApiError(409, why);
+      }
+      const at = () => this.#driverNow();
+      screen = new Screen(
+        at,
         events.log,
-        () => {
-          screenDown = true;
-          events.failed("Cua Driver stopped.");
-        },
         () => presence.agentCalled({ capability: "screen" }),
-        () => this.#switches?.refused("screen"),
+        () => this.#screenRefused(),
         // On a lent machine the agent acts only in the background.
         this.#switches?.lends ?? false
-      ) : void 0;
-      try {
-        if (!screen) throw new ApiError(409, refused2 ?? ready.reason ?? "The screen isn't ready.");
-        await screen.ready();
-      } catch (error64) {
-        await Promise.all([exec2?.close(), browser?.stop(), screen?.stop()]);
-        throw error64;
-      }
+      );
+      if (why) events.log(`It started without its screen, which its tools say: ${why}`);
+      else
+        try {
+          await screen.ready();
+        } catch (error64) {
+          if (!spec.again) {
+            await Promise.all([exec2?.close(), browser?.stop(), screen.stop()]);
+            throw error64;
+          }
+          events.log(`Its screen connects at its next call: ${error64.message}`);
+        }
       screenLive = new ScreenLive(
-        driver,
+        at,
         (line) => events.log(`Live view: ${line}`),
         () => presence.acted("person", { capability: "screen" })
       );
@@ -98758,19 +98853,21 @@ var ProcessRuntime = class {
       () => presence.acted("person", { capability: "files" })
     );
     const live = new Live(exec2, spec.access, load, presence, files, browserLive, screenLive);
+    const unavailableNow = () => this.#screenUnavailable();
     const surfaces = live.surfaces();
     return {
       browserTools: browser?.tools ?? [],
-      /** As they are now: a browser or a driver that has stopped can't be opened, and says so. */
+      /**
+       * As they are now: a browser that has stopped can't be opened, and says so; nor can the
+       * screen while it can't be used, as its tools say.
+       */
       get surfaces() {
+        const screenWhy = screen && unavailableNow();
         return surfaces.map(
           (one) => one.surface === "browser" && browserDown ? {
             ...one,
             unavailable: "Its browser has stopped. Stop the computer and start it again."
-          } : one.surface === "screen" && screenDown ? {
-            ...one,
-            unavailable: "Cua Driver has stopped. Stop the computer and start it again."
-          } : one
+          } : one.surface === "screen" && screenWhy ? { ...one, unavailable: screenWhy } : one
         );
       },
       acting: () => presence.acting(),
@@ -98788,10 +98885,7 @@ var ProcessRuntime = class {
           if (refusal) return refuseCall(response, message.id, refusal);
           return agentExec.handle(request2, response, message);
         }
-        if (endpoint === "screen") {
-          if (screenDown) throw new ApiError(502, "Cua Driver has stopped.");
-          return screen.handle(request2, response);
-        }
+        if (endpoint === "screen") return screen.handle(request2, response);
         if (browserDown) throw new ApiError(502, "Its browser has stopped.");
         return browser.handle(request2, response);
       },
@@ -98805,7 +98899,7 @@ var ProcessRuntime = class {
 };
 
 // src/handlers.ts
-var VERSION2 = "0.0.22";
+var VERSION2 = "0.0.24";
 function createHandlers(computers, connections, setup) {
   return {
     getInfo: async () => ({ version: VERSION2, ...await computers.offers() }),
@@ -100264,7 +100358,7 @@ var Computers = class {
         return;
       }
       const live = {};
-      await this.#start(stored, live).catch((error64) => {
+      await this.#start(stored, live, true).catch((error64) => {
         const why = `It didn't start again: ${messageOf2(error64)}`;
         this.#log(stored.id, why);
         if (this.#live.get(stored.id) !== live) return;
@@ -100437,7 +100531,7 @@ var Computers = class {
     stored.state = "running";
     const live = {};
     try {
-      await this.#start(stored, live);
+      await this.#start(stored, live, true);
     } catch (error64) {
       if (this.#live.get(id) === live) {
         await this.#halt(id);
@@ -100597,7 +100691,7 @@ var Computers = class {
    * Start it, as `live`. Stopped, killed or started again while it waits, it is refused, and what
    * came up meanwhile is stopped: nothing is left that no call reaches.
    */
-  async #start(stored, live) {
+  async #start(stored, live, again = false) {
     this.#live.set(stored.id, live);
     const stopped = () => this.#live.get(stored.id) !== live;
     const STOPPED = "It was stopped while it was starting.";
@@ -100617,6 +100711,7 @@ var Computers = class {
           access: stored.access,
           browser: stored.browser,
           screen: stored.screen === true,
+          again,
           workspace: stored.workspace
         },
         this.#folder(stored.id),
@@ -100736,7 +100831,7 @@ var OPENAPI = {
   "openapi": "3.1.0",
   "info": {
     "title": "AgentComputer",
-    "version": "0.0.22",
+    "version": "0.0.24",
     "description": "Computers for agents. This file is the source of truth: the HTTP API, the MCP control tools and the SDK are all generated from it. An operation with `x-mcp-tool` is also an MCP tool of that name.",
     "license": {
       "name": "Apache-2.0",
@@ -100832,7 +100927,7 @@ var OPENAPI = {
       ],
       "put": {
         "operationId": "setSetup",
-        "summary": "Set a part's switch, which lasts across restarts. Turning it on, or on again, also asks for everything the part is missing, as asking for it with no need named does. Where that couldn't be started, it answers 409, saying why, and the switch stays on.",
+        "summary": "Set a part's switch, which lasts across restarts. Turning it on, or on again, makes only the requests that show nothing, on the service's machine, macOS only: from macOS 26, Screen Recording's for an app hosting Cua Driver, while it is missing, which lists the app in its pane. Nothing that shows an alert or a window comes from the switch: Accessibility's alert, Cua Driver's own grant window and a browser's inspect page each come from ask with that need, on the person's click. Before macOS 26 Screen Recording's request is taken to draw an alert, so it waits for ask too; that is untested. Where a request it makes couldn't be started, it answers 409, saying why, and the switch stays on.",
         "requestBody": {
           "required": true,
           "content": {
@@ -100854,7 +100949,7 @@ var OPENAPI = {
         },
         "responses": {
           "200": {
-            "description": "Set, and its steps started.",
+            "description": "Set, and any request it makes started.",
             "content": {
               "application/json": {
                 "schema": {
@@ -100867,7 +100962,7 @@ var OPENAPI = {
             "$ref": "#/components/responses/Unauthorized"
           },
           "409": {
-            "description": "On, but the steps that ask for what it needs couldn't be started.",
+            "description": "On, but a request it makes couldn't be started.",
             "content": {
               "application/json": {
                 "schema": {
@@ -100892,7 +100987,7 @@ var OPENAPI = {
       ],
       "post": {
         "operationId": "askSetup",
-        "summary": "Ask the person, on the service's machine, macOS only, for one thing a part needs, or, with none named, for everything it is missing. screen-recording or accessibility, while it is missing: Cua Driver's own grant, its app started first, which makes the system's requests in its own order, Accessibility first. For a driver an app hosts, the app asks, for that grant alone, in its own way. The service opens no pane of System Settings: the person opens one with settings. macOS shows each request once: once it has been answered, asking again shows nothing and answers the same, so a client offers settings while a grant stays not-granted. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, the screen's grant while either is missing, and the first browser installed, Chrome before Edge, while none is on. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing.",
+        "summary": "Ask the person, on the service's machine, macOS only, for one thing a part needs, for a button they press for it. screen-recording or accessibility, while it is missing: for a driver an app hosts, the app makes macOS's request each time, so that macOS asks again whenever it would, such as after a reset of the app's privacy entries. That grant's pane of System Settings opens as well, a second later, except at the first request the service has made, for that app's bundle identifier, of a grant whose request may draw an alert: accessibility, and screen-recording before macOS 26. macOS draws that alert until it has been answered, and the alert's own button opens the pane; after a reset, the alert and the pane both come. From macOS 26 Screen Recording's request draws nothing, so its pane opens each time. For Cua Driver's own app, while it is missing: its own grant, its app started first, which makes the system's requests in its own order, Accessibility first, in a window of its own. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, it makes only what turning the part on makes. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing.",
         "requestBody": {
           "content": {
             "application/json": {
@@ -100923,7 +101018,7 @@ var OPENAPI = {
             "$ref": "#/components/responses/Unauthorized"
           },
           "409": {
-            "description": "The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started.",
+            "description": "The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started, or, once macOS's request was made, the grant's pane couldn't be opened.",
             "content": {
               "application/json": {
                 "schema": {
@@ -100948,7 +101043,7 @@ var OPENAPI = {
       ],
       "post": {
         "operationId": "openSetupSettings",
-        "summary": "Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane nowhere else. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409.",
+        "summary": "Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane only here and from ask, each on the person's click. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409.",
         "requestBody": {
           "required": true,
           "content": {
@@ -101495,7 +101590,7 @@ var OPENAPI = {
           "stopped",
           "failed"
         ],
-        "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+        "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
       },
       "Progress": {
         "type": "object",
@@ -101617,7 +101712,7 @@ var OPENAPI = {
           "screen": {
             "type": "boolean",
             "default": false,
-            "description": "Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready."
+            "description": "Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready. Once attached, the computer doesn't rest on it: brought back or started again while the screen can't be used, it runs, and its screen's tools say why."
           },
           "workspace": {
             "type": "string",
@@ -103821,7 +103916,7 @@ var OPERATIONS = [
     "operationId": "setSetup",
     "method": "PUT",
     "path": "/v1/setup/{capability}",
-    "summary": "Set a part's switch, which lasts across restarts. Turning it on, or on again, also asks for everything the part is missing, as asking for it with no need named does. Where that couldn't be started, it answers 409, saying why, and the switch stays on.",
+    "summary": "Set a part's switch, which lasts across restarts. Turning it on, or on again, makes only the requests that show nothing, on the service's machine, macOS only: from macOS 26, Screen Recording's for an app hosting Cua Driver, while it is missing, which lists the app in its pane. Nothing that shows an alert or a window comes from the switch: Accessibility's alert, Cua Driver's own grant window and a browser's inspect page each come from ask with that need, on the person's click. Before macOS 26 Screen Recording's request is taken to draw an alert, so it waits for ask too; that is untested. Where a request it makes couldn't be started, it answers 409, saying why, and the switch stays on.",
     "status": 200,
     "hasBody": true,
     "pathParameters": [
@@ -103943,7 +104038,7 @@ var OPERATIONS = [
     "operationId": "askSetup",
     "method": "POST",
     "path": "/v1/setup/{capability}/ask",
-    "summary": "Ask the person, on the service's machine, macOS only, for one thing a part needs, or, with none named, for everything it is missing. screen-recording or accessibility, while it is missing: Cua Driver's own grant, its app started first, which makes the system's requests in its own order, Accessibility first. For a driver an app hosts, the app asks, for that grant alone, in its own way. The service opens no pane of System Settings: the person opens one with settings. macOS shows each request once: once it has been answered, asking again shows nothing and answers the same, so a client offers settings while a grant stays not-granted. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, the screen's grant while either is missing, and the first browser installed, Chrome before Edge, while none is on. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing.",
+    "summary": "Ask the person, on the service's machine, macOS only, for one thing a part needs, for a button they press for it. screen-recording or accessibility, while it is missing: for a driver an app hosts, the app makes macOS's request each time, so that macOS asks again whenever it would, such as after a reset of the app's privacy entries. That grant's pane of System Settings opens as well, a second later, except at the first request the service has made, for that app's bundle identifier, of a grant whose request may draw an alert: accessibility, and screen-recording before macOS 26. macOS draws that alert until it has been answered, and the alert's own button opens the pane; after a reset, the alert and the pane both come. From macOS 26 Screen Recording's request draws nothing, so its pane opens each time. For Cua Driver's own app, while it is missing: its own grant, its app started first, which makes the system's requests in its own order, Accessibility first, in a window of its own. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, it makes only what turning the part on makes. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing.",
     "status": 200,
     "hasBody": true,
     "pathParameters": [
@@ -104073,7 +104168,7 @@ var OPERATIONS = [
     "operationId": "openSetupSettings",
     "method": "POST",
     "path": "/v1/setup/{capability}/settings",
-    "summary": "Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane nowhere else. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409.",
+    "summary": "Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane only here and from ask, each on the person's click. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409.",
     "status": 200,
     "hasBody": true,
     "pathParameters": [
@@ -104285,7 +104380,7 @@ var OPERATIONS = [
             "stopped",
             "failed"
           ],
-          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
         }
       },
       "required": []
@@ -104327,7 +104422,7 @@ var OPERATIONS = [
               "stopped",
               "failed"
             ],
-            "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+            "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
           },
           "reason": {
             "type": [
@@ -104594,7 +104689,7 @@ var OPERATIONS = [
                 "stopped",
                 "failed"
               ],
-              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
             },
             "reason": {
               "type": [
@@ -104811,7 +104906,7 @@ var OPERATIONS = [
         "screen": {
           "type": "boolean",
           "default": false,
-          "description": "Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready."
+          "description": "Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready. Once attached, the computer doesn't rest on it: brought back or started again while the screen can't be used, it runs, and its screen's tools say why."
         },
         "workspace": {
           "type": "string",
@@ -104875,7 +104970,7 @@ var OPERATIONS = [
                 "stopped",
                 "failed"
               ],
-              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
             },
             "reason": {
               "type": [
@@ -105110,7 +105205,7 @@ var OPERATIONS = [
                 "stopped",
                 "failed"
               ],
-              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+              "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
             },
             "reason": {
               "type": [
@@ -105445,7 +105540,7 @@ var OPERATIONS = [
             "stopped",
             "failed"
           ],
-          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
         },
         "reason": {
           "type": [
@@ -105664,7 +105759,7 @@ var OPERATIONS = [
             "stopped",
             "failed"
           ],
-          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
         },
         "reason": {
           "type": [
@@ -105888,7 +105983,7 @@ var OPERATIONS = [
             "stopped",
             "failed"
           ],
-          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again."
+          "description": "starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again."
         },
         "reason": {
           "type": [
@@ -106444,7 +106539,8 @@ ${JSON.stringify({ code: status, message })}
 
 // src/setup.ts
 import { execFile as execFile5, spawn as spawn6 } from "node:child_process";
-import { realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync9, realpathSync as realpathSync3 } from "node:fs";
+import { release } from "node:os";
 import { basename as basename3, join as join14 } from "node:path";
 import { promisify as promisify5 } from "node:util";
 
@@ -106472,12 +106568,15 @@ var WHAT = {
   browser: "their own browser"
 };
 var Switches = class {
+  /** The service's own folder, where they are kept. */
+  folder;
   #file;
   #lend;
   /** Only those the person set: the rest take the default of the way the service was started. */
   #set;
   /** `folder` is the service's own; `lend`, whether it only lends its machine. */
   constructor(folder, lend) {
+    this.folder = folder;
     this.#file = join13(folder, "switches.json");
     this.#lend = lend;
     this.#set = existsSync4(this.#file) ? kept(this.#file) : {};
@@ -106508,6 +106607,7 @@ var Switches = class {
 var exec = promisify5(execFile5);
 var thisMachine = () => ({
   ...here(),
+  release: release(),
   run: async (program2, args) => {
     try {
       await exec(program2, args, { timeout: 3e4 });
@@ -106527,6 +106627,8 @@ var thisMachine = () => ({
 });
 var IN_APP = /^(.*?\/[^/]+\.app)\/Contents\/(MacOS\/[^/]+$)?/;
 var APP_MS = 1e4;
+var PANE_MS = 1e3;
+var SILENT_FROM = 25;
 async function infoValue(app, key) {
   const plist = join14(app, "Contents", "Info.plist");
   try {
@@ -106548,18 +106650,48 @@ var PANE = {
   "screen-recording": "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture",
   accessibility: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility"
 };
+var Made = class {
+  #file;
+  #made;
+  constructor(folder) {
+    this.#file = join14(folder, "requests.json");
+    this.#made = {};
+    try {
+      const read = existsSync5(this.#file) ? JSON.parse(readFileSync9(this.#file, "utf8")) : {};
+      if (read && typeof read === "object" && !Array.isArray(read)) {
+        for (const [app, needs] of Object.entries(read))
+          if (Array.isArray(needs) && needs.every((need) => typeof need === "string"))
+            this.#made[app] = needs;
+      }
+    } catch {
+    }
+  }
+  has(app, need) {
+    return this.#made[app]?.includes(need) ?? false;
+  }
+  add(app, need) {
+    if (this.has(app, need)) return;
+    this.#made[app] = [...this.#made[app] ?? [], need];
+    try {
+      writePrivate(this.#file, JSON.stringify(this.#made));
+    } catch {
+    }
+  }
+};
 var NOTHING = { ready: true, needs: [] };
 var Setup = class {
   #switches;
   #driver;
   #browserData;
   #machine;
+  #made;
   /** `driver` and `browserData` are as `serve` names them: Cua Driver, and the browser's folder. */
   constructor(switches, driver = {}, browserData, machine2 = thisMachine()) {
     this.#switches = switches;
     this.#driver = driver;
     this.#browserData = browserData;
     this.#machine = machine2;
+    this.#made = new Made(switches.folder);
   }
   /** Each part, its switch, whether it has all it needs, and each thing it needs. */
   async capabilities() {
@@ -106608,14 +106740,14 @@ var Setup = class {
     return { ready: needs.some((one) => one.state === "on"), needs };
   }
   /**
-   * Set a part's switch. Turning it on, or on again, asks for everything it is missing; the switch
-   * stays on whether or not that could be started.
+   * Set a part's switch. Turning it on, or on again, makes only the requests that show nothing; the
+   * switch stays on whether or not they could be started.
    */
   async set(capability, on) {
     this.#switches.set(capability, on);
     if (on)
       try {
-        await this.#ask(capability);
+        await this.#quietly(capability);
       } catch (error64) {
         throw new ApiError(
           409,
@@ -106624,10 +106756,13 @@ var Setup = class {
       }
     return this.capabilities();
   }
-  /** Ask for one thing a part needs, or, with none named, for everything it is missing. */
+  /**
+   * Ask for one thing a part needs, on the person's click; with none named, only what turning the
+   * part on makes.
+   */
   async ask(capability, need) {
     try {
-      await this.#ask(capability, need);
+      await (need ? this.#ask(capability, need) : this.#quietly(capability));
     } catch (error64) {
       throw new ApiError(409, error64.message);
     }
@@ -106635,7 +106770,7 @@ var Setup = class {
   }
   /**
    * Open the pane of System Settings for one thing a part needs, whether it is missing or not: for
-   * the person's own choice, as nothing else opens one.
+   * the person's own choice, as only this and asking, each on their click, open one.
    */
   async settings(capability, need) {
     try {
@@ -106655,19 +106790,39 @@ var Setup = class {
       throw new Error(`There's no "${need}" for ${capability} here.`);
     return needs;
   }
-  /** Only macOS asks: elsewhere there is nothing to ask the person for. No pane opens. */
+  /**
+   * Whether macOS's request for a grant draws nothing: Screen Recording's, from macOS 26, where it
+   * only lists the app in its pane. Before 26 it is commonly seen to draw an alert, so it is taken
+   * as one; that is untested.
+   */
+  #silent(need) {
+    return need === "screen-recording" && Number.parseInt(this.#machine.release, 10) >= SILENT_FROM;
+  }
+  /**
+   * What turning a part on asks for: only the requests that show nothing, so that nothing appears
+   * at a switch. For an app hosting the driver, Screen Recording's while it is missing, where its
+   * request draws nothing. Accessibility's alert, Cua Driver's own grant window and a browser's
+   * inspect page each wait for the person's click on that need. Only macOS asks.
+   */
+  async #quietly(capability) {
+    if (capability !== "screen" || this.#machine.platform !== "darwin") return;
+    const driver = findDriver(this.#driver);
+    if (!driver?.socket || !this.#silent("screen-recording")) return;
+    const needs = await this.#needs(capability);
+    if (needs.some((one) => one.need === "screen-recording" && one.state !== "granted"))
+      await this.#request(driver, "screen-recording");
+  }
+  /** Ask for one thing a part needs, on the person's click. Only macOS asks. */
   async #ask(capability, need) {
     const needs = await this.#needs(capability, need);
     if (this.#machine.platform !== "darwin") return;
     if (capability === "screen") {
       const driver = findDriver(this.#driver);
       if (!driver) throw new Error("Cua Driver isn't installed on this machine.");
-      const asked = needs.filter((one) => one.state !== "granted" && (!need || one.need === need)).map((one) => one.need);
-      if (asked.length > 0)
-        await (driver.socket ? this.#askHost(driver, asked) : this.#askScreen(driver));
+      if (needs.some((one) => one.need === need && one.state === "granted")) return;
+      await (driver.socket ? this.#askHost(driver, need) : this.#askScreen(driver));
     }
-    if (capability === "browser" && (need || !needs.some((one) => one.state === "on")))
-      await this.#askBrowser(need);
+    if (capability === "browser") await this.#askBrowser(need);
   }
   /**
    * Cua Driver's own grant, with its app running first, started through the system so that the
@@ -106692,38 +106847,55 @@ var Setup = class {
     await this.#machine.start(driver.program, ["permissions", "grant"], quiet());
   }
   /**
-   * The grants of the app hosting the driver, which the driver can't ask for: the app asks, opened
-   * through the system so that what it asks is its own, whatever started the service, with
-   * `grant` and each grant to ask for, in turn.
+   * A grant of the app hosting the driver, which the driver can't ask for, on the person's click.
+   * The app makes macOS's request each time, so macOS asks again whenever it would, such as after a
+   * reset of the app's privacy entries. The grant's pane opens as well, once the app's row is
+   * written there, except at the first request of one whose request may draw an alert: macOS draws
+   * it until the person has answered it once, and its own button opens the pane.
    */
-  async #askHost(driver, asked) {
+  async #askHost(driver, need) {
+    const host = await this.#request(driver, need);
+    if (!this.#silent(need)) {
+      const app = await infoValue(host.app, "CFBundleIdentifier") ?? host.app;
+      const first2 = !this.#made.has(app, need);
+      this.#made.add(app, need);
+      if (first2) return;
+    }
+    await this.#pane(need);
+  }
+  /** A grant's pane, once the request just made has had its row written there. */
+  async #pane(need) {
+    const pane = PANE[need];
+    if (!pane) return;
+    await sleep8(PANE_MS);
+    try {
+      await this.#machine.run("/usr/bin/open", [pane]);
+    } catch (error64) {
+      throw new Error(
+        `macOS's request was made, but its pane didn't open: ${error64.message}`
+      );
+    }
+  }
+  /**
+   * macOS's request for a grant of the app hosting the driver: the app makes it, opened through the
+   * system so that it is the app's own, whatever started the service, with `grant` and the grant.
+   */
+  async #request(driver, need) {
     const host = await driverApp(driver.program);
     if (!host)
       throw new Error(
         "The app running Cua Driver can't be told from here: the driver isn't inside it."
       );
-    await this.#machine.run("/usr/bin/open", [
-      "-n",
-      "-g",
-      "-a",
-      host.app,
-      "--args",
-      "grant",
-      ...asked
-    ]);
+    await this.#machine.run("/usr/bin/open", ["-n", "-g", "-a", host.app, "--args", "grant", need]);
+    return host;
   }
   /**
-   * The browser asked for, or else the first this can open, Chrome before Edge, opened at its
-   * inspect page, where remote debugging is switched on. One the service was given only the folder
-   * of, the person opens themselves.
+   * The browser asked for, opened at its inspect page, where remote debugging is switched on. One
+   * the service was given only the folder of, the person opens themselves.
    */
   async #askBrowser(need) {
-    const each = browsers(this.#browserData, this.#machine);
-    const one = each.find((kind) => need ? kind.browser === need : kind.at);
-    if (!one) {
-      if (each.some((kind) => kind.installed)) return;
-      throw new Error("Neither Chrome nor Edge is installed on this machine.");
-    }
+    const one = browsers(this.#browserData, this.#machine).find((kind) => kind.browser === need);
+    if (!one) return;
     if (!one.installed) throw new Error(`${one.name} isn't installed on this machine.`);
     if (!one.at)
       throw new Error(

package/dist/types/generated/schema.d.ts

@@ -65,7 +65,7 @@ export interface paths {
             cookie?: never;
         };
         get?: never;
-        /** Set a part's switch, which lasts across restarts. Turning it on, or on again, also asks for everything the part is missing, as asking for it with no need named does. Where that couldn't be started, it answers 409, saying why, and the switch stays on. */
+        /** Set a part's switch, which lasts across restarts. Turning it on, or on again, makes only the requests that show nothing, on the service's machine, macOS only: from macOS 26, Screen Recording's for an app hosting Cua Driver, while it is missing, which lists the app in its pane. Nothing that shows an alert or a window comes from the switch: Accessibility's alert, Cua Driver's own grant window and a browser's inspect page each come from ask with that need, on the person's click. Before macOS 26 Screen Recording's request is taken to draw an alert, so it waits for ask too; that is untested. Where a request it makes couldn't be started, it answers 409, saying why, and the switch stays on. */
         put: operations["setSetup"];
         post?: never;
         delete?: never;
@@ -85,7 +85,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Ask the person, on the service's machine, macOS only, for one thing a part needs, or, with none named, for everything it is missing. screen-recording or accessibility, while it is missing: Cua Driver's own grant, its app started first, which makes the system's requests in its own order, Accessibility first. For a driver an app hosts, the app asks, for that grant alone, in its own way. The service opens no pane of System Settings: the person opens one with settings. macOS shows each request once: once it has been answered, asking again shows nothing and answers the same, so a client offers settings while a grant stays not-granted. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, the screen's grant while either is missing, and the first browser installed, Chrome before Edge, while none is on. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing. */
+        /** Ask the person, on the service's machine, macOS only, for one thing a part needs, for a button they press for it. screen-recording or accessibility, while it is missing: for a driver an app hosts, the app makes macOS's request each time, so that macOS asks again whenever it would, such as after a reset of the app's privacy entries. That grant's pane of System Settings opens as well, a second later, except at the first request the service has made, for that app's bundle identifier, of a grant whose request may draw an alert: accessibility, and screen-recording before macOS 26. macOS draws that alert until it has been answered, and the alert's own button opens the pane; after a reset, the alert and the pane both come. From macOS 26 Screen Recording's request draws nothing, so its pane opens each time. For Cua Driver's own app, while it is missing: its own grant, its app started first, which makes the system's requests in its own order, Accessibility first, in a window of its own. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. With none named, it makes only what turning the part on makes. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing. */
         post: operations["askSetup"];
         delete?: never;
         options?: never;
@@ -104,7 +104,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane nowhere else. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409. */
+        /** Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane only here and from ask, each on the person's click. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409. */
         post: operations["openSetupSettings"];
         delete?: never;
         options?: never;
@@ -315,7 +315,7 @@ export interface components {
          */
         Access: "none" | "read" | "files" | "terminal";
         /**
-         * @description starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again.
+         * @description starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again.
          * @enum {string}
          */
         ComputerState: "starting" | "running" | "stopped" | "failed";
@@ -365,7 +365,7 @@ export interface components {
              */
             browser: boolean | "own";
             /**
-             * @description Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready.
+             * @description Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready. Once attached, the computer doesn't rest on it: brought back or started again while the screen can't be used, it runs, and its screen's tools say why.
              * @default false
              */
             screen: boolean;
@@ -980,7 +980,7 @@ export interface operations {
             };
         };
         responses: {
-            /** @description Set, and its steps started. */
+            /** @description Set, and any request it makes started. */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -990,7 +990,7 @@ export interface operations {
                 };
             };
             401: components["responses"]["Unauthorized"];
-            /** @description On, but the steps that ask for what it needs couldn't be started. */
+            /** @description On, but a request it makes couldn't be started. */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -1028,7 +1028,7 @@ export interface operations {
                 };
             };
             401: components["responses"]["Unauthorized"];
-            /** @description The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started. */
+            /** @description The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started, or, once macOS's request was made, the grant's pane couldn't be opened. */
             409: {
                 headers: {
                     [name: string]: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/computer",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Computers for agents, as a service: a terminal, files and a browser over MCP",
   "license": "Apache-2.0",
   "repository": {