aicomputer 0.1.21 → 0.2.0

package/README.md

@@ -1,169 +1,88 @@
-# `aicomputer`
+# aicomputer
 
-Agent Computer CLI for creating, opening, and managing computers from the terminal.
+TypeScript SDK for Agent Computer.
 
 ## Install
 
 ```bash
-npm install -g aicomputer
+pnpm add aicomputer
 ```
 
-On macOS and Linux, the npm install and update flow also installs the CLI-managed
-Mutagen binary used by `computer mount`.
+## Authenticate
 
-Upgrade the installed CLI later with:
+```ts
+import { AgentComputer } from "aicomputer";
 
-```bash
-computer upgrade
-```
-
-Or run it directly with Nix:
-
-```bash
-nix run github:getcompanion-ai/agentcomputer?dir=apps/cli -- login
-```
-
-For local testing from this checkout, prefer:
-
-```bash
-nix run path:./apps/cli -- --version
-```
-
-To declare it in a flake-based Nix config:
-
-```nix
-{
-  inputs.agentcomputer-cli = {
-    url = "github:getcompanion-ai/agentcomputer?dir=apps/cli";
-    inputs.nixpkgs.follows = "nixpkgs";
-  };
-}
-
-home.packages = [
-  agentcomputer-cli.packages.${pkgs.system}.default
-];
-
-# or
-
-environment.systemPackages = [
-  agentcomputer-cli.packages.${pkgs.system}.default
-];
+const client = new AgentComputer({
+  apiKey: process.env.AGENTCOMPUTER_API_KEY!,
+});
 ```
 
-## Private Repo Rollout
+## Quickstart
 
-To keep Nix distribution aligned with the npm CLI release flow for this private repo:
+```ts
+import { AgentComputer } from "aicomputer";
 
-1. Create a Cachix cache for the CLI.
-2. Add a GitHub Actions repository variable named `CACHIX_CACHE` with that cache name.
-3. Add a GitHub Actions repository secret named `CACHIX_AUTH_TOKEN` with a write token for that cache.
-4. Run the `CLI Release` workflow or push a `cli-v*` tag.
+const client = new AgentComputer({
+  apiKey: process.env.AGENTCOMPUTER_API_KEY!,
+});
 
-The release workflow will:
+const computer = await client.computers.create({
+  displayName: "Quickstart computer",
+});
 
-- build the CLI with `npm ci`
-- build the Nix package
-- sync `apps/cli/package-lock.json` and `apps/cli/package.nix` when the CLI version changes
-- publish the npm package
-- push the built Nix closure to the configured Cachix cache
+await computer.ensureRunning();
 
-Consumers should add the binary cache to their Nix config:
+const result = await computer.commands.run(["node", "--version"]);
+console.log(result.stdout.trim());
 
-```nix
-nix.settings = {
-  substituters = [
-    "https://cache.nixos.org"
-    "https://<your-cache>.cachix.org"
-  ];
-  trusted-public-keys = [
-    "<your-cache>.cachix.org-1:<your-public-key>"
-  ];
-};
+await computer.ensureStopped();
 ```
 
-## Usage
+## Run a command
 
-After installing, use the `computer` command:
-
-```bash
-computer login
-computer upgrade
-computer login --api-key <ac_live_...>
-computer claude-login
-computer codex-login
-computer whoami
-computer create my-box
-computer power-off my-box
-computer power-on my-box
-computer open my-box
-computer ssh
-computer ssh my-box
-computer ssh my-box --tmux
-computer ssh --setup
-computer ssh my-box -N -L 3000:localhost:3000
-computer mount
-computer mount --background
-computer mount status
-computer agent agents my-box
-computer agent sessions list my-box
-computer agent prompt my-box "inspect /home/node" --agent codex
-computer acp serve my-box --agent codex
+```ts
+const result = await computer.commands.run(["python3", "-c", "print('hello')"]);
+console.log(result.exitCode, result.stdout);
 ```
 
-`computer login` authenticates the CLI against Agent Computer. Use
-`computer claude-login` and `computer codex-login` to install Claude Code or
-Codex credentials onto a machine after the CLI is already logged in. Use
-`computer upgrade` to update a global npm install or the matching Nix profile
-entry.
-
-Use `computer power-off` to stop a managed worker without deleting its durable
-home volume. Use `computer power-on` to recreate the runtime against the same
-stored machine and home state.
+For long-lived commands, use the typed command handle:
 
-Run `computer ssh` without a handle in an interactive terminal to pick from your available machines.
+```ts
+const server = await computer.commands.start(
+  ["python3", "-m", "http.server", "3000"],
+  {
+    onStdout: (chunk) => process.stdout.write(chunk),
+    onStderr: (chunk) => process.stderr.write(chunk),
+  },
+);
 
