@agentorg/cli 0.0.5 → 0.0.7

package/dist/node_modules/@agentorg/computer/dist/types/sdk.d.ts

@@ -0,0 +1,242 @@
+import type { components } from "./generated/schema.js";
+type Schemas = components["schemas"];
+export type ComputerInfo = Schemas["Computer"];
+export type ComputerDetail = Schemas["ComputerDetail"];
+export type ServiceInfo = Schemas["ServiceInfo"];
+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 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. */
+    closed: Promise<{
+        code: number;
+        reason: string;
+    }>;
+}
+/** 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. */
+    apiKey?: string;
+    /** The service's address; `AGENTCOMPUTER_API_URL`, else `http://127.0.0.1:7878`. */
+    apiUrl?: string;
+}
+export interface CreateOpts extends ConnectionOpts {
+    access: Schemas["Access"];
+    browser?: boolean;
+    workspace?: string;
+    name?: string;
+    /** How long until it stops, in milliseconds. By default it doesn't. */
+    timeoutMs?: number;
+    metadata?: Record<string, string>;
+}
+export interface CommandResult {
+    exitCode: number;
+    output: string;
+    seconds: number;
+}
+export interface RunningCommand {
+    sessionId: string;
+    output: string;
+}
+/** The service refused, or a computer's tool failed. */
+export declare class ComputerError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+/** What the command tools answer. */
+interface CommandAnswer {
+    exit_code: number | null;
+    seconds: number;
+    session_id: string | null;
+    text: string;
+}
+/** An MCP client for one endpoint, connected when first used. */
+declare class Endpoint {
+    #private;
+    constructor(url: string | null, token: string);
+    text(name: string, args: Record<string, unknown>): Promise<string>;
+    command(name: string, args: Record<string, unknown>): Promise<CommandAnswer>;
+    close(): Promise<void>;
+}
+type Opener = (surface: LiveSurface, mode: LiveMode) => Promise<LiveSession>;
+/** Every terminal on the computer: the agent's commands and a person's shells alike. */
+declare class Terminals {
+    #private;
+    constructor(open: Opener);
+    /**
+     * 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: {
+        onEvent: (event: TerminalEvent) => void;
+        mode?: LiveMode;
+    }): Promise<TerminalsHandle>;
+}
+/** Commands on a computer with the terminal level. */
+declare class Commands {
+    #private;
+    constructor(endpoint: Endpoint);
+    /** Run a command to its end. */
+    run(cmd: string, opts?: {
+        cwd?: string;
+    }): Promise<CommandResult>;
+    /** Start a command and return while it runs, unless it ends at once. */
+    run(cmd: string, opts: {
+        cwd?: string;
+        background: true;
+    }): Promise<RunningCommand | CommandResult>;
+    /** Type into a running command, and return what it wrote since. */
+    sendStdin(sessionId: string, data: string): Promise<string>;
+}
+/** Files in a computer's workspace. */
+declare class Files {
+    #private;
+    constructor(endpoint: Endpoint);
+    /** A text file's content, whole: a line too long for the tool to return is an error. */
+    read(path: string): Promise<string>;
+    /** Make a new file, or fill an empty one. */
+    write(path: string, content: string): Promise<void>;
+    /** Replace exact text, and return the unified diff. */
+    edit(path: string, oldText: string, newText: string, opts?: {
+        replaceAll?: boolean;
+    }): Promise<string>;
+    /** A folder's entries, the first thousand. */
+    list(path?: string): Promise<({
+        name: string;
+        type: "dir";
+        size?: undefined;
+    } | {
+        name: string;
+        type: "file";
+        size: number;
+    })[]>;
+    /** Lines matching text under a folder, as `path:line:text`. */
+    search(pattern: string, opts?: {
+        path?: string;
+        regex?: boolean;
+    }): Promise<string[]>;
+}
+/** One computer. Make one with `Computer.create`. */
+export declare class Computer {
+    #private;
+    readonly computerID: string;
+    readonly commands: Commands;
+    readonly files: Files;
+    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. */
+    static connect(computerID: string, opts: ConnectionOpts & {
+        accessToken: string;
+    }): Promise<Computer>;
+    static list(opts?: ConnectionOpts & {
+        state?: Schemas["ComputerState"];
+    }): Promise<ComputerInfo[]>;
+    static serviceInfo(opts?: ConnectionOpts): Promise<ServiceInfo>;
+    static getInfo(computerID: string, opts?: ConnectionOpts): Promise<ComputerDetail>;
+    /** It now stops this long from now, replacing any earlier timeout. */
+    static setTimeout(computerID: string, timeoutMs: number, opts?: ConnectionOpts): Promise<ComputerInfo>;
+    static stop(computerID: string, opts?: ConnectionOpts): Promise<ComputerInfo>;
+    static start(computerID: string, opts?: ConnectionOpts & {
+        timeoutMs?: number;
+    }): Promise<ComputerInfo>;
+    static getLogs(computerID: string, opts?: ConnectionOpts): Promise<ComputerLog[]>;
+    /** A one-time ticket to open one of its surfaces live, within a minute. */
+    static createLiveSession(computerID: string, session: {
+        surface: LiveSurface;
+        mode?: LiveMode;
+    }, opts?: ConnectionOpts): Promise<LiveSession>;
+    static kill(computerID: string, opts?: ConnectionOpts): Promise<void>;
+    /** The endpoint to give an MCP client. */
+    getMcpUrl(endpoint?: "computer" | "browser"): string;
+    /** The token for those endpoints. */
+    getMcpToken(): string;
+    getInfo(): Promise<{
+        computerID: string;
+        name: string;
+        state: components["schemas"]["ComputerState"];
+        access: components["schemas"]["Access"];
+        browser: boolean;
+        workspace: string | null;
+        startedAt: string;
+        endAt: string | null;
+        metadata: components["schemas"]["Metadata"];
+        endpoints: components["schemas"]["Endpoints"];
+    } & {
+        uptimeSeconds: number;
+        surfaces: components["schemas"]["SurfaceInfo"][];
+        tools: {
+            computer: string[];
+            browser: string[];
+        };
+    }>;
+    isRunning(): Promise<boolean>;
+    setTimeout(timeoutMs: number): Promise<{
+        computerID: string;
+        name: string;
+        state: components["schemas"]["ComputerState"];
+        access: components["schemas"]["Access"];
+        browser: boolean;
+        workspace: string | null;
+        startedAt: string;
+        endAt: string | null;
+        metadata: components["schemas"]["Metadata"];
+        endpoints: components["schemas"]["Endpoints"];
+    }>;
+    stop(): Promise<{
+        computerID: string;
+        name: string;
+        state: components["schemas"]["ComputerState"];
+        access: components["schemas"]["Access"];
+        browser: boolean;
+        workspace: string | null;
+        startedAt: string;
+        endAt: string | null;
+        metadata: components["schemas"]["Metadata"];
+        endpoints: components["schemas"]["Endpoints"];
+    }>;
+    start(opts?: {
+        timeoutMs?: number;
+    }): Promise<{
+        computerID: string;
+        name: string;
+        state: components["schemas"]["ComputerState"];
+        access: components["schemas"]["Access"];
+        browser: boolean;
+        workspace: string | null;
+        startedAt: string;
+        endAt: string | null;
+        metadata: components["schemas"]["Metadata"];
+        endpoints: components["schemas"]["Endpoints"];
+    }>;
+    liveSession(surface: LiveSurface, mode?: LiveMode): Promise<{
+        url: string;
+        protocol: string;
+        surface: components["schemas"]["Surface"];
+        mode: components["schemas"]["LiveMode"];
+        expiresAt: string;
+    }>;
+    getLogs(): Promise<{
+        timestamp: string;
+        line: string;
+    }[]>;
+    kill(): Promise<void>;
+    /** Close this object's connection. The computer keeps running. */
+    close(): Promise<void>;
+}
+export {};

package/dist/node_modules/@agentorg/computer/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@agentorg/computer",
+  "version": "0.0.10",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/sdk.d.ts",
+      "default": "./dist/sdk.js"
+    }
+  }
+}

