@agentorg/computer 0.0.23 → 0.0.24

package/README.md

@@ -50,14 +50,22 @@ 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 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. That ends the connections of computers using the screen, which then say Cua Driver has stopped.
+  - 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.

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.23";
+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.23",
+    "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",
@@ -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",
@@ -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": [

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

@@ -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;

package/package.json

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