-Run `computer ssh --setup` once to register your SSH key and add a global alias:
-
-```bash
-ssh agentcomputer.ai
-ssh my-box@agentcomputer.ai
+await server.wait({ rejectOnNonZero: false });
 ```
 
-Use `computer ssh <handle> <ssh args>` when you want the CLI to resolve
-the machine and identity while still passing standard SSH tunnel flags through
-to the underlying client. Long-running SSH sessions and forwarded tunnels stay
-on the same resilient path:
+## Publish a port
 
-```bash
-computer ssh my-box -N -L 3000:localhost:3000
+```ts
+await computer.waitForPort(3000);
+const published = await computer.ports.publish({ port: 3000, name: "app" });
+console.log(published.public_url);
 ```
 
-`computer ssh` now launches through `autossh` by default. Nix installs package
-`ssh`, `scp`, and `autossh` together. Global npm installs on macOS and Linux
-provision Agent Computer's bundled `autossh` copy during postinstall and retry
-that install on first SSH use if npm scripts were skipped. npm users still need
-local OpenSSH client tools available.
+## PTY sessions
 
-Use `computer ssh <handle> --tmux` when you want reconnects to reattach to the
-same remote shell session instead of dropping you into a fresh shell. The flag
-attaches to `tmux new-session -A -s agentcomputer`, so it is meant for
-interactive shells, not `-N` tunnels or other non-interactive SSH flows.
+```ts
+const shell = await computer.pty.create({
+  cols: 120,
+  rows: 32,
+  onData: (chunk) => process.stdout.write(chunk),
+});
 
-Run `computer mount` to start the mount controller in the foreground and mirror
-all SSH-ready machine homes under `~/agentcomputer/<handle>`.
-On macOS, the foreground command also opens Finder to `~/agentcomputer` after
-the controller starts.
-
-Run `computer mount --background` to start the same controller detached from
-your terminal. It prints the controller PID immediately so you can inspect it
-later with `computer mount status`.
-
-This uses the same SSH setup as `computer ssh --setup`. For npm installs on
-macOS and Linux, the CLI auto-installs its bundled Mutagen copy and will retry
-that install on first mount if npm scripts were skipped. You still need the
-OpenSSH client tools (`ssh` and `scp`) available locally. The temporary
-`~/agentcomputer` root is removed when the command exits.
+await shell.sendInput("uname -a\n");
+await shell.resize(140, 40);
+await shell.kill();
+```
 
-Use `computer agent` to inspect agents on one machine and manage remote sessions. Use `computer acp serve` when you want to expose one remote session through a local ACP bridge.
+## Docs
 
-You can also run without a global install via `npx aicomputer <command>`.
+- Web docs: `https://agentcomputer.ai/docs/typescript-sdk`
+- Generated API reference is published from the package source into the docs site.

package/dist/index.d.ts