package/dist/node_modules/@agentorg/computer-connector/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { type ComputerProvider, type ComputerProviderOptions, startComputerProvider, } from "./provider.js";

package/dist/node_modules/@agentorg/computer-connector/dist/src/index.js

@@ -0,0 +1 @@
+export { startComputerProvider, } from "./provider.js";

package/dist/node_modules/@agentorg/computer-connector/dist/src/provider.d.ts

@@ -0,0 +1,24 @@
+import { type Timing } from "@agentorg/mcp";
+import { type Log } from "@agentorg/sdk";
+export interface ComputerProviderOptions {
+    hubUrl: string;
+    /** The provider's own Actor, bound to `hub.actors@1` at its slot `actors`. */
+    actorId: string;
+    credential: string;
+    /** A private folder of the provider's, which holds each connection's Hub credential. */
+    dir: string;
+    /** Where a service on this machine writes its address and token; the service's own default. */
+    dataFolder?: string;
+    /** Where an agent's own folder goes when none is named; `~/Agents` by default. */
+    agentsFolder?: string;
+    /** The hosted server the web unit connects to; Exa's by default. For tests. */
+    webUrl?: string;
+    log?: Log;
+    timing?: Timing;
+}
+export interface ComputerProvider {
+    /** Leave the Hub and let every connection go. The computers stay, and resume at the next start. */
+    close(): Promise<void>;
+}
+/** Run the units' provider as an Actor exporting `unit.provider@1` as `provider`. */
+export declare function startComputerProvider(options: ComputerProviderOptions): Promise<ComputerProvider>;