@agentorg/computer 0.0.17 → 0.0.19

package/dist/sdk.js

@@ -24595,6 +24595,19 @@ var ComputerError = class extends Error {
   }
 };
 var seconds = (ms) => Math.max(1, Math.ceil(ms / 1e3));
+function requestOf(opts) {
+  const { access, browser, name, timeoutMs, metadata, apiKey, apiUrl } = opts;
+  return {
+    connection: { ...apiKey ? { apiKey } : {}, ...apiUrl ? { apiUrl } : {} },
+    body: {
+      access,
+      browser: browser ?? false,
+      ...name === void 0 ? {} : { name },
+      ...timeoutMs === void 0 ? {} : { timeout: seconds(timeoutMs) },
+      ...metadata === void 0 ? {} : { metadata }
+    }
+  };
+}
 function apiOf(opts = {}) {
   const apiKey = opts.apiKey ?? process.env.AGENTCOMPUTER_API_KEY;
   if (!apiKey) throw new ComputerError(401, "Pass apiKey, or set AGENTCOMPUTER_API_KEY.");
@@ -24794,23 +24807,30 @@ var Computer = class _Computer {
     this.files = new Files(this.#computer);
   }
   static async create(opts) {
-    const { access, browser, isolation, workspace, name, timeoutMs, metadata, apiKey, apiUrl } = opts;
-    const connection = { ...apiKey ? { apiKey } : {}, ...apiUrl ? { apiUrl } : {} };
+    const { isolation, workspace, copyFrom } = opts;
+    const { connection, body } = requestOf(opts);
     const created = answered(
       await apiOf(connection).POST("/v1/computers", {
         body: {
-          access,
-          browser: browser ?? false,
+          ...body,
           ...isolation === void 0 ? {} : { isolation },
           ...workspace === void 0 ? {} : { workspace },
-          ...name === void 0 ? {} : { name },
-          ...timeoutMs === void 0 ? {} : { timeout: seconds(timeoutMs) },
-          ...metadata === void 0 ? {} : { metadata }
+          ...copyFrom === void 0 ? {} : { copyFrom }
         }
       })
     );
     return new _Computer(connection, created, created.accessToken);
   }
+  /** This computer, attached whole. Killing it detaches it and removes nothing of the machine's. */
+  static async attach(opts) {
+    const { connection, body } = requestOf(opts);
+    const attached = answered(
+      await apiOf(connection).POST("/v1/computers/attach", {
+        body: { ...body, workspace: opts.workspace }
+      })
+    );
+    return new _Computer(connection, attached, attached.accessToken);
+  }
   /** A computer made earlier. Its token was shown when it was made, and only then. */
   static async connect(computerID, opts) {
     const { accessToken, ...connection } = opts;

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

@@ -11,7 +11,7 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        /** What this service is and how it isolates its computers. */
+        /** What this service offers: this computer, the kinds of computer it can make, and the browsers that can go with each, every one ready or not and why. */
         get: operations["getInfo"];
         put?: never;
         post?: never;
@@ -39,6 +39,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/computers/attach": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Attach this computer, the machine the service runs on, whole: its files and commands reach all of it, as whoever started the service. Each call attaches it as a computer of its own, with its own id and token. Killing one detaches it and removes nothing of the machine's. Refused with 409 by a service that other machines can reach, which doesn't offer it. */
+        post: operations["attachComputer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/computers/{computerID}": {
         parameters: {
             query?: never;
@@ -207,13 +224,28 @@ export interface components {
             browser: boolean;
             /** @description The full path of a folder that exists, on the service's machine. With none, the service makes a folder, which goes when the computer is killed. A folder named here never does. */
             workspace?: string;
-            /** @description How it is isolated, which it keeps for as long as it exists. Left out, it is the service's own, the `isolation` that `getInfo` answers. */
+            /** @description The full path of a folder on the service's machine. The workspace the service makes starts with a copy of what is in it, taken once when the computer is made; the folder itself is never mounted or changed. Links are copied as they are, and sockets, pipes and devices are left out. Use it instead of workspace; it needs access other than none. */
+            copyFrom?: string;
+            /** @description How it is isolated, which it keeps for as long as it exists: container, the default. One with no isolation is no longer made, and asking for one is refused: attach this computer instead. */
             isolation?: components["schemas"]["Isolation"];
             timeout?: components["schemas"]["Timeout"];
             metadata?: components["schemas"]["Metadata"];
         };
+        AttachComputer: {
+            name?: string;
+            access: components["schemas"]["Access"];
+            /**
+             * @description Whether it has a headless browser of its own. With access none, it must.
+             * @default false
+             */
+            browser: boolean;
+            /** @description Its work folder: the full path of a folder that exists. Commands and relative paths start there and its agent is told to work there, but nothing keeps its files inside it. Detaching never removes it. */
+            workspace: string;
+            timeout?: components["schemas"]["Timeout"];
+            metadata?: components["schemas"]["Metadata"];
+        };
         /**
-         * @description none: processes of whoever started the service. container: a container of its own, which needs Docker on the service's machine.
+         * @description none: processes of whoever started the service, which only this computer has now; a computer made with no isolation before can't start again. container: a container of its own, which needs Docker on the service's machine.
          * @enum {string}
          */
         Isolation: "none" | "container";
@@ -231,7 +263,9 @@ export interface components {
             access: components["schemas"]["Access"];
             /** @description The isolation it was made in. It is never run in another. */
             isolation: components["schemas"]["Isolation"];
-            /** @description The version of the program it ran at its last start. With no isolation it is the service's `version` (see `getInfo`). In a container it is the version inside its image, and null for a container made before 0.0.17, which doesn't say, until it is made again. It is kept from its last start, so a stopped computer's can be older than the service's until it starts. Compare it with the service's to show that a computer runs an older program. */
+            /** @description Whether it is this computer, attached rather than made: the service's machine, whole, acting as whoever started the service, with no isolation. False with isolation none marks a computer made with no isolation by an earlier version, which can't start again; its workspace is kept. */
+            attached: boolean;
+            /** @description The version of the program it ran at its last start. For this computer it is the service's `version` (see `getInfo`). In a container it is the version inside its image, and null for a container made before 0.0.17, which doesn't say, until it is made again. It is kept from its last start, so a stopped computer's can be older than the service's until it starts. Compare it with the service's to show that a computer runs an older program. */
             version: string | null;
             browser: boolean;
             workspace: string | null;
@@ -452,7 +486,7 @@ export interface components {
             /** @constant */
             type: "reading";
             /**
-             * @description Whose numbers these are. computer: this computer's own, which a container's are. machine: the whole machine's, which a computer with no isolation shares with whatever else runs there, so every computer of that service reads the same; and a container's where it can't read its own.
+             * @description Whose numbers these are. computer: the computer's own, as a container's are. machine: the whole machine's, as this computer's are, which it shares with whatever else runs there; and a container's where it can't read its own.
              * @enum {string}
              */
             scope: "computer" | "machine";
@@ -559,12 +593,42 @@ export interface components {
                 line: string;
             }[];
         };
+        Readiness: {
+            ready: boolean;
+            /** @description Why it isn't ready, in a line a person reads. Only when it isn't. */
+            reason?: string;
+        };
+        /**
+         * @description What a computer offers its agent and the person: what it is, its terminals, its files and its screen.
+         * @enum {string}
+         */
+        Capability: "about" | "terminal" | "files" | "screen";
+        CapabilityState: components["schemas"]["Readiness"] & {
+            capability: components["schemas"]["Capability"];
+        };
+        /**
+         * @description headless: a headless browser with a profile of its own, beside the computer, which a person watches and controls through its live view.
+         * @enum {string}
+         */
+        BrowserKind: "headless";
+        BrowserState: components["schemas"]["Readiness"] & {
+            kind: components["schemas"]["BrowserKind"];
+        };
+        Offer: components["schemas"]["Readiness"] & {
+            /** @description What such a computer has, each ready or not. */
+            capabilities: components["schemas"]["CapabilityState"][];
+            /** @description The browsers that can go with it, each ready or not. */
+            browsers: components["schemas"]["BrowserState"][];
+        };
+        MadeKind: components["schemas"]["Offer"] & {
+            isolation: components["schemas"]["Isolation"];
+        };
         ServiceInfo: {
             version: string;
-            /** @description The isolation of a computer made without saying which, chosen when the service is started. */
-            isolation: components["schemas"]["Isolation"];
-            /** @description The isolations a computer can be made in now, `none` first. `container` is among them while Docker answers on the service's machine. It is what to offer, not a promise: Docker is asked for a second here and for ten when a container is made, so one that is slow can be missing here and still be made. If `isolation` itself is missing, a computer made without saying which is refused with 409. */
-            isolationsAvailable: components["schemas"]["Isolation"][];
+            /** @description This computer, the machine the service runs on, attached whole, as whoever started the service. It can be attached while ready: only where the service listens on loopback, with no proxy in front and no public address. Elsewhere it isn't offered, and one attached before is refused at start. */
+            thisComputer: components["schemas"]["Offer"];
+            /** @description Each kind of computer it makes, ready while it can be made now. A container is ready while Docker answers on the service's machine: asked for a second here and for ten when one is made, so one that is slow can be not ready here and still be made. */
+            made: components["schemas"]["MadeKind"][];
         };
     };
     responses: {
@@ -663,6 +727,34 @@ export interface operations {
             };
             400: components["responses"]["Error"];
             401: components["responses"]["Unauthorized"];
+            409: components["responses"]["Error"];
+        };
+    };
+    attachComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["AttachComputer"];
+            };
+        };
+        responses: {
+            /** @description It, with its access token, shown only now. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreatedComputer"];
+                };
+            };
+            400: components["responses"]["Error"];
+            401: components["responses"]["Unauthorized"];
+            409: components["responses"]["Error"];
         };
     };
     getComputer: {
@@ -794,6 +886,7 @@ export interface operations {
             };
             401: components["responses"]["Unauthorized"];
             404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
         };
     };
     getComputerLogs: {

package/dist/types/sdk.d.ts

@@ -38,14 +38,21 @@ export interface ConnectionOpts {
 export interface CreateOpts extends ConnectionOpts {
     access: Schemas["Access"];
     browser?: boolean;
-    /** How it is isolated. By default, as the service was started to make them. */
+    /** How it is isolated: a container by default, and no other is offered now. */
     isolation?: Schemas["Isolation"];
     workspace?: string;
+    /** A folder whose files its workspace starts with, copied once when it is made. */
+    copyFrom?: string;
     name?: string;
     /** How long until it stops, in milliseconds. By default it doesn't. */
     timeoutMs?: number;
     metadata?: Record<string, string>;
 }
+/** This computer, attached whole: its files and commands reach all of it, as the service's user. */
+export interface AttachOpts extends Omit<CreateOpts, "isolation" | "workspace" | "copyFrom"> {
+    /** Its work folder, where commands and relative paths start. Detaching never removes it. */
+    workspace: string;
+}
 export interface CommandResult {
     exitCode: number;
     output: string;
@@ -142,6 +149,8 @@ export declare class Computer {
     readonly terminals: Terminals;
     private constructor();
     static create(opts: CreateOpts): Promise<Computer>;
+    /** This computer, attached whole. Killing it detaches it and removes nothing of the machine's. */
+    static attach(opts: AttachOpts): Promise<Computer>;
     /** A computer made earlier. Its token was shown when it was made, and only then. */
     static connect(computerID: string, opts: ConnectionOpts & {
         accessToken: string;
@@ -174,6 +183,7 @@ export declare class Computer {
         state: components["schemas"]["ComputerState"];
         access: components["schemas"]["Access"];
         isolation: components["schemas"]["Isolation"];
+        attached: boolean;
         version: string | null;
         browser: boolean;
         workspace: string | null;
@@ -196,6 +206,7 @@ export declare class Computer {
         state: components["schemas"]["ComputerState"];
         access: components["schemas"]["Access"];
         isolation: components["schemas"]["Isolation"];
+        attached: boolean;
         version: string | null;
         browser: boolean;
         workspace: string | null;
@@ -210,6 +221,7 @@ export declare class Computer {
         state: components["schemas"]["ComputerState"];
         access: components["schemas"]["Access"];
         isolation: components["schemas"]["Isolation"];
+        attached: boolean;
         version: string | null;
         browser: boolean;
         workspace: string | null;
@@ -226,6 +238,7 @@ export declare class Computer {
         state: components["schemas"]["ComputerState"];
         access: components["schemas"]["Access"];
         isolation: components["schemas"]["Isolation"];
+        attached: boolean;
         version: string | null;
         browser: boolean;
         workspace: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/computer",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Computers for agents, as a service: a terminal, files and a browser over MCP",
   "license": "Apache-2.0",
   "repository": {
@@ -21,6 +21,9 @@
     "dist/THIRD_PARTY_LICENSES.txt",
     "NOTICE"
   ],
+  "publishConfig": {
+    "tag": "next"
+  },
   "scripts": {
     "generate": "node scripts/generate.js",
     "build": "tsc -p tsconfig.json && node scripts/bundle.js",
@@ -31,7 +34,7 @@
     "playwright-core": "1.65.0-alpha-2026-10-30"
   },
   "devDependencies": {
-    "@agentorg/exec": "0.0.8",
+    "@agentorg/exec": "0.0.9",
     "@biomejs/biome": "2.6.5",
     "@modelcontextprotocol/client": "2.4.0",
     "@modelcontextprotocol/node": "2.1.2",