@@ -1 +1,381 @@
-#!/usr/bin/env node
+import { ComputerImageResponse, AccessSessionResponse, createPublicApiClient, ListPublishedPortsResponse, PublishedPortResponse, PublishedPortMutationResponse, ListSharesResponse, ShareResponse, ListSnapshotsResponse, SnapshotResponse, ComputerResponse, ComputerConnectionResponse, CreateSSHCertificateRequest, SSHCertificateResponse, CreateComputerRequest, ListSSHKeysResponse, CreateSSHKeyRequest, SSHKeyEnvelope, PublicApiClientOptions, AccessTokenProvider, MeResponse, UsageEnvelope, ResolveShareResponse, CreateAccessSessionRequest, AccessSessionEnvelope, OperationResponse } from '@microagentcomputer/public-api-client';
+export { AccessSessionEnvelope, AccessSessionResponse, AccessTokenProvider, ComputerConnectionResponse, ComputerImageResponse, ComputerMutationResponse, ComputerResponse, CreateAccessSessionRequest, CreateComputerRequest, CreateEmailShareRequest, CreateLinkShareRequest, CreatePublishedPortRequest, CreateSSHCertificateRequest, CreateSSHKeyRequest, ExecCommandRequest, ExecCommandResponse, MeResponse, OperationResponse, PublicApiError, PublishedPortResponse, ResolveShareResponse, RestoreSnapshotRequest, SSHCertificateResponse, ShareResponse, SnapshotResponse, UpdateComputerRequest, UsageEnvelope } from '@microagentcomputer/public-api-client';
+
+type LowLevelClient = ReturnType<typeof createPublicApiClient>;
+type ComputerState = ComputerResponse["state"];
+type ComputerSource = CreateComputerRequest["source"];
+type ComputerCapability = "process" | "files" | "git" | (string & {});
+type WaitOptions = {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+type AgentComputerOptions = Omit<PublicApiClientOptions, "accessToken" | "baseUrl"> & {
+    baseUrl?: string;
+    apiKey?: AccessTokenProvider;
+    accessToken?: AccessTokenProvider;
+    defaultPollIntervalMs?: number;
+    defaultOperationTimeoutMs?: number;
+    defaultComputerStateTimeoutMs?: number;
+    defaultConnectRequestTimeoutMs?: number;
+};
+type ComputerCreateOptions = {
+    handle?: string;
+    displayName?: string;
+    source?: ComputerSource;
+    sizePreset?: string;
+    authorizedKeys?: string[];
+};
+type ComputerEnsureOptions = ComputerCreateOptions & {
+    id?: string;
+    start?: boolean;
+    updateMetadata?: boolean;
+};
+type ComputerUpdateOptions = {
+    displayName?: string;
+};
+type CommandRunOptions = {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    requestTimeoutMs?: number;
+    user?: string;
+    signal?: AbortSignal;
+};
+type CommandStartOptions = CommandRunOptions & {
+    tag?: string;
+    stdin?: boolean;
+    onStdout?: CommandOutputHandler;
+    onStderr?: CommandOutputHandler;
+    onExit?: (result: CommandResult) => void;
+};
+type PtyStartOptions = Omit<CommandRunOptions, "timeoutMs"> & {
+    cols?: number;
+    rows?: number;
+    tag?: string;
+    onData?: PtyOutputHandler;
+    onExit?: (result: PtyResult) => void;
+};
+type ExecSessionCreateOptions = {
+    ttlSeconds?: number;
+    signal?: AbortSignal;
+};
+type CommandSelector = number | string | {
+    pid: number;
+} | {
+    tag: string;
+};
+type CommandSignal = "SIGTERM" | "SIGKILL";
+type CommandOutputHandler = (chunk: string, raw: Uint8Array) => void;
+type PtyOutputHandler = (chunk: string, raw: Uint8Array) => void;
+type CommandInfo = {
+    pid: number;
+    tag?: string;
+    cmd: string;
+    args: string[];
+    envs: Record<string, string>;
+    cwd?: string;
+};
+type CommandResult = {
+    pid: number;
+    tag?: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    status: string;
+    error?: string;
+};
+type PtyResult = {
+    pid: number;
+    tag?: string;
+    output: string;
+    exitCode: number;
+    status: string;
+    error?: string;
+};
+type ShareLinkOptions = {
+    expiresAt?: string;
+    allowBrowser?: boolean;
+    allowVnc?: boolean;
+    signal?: AbortSignal;
+};
+type ShareEmailOptions = ShareLinkOptions & {
+    email: string;
+};
+type PublishPortOptions = {
+    port: number;
+    name?: string;
+    signal?: AbortSignal;
+};
+type SnapshotRestoreOptions = {
+    handle?: string;
+    displayName?: string;
+    authorizedKeys?: string[];
+    signal?: AbortSignal;
+};
+declare class AgentComputer {
+    readonly images: ComputerImagesClient;
+    readonly computers: ComputersClient;
+    readonly snapshots: SnapshotsClient;
+    readonly sshKeys: SSHKeysClient;
+    private readonly client;
+    private readonly fetchImpl;
+    private readonly defaultPollIntervalMs;
+    private readonly defaultOperationTimeoutMs;
+    private readonly defaultComputerStateTimeoutMs;
+    private readonly defaultConnectRequestTimeoutMs;
+    constructor(options?: AgentComputerOptions);
+    me(signal?: AbortSignal): Promise<MeResponse>;
+    usage(signal?: AbortSignal): Promise<UsageEnvelope>;
+    resolveShare(shareToken: string, signal?: AbortSignal): Promise<ResolveShareResponse>;
+    redeemShare(shareToken: string, body?: Partial<CreateAccessSessionRequest>, signal?: AbortSignal): Promise<AccessSessionEnvelope>;
+    waitForOperation(operationOrId: string | Pick<OperationResponse, "id">, options?: WaitOptions): Promise<OperationResponse>;
+    waitForComputerState(computerId: string, targetState: ComputerState, options?: WaitOptions): Promise<Computer>;
+    computer(idOrHandle: string): Promise<Computer>;
+    /** @internal */
+    internalClient(): LowLevelClient;
+    /** @internal */
+    internalFetch(): typeof fetch;
+    /** @internal */
+    internalDefaultPollIntervalMs(): number;
+    /** @internal */
+    internalDefaultComputerStateTimeoutMs(): number;
+    /** @internal */
+    internalDefaultOperationTimeoutMs(): number;
+    /** @internal */
+    internalDefaultConnectRequestTimeoutMs(): number;
+}
+declare class ComputerImagesClient {
+    private readonly sdk;
+    constructor(sdk: AgentComputer);
+    list(signal?: AbortSignal): Promise<ComputerImageResponse[]>;
+    get(imageId: string, signal?: AbortSignal): Promise<ComputerImageResponse>;
+    getDefault(signal?: AbortSignal): Promise<ComputerImageResponse>;
+}
+declare class ComputersClient {
+    private readonly sdk;
+    constructor(sdk: AgentComputer);
+    list(signal?: AbortSignal): Promise<Computer[]>;
+    get(computerId: string, signal?: AbortSignal): Promise<Computer>;
+    getByHandle(handle: string, signal?: AbortSignal): Promise<Computer | null>;
+    resolve(idOrHandle: string, signal?: AbortSignal): Promise<Computer>;
+    create(options?: ComputerCreateOptions, signal?: AbortSignal): Promise<Computer>;
+    ensure(options?: ComputerEnsureOptions, signal?: AbortSignal): Promise<Computer>;
+    private defaultSource;
+}
+declare class Computer {
+    private readonly sdk;
+    private computer;
+    readonly commands: ComputerCommandsClient;
+    readonly pty: ComputerPtyClient;
+    readonly files: ComputerFilesClient;
+    readonly git: ComputerGitClient;
+    readonly ports: ComputerPortsClient;
+    readonly shares: ComputerSharesClient;
+    readonly snapshots: ComputerSnapshotsClient;
+    constructor(sdk: AgentComputer, computer: ComputerResponse);
+    get raw(): ComputerResponse;
+    get id(): string;
+    get handle(): string;
+    get displayName(): string;
+    get state(): ComputerState;
+    get sourceKind(): ComputerResponse["source_kind"];
+    get sourceSnapshotId(): string | null | undefined;
+    get createdAt(): string;
+    get updatedAt(): string;
+    get deletedAt(): string | null | undefined;
+    get primaryUrl(): string;
+    get failureReason(): string | null | undefined;
+    internalSdk(): AgentComputer;
+    refresh(signal?: AbortSignal): Promise<Computer>;
+    update(options: ComputerUpdateOptions, signal?: AbortSignal): Promise<Computer>;
+    start(signal?: AbortSignal): Promise<Computer>;
+    stop(signal?: AbortSignal): Promise<Computer>;
+    delete(signal?: AbortSignal): Promise<void>;
+    ensureRunning(options?: WaitOptions): Promise<Computer>;
+    ensureStopped(options?: WaitOptions): Promise<Computer>;
+    waitUntilRunning(options?: WaitOptions): Promise<Computer>;
+    waitUntilStopped(options?: WaitOptions): Promise<Computer>;
+    getConnection(signal?: AbortSignal): Promise<ComputerConnectionResponse>;
+    createBrowserAccess(options?: ExecSessionCreateOptions): Promise<AccessSessionResponse>;
+    createVNCAccess(options?: ExecSessionCreateOptions): Promise<AccessSessionResponse>;
+    createSSHCertificate(body: CreateSSHCertificateRequest, signal?: AbortSignal): Promise<SSHCertificateResponse>;
+    execCapabilities(signal?: AbortSignal): Promise<readonly string[]>;
+    supportsCapability(capability: ComputerCapability, signal?: AbortSignal): Promise<boolean>;
+    requireCapability(capability: "files" | "git", signal?: AbortSignal): Promise<readonly string[]>;
+    waitForPort(port: number, options?: WaitOptions): Promise<PublishedPortResponse>;
+    waitForUrl(url: string, options?: WaitOptions): Promise<Response>;
+    waitForProcess(selectorOrPredicate: CommandSelector | ((command: CommandInfo) => boolean), options?: WaitOptions): Promise<CommandInfo>;
+    waitForFile(path: string, options?: WaitOptions): Promise<void>;
+}
+declare class ExecTransportError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        details?: unknown;
+    });
+}
+declare class UnsupportedCapabilityError extends Error {
+    readonly capability: "files" | "git";
+    readonly availableCapabilities: readonly string[];
+    constructor(capability: "files" | "git", availableCapabilities?: readonly string[]);
+}
+declare class CommandExitError extends Error {
+    readonly result: CommandResult;
+    constructor(result: CommandResult);
+}
+type ExecGatewayMethod = "List" | "Start" | "Connect" | "Update" | "SendInput" | "SendSignal" | "CloseStdin";
+declare class ExecGatewayConnection {
+    private readonly client;
+    private readonly fetchImpl;
+    private readonly computerId;
+    readonly session: AccessSessionResponse;
+    constructor(client: LowLevelClient, fetchImpl: typeof fetch, computerId: string, session: AccessSessionResponse);
+    close(signal?: AbortSignal): Promise<void>;
+    requestJson<T>(method: ExecGatewayMethod, body: unknown, options?: {
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+    }): Promise<T>;
+    openStream(method: "Start" | "Connect", body: unknown, options?: {
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+    }): Promise<ReadableStreamDefaultReader<Uint8Array>>;
+    private endpoint;
+    private authorizationHeader;
+    private request;
+}
+declare class CommandHandle {
+    private readonly commands;
+    private readonly gateway;
+    private readonly reader;
+    private readonly selector;
+    private readonly stdoutChunks;
+    private readonly stderrChunks;
+    private readonly pidPromise;
+    private readonly resultPromise;
+    private pidResolve;
+    private pidReject;
+    private resolvedPid?;
+    private closed;
+    constructor(commands: ComputerCommandsClient, gateway: ExecGatewayConnection, reader: ReadableStreamDefaultReader<Uint8Array>, initialSelector: CommandSelector | undefined, handlers?: Pick<CommandStartOptions, "onStdout" | "onStderr" | "onExit">);
+    get pid(): number;
+    get stdout(): string;
+    get stderr(): string;
+    wait(options?: {
+        rejectOnNonZero?: boolean;
+    }): Promise<CommandResult>;
+    disconnect(): Promise<void>;
+    kill(signal?: CommandSignal, requestSignal?: AbortSignal): Promise<void>;
+    sendStdin(data: string | Uint8Array, requestSignal?: AbortSignal): Promise<void>;
+    closeStdin(requestSignal?: AbortSignal): Promise<void>;
+    awaitPid(): Promise<number>;
+    private currentSelector;
+    private consume;
+}
+declare class PtySession {
+    private readonly commands;
+    private readonly gateway;
+    private readonly reader;
+    private readonly selector;
+    private readonly outputChunks;
+    private readonly pidPromise;
+    private readonly resultPromise;
+    private pidResolve;
+    private pidReject;
+    private resolvedPid?;
+    private closed;
+    constructor(commands: ComputerCommandsClient, gateway: ExecGatewayConnection, reader: ReadableStreamDefaultReader<Uint8Array>, initialSelector: CommandSelector | undefined, handlers?: Pick<PtyStartOptions, "onData" | "onExit">);
+    get pid(): number;
+    get output(): string;
+    wait(options?: {
+        rejectOnNonZero?: boolean;
+    }): Promise<PtyResult>;
+    sendInput(data: string | Uint8Array, requestSignal?: AbortSignal): Promise<void>;
+    resize(cols: number, rows: number, requestSignal?: AbortSignal): Promise<void>;
+    kill(signal?: CommandSignal, requestSignal?: AbortSignal): Promise<void>;
+    disconnect(): Promise<void>;
+    awaitPid(): Promise<number>;
+    private currentSelector;
+    private consume;
+}
+declare class ComputerCommandsClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    run(command: string | readonly string[], options?: CommandRunOptions): Promise<CommandResult>;
+    start(command: string | readonly string[], options?: CommandStartOptions): Promise<CommandHandle>;
+    connect(selector: CommandSelector, options?: Omit<CommandStartOptions, "stdin">): Promise<CommandHandle>;
+    list(signal?: AbortSignal): Promise<CommandInfo[]>;
+    sendStdin(selector: CommandSelector, data: string | Uint8Array, signal?: AbortSignal): Promise<void>;
+    sendPtyInput(selector: CommandSelector, data: string | Uint8Array, signal?: AbortSignal): Promise<void>;
+    closeStdin(selector: CommandSelector, signal?: AbortSignal): Promise<void>;
+    kill(selector: CommandSelector, signalName?: CommandSignal, signal?: AbortSignal): Promise<void>;
+    resizePty(selector: CommandSelector, cols: number, rows: number, signal?: AbortSignal): Promise<void>;
+    private sendProcessInput;
+    /** @internal */
+    createGateway(options: {
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+    }): Promise<ExecGatewayConnection>;
+}
+declare class ComputerPtyClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    create(options?: PtyStartOptions): Promise<PtySession>;
+    start(command: string | readonly string[], options?: PtyStartOptions): Promise<PtySession>;
+    attach(selector: CommandSelector, options?: Pick<PtyStartOptions, "requestTimeoutMs" | "signal" | "onData" | "onExit">): Promise<PtySession>;
+    connect(selector: CommandSelector, options?: Pick<PtyStartOptions, "requestTimeoutMs" | "signal" | "onData" | "onExit">): Promise<PtySession>;
+}
+declare class ComputerFilesClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    readText(path: string, signal?: AbortSignal): Promise<string>;
+    writeText(path: string, content: string, signal?: AbortSignal): Promise<void>;
+    remove(path: string, signal?: AbortSignal): Promise<void>;
+}
+declare class ComputerGitClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    status(signal?: AbortSignal): Promise<string>;
+    clone(repoUrl: string, signal?: AbortSignal): Promise<void>;
+    pull(signal?: AbortSignal): Promise<void>;
+}
+declare class ComputerPortsClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    list(signal?: AbortSignal): Promise<ListPublishedPortsResponse["ports"]>;
+    publish(options: PublishPortOptions): Promise<PublishedPortResponse>;
+    delete(port: number, signal?: AbortSignal): Promise<PublishedPortMutationResponse["port"]>;
+}
+declare class ComputerSharesClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    list(signal?: AbortSignal): Promise<ListSharesResponse["shares"]>;
+    createLink(options?: ShareLinkOptions): Promise<ShareResponse>;
+    createEmail(options: ShareEmailOptions): Promise<ShareResponse>;
+    delete(shareId: string, signal?: AbortSignal): Promise<void>;
+}
+declare class ComputerSnapshotsClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    list(signal?: AbortSignal): Promise<ListSnapshotsResponse["snapshots"]>;
+    create(signal?: AbortSignal): Promise<SnapshotResponse>;
+}
+declare class SnapshotsClient {
+    private readonly sdk;
+    constructor(sdk: AgentComputer);
+    get(snapshotId: string, signal?: AbortSignal): Promise<SnapshotResponse>;
+    delete(snapshotId: string, signal?: AbortSignal): Promise<SnapshotResponse>;
+    restore(snapshotId: string, options?: SnapshotRestoreOptions): Promise<Computer>;
+}
+declare class SSHKeysClient {
+    private readonly sdk;
+    constructor(sdk: AgentComputer);
+    list(signal?: AbortSignal): Promise<ListSSHKeysResponse["ssh_keys"]>;
+    create(body: CreateSSHKeyRequest, signal?: AbortSignal): Promise<SSHKeyEnvelope["ssh_key"]>;
+    delete(sshKeyId: string, signal?: AbortSignal): Promise<void>;
+}
+
+export { AgentComputer, type AgentComputerOptions, CommandExitError, CommandHandle, type CommandInfo, type CommandOutputHandler, type CommandResult, type CommandRunOptions, type CommandSelector, type CommandSignal, type CommandStartOptions, Computer, type ComputerCapability, ComputerCommandsClient, type ComputerCreateOptions, type ComputerEnsureOptions, ComputerFilesClient, ComputerGitClient, ComputerImagesClient, ComputerPortsClient, ComputerPtyClient, ComputerSharesClient, ComputerSnapshotsClient, type ComputerSource, type ComputerState, type ComputerUpdateOptions, ComputersClient, type ExecSessionCreateOptions, ExecTransportError, type PtyOutputHandler, type PtyResult, PtySession, type PtyStartOptions, type PublishPortOptions, SSHKeysClient, type ShareEmailOptions, type ShareLinkOptions, type SnapshotRestoreOptions, SnapshotsClient, UnsupportedCapabilityError, type WaitOptions };