@agentorg/cli 0.0.6 → 0.0.7

package/dist/node_modules/@agentorg/computer/dist/types/generated/schema.d.ts

@@ -0,0 +1,860 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/v1/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** What this service is and how it isolates its computers. */
+        get: operations["getInfo"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List the computers. */
+        get: operations["listComputers"];
+        put?: never;
+        /** Create a computer. It answers once the computer is running. */
+        post: operations["createComputer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        /** One computer, with how long it has run and the tools it offers. */
+        get: operations["getComputer"];
+        put?: never;
+        post?: never;
+        /** Stop it for good and remove what the service made. A folder someone named stays. */
+        delete: operations["killComputer"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}/timeout": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** It now stops this many seconds from now, replacing any earlier timeout. */
+        post: operations["setComputerTimeout"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}/stop": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Stop what it is running. Its folder and its token stay, and it can start again. */
+        post: operations["stopComputer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}/start": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Start a stopped computer again, with the same token and folder. */
+        post: operations["startComputer"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}/logs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        /** What its servers wrote, and each request it was sent. */
+        get: operations["getComputerLogs"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/computers/{computerID}/live": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** A one-time ticket to watch or operate one of its surfaces live: its terminals, its files, its browser, or its load. Open its url as a WebSocket within 60 seconds. */
+        post: operations["createLiveSession"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/live/{liveID}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                liveID: string;
+            };
+            cookie?: never;
+        };
+        /** Open a live session as a WebSocket. The ticket in its path is its authority and works once, so it takes no token. A request with an Origin header is refused unless the service was told to allow that origin. */
+        get: operations["openLiveSession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        Error: {
+            code: number;
+            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, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden.
+         * @enum {string}
+         */
+        Access: "none" | "read" | "files" | "terminal";
+        /** @enum {string} */
+        ComputerState: "running" | "stopped" | "failed";
+        /** @description Seconds from now until the computer stops. */
+        Timeout: number;
+        /** @description Your own labels, kept and returned as given. */
+        Metadata: {
+            [key: string]: string;
+        };
+        NewComputer: {
+            name?: string;
+            access: components["schemas"]["Access"];
+            /**
+             * @description Whether it has a browser. With access none, it must.
+             * @default false
+             */
+            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;
+            timeout?: components["schemas"]["Timeout"];
+            metadata?: components["schemas"]["Metadata"];
+        };
+        /** @description MCP over Streamable HTTP, each taking the computer's access token as a bearer. */
+        Endpoints: {
+            /** @description The terminal and files. */
+            computer: string | null;
+            /** @description The browser. */
+            browser: string | null;
+        };
+        Computer: {
+            computerID: string;
+            name: string;
+            state: components["schemas"]["ComputerState"];
+            access: components["schemas"]["Access"];
+            browser: boolean;
+            workspace: string | null;
+            /**
+             * Format: date-time
+             * @description When it last started.
+             */
+            startedAt: string;
+            /**
+             * Format: date-time
+             * @description When it will stop; null if it has no timeout.
+             */
+            endAt: string | null;
+            metadata: components["schemas"]["Metadata"];
+            endpoints: components["schemas"]["Endpoints"];
+        };
+        CreatedComputer: components["schemas"]["Computer"] & {
+            /** @description Good only for this computer's endpoints. Shown only now. */
+            accessToken: string;
+        };
+        ComputerDetail: components["schemas"]["Computer"] & {
+            uptimeSeconds: number;
+            /** @description What can be opened live while it runs. */
+            surfaces: components["schemas"]["SurfaceInfo"][];
+            tools: {
+                computer: string[];
+                browser: string[];
+            };
+        };
+        /**
+         * @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. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches.
+         * @enum {string}
+         */
+        Surface: "terminal" | "files" | "browser" | "load";
+        /**
+         * @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";
+        SurfaceInfo: {
+            surface: components["schemas"]["Surface"];
+            protocol: string;
+            /** @description Whether it can be operated */
+            operate: boolean;
+            /** @description Why it can't be opened now, if it can't. */
+            unavailable?: string;
+        };
+        NewLiveSession: {
+            surface: components["schemas"]["Surface"];
+            /** @default watch */
+            mode: components["schemas"]["LiveMode"];
+        };
+        LiveSession: {
+            /** @description The WebSocket to open */
+            url: string;
+            protocol: string;
+            surface: components["schemas"]["Surface"];
+            mode: components["schemas"]["LiveMode"];
+            /** Format: date-time */
+            expiresAt: string;
+        };
+        /** @description What the service sends on a screencast@1 socket, as JSON text. */
+        ScreencastEvent: {
+            /** @constant */
+            type: "tabs";
+            tabs: {
+                id: number;
+                url: string;
+                title: string;
+            }[];
+            shown: number | null;
+        } | {
+            /** @constant */
+            type: "viewport";
+            width: number;
+            height: number;
+        } | {
+            /** @constant */
+            type: "dialog";
+            open: boolean;
+            /** @enum {string} */
+            kind?: "alert" | "confirm" | "prompt" | "beforeunload";
+            message?: string;
+            defaultValue?: string;
+        } | {
+            /** @constant */
+            type: "file-chooser";
+            open: boolean;
+            multiple?: boolean;
+        } | {
+            /** @constant */
+            type: "choice";
+            multiple: boolean;
+            options: {
+                value: string;
+                label: string;
+                selected: boolean;
+            }[];
+        };
+        /** @description What an operate socket sends on screencast@1, as JSON text. A watch socket's is dropped. */
+        ScreencastInput: {
+            /** @constant */
+            type: "mouse";
+            /** @enum {string} */
+            action: "move" | "down" | "up" | "wheel";
+            x: number;
+            y: number;
+            /** @enum {string} */
+            button?: "left" | "right" | "middle";
+            deltaX?: number;
+            deltaY?: number;
+        } | {
+            /** @constant */
+            type: "key";
+            /** @enum {string} */
+            action: "down" | "up";
+            /** @description A key name */
+            key: string;
+        } | {
+            /** @constant */
+            type: "text";
+            text: string;
+        } | {
+            /** @constant */
+            type: "dialog";
+            accept: boolean;
+            text?: string;
+        } | {
+            /** @constant */
+            type: "files";
+            files: {
+                name: string;
+                mimeType?: string;
+                /** @description Base64. */
+                data: string;
+            }[];
+        } | {
+            /** @constant */
+            type: "choice";
+            values: string[];
+        } | {
+            /** @constant */
+            type: "tab";
+            /** @enum {string} */
+            action: "show" | "open" | "close";
+            id?: number;
+            url?: string;
+        } | {
+            /** @constant */
+            type: "navigate";
+            /** @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: "stop";
+            id: string;
+        };
+        /** @description What the service sends on a metrics@1 socket, as JSON text. What a socket sends is dropped. */
+        LoadReading: {
+            /** @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.
+             * @enum {string}
+             */
+            scope: "computer" | "machine";
+            /** @description Of all the machine's CPUs, since the reading before. One decimal. */
+            cpuUsedPct: number;
+            /** @description Bytes in use. */
+            memUsed: number;
+            /** @description Bytes the machine has: no computer has a limit. */
+            memTotal: number;
+            /** @description Bytes used on the volume its workspace is on, or its own folder where it has no workspace. The volume's, not the workspace's own size. */
+            diskUsed: number;
+            /** @description Bytes on that volume. */
+            diskTotal: number;
+        };
+        /** @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: {
+                /** Format: date-time */
+                timestamp: string;
+                line: string;
+            }[];
+        };
+        ServiceInfo: {
+            version: string;
+            /**
+             * @description How this service isolates its computers, chosen when it is started.
+             * @enum {string}
+             */
+            isolation: "none" | "container";
+        };
+    };
+    responses: {
+        /** @description It was refused. */
+        Error: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description No valid token. */
+        Unauthorized: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content?: never;
+        };
+    };
+    parameters: {
+        computerID: string;
+    };
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    getInfo: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The service. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ServiceInfo"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    listComputers: {
+        parameters: {
+            query?: {
+                /** @description Only computers in this state. */
+                state?: components["schemas"]["ComputerState"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The computers, newest first. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Computer"][];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    createComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["NewComputer"];
+            };
+        };
+        responses: {
+            /** @description The computer, 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"];
+        };
+    };
+    getComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The computer. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ComputerDetail"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+        };
+    };
+    killComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Gone. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+        };
+    };
+    setComputerTimeout: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    timeout: components["schemas"]["Timeout"];
+                };
+            };
+        };
+        responses: {
+            /** @description The computer. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Computer"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
+        };
+    };
+    stopComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The computer. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Computer"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+        };
+    };
+    startComputer: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    timeout?: components["schemas"]["Timeout"];
+                };
+            };
+        };
+        responses: {
+            /** @description The computer. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Computer"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+        };
+    };
+    getComputerLogs: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The logs. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ComputerLogs"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+        };
+    };
+    createLiveSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                computerID: components["parameters"]["computerID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["NewLiveSession"];
+            };
+        };
+        responses: {
+            /** @description The ticket. */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["LiveSession"];
+                };
+            };
+            400: components["responses"]["Error"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["Error"];
+            409: components["responses"]["Error"];
+        };
+    };
+    openLiveSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                liveID: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The socket */
+            101: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            403: components["responses"]["Error"];
+            404: components["responses"]["Error"];
+            426: components["responses"]["Error"];
+        };
+    };
+}