@agentorg/computer 0.0.7 → 0.0.9

package/dist/sdk.js

@@ -24573,6 +24573,18 @@ function removeTrailingSlash(url2) {
   return url2;
 }
 
+// src/text.ts
+var MAX_TEXT = 1e4;
+function* pieces(text, most = MAX_TEXT) {
+  for (let from = 0; from < text.length; ) {
+    let to = Math.min(from + most, text.length);
+    const last = text.charCodeAt(to - 1);
+    if (to < text.length && last >= 55296 && last <= 56319) to -= 1;
+    yield text.slice(from, to);
+    from = to;
+  }
+}
+
 // src/sdk.ts
 var ComputerError = class extends Error {
   code;
@@ -24657,32 +24669,30 @@ async function openLive(session, onMessage) {
   ws.addEventListener("message", (event) => onMessage(event.data));
   return { ws, closed };
 }
-var INPUT = 48;
-var RESIZE = 49;
-var Pty = class {
+var Terminals = class {
   #open;
   constructor(open2) {
     this.#open = open2;
   }
-  /** Attach to its shell, starting one if none is running. Every attachment shares it. */
+  /**
+   * Each terminal as it starts, writes and exits: those already there first, each with the end of
+   * what it wrote. Operating, the default, can also open a shell and act on any of them.
+   */
   async connect(opts) {
-    const mode = opts.mode ?? "operate";
-    const decoder = new TextDecoder();
-    const { ws, closed } = await openLive(await this.#open("terminal", mode), (data) => {
-      if (typeof data === "string") return;
-      const frame = new Uint8Array(data);
-      if (frame[0] === INPUT) opts.onData(decoder.decode(frame.subarray(1), { stream: true }));
-    });
-    const send = (type, text) => {
-      const body = new TextEncoder().encode(text);
-      const frame = new Uint8Array(body.length + 1);
-      frame[0] = type;
-      frame.set(body, 1);
-      ws.send(frame);
-    };
+    const { ws, closed } = await openLive(
+      await this.#open("terminal", opts.mode ?? "operate"),
+      (data) => {
+        if (typeof data === "string") opts.onEvent(JSON.parse(data));
+      }
+    );
+    const send = (input) => ws.send(JSON.stringify(input));
     return {
-      sendInput: (data) => send(INPUT, data),
-      resize: (columns, rows) => send(RESIZE, JSON.stringify({ columns, rows })),
+      openShell: (columns, rows) => send({ type: "open", columns, rows }),
+      sendInput: (id, text) => {
+        for (const piece of pieces(text)) send({ type: "input", id, text: piece });
+      },
+      resize: (id, columns, rows) => send({ type: "resize", id, columns, rows }),
+      stop: (id) => send({ type: "stop", id }),
       close: () => ws.close(),
       closed
     };
@@ -24690,17 +24700,8 @@ var Pty = class {
 };
 var Commands = class {
   #endpoint;
-  #open;
-  constructor(endpoint, open2) {
+  constructor(endpoint) {
     this.#endpoint = endpoint;
-    this.#open = open2;
-  }
-  /** Each of the agent's commands as it runs: the ones already heard first, then as they come. */
-  async watch(onEvent) {
-    const { ws, closed } = await openLive(await this.#open("commands", "watch"), (data) => {
-      if (typeof data === "string") onEvent(JSON.parse(data));
-    });
-    return { close: () => ws.close(), closed };
   }
   async run(cmd, opts = {}) {
     let answer = await this.#endpoint.command("exec_command", {
@@ -24777,7 +24778,7 @@ var Computer = class _Computer {
   computerID;
   commands;
   files;
-  pty;
+  terminals;
   #connection;
   #token;
   #computer;
@@ -24788,9 +24789,8 @@ var Computer = class _Computer {
     this.#token = token;
     this.#urls = info.endpoints;
     this.#computer = new Endpoint(info.endpoints.computer, token);
-    const open2 = (surface, mode) => this.liveSession(surface, mode);
-    this.commands = new Commands(this.#computer, open2);
-    this.pty = new Pty(open2);
+    this.commands = new Commands(this.#computer);
+    this.terminals = new Terminals((surface, mode) => this.liveSession(surface, mode));
     this.files = new Files(this.#computer);
   }
   static async create(opts) {

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

@@ -146,7 +146,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** A one-time ticket to watch or operate one of its surfaces live: the agent's commands as they run, or a shell of your own. Open its url as a WebSocket within 60 seconds. */
+        /** A one-time ticket to watch or operate one of its surfaces live: its terminals, its files, or its browser. Open its url as a WebSocket within 60 seconds. */
         post: operations["createLiveSession"];
         delete?: never;
         options?: never;
@@ -182,7 +182,7 @@ export interface components {
             message: string;
         };
         /**
-         * @description How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command and write_stdin. Below terminal, the browser's code-running tool is hidden.
+         * @description How far it reaches into files and commands, each level containing the one before: `read` has read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden.
          * @enum {string}
          */
         Access: "none" | "read" | "files" | "terminal";
@@ -248,12 +248,12 @@ export interface components {
             };
         };
         /**
-         * @description commands: the agent's commands as they run, read-only, in commands@1. terminal: a shell of your own in its workspace, as its user, in pty@1. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Opening it to operate makes you the driver: the agent's browser calls wait up to 25 seconds while you are, then answer that a person has or had it. You stop being the driver when you send release, close the socket, or send nothing for 60 seconds, and sending input takes it again.
+         * @description terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes.
          * @enum {string}
          */
-        Surface: "commands" | "terminal" | "browser";
+        Surface: "terminal" | "files" | "browser";
         /**
-         * @description In watch, what you send is dropped.
+         * @description In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed.
          * @enum {string}
          */
         LiveMode: "watch" | "operate";
@@ -262,7 +262,7 @@ export interface components {
             protocol: string;
             /** @description Whether it can be operated */
             operate: boolean;
-            /** @description Why it can't be opened here */
+            /** @description Why it can't be opened now, if it can't. */
             unavailable?: string;
         };
         NewLiveSession: {
@@ -316,12 +316,6 @@ export interface components {
                 label: string;
                 selected: boolean;
             }[];
-        } | {
-            /** @constant */
-            type: "driver";
-            you: boolean;
-            held: boolean;
-            agentWaiting: boolean;
         };
         /** @description What an operate socket sends on screencast@1, as JSON text. A watch socket's is dropped. */
         ScreencastInput: {
@@ -374,11 +368,152 @@ export interface components {
         } | {
             /** @constant */
             type: "navigate";
-            /** @description A URL */
+            /** @description A URL, or back, forward or reload. */
             to: string;
+        };
+        /** @description What the service sends on a terminal@1 socket, as JSON text, no message over 65,536 bytes. A terminal is a command the agent started or a shell a person opened; its id is the session id the agent's tools use. A new socket is first sent, for each terminal already there, the oldest first, its start, the end of what it wrote (its last 65,536 characters), and its exit if it has ended; then each event as it happens, with nothing to mark where the first ends. The last 64 that ended are among those already there, and one that leaves that list is not told. A character here is a UTF-16 unit. A socket with more than 4 MiB still to be sent to it is closed, with no close frame (1006): one that has stopped reading, or one that is reading while a terminal writes tens of megabytes at once. It isn't an error. Opened again, it is sent every terminal afresh, with the last 65,536 characters each wrote, in place of whatever it held. */
+        TerminalEvent: {
+            /** @constant */
+            type: "start";
+            id: string;
+            /**
+             * @description The way in it came: agent through a tool, person through this surface.
+             * @enum {string}
+             */
+            by: "agent" | "person";
+            /** @description Its command, the first 8,000 characters of it. */
+            cmd: string;
+            /** @description Its folder, the first 2,000 characters of it. */
+            workdir: string;
+            /** @description Whether it is on a terminal device, as a person's shell is. One that isn't, as the agent's commands aren't, echoes nothing typed into it and wants a line feed for Enter. Nothing tells the size of one that is. */
+            tty: boolean;
+            /** Format: date-time */
+            at: string;
+        } | {
+            /** @constant */
+            type: "output";
+            id: string;
+            /**
+             * @description Left out for one on a terminal device, which has one stream, and in what a new socket is first sent, where the two are one text.
+             * @enum {string}
+             */
+            stream?: "stdout" | "stderr";
+            text: string;
+        } | {
+            /** @constant */
+            type: "exit";
+            id: string;
+            exitCode: number;
+            /** Format: date-time */
+            at: string;
+        } | {
+            /** @constant */
+            type: "refused";
+            message: string;
+        };
+        /** @description What an operate socket sends on terminal@1, as JSON text. One that can't be done, or that is none of these, is answered with refused. What a watch socket sends is dropped. A message over 65,536 bytes closes the socket, so a long text goes as several inputs. */
+        TerminalInput: {
+            /** @constant */
+            type: "open";
+            columns: number;
+            rows: number;
+        } | {
+            /** @constant */
+            type: "input";
+            id: string;
+            text: string;
+        } | {
+            /** @constant */
+            type: "resize";
+            id: string;
+            columns: number;
+            rows: number;
         } | {
             /** @constant */
-            type: "release";
+            type: "stop";
+            id: string;
+        };
+        /** @description What a socket sends on files@1, as JSON text. Each has an id of its own choosing, which the answer repeats; answers come as they are ready, in any order, and ids aren't checked for repeats. A request still unanswered when the socket closes gets no answer. A path is from the workspace, with / between its parts, or absolute inside it, and nothing outside the workspace is reached. A binary message that follows no write closes the socket, and so does any message over 1,048,576 bytes. */
+        FilesRequest: {
+            /** @constant */
+            type: "list";
+            id: string;
+            /** @description The workspace itself, if left out. */
+            path?: string;
+        } | {
+            /** @constant */
+            type: "read";
+            id: string;
+            path: string;
+            offset: number;
+            length: number;
+        } | {
+            /** @constant */
+            type: "changed";
+            id: string;
+            /** Format: date-time */
+            since: string;
+        } | {
+            /** @constant */
+            type: "write";
+            id: string;
+            path: string;
+            offset: number;
+            length: number;
+            last: boolean;
+        };
+        /** @description What the service sends on files@1, as JSON text, each with the id it answers. Nothing comes between a data message and its bytes. */
+        FilesAnswer: {
+            /** @constant */
+            type: "entries";
+            id: string;
+            path: string;
+            entries: {
+                name: string;
+                /** @enum {string} */
+                kind: "file" | "folder" | "link";
+                size: number;
+                /** Format: date-time */
+                modifiedAt: string;
+            }[];
+            /** @description Whether the folder has more than these. */
+            more: boolean;
+        } | {
+            /** @constant */
+            type: "data";
+            id: string;
+            path: string;
+            offset: number;
+            /** @description How many bytes follow. */
+            length: number;
+            size: number;
+            /** Format: date-time */
+            modifiedAt: string;
+        } | {
+            /** @constant */
+            type: "changes";
+            id: string;
+            /** Format: date-time */
+            since: string;
+            changes: {
+                path: string;
+                size: number;
+                /** Format: date-time */
+                modifiedAt: string;
+            }[];
+            /** @description Whether more than these changed. */
+            more: boolean;
+        } | {
+            /** @constant */
+            type: "written";
+            id: string;
+            path: string;
+            size: number;
+        } | {
+            /** @constant */
+            type: "refused";
+            id: string;
+            message: string;
         };
         ComputerLogs: {
             logs: {

package/dist/types/sdk.d.ts

@@ -7,24 +7,11 @@ export type ComputerLog = Schemas["ComputerLogs"]["logs"][number];
 export type LiveSurface = Schemas["Surface"];
 export type LiveMode = Schemas["LiveMode"];
 export type LiveSession = Schemas["LiveSession"];
-/** What happens to one of the agent's commands, as it happens. */
-export type CommandEvent = {
-    type: "start";
-    id: string;
-    cmd: string;
-    workdir: string;
-    at: string;
-} | {
-    type: "output";
-    id: string;
-    stream: "stdout" | "stderr";
-    text: string;
-} | {
-    type: "exit";
-    id: string;
-    exitCode: number;
-    at: string;
-};
+/**
+ * What happens to a terminal, as it happens: the agent's command or a person's shell. And
+ * `refused`, with why, when what this connection asked wasn't done.
+ */
+export type TerminalEvent = Schemas["TerminalEvent"];
 export interface LiveHandle {
     close(): void;
     /** Resolves when the socket closes, with why. */
@@ -33,9 +20,14 @@ export interface LiveHandle {
         reason: string;
     }>;
 }
-export interface PtyHandle extends LiveHandle {
-    sendInput(data: string): void;
-    resize(columns: number, rows: number): void;
+/** What an operating connection can do. What can't be done comes back as a `refused` event. */
+export interface TerminalsHandle extends LiveHandle {
+    /** Start a shell of your own. It arrives as a `start` event, which carries its id. */
+    openShell(columns: number, rows: number): void;
+    /** Type into a running terminal, the agent's included: a long text as several messages. */
+    sendInput(id: string, text: string): void;
+    resize(id: string, columns: number, rows: number): void;
+    stop(id: string): void;
 }
 export interface ConnectionOpts {
     /** The control token; `AGENTCOMPUTER_API_KEY` by default. */
@@ -82,22 +74,23 @@ declare class Endpoint {
     close(): Promise<void>;
 }
 type Opener = (surface: LiveSurface, mode: LiveMode) => Promise<LiveSession>;
-/** A shell of your own on the computer, beside the agent's commands. */
-declare class Pty {
+/** Every terminal on the computer: the agent's commands and a person's shells alike. */
+declare class Terminals {
     #private;
     constructor(open: Opener);
-    /** Attach to its shell, starting one if none is running. Every attachment shares it. */
+    /**
+     * Each terminal as it starts, writes and exits: those already there first, each with the end of
+     * what it wrote. Operating, the default, can also open a shell and act on any of them.
+     */
     connect(opts: {
-        onData: (data: string) => void;
+        onEvent: (event: TerminalEvent) => void;
         mode?: LiveMode;
-    }): Promise<PtyHandle>;
+    }): Promise<TerminalsHandle>;
 }
 /** Commands on a computer with the terminal level. */
 declare class Commands {
     #private;
-    constructor(endpoint: Endpoint, open: Opener);
-    /** Each of the agent's commands as it runs: the ones already heard first, then as they come. */
-    watch(onEvent: (event: CommandEvent) => void): Promise<LiveHandle>;
+    constructor(endpoint: Endpoint);
     /** Run a command to its end. */
     run(cmd: string, opts?: {
         cwd?: string;
@@ -144,7 +137,7 @@ export declare class Computer {
     readonly computerID: string;
     readonly commands: Commands;
     readonly files: Files;
-    readonly pty: Pty;
+    readonly terminals: Terminals;
     private constructor();
     static create(opts: CreateOpts): Promise<Computer>;
     /** A computer made earlier. Its token was shown when it was made, and only then. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/computer",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Computers for agents, as a service: a terminal, files and a browser over MCP",
   "license": "Apache-2.0",
   "repository": {
@@ -28,15 +28,15 @@
     "test": "npm run build && node --test --test-timeout=60000 \"out/test/**/*.test.js\""
   },
   "dependencies": {
-    "@playwright/mcp": "0.0.84",
     "playwright-core": "1.65.0-alpha-2026-10-30"
   },
   "devDependencies": {
-    "@agentorg/exec": "0.0.3",
+    "@agentorg/exec": "0.0.5",
     "@biomejs/biome": "2.6.5",
     "@modelcontextprotocol/client": "2.4.0",
     "@modelcontextprotocol/node": "2.1.2",
     "@modelcontextprotocol/server": "2.4.0",
+    "@playwright/mcp": "0.0.84",
     "@types/node": "^22.20.5",
     "@types/ws": "8.18.2",
     "ajv": "8.20.0",