aicomputer 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-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';
+import { ComputerImageResponse, AccessSessionResponse, createPublicApiClient, ComputerFileEntry, ComputerFileStat, ComputerFileGrepMatch, FuseMountResponse, ListPublishedPortsResponse, PublishedPortResponse, PublishedPortMutationResponse, ListSharesResponse, ShareResponse, ListSnapshotsResponse, SnapshotResponse, ComputerResponse, ComputerUsageEnvelope, ComputerConnectionResponse, CreateSSHCertificateRequest, SSHCertificateResponse, ComputerCapacityCheckResponse, CreateComputerRequest, ListSSHKeysResponse, CreateSSHKeyRequest, SSHKeyEnvelope, PublicApiClientOptions, AccessTokenProvider, MeResponse, UsageEnvelope, ResolveShareResponse, CreateAccessSessionRequest, AccessSessionEnvelope, OperationResponse } from '@microagentcomputer/public-api-client';
+export { AccessSessionEnvelope, AccessSessionResponse, AccessTokenProvider, ComputerCapacityCheckRequest, ComputerCapacityCheckResponse, ComputerConnectionResponse, ComputerFileEntry, ComputerFileGrepMatch, ComputerFileStat, ComputerImageResponse, ComputerMutationResponse, ComputerResponse, ComputerUsageEnvelope, CreateAccessSessionRequest, CreateComputerRequest, CreateFuseMountRequest, CreateLinkShareRequest, CreatePublishedPortRequest, CreateSSHCertificateRequest, CreateSSHKeyRequest, ExecCommandRequest, ExecCommandResponse, FuseMountMutationResponse, FuseMountResponse, ListFuseMountsResponse, MeResponse, OperationResponse, PublicApiError, PublishedPortResponse, ResizeComputerRequest, ResolveShareResponse, RestoreSnapshotRequest, SSHCertificateResponse, ShareResponse, SnapshotResponse, TransferComputerRequest, 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 FileEntry = ComputerFileEntry;
+type FileStat = ComputerFileStat;
+type FileGrepMatch = ComputerFileGrepMatch;
 type WaitOptions = {
     pollIntervalMs?: number;
     timeoutMs?: number;
@@ -24,6 +27,8 @@ type ComputerCreateOptions = {
     displayName?: string;
     source?: ComputerSource;
     sizePreset?: string;
+    memoryMiB?: number;
+    storageBytes?: number;
     authorizedKeys?: string[];
 };
 type ComputerEnsureOptions = ComputerCreateOptions & {
@@ -34,6 +39,35 @@ type ComputerEnsureOptions = ComputerCreateOptions & {
 type ComputerUpdateOptions = {
     displayName?: string;
 };
+type ComputerResizeOptions = {
+    sizePreset: string;
+    memoryMiB?: never;
+    storageBytes?: never;
+    signal?: AbortSignal;
+} | {
+    sizePreset?: "custom";
+    memoryMiB: number;
+    storageBytes: number;
+    signal?: AbortSignal;
+};
+type LowLevelComputerResizeOptions = {
+    size_preset: string;
+    requested_memory_mib?: never;
+    requested_storage_bytes?: never;
+    signal?: AbortSignal;
+} | {
+    size_preset?: "custom";
+    requested_memory_mib: number;
+    requested_storage_bytes: number;
+    signal?: AbortSignal;
+};
+type ComputerCapacityOptions = {
+    sizePreset?: string;
+    memoryMiB?: number;
+    storageBytes?: number;
+    excludeComputerId?: string;
+    computerId?: string;
+};
 type CommandRunOptions = {
     cwd?: string;
     env?: Record<string, string>;
@@ -93,18 +127,63 @@ type PtyResult = {
     status: string;
     error?: string;
 };
+type FileReadOptions = {
+    signal?: AbortSignal;
+};
+type FileWriteOptions = {
+    mode?: number;
+    signal?: AbortSignal;
+};
+type FileRemoveOptions = {
+    recursive?: boolean;
+    signal?: AbortSignal;
+};
+type FileListOptions = {
+    recursive?: boolean;
+    signal?: AbortSignal;
+};
+type FilePatchOptions = {
+    signal?: AbortSignal;
+};
+type FileReadRange = {
+    offset: number;
+    length: number;
+};
+type FileWriteRange = {
+    offset: number;
+};
+type FileMkdirOptions = {
+    recursive?: boolean;
+    signal?: AbortSignal;
+};
+type FilePatchEdit = {
+    find: string;
+    replace: string;
+};
+type FilePatchRequest = FilePatchEdit[] | {
+    setContents: string;
+};
+type FileGrepOptions = {
+    path?: string;
+    regex?: boolean;
+    caseInsensitive?: boolean;
+    maxMatches?: number;
+    signal?: AbortSignal;
+};
 type ShareLinkOptions = {
     expiresAt?: string;
     allowBrowser?: boolean;
     allowVnc?: boolean;
     signal?: AbortSignal;
 };
-type ShareEmailOptions = ShareLinkOptions & {
-    email: string;
+type TransferComputerOptions = {
+    targetOrgId: string;
+    signal?: AbortSignal;
 };
 type PublishPortOptions = {
     port: number;
     name?: string;
+    visibility?: "public" | "private";
     signal?: AbortSignal;
 };
 type SnapshotRestoreOptions = {
@@ -159,6 +238,7 @@ declare class ComputersClient {
     get(computerId: string, signal?: AbortSignal): Promise<Computer>;
     getByHandle(handle: string, signal?: AbortSignal): Promise<Computer | null>;
     resolve(idOrHandle: string, signal?: AbortSignal): Promise<Computer>;
+    checkCapacity(options?: ComputerCapacityOptions, signal?: AbortSignal): Promise<ComputerCapacityCheckResponse>;
     create(options?: ComputerCreateOptions, signal?: AbortSignal): Promise<Computer>;
     ensure(options?: ComputerEnsureOptions, signal?: AbortSignal): Promise<Computer>;
     private defaultSource;
@@ -170,6 +250,7 @@ declare class Computer {
     readonly pty: ComputerPtyClient;
     readonly files: ComputerFilesClient;
     readonly git: ComputerGitClient;
+    readonly mounts: ComputerMountsClient;
     readonly ports: ComputerPortsClient;
     readonly shares: ComputerSharesClient;
     readonly snapshots: ComputerSnapshotsClient;
@@ -191,7 +272,11 @@ declare class Computer {
     update(options: ComputerUpdateOptions, signal?: AbortSignal): Promise<Computer>;
     start(signal?: AbortSignal): Promise<Computer>;
     stop(signal?: AbortSignal): Promise<Computer>;
+    resize(options: ComputerResizeOptions | LowLevelComputerResizeOptions, signal?: AbortSignal): Promise<Computer>;
     delete(signal?: AbortSignal): Promise<void>;
+    transfer(options: TransferComputerOptions): Promise<Computer>;
+    usage(signal?: AbortSignal): Promise<ComputerUsageEnvelope>;
+    ensureReady(options?: WaitOptions): Promise<Computer>;
     ensureRunning(options?: WaitOptions): Promise<Computer>;
     ensureStopped(options?: WaitOptions): Promise<Computer>;
     waitUntilRunning(options?: WaitOptions): Promise<Computer>;
@@ -331,9 +416,23 @@ declare class ComputerPtyClient {
 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>;
+    readText(path: string, opts?: FileReadOptions | AbortSignal): Promise<string>;
+    readBytes(path: string, opts?: FileReadOptions): Promise<Uint8Array>;
+    writeText(path: string, content: string, opts?: FileWriteOptions | AbortSignal): Promise<void>;
+    writeBytes(path: string, content: Uint8Array, opts?: FileWriteOptions): Promise<void>;
+    remove(path: string, opts?: FileRemoveOptions | AbortSignal): Promise<void>;
+    list(path: string, opts?: FileListOptions): Promise<FileEntry[]>;
+    stat(path: string, opts?: FileReadOptions): Promise<FileStat>;
+    exists(path: string, opts?: FileReadOptions): Promise<boolean>;
+    patch(path: string, edits: FilePatchRequest, opts?: FilePatchOptions): Promise<{
+        version: number;
+    }>;
+    readRange(path: string, range: FileReadRange, opts?: FileReadOptions): Promise<Uint8Array>;
+    writeRange(path: string, range: FileWriteRange, content: Uint8Array, opts?: FileWriteOptions): Promise<void>;
+    mkdir(path: string, opts?: FileMkdirOptions): Promise<void>;
+    move(from: string, to: string, opts?: FileReadOptions): Promise<void>;
+    grep(pattern: string, opts?: FileGrepOptions): Promise<FileGrepMatch[]>;
+    private operate;
 }
 declare class ComputerGitClient {
     private readonly computer;
@@ -342,6 +441,26 @@ declare class ComputerGitClient {
     clone(repoUrl: string, signal?: AbortSignal): Promise<void>;
     pull(signal?: AbortSignal): Promise<void>;
 }
+type AttachMountOptions = {
+    kind: "r2" | "s3" | "gcs" | "webdav";
+    targetPath: string;
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    region?: string;
+    readOnly?: boolean;
+    vfsCacheMode?: string;
+    signal?: AbortSignal;
+};
+declare class ComputerMountsClient {
+    private readonly computer;
+    constructor(computer: Computer);
+    list(signal?: AbortSignal): Promise<FuseMountResponse[]>;
+    attach(options: AttachMountOptions): Promise<FuseMountResponse>;
+    detach(mountId: string, signal?: AbortSignal): Promise<FuseMountResponse>;
+    private find;
+}
 declare class ComputerPortsClient {
     private readonly computer;
     constructor(computer: Computer);
@@ -354,7 +473,6 @@ declare class ComputerSharesClient {
     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 {
@@ -378,4 +496,4 @@ declare class SSHKeysClient {
     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 };
+export { AgentComputer, type AgentComputerOptions, type AttachMountOptions, CommandExitError, CommandHandle, type CommandInfo, type CommandOutputHandler, type CommandResult, type CommandRunOptions, type CommandSelector, type CommandSignal, type CommandStartOptions, Computer, type ComputerCapability, type ComputerCapacityOptions, ComputerCommandsClient, type ComputerCreateOptions, type ComputerEnsureOptions, ComputerFilesClient, ComputerGitClient, ComputerImagesClient, ComputerMountsClient, ComputerPortsClient, ComputerPtyClient, type ComputerResizeOptions, ComputerSharesClient, ComputerSnapshotsClient, type ComputerSource, type ComputerState, type ComputerUpdateOptions, ComputersClient, type ExecSessionCreateOptions, ExecTransportError, type FileEntry, type FileGrepMatch, type FileGrepOptions, type FileListOptions, type FileMkdirOptions, type FilePatchEdit, type FilePatchOptions, type FilePatchRequest, type FileReadOptions, type FileReadRange, type FileRemoveOptions, type FileStat, type FileWriteOptions, type FileWriteRange, type LowLevelComputerResizeOptions, type PtyOutputHandler, type PtyResult, PtySession, type PtyStartOptions, type PublishPortOptions, SSHKeysClient, type ShareLinkOptions, type SnapshotRestoreOptions, SnapshotsClient, type TransferComputerOptions, UnsupportedCapabilityError, type WaitOptions };

package/dist/index.js

@@ -92,9 +92,23 @@ function createPublicApiClient(options) {
     async getUsage(signal) {
       return request("/v1/usage", { signal });
     },
+    async updateBillingPreferences(body, signal) {
+      return request("/v1/billing/preferences", {
+        method: "PATCH",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
     async listComputerSizePresets(signal) {
       return requestNoAuth("/v1/computer-size-presets", { signal });
     },
+    async checkComputerCapacity(body, signal) {
+      return request("/v1/computer-capacity/check", {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
     async listComputerImages(signal) {
       return request("/v1/computer-images", { signal });
     },
@@ -139,6 +153,20 @@ function createPublicApiClient(options) {
         signal
       });
     },
+    async resizeComputer(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/actions/resize`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async transferComputer(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/actions/transfer`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
     async getComputerConnection(computerId, signal) {
       return request(`/v1/computers/${encodeURIComponent(computerId)}/connection`, { signal });
     },
@@ -149,6 +177,22 @@ function createPublicApiClient(options) {
         signal
       });
     },
+    async operateComputerFiles(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/files/ops`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async getComputerUsage(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/usage`, { signal });
+    },
+    async ensureReadyComputer(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/actions/ensure-ready`, {
+        method: "POST",
+        signal
+      });
+    },
     async getOperation(operationId, signal) {
       return request(`/v1/operations/${encodeURIComponent(operationId)}`, { signal });
     },
@@ -225,19 +269,6 @@ function createPublicApiClient(options) {
         signal
       });
     },
-    async createEmailShare(computerId, body, signal) {
-      return request(`/v1/computers/${encodeURIComponent(computerId)}/shares/emails`, {
-        method: "POST",
-        body: JSON.stringify(body),
-        signal
-      });
-    },
-    async deleteEmailShare(computerId, shareId, signal) {
-      return request(`/v1/computers/${encodeURIComponent(computerId)}/shares/emails/${encodeURIComponent(shareId)}`, {
-        method: "DELETE",
-        signal
-      });
-    },
     async resolveShare(shareToken, signal) {
       return requestNoAuth(`/v1/shares/${encodeURIComponent(shareToken)}`, { signal });
     },
@@ -288,6 +319,22 @@ function createPublicApiClient(options) {
         method: "DELETE",
         signal
       });
+    },
+    async listFuseMounts(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/mounts`, { signal });
+    },
+    async createFuseMount(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/mounts`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async deleteFuseMount(computerId, mountId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/mounts/${encodeURIComponent(mountId)}`, {
+        method: "DELETE",
+        signal
+      });
     }
   };
   return client;
@@ -316,7 +363,6 @@ var DEFAULT_COMPUTER_STATE_TIMEOUT_MS = 3e5;
 var DEFAULT_CONNECT_REQUEST_TIMEOUT_MS = 3e4;
 var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["computer_not_found", "snapshot_not_found"]);
 var COMPUTER_FAILURE_STATES = /* @__PURE__ */ new Set(["failed", "deleted", "deleting"]);
-var defaultComputerSizePreset = "ram-2g";
 var AgentComputer = class {
   images;
   computers;
@@ -483,13 +529,27 @@ var ComputersClient = class {
     }
     throw new PublicApiError(404, `computer ${idOrHandle} not found`, "computer_not_found");
   }
+  async checkCapacity(options = {}, signal) {
+    return this.sdk.internalClient().checkComputerCapacity(
+      {
+        size_preset: options.sizePreset,
+        requested_memory_mib: options.memoryMiB,
+        requested_storage_bytes: options.storageBytes,
+        exclude_computer_id: options.excludeComputerId,
+        computer_id: options.computerId
+      },
+      signal
+    );
+  }
   async create(options = {}, signal) {
     const source = options.source ?? await this.defaultSource(signal);
     const response = await this.sdk.internalClient().createComputer(
       {
         handle: options.handle,
         display_name: options.displayName,
-        size_preset: source.kind === "image" ? options.sizePreset ?? defaultComputerSizePreset : options.sizePreset,
+        size_preset: options.sizePreset,
+        requested_memory_mib: options.memoryMiB,
+        requested_storage_bytes: options.storageBytes,
         source,
         guest: options.authorizedKeys && options.authorizedKeys.length > 0 ? { authorized_keys: options.authorizedKeys } : void 0
       },
@@ -538,6 +598,7 @@ var Computer = class {
     this.pty = new ComputerPtyClient(this);
     this.files = new ComputerFilesClient(this);
     this.git = new ComputerGitClient(this);
+    this.mounts = new ComputerMountsClient(this);
     this.ports = new ComputerPortsClient(this);
     this.shares = new ComputerSharesClient(this);
     this.snapshots = new ComputerSnapshotsClient(this);
@@ -548,6 +609,7 @@ var Computer = class {
   pty;
   files;
   git;
+  mounts;
   ports;
   shares;
   snapshots;
@@ -618,12 +680,48 @@ var Computer = class {
     this.computer = (await this.sdk.internalClient().getComputer(this.id, signal)).computer;
     return this;
   }
+  async resize(options, signal) {
+    const lowLevelOptions = options;
+    const highLevelOptions = options;
+    const sizePreset = "size_preset" in options ? lowLevelOptions.size_preset : highLevelOptions.sizePreset;
+    const requestedMemoryMiB = "requested_memory_mib" in options ? lowLevelOptions.requested_memory_mib : highLevelOptions.memoryMiB;
+    const requestedStorageBytes = "requested_storage_bytes" in options ? lowLevelOptions.requested_storage_bytes : highLevelOptions.storageBytes;
+    const requestSignal = "signal" in options && options.signal !== void 0 ? options.signal : signal;
+    if ((!sizePreset || sizePreset === "custom") && (requestedMemoryMiB === void 0 || requestedStorageBytes === void 0)) {
+      throw new Error("resize requires sizePreset or memoryMiB plus storageBytes");
+    }
+    const response = await this.sdk.internalClient().resizeComputer(
+      this.id,
+      {
+        size_preset: sizePreset,
+        requested_memory_mib: requestedMemoryMiB,
+        requested_storage_bytes: requestedStorageBytes
+      },
+      requestSignal
+    );
+    await waitForOperationIfPresent(this.sdk, response.operation, requestSignal);
+    this.computer = (await this.sdk.internalClient().getComputer(this.id, requestSignal)).computer;
+    return this;
+  }
   async delete(signal) {
     const response = await this.sdk.internalClient().deleteComputer(this.id, signal);
     await waitForOperationIfPresent(this.sdk, response.operation, signal);
     this.computer = response.computer;
   }
-  async ensureRunning(options = {}) {
+  async transfer(options) {
+    const response = await this.sdk.internalClient().transferComputer(
+      this.id,
+      { target_org_id: options.targetOrgId },
+      options.signal
+    );
+    await waitForOperationIfPresent(this.sdk, response.operation, options.signal);
+    this.computer = response.computer;
+    return this;
+  }
+  async usage(signal) {
+    return this.sdk.internalClient().getComputerUsage(this.id, signal);
+  }
+  async ensureReady(options = {}) {
     await this.refresh(options.signal);
     if (this.state === "running") {
       return this;
@@ -638,12 +736,18 @@ var Computer = class {
         this.computer
       );
     }
-    if (this.state === "stopped") {
-      await this.start(options.signal);
+    const response = await this.sdk.internalClient().ensureReadyComputer(this.id, options.signal);
+    await waitForOperationIfPresent(this.sdk, response.operation, options.signal);
+    if (response.computer.state !== "running") {
+      await this.waitUntilRunning(options);
+    } else {
+      this.computer = response.computer;
     }
-    await this.waitUntilRunning(options);
     return this;
   }
+  async ensureRunning(options = {}) {
+    return this.ensureReady(options);
+  }
   async ensureStopped(options = {}) {
     await this.refresh(options.signal);
     if (this.state === "stopped") {
@@ -1400,29 +1504,171 @@ var ComputerPtyClient = class {
 var ComputerFilesClient = class {
   constructor(computer) {
     this.computer = computer;
-    void computer;
   }
   computer;
-  async readText(path, signal) {
-    await this.computer.requireCapability("files", signal);
-    throw new ExecTransportError("files capability is advertised but the SDK file transport is not implemented yet", {
-      code: "files_transport_unimplemented",
-      details: { computerId: this.computer.id, path }
-    });
+  async readText(path, opts) {
+    const response = await this.operate({
+      operation: "read_text",
+      path
+    }, signalFromFileOptions(opts));
+    return response.content ?? "";
+  }
+  async readBytes(path, opts) {
+    const response = await this.operate(
+      {
+        operation: "read_bytes",
+        path
+      },
+      opts?.signal
+    );
+    return base64ToBytes(response.content_base64 ?? "");
   }
-  async writeText(path, content, signal) {
-    await this.computer.requireCapability("files", signal);
-    throw new ExecTransportError("files capability is advertised but the SDK file transport is not implemented yet", {
-      code: "files_transport_unimplemented",
-      details: { computerId: this.computer.id, path, size: content.length }
-    });
+  async writeText(path, content, opts) {
+    const normalized = normalizeFileWriteOptions(opts);
+    await this.operate(
+      {
+        operation: "write_text",
+        path,
+        content,
+        mode: normalized.mode
+      },
+      normalized.signal
+    );
   }
-  async remove(path, signal) {
-    await this.computer.requireCapability("files", signal);
-    throw new ExecTransportError("files capability is advertised but the SDK file transport is not implemented yet", {
-      code: "files_transport_unimplemented",
-      details: { computerId: this.computer.id, path }
-    });
+  async writeBytes(path, content, opts) {
+    await this.operate(
+      {
+        operation: "write_bytes",
+        path,
+        content_base64: bytesToBase64(content),
+        mode: opts?.mode
+      },
+      opts?.signal
+    );
+  }
+  async remove(path, opts) {
+    const normalized = normalizeFileRemoveOptions(opts);
+    await this.operate(
+      {
+        operation: "remove",
+        path,
+        recursive: normalized.recursive
+      },
+      normalized.signal
+    );
+  }
+  async list(path, opts = {}) {
+    const response = await this.operate(
+      {
+        operation: "list",
+        path,
+        recursive: opts.recursive
+      },
+      opts.signal
+    );
+    return response.entries ?? [];
+  }
+  async stat(path, opts = {}) {
+    const response = await this.operate(
+      {
+        operation: "stat",
+        path
+      },
+      opts.signal
+    );
+    if (!response.stat) {
+      throw new PublicApiError(500, "file stat response missing stat payload", "file_stat_missing", {
+        computer_id: this.computer.id,
+        path
+      });
+    }
+    return response.stat;
+  }
+  async exists(path, opts = {}) {
+    const response = await this.operate(
+      {
+        operation: "exists",
+        path
+      },
+      opts.signal
+    );
+    return response.exists ?? false;
+  }
+  async patch(path, edits, opts = {}) {
+    const response = await this.operate(
+      Array.isArray(edits) ? {
+        operation: "patch",
+        path,
+        edits
+      } : {
+        operation: "patch",
+        path,
+        set_contents: edits.setContents
+      },
+      opts.signal
+    );
+    return { version: response.version ?? 0 };
+  }
+  async readRange(path, range, opts = {}) {
+    const response = await this.operate(
+      {
+        operation: "read_range",
+        path,
+        offset: range.offset,
+        length: range.length
+      },
+      opts.signal
+    );
+    return base64ToBytes(response.content_base64 ?? "");
+  }
+  async writeRange(path, range, content, opts = {}) {
+    await this.operate(
+      {
+        operation: "write_range",
+        path,
+        offset: range.offset,
+        content_base64: bytesToBase64(content),
+        mode: opts.mode
+      },
+      opts.signal
+    );
+  }
+  async mkdir(path, opts = {}) {
+    await this.operate(
+      {
+        operation: "mkdir",
+        path,
+        recursive: opts.recursive
+      },
+      opts.signal
+    );
+  }
+  async move(from, to, opts = {}) {
+    await this.operate(
+      {
+        operation: "move",
+        path: from,
+        to
+      },
+      opts.signal
+    );
+  }
+  async grep(pattern, opts = {}) {
+    const response = await this.operate(
+      {
+        operation: "grep",
+        path: opts.path,
+        pattern,
+        regex: opts.regex,
+        case_insensitive: opts.caseInsensitive,
+        max_matches: opts.maxMatches
+      },
+      opts.signal
+    );
+    return response.matches ?? [];
+  }
+  operate(body, signal) {
+    return this.computer.internalSdk().internalClient().operateComputerFiles(this.computer.id, body, signal);
   }
 };
 var ComputerGitClient = class {
@@ -1453,6 +1699,51 @@ var ComputerGitClient = class {
     });
   }
 };
+var ComputerMountsClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async list(signal) {
+    const response = await this.computer.internalSdk().internalClient().listFuseMounts(
+      this.computer.id,
+      signal
+    );
+    return response.mounts;
+  }
+  async attach(options) {
+    const response = await this.computer.internalSdk().internalClient().createFuseMount(
+      this.computer.id,
+      {
+        kind: options.kind,
+        target_path: options.targetPath,
+        bucket: options.bucket,
+        access_key_id: options.accessKeyId,
+        secret_access_key: options.secretAccessKey,
+        endpoint: options.endpoint,
+        region: options.region,
+        read_only: options.readOnly,
+        vfs_cache_mode: options.vfsCacheMode
+      },
+      options.signal
+    );
+    await waitForOperationIfPresent(this.computer.internalSdk(), response.operation, options.signal);
+    return await this.find(response.mount.id, options.signal) ?? response.mount;
+  }
+  async detach(mountId, signal) {
+    const response = await this.computer.internalSdk().internalClient().deleteFuseMount(
+      this.computer.id,
+      mountId,
+      signal
+    );
+    await waitForOperationIfPresent(this.computer.internalSdk(), response.operation, signal);
+    return await this.find(response.mount.id, signal) ?? response.mount;
+  }
+  async find(mountId, signal) {
+    const mounts = await this.list(signal);
+    return mounts.find((mount) => mount.id === mountId) ?? null;
+  }
+};
 var ComputerPortsClient = class {
   constructor(computer) {
     this.computer = computer;
@@ -1470,7 +1761,8 @@ var ComputerPortsClient = class {
       this.computer.id,
       {
         port: options.port,
-        name: options.name
+        name: options.name,
+        visibility: options.visibility
       },
       options.signal
     );
@@ -1511,29 +1803,7 @@ var ComputerSharesClient = class {
     );
     return response.share;
   }
-  async createEmail(options) {
-    const response = await this.computer.internalSdk().internalClient().createEmailShare(
-      this.computer.id,
-      {
-        email: options.email,
-        expires_at: options.expiresAt,
-        allow_browser: options.allowBrowser,
-        allow_vnc: options.allowVnc
-      },
-      options.signal
-    );
-    return response.share;
-  }
   async delete(shareId, signal) {
-    const shares = await this.list(signal);
-    const existing = shares.find((share) => share.id === shareId);
-    if (!existing) {
-      throw new PublicApiError(404, `share ${shareId} not found`, "share_not_found");
-    }
-    if (existing.kind === "email") {
-      await this.computer.internalSdk().internalClient().deleteEmailShare(this.computer.id, shareId, signal);
-      return;
-    }
     await this.computer.internalSdk().internalClient().deleteLinkShare(this.computer.id, shareId, signal);
   }
 };
@@ -1691,6 +1961,36 @@ function shellQuote(value) {
 function encodeData(data) {
   return typeof data === "string" ? new TextEncoder().encode(data) : data;
 }
+function isAbortSignal(value) {
+  return typeof AbortSignal !== "undefined" && value instanceof AbortSignal;
+}
+function signalFromFileOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  if (isAbortSignal(options)) {
+    return options;
+  }
+  return options.signal;
+}
+function normalizeFileWriteOptions(options) {
+  if (!options) {
+    return {};
+  }
+  if (isAbortSignal(options)) {
+    return { signal: options };
+  }
+  return options;
+}
+function normalizeFileRemoveOptions(options) {
+  if (!options) {
+    return {};
+  }
+  if (isAbortSignal(options)) {
+    return { signal: options };
+  }
+  return options;
+}
 function bytesToBase64(bytes) {
   let binary = "";
   for (const byte of bytes) {
@@ -1847,6 +2147,7 @@ export {
   ComputerFilesClient,
   ComputerGitClient,
   ComputerImagesClient,
+  ComputerMountsClient,
   ComputerPortsClient,
   ComputerPtyClient,
   ComputerSharesClient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicomputer",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "High-level TypeScript SDK for AgentComputer computers and execution workflows.",
   "license": "MIT",