aicomputer 0.1.0

package/dist/index.js

@@ -0,0 +1,1856 @@
+// ../public-api-client/dist/index.js
+var PublicApiError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(status, message, code, details) {
+    super(message);
+    this.name = "PublicApiError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+function delay(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      const abort = () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", abort, { once: true });
+    }
+  });
+}
+function createPublicApiClient(options) {
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("fetch is required");
+  }
+  const getAccessToken = async () => {
+    if (typeof options.accessToken === "function") {
+      const token = await options.accessToken();
+      return token?.trim() || void 0;
+    }
+    return options.accessToken?.trim() || void 0;
+  };
+  const request = async (path, init = {}) => {
+    const headers = new Headers(init.headers);
+    if (!headers.has("accept")) {
+      headers.set("accept", "application/json");
+    }
+    if (init.body !== void 0 && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const token = await getAccessToken();
+    if (token) {
+      headers.set("authorization", `Bearer ${token}`);
+    }
+    const response = await fetchImpl(`${baseUrl}${path}`, {
+      ...init,
+      headers
+    });
+    if (!response.ok) {
+      throw await toPublicApiError(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await response.json();
+  };
+  const requestNoAuth = async (path, init = {}) => {
+    const headers = new Headers(init.headers);
+    if (!headers.has("accept")) {
+      headers.set("accept", "application/json");
+    }
+    if (init.body !== void 0 && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const response = await fetchImpl(`${baseUrl}${path}`, {
+      ...init,
+      headers
+    });
+    if (!response.ok) {
+      throw await toPublicApiError(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await response.json();
+  };
+  const client = {
+    request,
+    requestNoAuth,
+    async getMe(signal) {
+      return request("/v1/me", { signal });
+    },
+    async getUsage(signal) {
+      return request("/v1/usage", { signal });
+    },
+    async listComputerImages(signal) {
+      return request("/v1/computer-images", { signal });
+    },
+    async getComputerImage(imageId, signal) {
+      return request(`/v1/computer-images/${encodeURIComponent(imageId)}`, { signal });
+    },
+    async listComputers(signal) {
+      return request("/v1/computers", { signal });
+    },
+    async getComputer(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}`, { signal });
+    },
+    async createComputer(body, signal) {
+      return request("/v1/computers", {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async updateComputer(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}`, {
+        method: "PATCH",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async deleteComputer(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}`, {
+        method: "DELETE",
+        signal
+      });
+    },
+    async startComputer(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/actions/start`, {
+        method: "POST",
+        signal
+      });
+    },
+    async stopComputer(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/actions/stop`, {
+        method: "POST",
+        signal
+      });
+    },
+    async getComputerConnection(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/connection`, { signal });
+    },
+    async execCommand(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/exec`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async getOperation(operationId, signal) {
+      return request(`/v1/operations/${encodeURIComponent(operationId)}`, { signal });
+    },
+    async waitForOperation(operationId, options2 = {}) {
+      const pollIntervalMs = options2.pollIntervalMs ?? 1500;
+      const timeoutMs = options2.timeoutMs ?? 2 * 6e4;
+      const startedAt = Date.now();
+      while (true) {
+        const { operation } = await client.getOperation(operationId, options2.signal);
+        if (operation.status === "succeeded") {
+          return operation;
+        }
+        if (operation.status === "failed") {
+          throw new PublicApiError(409, operation.error_message || "operation failed", "operation_failed", operation);
+        }
+        if (Date.now() - startedAt > timeoutMs) {
+          throw new PublicApiError(408, "operation timed out", "operation_timeout", operation);
+        }
+        await delay(pollIntervalMs, options2.signal);
+      }
+    },
+    async createAccessSession(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/access-sessions`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async getAccessSession(computerId, sessionId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/access-sessions/${encodeURIComponent(sessionId)}`, { signal });
+    },
+    async deleteAccessSession(computerId, sessionId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/access-sessions/${encodeURIComponent(sessionId)}`, {
+        method: "DELETE",
+        signal
+      });
+    },
+    async listSSHKeys(signal) {
+      return request("/v1/ssh-keys", { signal });
+    },
+    async createSSHKey(body, signal) {
+      return request("/v1/ssh-keys", {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async deleteSSHKey(sshKeyId, signal) {
+      return request(`/v1/ssh-keys/${encodeURIComponent(sshKeyId)}`, {
+        method: "DELETE",
+        signal
+      });
+    },
+    async createSSHCertificate(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/ssh/certificates`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async listShares(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/shares`, { signal });
+    },
+    async createLinkShare(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/shares/links`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async deleteLinkShare(computerId, shareId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/shares/links/${encodeURIComponent(shareId)}`, {
+        method: "DELETE",
+        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 });
+    },
+    async redeemShare(shareToken, body, signal) {
+      return requestNoAuth(`/v1/shares/${encodeURIComponent(shareToken)}/access-sessions`, {
+        method: "POST",
+        body: body ? JSON.stringify(body) : void 0,
+        signal
+      });
+    },
+    async listSnapshots(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/snapshots`, { signal });
+    },
+    async getSnapshot(snapshotId, signal) {
+      return request(`/v1/snapshots/${encodeURIComponent(snapshotId)}`, { signal });
+    },
+    async createSnapshot(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/snapshots`, {
+        method: "POST",
+        signal
+      });
+    },
+    async deleteSnapshot(snapshotId, signal) {
+      return request(`/v1/snapshots/${encodeURIComponent(snapshotId)}`, {
+        method: "DELETE",
+        signal
+      });
+    },
+    async restoreSnapshot(snapshotId, body, signal) {
+      return request(`/v1/snapshots/${encodeURIComponent(snapshotId)}/restore`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async listPublishedPorts(computerId, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/ports`, { signal });
+    },
+    async createPublishedPort(computerId, body, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/ports`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        signal
+      });
+    },
+    async deletePublishedPort(computerId, port, signal) {
+      return request(`/v1/computers/${encodeURIComponent(computerId)}/ports/${encodeURIComponent(String(port))}`, {
+        method: "DELETE",
+        signal
+      });
+    }
+  };
+  return client;
+}
+async function toPublicApiError(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    try {
+      const payload = await response.json();
+      const code = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "object" && payload.error?.code ? payload.error?.code : void 0;
+      const message = typeof payload === "object" && payload !== null && "error" in payload && typeof payload.error === "object" && payload.error?.message ? payload.error?.message : JSON.stringify(payload);
+      return new PublicApiError(response.status, message || response.statusText || "request failed", code, payload);
+    } catch (error) {
+      return new PublicApiError(response.status, response.statusText || "request failed", void 0, error);
+    }
+  }
+  const body = await response.text().catch(() => "");
+  return new PublicApiError(response.status, body || response.statusText || "request failed");
+}
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://micro-api.computer.agentcomputer.ai";
+var DEFAULT_POLL_INTERVAL_MS = 1500;
+var DEFAULT_OPERATION_TIMEOUT_MS = 12e4;
+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 AgentComputer = class {
+  images;
+  computers;
+  snapshots;
+  sshKeys;
+  client;
+  fetchImpl;
+  defaultPollIntervalMs;
+  defaultOperationTimeoutMs;
+  defaultComputerStateTimeoutMs;
+  defaultConnectRequestTimeoutMs;
+  constructor(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new Error("fetch is required");
+    }
+    this.fetchImpl = fetchImpl;
+    this.defaultPollIntervalMs = options.defaultPollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.defaultOperationTimeoutMs = options.defaultOperationTimeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS;
+    this.defaultComputerStateTimeoutMs = options.defaultComputerStateTimeoutMs ?? DEFAULT_COMPUTER_STATE_TIMEOUT_MS;
+    this.defaultConnectRequestTimeoutMs = options.defaultConnectRequestTimeoutMs ?? DEFAULT_CONNECT_REQUEST_TIMEOUT_MS;
+    this.client = createPublicApiClient({
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      accessToken: options.apiKey ?? options.accessToken,
+      fetch: fetchImpl
+    });
+    this.images = new ComputerImagesClient(this);
+    this.computers = new ComputersClient(this);
+    this.snapshots = new SnapshotsClient(this);
+    this.sshKeys = new SSHKeysClient(this);
+  }
+  async me(signal) {
+    return this.client.getMe(signal);
+  }
+  async usage(signal) {
+    return this.client.getUsage(signal);
+  }
+  async resolveShare(shareToken, signal) {
+    return this.client.resolveShare(shareToken, signal);
+  }
+  async redeemShare(shareToken, body, signal) {
+    return this.client.redeemShare(shareToken, body, signal);
+  }
+  async waitForOperation(operationOrId, options = {}) {
+    const operationId = typeof operationOrId === "string" ? operationOrId : operationOrId.id;
+    return this.client.waitForOperation(operationId, {
+      pollIntervalMs: options.pollIntervalMs ?? this.defaultPollIntervalMs,
+      timeoutMs: options.timeoutMs ?? this.defaultOperationTimeoutMs,
+      signal: options.signal
+    });
+  }
+  async waitForComputerState(computerId, targetState, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.defaultComputerStateTimeoutMs;
+    const pollIntervalMs = options.pollIntervalMs ?? this.defaultPollIntervalMs;
+    const startedAt = Date.now();
+    while (true) {
+      const computer = await this.client.getComputer(computerId, options.signal);
+      if (computer.computer.state === targetState) {
+        return new Computer(this, computer.computer);
+      }
+      if (COMPUTER_FAILURE_STATES.has(computer.computer.state)) {
+        throw new PublicApiError(
+          409,
+          `computer entered terminal state ${computer.computer.state}`,
+          "computer_terminal_state",
+          computer.computer
+        );
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new PublicApiError(
+          408,
+          `computer did not reach ${targetState} before timeout`,
+          "computer_state_timeout",
+          computer.computer
+        );
+      }
+      await delay(pollIntervalMs, options.signal);
+    }
+  }
+  computer(idOrHandle) {
+    return this.computers.resolve(idOrHandle);
+  }
+  /** @internal */
+  internalClient() {
+    return this.client;
+  }
+  /** @internal */
+  internalFetch() {
+    return this.fetchImpl;
+  }
+  /** @internal */
+  internalDefaultPollIntervalMs() {
+    return this.defaultPollIntervalMs;
+  }
+  /** @internal */
+  internalDefaultComputerStateTimeoutMs() {
+    return this.defaultComputerStateTimeoutMs;
+  }
+  /** @internal */
+  internalDefaultOperationTimeoutMs() {
+    return this.defaultOperationTimeoutMs;
+  }
+  /** @internal */
+  internalDefaultConnectRequestTimeoutMs() {
+    return this.defaultConnectRequestTimeoutMs;
+  }
+};
+var ComputerImagesClient = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async list(signal) {
+    const response = await this.sdk.internalClient().listComputerImages(signal);
+    return response.images;
+  }
+  async get(imageId, signal) {
+    const response = await this.sdk.internalClient().getComputerImage(imageId, signal);
+    return response.image;
+  }
+  async getDefault(signal) {
+    const images = await this.list(signal);
+    const active = images.find((image) => image.status === "active");
+    if (active) {
+      return active;
+    }
+    if (images[0]) {
+      return images[0];
+    }
+    throw new PublicApiError(404, "no computer images are available", "image_not_found");
+  }
+};
+var ComputersClient = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async list(signal) {
+    const response = await this.sdk.internalClient().listComputers(signal);
+    return response.computers.map((computer) => new Computer(this.sdk, computer));
+  }
+  async get(computerId, signal) {
+    const response = await this.sdk.internalClient().getComputer(computerId, signal);
+    return new Computer(this.sdk, response.computer);
+  }
+  async getByHandle(handle, signal) {
+    const computers = await this.list(signal);
+    return computers.find((computer) => computer.handle === handle) ?? null;
+  }
+  async resolve(idOrHandle, signal) {
+    try {
+      return await this.get(idOrHandle, signal);
+    } catch (error) {
+      if (!(error instanceof PublicApiError)) {
+        throw error;
+      }
+      if (!NOT_FOUND_CODES.has(error.code ?? "")) {
+        throw error;
+      }
+    }
+    const byHandle = await this.getByHandle(idOrHandle, signal);
+    if (byHandle) {
+      return byHandle;
+    }
+    throw new PublicApiError(404, `computer ${idOrHandle} not found`, "computer_not_found");
+  }
+  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,
+        source,
+        guest: options.authorizedKeys && options.authorizedKeys.length > 0 ? { authorized_keys: options.authorizedKeys } : void 0
+      },
+      signal
+    );
+    await waitForOperationIfPresent(this.sdk, response.operation, signal);
+    const refreshed = await this.sdk.internalClient().getComputer(response.computer.id, signal);
+    return new Computer(this.sdk, refreshed.computer);
+  }
+  async ensure(options = {}, signal) {
+    let computer;
+    if (options.id) {
+      computer = await this.get(options.id, signal);
+    } else if (options.handle) {
+      const existing = await this.getByHandle(options.handle, signal);
+      computer = existing ?? await this.create(options, signal);
+    } else {
+      computer = await this.create(options, signal);
+    }
+    if (options.updateMetadata && options.displayName !== void 0) {
+      computer = await computer.update(
+        {
+          displayName: options.displayName
+        },
+        signal
+      );
+    }
+    if (options.start) {
+      await computer.ensureRunning({ signal });
+    }
+    return computer;
+  }
+  async defaultSource(signal) {
+    const image = await this.sdk.images.getDefault(signal);
+    return {
+      kind: "image",
+      image_id: image.id
+    };
+  }
+};
+var Computer = class {
+  constructor(sdk, computer) {
+    this.sdk = sdk;
+    this.computer = computer;
+    this.commands = new ComputerCommandsClient(this);
+    this.pty = new ComputerPtyClient(this);
+    this.files = new ComputerFilesClient(this);
+    this.git = new ComputerGitClient(this);
+    this.ports = new ComputerPortsClient(this);
+    this.shares = new ComputerSharesClient(this);
+    this.snapshots = new ComputerSnapshotsClient(this);
+  }
+  sdk;
+  computer;
+  commands;
+  pty;
+  files;
+  git;
+  ports;
+  shares;
+  snapshots;
+  get raw() {
+    return this.computer;
+  }
+  get id() {
+    return this.computer.id;
+  }
+  get handle() {
+    return this.computer.handle;
+  }
+  get displayName() {
+    return this.computer.display_name;
+  }
+  get state() {
+    return this.computer.state;
+  }
+  get sourceKind() {
+    return this.computer.source_kind;
+  }
+  get sourceSnapshotId() {
+    return this.computer.source_snapshot_id;
+  }
+  get createdAt() {
+    return this.computer.created_at;
+  }
+  get updatedAt() {
+    return this.computer.updated_at;
+  }
+  get deletedAt() {
+    return this.computer.deleted_at;
+  }
+  get primaryUrl() {
+    return this.computer.primary_url;
+  }
+  get failureReason() {
+    return this.computer.failure_reason;
+  }
+  internalSdk() {
+    return this.sdk;
+  }
+  async refresh(signal) {
+    const response = await this.sdk.internalClient().getComputer(this.id, signal);
+    this.computer = response.computer;
+    return this;
+  }
+  async update(options, signal) {
+    const response = await this.sdk.internalClient().updateComputer(
+      this.id,
+      {
+        display_name: options.displayName ?? this.displayName
+      },
+      signal
+    );
+    this.computer = response.computer;
+    return this;
+  }
+  async start(signal) {
+    const response = await this.sdk.internalClient().startComputer(this.id, signal);
+    await waitForOperationIfPresent(this.sdk, response.operation, signal);
+    this.computer = (await this.sdk.internalClient().getComputer(this.id, signal)).computer;
+    return this;
+  }
+  async stop(signal) {
+    const response = await this.sdk.internalClient().stopComputer(this.id, signal);
+    await waitForOperationIfPresent(this.sdk, response.operation, signal);
+    this.computer = (await this.sdk.internalClient().getComputer(this.id, signal)).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 = {}) {
+    await this.refresh(options.signal);
+    if (this.state === "running") {
+      return this;
+    }
+    if (this.state === "stopping") {
+      await this.waitUntilStopped(options);
+    } else if (COMPUTER_FAILURE_STATES.has(this.state)) {
+      throw new PublicApiError(
+        409,
+        `computer cannot be started from ${this.state}`,
+        "computer_not_startable",
+        this.computer
+      );
+    }
+    if (this.state === "stopped") {
+      await this.start(options.signal);
+    }
+    await this.waitUntilRunning(options);
+    return this;
+  }
+  async ensureStopped(options = {}) {
+    await this.refresh(options.signal);
+    if (this.state === "stopped") {
+      return this;
+    }
+    if (this.state === "starting" || this.state === "provisioning") {
+      await this.waitUntilRunning(options);
+    }
+    if (this.state === "running") {
+      await this.stop(options.signal);
+    } else if (COMPUTER_FAILURE_STATES.has(this.state)) {
+      throw new PublicApiError(
+        409,
+        `computer cannot be stopped from ${this.state}`,
+        "computer_not_stoppable",
+        this.computer
+      );
+    }
+    await this.waitUntilStopped(options);
+    return this;
+  }
+  async waitUntilRunning(options = {}) {
+    const computer = await this.sdk.waitForComputerState(this.id, "running", options);
+    this.computer = computer.raw;
+    return this;
+  }
+  async waitUntilStopped(options = {}) {
+    const computer = await this.sdk.waitForComputerState(this.id, "stopped", options);
+    this.computer = computer.raw;
+    return this;
+  }
+  async getConnection(signal) {
+    return this.sdk.internalClient().getComputerConnection(this.id, signal);
+  }
+  async createBrowserAccess(options = {}) {
+    await this.ensureRunning({ signal: options.signal });
+    const response = await this.sdk.internalClient().createAccessSession(
+      this.id,
+      {
+        kind: "browser",
+        ttl_seconds: options.ttlSeconds
+      },
+      options.signal
+    );
+    return response.session;
+  }
+  async createVNCAccess(options = {}) {
+    await this.ensureRunning({ signal: options.signal });
+    const response = await this.sdk.internalClient().createAccessSession(
+      this.id,
+      {
+        kind: "vnc",
+        ttl_seconds: options.ttlSeconds
+      },
+      options.signal
+    );
+    return response.session;
+  }
+  async createSSHCertificate(body, signal) {
+    await this.ensureRunning({ signal });
+    return this.sdk.internalClient().createSSHCertificate(this.id, body, signal);
+  }
+  async execCapabilities(signal) {
+    await this.ensureRunning({ signal });
+    const response = await this.sdk.internalClient().createAccessSession(
+      this.id,
+      { kind: "exec" },
+      signal
+    );
+    try {
+      return response.session.transport?.capabilities ?? [];
+    } finally {
+      await this.sdk.internalClient().deleteAccessSession(this.id, response.session.id, signal).catch(() => void 0);
+    }
+  }
+  async supportsCapability(capability, signal) {
+    return (await this.execCapabilities(signal)).includes(capability);
+  }
+  async requireCapability(capability, signal) {
+    const availableCapabilities = await this.execCapabilities(signal);
+    if (!availableCapabilities.includes(capability)) {
+      throw new UnsupportedCapabilityError(capability, availableCapabilities);
+    }
+    return availableCapabilities;
+  }
+  async waitForPort(port, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.sdk.internalDefaultComputerStateTimeoutMs();
+    const pollIntervalMs = options.pollIntervalMs ?? this.sdk.internalDefaultPollIntervalMs();
+    const startedAt = Date.now();
+    while (true) {
+      const ports = await this.ports.list(options.signal);
+      const publishedPort = ports.find((candidate) => candidate.port === port);
+      if (publishedPort?.state === "ready") {
+        return publishedPort;
+      }
+      if (publishedPort?.state === "failed") {
+        throw new PublicApiError(
+          409,
+          publishedPort.failure_reason || `published port ${port} failed`,
+          "published_port_failed",
+          publishedPort
+        );
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new PublicApiError(
+          408,
+          `computer port ${port} did not become ready before timeout`,
+          "computer_port_timeout",
+          { computer_id: this.id, port }
+        );
+      }
+      await delay(pollIntervalMs, options.signal);
+    }
+  }
+  async waitForUrl(url, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.sdk.internalDefaultComputerStateTimeoutMs();
+    const pollIntervalMs = options.pollIntervalMs ?? this.sdk.internalDefaultPollIntervalMs();
+    const startedAt = Date.now();
+    while (true) {
+      try {
+        const response = await this.sdk.internalFetch()(url, {
+          method: "GET",
+          redirect: "follow",
+          signal: options.signal
+        });
+        if (response.ok) {
+          return response;
+        }
+      } catch {
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new PublicApiError(
+          408,
+          `url ${url} did not become reachable before timeout`,
+          "computer_url_timeout",
+          { computer_id: this.id, url }
+        );
+      }
+      await delay(pollIntervalMs, options.signal);
+    }
+  }
+  async waitForProcess(selectorOrPredicate, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.sdk.internalDefaultComputerStateTimeoutMs();
+    const pollIntervalMs = options.pollIntervalMs ?? this.sdk.internalDefaultPollIntervalMs();
+    const matcher = typeof selectorOrPredicate === "function" ? selectorOrPredicate : (command) => matchesCommandSelector(command, selectorOrPredicate);
+    const startedAt = Date.now();
+    while (true) {
+      const commands = await this.commands.list(options.signal);
+      const match = commands.find(matcher);
+      if (match) {
+        return match;
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new PublicApiError(
+          408,
+          "computer process did not become available before timeout",
+          "computer_process_timeout",
+          { computer_id: this.id, selector: selectorOrPredicate }
+        );
+      }
+      await delay(pollIntervalMs, options.signal);
+    }
+  }
+  async waitForFile(path, options = {}) {
+    const timeoutMs = options.timeoutMs ?? this.sdk.internalDefaultComputerStateTimeoutMs();
+    const pollIntervalMs = options.pollIntervalMs ?? this.sdk.internalDefaultPollIntervalMs();
+    const startedAt = Date.now();
+    while (true) {
+      let exists = false;
+      try {
+        await this.commands.run(
+          ["sh", "-lc", `test -e ${shellQuote(path)}`],
+          { signal: options.signal }
+        );
+        exists = true;
+      } catch (error) {
+        if (!(error instanceof CommandExitError)) {
+          throw error;
+        }
+        if (error.result.exitCode !== 1) {
+          throw error;
+        }
+      }
+      if (exists) {
+        return;
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new PublicApiError(
+          408,
+          `file ${path} did not appear before timeout`,
+          "computer_file_timeout",
+          { computer_id: this.id, path }
+        );
+      }
+      await delay(pollIntervalMs, options.signal);
+    }
+  }
+};
+var ExecTransportError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ExecTransportError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+  }
+};
+var UnsupportedCapabilityError = class extends Error {
+  capability;
+  availableCapabilities;
+  constructor(capability, availableCapabilities = []) {
+    super(`${capability} capability is not advertised by computer exec sessions`);
+    this.name = "UnsupportedCapabilityError";
+    this.capability = capability;
+    this.availableCapabilities = availableCapabilities;
+  }
+};
+var CommandExitError = class extends Error {
+  result;
+  constructor(result) {
+    super(result.error || `command exited with code ${result.exitCode}`);
+    this.name = "CommandExitError";
+    this.result = result;
+  }
+};
+var ExecGatewayConnection = class {
+  constructor(client, fetchImpl, computerId, session) {
+    this.client = client;
+    this.fetchImpl = fetchImpl;
+    this.computerId = computerId;
+    this.session = session;
+  }
+  client;
+  fetchImpl;
+  computerId;
+  session;
+  async close(signal) {
+    try {
+      await this.client.deleteAccessSession(this.computerId, this.session.id, signal);
+    } catch (error) {
+      if (error instanceof PublicApiError && (error.status === 404 || error.status === 410)) {
+        return;
+      }
+      throw error;
+    }
+  }
+  async requestJson(method, body, options = {}) {
+    const response = await this.request(method, body, {
+      accept: "application/json",
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+    return await response.json();
+  }
+  async openStream(method, body, options = {}) {
+    const response = await this.request(method, body, {
+      accept: "application/connect+json",
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs,
+      connectStream: true
+    });
+    if (!response.body) {
+      throw new ExecTransportError("exec gateway did not return a stream body");
+    }
+    return response.body.getReader();
+  }
+  endpoint(method) {
+    return `${this.session.connect_url.replace(/\/+$/, "")}/process.Process/${method}`;
+  }
+  authorizationHeader() {
+    if (!this.session.connect_token) {
+      throw new PublicApiError(
+        401,
+        "exec session does not include a connect token",
+        "missing_connect_token",
+        this.session
+      );
+    }
+    return `Bearer ${this.session.connect_token}`;
+  }
+  async request(method, body, options) {
+    const { signal, clear } = createTimedSignal(
+      options.signal,
+      options.requestTimeoutMs ?? DEFAULT_CONNECT_REQUEST_TIMEOUT_MS
+    );
+    try {
+      const headers = new Headers();
+      headers.set("authorization", this.authorizationHeader());
+      headers.set("accept", options.accept);
+      headers.set("content-type", "application/json");
+      if (options.connectStream) {
+        headers.set("connect-protocol-version", "1");
+      }
+      const response = await this.fetchImpl(this.endpoint(method), {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal
+      });
+      if (!response.ok) {
+        throw await responseToExecTransportError(response);
+      }
+      return response;
+    } finally {
+      clear();
+    }
+  }
+};
+var CommandHandle = class {
+  constructor(commands, gateway, reader, initialSelector, handlers = {}) {
+    this.commands = commands;
+    this.gateway = gateway;
+    this.reader = reader;
+    this.selector = initialSelector;
+    this.pidPromise = new Promise((resolve, reject) => {
+      this.pidResolve = resolve;
+      this.pidReject = reject;
+    });
+    if (typeof initialSelector === "number") {
+      this.resolvedPid = initialSelector;
+      this.pidResolve(initialSelector);
+    } else if (typeof initialSelector === "object" && "pid" in initialSelector) {
+      this.resolvedPid = initialSelector.pid;
+      this.pidResolve(initialSelector.pid);
+    }
+    this.resultPromise = this.consume(handlers);
+  }
+  commands;
+  gateway;
+  reader;
+  selector;
+  stdoutChunks = [];
+  stderrChunks = [];
+  pidPromise;
+  resultPromise;
+  pidResolve;
+  pidReject;
+  resolvedPid;
+  closed = false;
+  get pid() {
+    if (this.resolvedPid === void 0) {
+      throw new Error("command pid is not available yet");
+    }
+    return this.resolvedPid;
+  }
+  get stdout() {
+    return this.stdoutChunks.join("");
+  }
+  get stderr() {
+    return this.stderrChunks.join("");
+  }
+  async wait(options = {}) {
+    const result = await this.resultPromise;
+    if (options.rejectOnNonZero ?? true) {
+      assertSuccessfulCommand(result);
+    }
+    return result;
+  }
+  async disconnect() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.reader.cancel("disconnected").catch(() => void 0);
+    await this.gateway.close().catch(() => void 0);
+  }
+  async kill(signal = "SIGTERM", requestSignal) {
+    await this.commands.kill(this.currentSelector(), signal, requestSignal);
+  }
+  async sendStdin(data, requestSignal) {
+    await this.commands.sendStdin(this.currentSelector(), data, requestSignal);
+  }
+  async closeStdin(requestSignal) {
+    await this.commands.closeStdin(this.currentSelector(), requestSignal);
+  }
+  async awaitPid() {
+    return this.pidPromise;
+  }
+  currentSelector() {
+    if (this.resolvedPid !== void 0) {
+      return { pid: this.resolvedPid };
+    }
+    if (!this.selector) {
+      throw new ExecTransportError("command selector is not available until the process starts");
+    }
+    return this.selector;
+  }
+  async consume(handlers) {
+    try {
+      const result = await consumeProcessStream(this.reader, {
+        onStart: (pid) => {
+          this.resolvedPid = pid;
+          this.pidResolve(pid);
+        },
+        onStdout: (chunk, raw) => {
+          this.stdoutChunks.push(chunk);
+          handlers.onStdout?.(chunk, raw);
+        },
+        onStderr: (chunk, raw) => {
+          this.stderrChunks.push(chunk);
+          handlers.onStderr?.(chunk, raw);
+        }
+      });
+      if (this.resolvedPid === void 0) {
+        throw new ExecTransportError("command stream ended before pid was reported");
+      }
+      const commandResult = {
+        pid: this.resolvedPid,
+        tag: extractTag(this.selector),
+        stdout: this.stdout,
+        stderr: this.stderr,
+        exitCode: result.exitCode,
+        status: result.status,
+        error: result.error
+      };
+      handlers.onExit?.(commandResult);
+      return commandResult;
+    } catch (error) {
+      this.pidReject(error);
+      throw error;
+    } finally {
+      this.closed = true;
+      await this.gateway.close().catch(() => void 0);
+    }
+  }
+};
+var PtySession = class {
+  constructor(commands, gateway, reader, initialSelector, handlers = {}) {
+    this.commands = commands;
+    this.gateway = gateway;
+    this.reader = reader;
+    this.selector = initialSelector;
+    this.pidPromise = new Promise((resolve, reject) => {
+      this.pidResolve = resolve;
+      this.pidReject = reject;
+    });
+    if (typeof initialSelector === "number") {
+      this.resolvedPid = initialSelector;
+      this.pidResolve(initialSelector);
+    } else if (typeof initialSelector === "object" && "pid" in initialSelector) {
+      this.resolvedPid = initialSelector.pid;
+      this.pidResolve(initialSelector.pid);
+    }
+    this.resultPromise = this.consume(handlers);
+  }
+  commands;
+  gateway;
+  reader;
+  selector;
+  outputChunks = [];
+  pidPromise;
+  resultPromise;
+  pidResolve;
+  pidReject;
+  resolvedPid;
+  closed = false;
+  get pid() {
+    if (this.resolvedPid === void 0) {
+      throw new Error("pty pid is not available yet");
+    }
+    return this.resolvedPid;
+  }
+  get output() {
+    return this.outputChunks.join("");
+  }
+  async wait(options = {}) {
+    const result = await this.resultPromise;
+    if (options.rejectOnNonZero ?? true) {
+      assertSuccessfulCommand({
+        pid: result.pid,
+        tag: result.tag,
+        stdout: result.output,
+        stderr: "",
+        exitCode: result.exitCode,
+        status: result.status,
+        error: result.error
+      });
+    }
+    return result;
+  }
+  async sendInput(data, requestSignal) {
+    await this.commands.sendPtyInput(this.currentSelector(), data, requestSignal);
+  }
+  async resize(cols, rows, requestSignal) {
+    await this.commands.resizePty(this.currentSelector(), cols, rows, requestSignal);
+  }
+  async kill(signal = "SIGTERM", requestSignal) {
+    await this.commands.kill(this.currentSelector(), signal, requestSignal);
+  }
+  async disconnect() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    await this.reader.cancel("disconnected").catch(() => void 0);
+    await this.gateway.close().catch(() => void 0);
+  }
+  async awaitPid() {
+    return this.pidPromise;
+  }
+  currentSelector() {
+    if (this.resolvedPid !== void 0) {
+      return { pid: this.resolvedPid };
+    }
+    if (!this.selector) {
+      throw new ExecTransportError("pty selector is not available until the process starts");
+    }
+    return this.selector;
+  }
+  async consume(handlers) {
+    try {
+      const result = await consumeProcessStream(this.reader, {
+        onStart: (pid) => {
+          this.resolvedPid = pid;
+          this.pidResolve(pid);
+        },
+        onPty: (chunk, raw) => {
+          this.outputChunks.push(chunk);
+          handlers.onData?.(chunk, raw);
+        }
+      });
+      if (this.resolvedPid === void 0) {
+        throw new ExecTransportError("pty stream ended before pid was reported");
+      }
+      const ptyResult = {
+        pid: this.resolvedPid,
+        tag: extractTag(this.selector),
+        output: this.output,
+        exitCode: result.exitCode,
+        status: result.status,
+        error: result.error
+      };
+      handlers.onExit?.(ptyResult);
+      return ptyResult;
+    } catch (error) {
+      this.pidReject(error);
+      throw error;
+    } finally {
+      this.closed = true;
+      await this.gateway.close().catch(() => void 0);
+    }
+  }
+};
+var ComputerCommandsClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async run(command, options = {}) {
+    await this.computer.ensureRunning({ signal: options.signal });
+    const response = await this.computer.internalSdk().internalClient().execCommand(
+      this.computer.id,
+      {
+        command: normalizeCommand(command),
+        cwd: options.cwd,
+        env: options.env,
+        timeout_ms: options.timeoutMs,
+        user: options.user
+      },
+      options.signal
+    );
+    const result = commandResultFromExec(response);
+    assertSuccessfulCommand(result);
+    return result;
+  }
+  async start(command, options = {}) {
+    const gateway = await this.createGateway({
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+    const reader = await gateway.openStream(
+      "Start",
+      {
+        process: buildProcessConfig(command, options),
+        stdin: options.stdin ?? true,
+        tag: options.tag
+      },
+      options
+    );
+    const handle = new CommandHandle(
+      this,
+      gateway,
+      reader,
+      options.tag ? { tag: options.tag } : void 0,
+      options
+    );
+    await handle.awaitPid();
+    return handle;
+  }
+  async connect(selector, options = {}) {
+    const gateway = await this.createGateway({
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+    const reader = await gateway.openStream(
+      "Connect",
+      {
+        process: toProcessSelectorWire(selector)
+      },
+      options
+    );
+    const handle = new CommandHandle(this, gateway, reader, selector, options);
+    await handle.awaitPid();
+    return handle;
+  }
+  async list(signal) {
+    const gateway = await this.createGateway({ signal });
+    try {
+      const response = await gateway.requestJson("List", {}, { signal });
+      return (response.processes ?? []).map((process) => ({
+        pid: process.pid ?? 0,
+        tag: process.tag,
+        cmd: process.config?.cmd ?? "",
+        args: process.config?.args ?? [],
+        envs: process.config?.envs ?? {},
+        cwd: process.config?.cwd
+      }));
+    } finally {
+      await gateway.close(signal).catch(() => void 0);
+    }
+  }
+  async sendStdin(selector, data, signal) {
+    await this.sendProcessInput(selector, { stdin: bytesToBase64(encodeData(data)) }, signal);
+  }
+  async sendPtyInput(selector, data, signal) {
+    await this.sendProcessInput(selector, { pty: bytesToBase64(encodeData(data)) }, signal);
+  }
+  async closeStdin(selector, signal) {
+    const gateway = await this.createGateway({ signal });
+    try {
+      await gateway.requestJson("CloseStdin", { process: toProcessSelectorWire(selector) }, { signal });
+    } finally {
+      await gateway.close(signal).catch(() => void 0);
+    }
+  }
+  async kill(selector, signalName = "SIGTERM", signal) {
+    const gateway = await this.createGateway({ signal });
+    try {
+      await gateway.requestJson(
+        "SendSignal",
+        {
+          process: toProcessSelectorWire(selector),
+          signal: signalName === "SIGKILL" ? "SIGNAL_SIGKILL" : "SIGNAL_SIGTERM"
+        },
+        { signal }
+      );
+    } finally {
+      await gateway.close(signal).catch(() => void 0);
+    }
+  }
+  async resizePty(selector, cols, rows, signal) {
+    const gateway = await this.createGateway({ signal });
+    try {
+      await gateway.requestJson(
+        "Update",
+        {
+          process: toProcessSelectorWire(selector),
+          pty: { size: { cols, rows } }
+        },
+        { signal }
+      );
+    } finally {
+      await gateway.close(signal).catch(() => void 0);
+    }
+  }
+  async sendProcessInput(selector, input, signal) {
+    const gateway = await this.createGateway({ signal });
+    try {
+      await gateway.requestJson(
+        "SendInput",
+        {
+          process: toProcessSelectorWire(selector),
+          input
+        },
+        { signal }
+      );
+    } finally {
+      await gateway.close(signal).catch(() => void 0);
+    }
+  }
+  /** @internal */
+  async createGateway(options) {
+    await this.computer.ensureRunning({ signal: options.signal });
+    const response = await this.computer.internalSdk().internalClient().createAccessSession(
+      this.computer.id,
+      { kind: "exec" },
+      options.signal
+    );
+    return new ExecGatewayConnection(
+      this.computer.internalSdk().internalClient(),
+      this.computer.internalSdk().internalFetch(),
+      this.computer.id,
+      response.session
+    );
+  }
+};
+var ComputerPtyClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async create(options = {}) {
+    return this.start(["sh"], options);
+  }
+  async start(command, options = {}) {
+    const gateway = await this.computer.commands.createGateway({
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+    const reader = await gateway.openStream(
+      "Start",
+      {
+        process: buildProcessConfig(command, options),
+        pty: {
+          size: {
+            cols: options.cols ?? 80,
+            rows: options.rows ?? 24
+          }
+        }
+      },
+      options
+    );
+    const session = new PtySession(
+      this.computer.commands,
+      gateway,
+      reader,
+      options.tag ? { tag: options.tag } : void 0,
+      options
+    );
+    await session.awaitPid();
+    return session;
+  }
+  async attach(selector, options = {}) {
+    return this.connect(selector, options);
+  }
+  async connect(selector, options = {}) {
+    const gateway = await this.computer.commands.createGateway({
+      signal: options.signal,
+      requestTimeoutMs: options.requestTimeoutMs
+    });
+    const reader = await gateway.openStream(
+      "Connect",
+      { process: toProcessSelectorWire(selector) },
+      options
+    );
+    const session = new PtySession(this.computer.commands, gateway, reader, selector, options);
+    await session.awaitPid();
+    return session;
+  }
+};
+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 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 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 }
+    });
+  }
+};
+var ComputerGitClient = class {
+  constructor(computer) {
+    this.computer = computer;
+    void computer;
+  }
+  computer;
+  async status(signal) {
+    await this.computer.requireCapability("git", signal);
+    throw new ExecTransportError("git capability is advertised but the SDK git transport is not implemented yet", {
+      code: "git_transport_unimplemented",
+      details: { computerId: this.computer.id }
+    });
+  }
+  async clone(repoUrl, signal) {
+    await this.computer.requireCapability("git", signal);
+    throw new ExecTransportError("git capability is advertised but the SDK git transport is not implemented yet", {
+      code: "git_transport_unimplemented",
+      details: { computerId: this.computer.id, repoUrl }
+    });
+  }
+  async pull(signal) {
+    await this.computer.requireCapability("git", signal);
+    throw new ExecTransportError("git capability is advertised but the SDK git transport is not implemented yet", {
+      code: "git_transport_unimplemented",
+      details: { computerId: this.computer.id }
+    });
+  }
+};
+var ComputerPortsClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async list(signal) {
+    const response = await this.computer.internalSdk().internalClient().listPublishedPorts(
+      this.computer.id,
+      signal
+    );
+    return response.ports;
+  }
+  async publish(options) {
+    const response = await this.computer.internalSdk().internalClient().createPublishedPort(
+      this.computer.id,
+      {
+        port: options.port,
+        name: options.name
+      },
+      options.signal
+    );
+    await waitForOperationIfPresent(this.computer.internalSdk(), response.operation, options.signal);
+    return response.port;
+  }
+  async delete(port, signal) {
+    const response = await this.computer.internalSdk().internalClient().deletePublishedPort(
+      this.computer.id,
+      port,
+      signal
+    );
+    await waitForOperationIfPresent(this.computer.internalSdk(), response.operation, signal);
+    return response.port;
+  }
+};
+var ComputerSharesClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async list(signal) {
+    const response = await this.computer.internalSdk().internalClient().listShares(
+      this.computer.id,
+      signal
+    );
+    return response.shares;
+  }
+  async createLink(options = {}) {
+    const response = await this.computer.internalSdk().internalClient().createLinkShare(
+      this.computer.id,
+      {
+        expires_at: options.expiresAt,
+        allow_browser: options.allowBrowser,
+        allow_vnc: options.allowVnc
+      },
+      options.signal
+    );
+    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);
+  }
+};
+var ComputerSnapshotsClient = class {
+  constructor(computer) {
+    this.computer = computer;
+  }
+  computer;
+  async list(signal) {
+    const response = await this.computer.internalSdk().internalClient().listSnapshots(
+      this.computer.id,
+      signal
+    );
+    return response.snapshots;
+  }
+  async create(signal) {
+    const response = await this.computer.internalSdk().internalClient().createSnapshot(
+      this.computer.id,
+      signal
+    );
+    await waitForOperationIfPresent(this.computer.internalSdk(), response.operation, signal);
+    const snapshot = await this.computer.internalSdk().internalClient().getSnapshot(
+      response.snapshot.id,
+      signal
+    );
+    return snapshot.snapshot;
+  }
+};
+var SnapshotsClient = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async get(snapshotId, signal) {
+    const response = await this.sdk.internalClient().getSnapshot(snapshotId, signal);
+    return response.snapshot;
+  }
+  async delete(snapshotId, signal) {
+    const response = await this.sdk.internalClient().deleteSnapshot(snapshotId, signal);
+    await waitForOperationIfPresent(this.sdk, response.operation, signal);
+    return response.snapshot;
+  }
+  async restore(snapshotId, options = {}) {
+    const response = await this.sdk.internalClient().restoreSnapshot(
+      snapshotId,
+      {
+        handle: options.handle,
+        display_name: options.displayName,
+        guest: options.authorizedKeys && options.authorizedKeys.length > 0 ? { authorized_keys: options.authorizedKeys } : void 0
+      },
+      options.signal
+    );
+    await waitForOperationIfPresent(this.sdk, response.operation, options.signal);
+    return new Computer(this.sdk, response.computer);
+  }
+};
+var SSHKeysClient = class {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  sdk;
+  async list(signal) {
+    const response = await this.sdk.internalClient().listSSHKeys(signal);
+    return response.ssh_keys;
+  }
+  async create(body, signal) {
+    const response = await this.sdk.internalClient().createSSHKey(body, signal);
+    return response.ssh_key;
+  }
+  async delete(sshKeyId, signal) {
+    await this.sdk.internalClient().deleteSSHKey(sshKeyId, signal);
+  }
+};
+function normalizeCommand(command) {
+  if (typeof command === "string") {
+    const trimmed = command.trim();
+    if (!trimmed) {
+      throw new Error("command must not be empty");
+    }
+    return ["sh", "-lc", trimmed];
+  }
+  if (command.length === 0) {
+    throw new Error("command must not be empty");
+  }
+  return [...command];
+}
+function buildProcessConfig(command, options) {
+  if (options.user) {
+    throw new ExecTransportError("exec gateway processes do not yet support user overrides");
+  }
+  const [cmd, ...args] = normalizeCommand(command);
+  return {
+    cmd,
+    args,
+    cwd: options.cwd,
+    envs: options.env
+  };
+}
+async function waitForOperationIfPresent(sdk, operation, signal) {
+  if (!operation?.id) {
+    return;
+  }
+  await sdk.waitForOperation(operation.id, { signal });
+}
+function commandResultFromExec(response) {
+  return {
+    pid: 0,
+    stdout: response.stdout,
+    stderr: response.stderr,
+    exitCode: response.exit_code,
+    status: response.exit_code === 0 ? "exited" : "failed"
+  };
+}
+function assertSuccessfulCommand(result) {
+  if (result.exitCode !== 0) {
+    throw new CommandExitError(result);
+  }
+}
+function toProcessSelectorWire(selector) {
+  if (typeof selector === "number") {
+    return { pid: selector };
+  }
+  if (typeof selector === "string") {
+    return { tag: selector };
+  }
+  if ("pid" in selector) {
+    return { pid: selector.pid };
+  }
+  return { tag: selector.tag };
+}
+function matchesCommandSelector(command, selector) {
+  if (typeof selector === "number") {
+    return command.pid === selector;
+  }
+  if (typeof selector === "string") {
+    return command.tag === selector;
+  }
+  if ("pid" in selector) {
+    return command.pid === selector.pid;
+  }
+  return command.tag === selector.tag;
+}
+function extractTag(selector) {
+  if (typeof selector === "string") {
+    return selector;
+  }
+  if (typeof selector === "object" && "tag" in selector) {
+    return selector.tag;
+  }
+  return void 0;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function encodeData(data) {
+  return typeof data === "string" ? new TextEncoder().encode(data) : data;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function base64ToBytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function createTimedSignal(parentSignal, timeoutMs) {
+  if (!parentSignal && (!timeoutMs || timeoutMs <= 0)) {
+    return { signal: void 0, clear: () => {
+    } };
+  }
+  const controller = new AbortController();
+  let timer;
+  const abortFromParent = () => {
+    controller.abort(parentSignal?.reason);
+  };
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      controller.abort(parentSignal.reason);
+    } else {
+      parentSignal.addEventListener("abort", abortFromParent, { once: true });
+    }
+  }
+  if (timeoutMs && timeoutMs > 0) {
+    timer = setTimeout(() => {
+      controller.abort(new DOMException("Timed out", "TimeoutError"));
+    }, timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    clear: () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      if (parentSignal) {
+        parentSignal.removeEventListener("abort", abortFromParent);
+      }
+    }
+  };
+}
+async function consumeProcessStream(reader, handlers) {
+  let buffered = new Uint8Array(0);
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    buffered = concatBytes(buffered, value);
+    while (buffered.length >= 5) {
+      const flags = buffered[0];
+      const messageLength = buffered[1] << 24 >>> 0 | buffered[2] << 16 | buffered[3] << 8 | buffered[4];
+      const frameLength = 5 + messageLength;
+      if (buffered.length < frameLength) {
+        break;
+      }
+      const payload = buffered.slice(5, frameLength);
+      buffered = buffered.slice(frameLength);
+      if (flags & 1) {
+        throw new ExecTransportError("compressed connect stream messages are not supported");
+      }
+      const text = new TextDecoder().decode(payload);
+      const message = text ? JSON.parse(text) : {};
+      if (flags & 2) {
+        const endError = typeof message === "object" && message !== null ? message.error : void 0;
+        if (endError?.message) {
+          throw new ExecTransportError(endError.message, {
+            code: endError.code,
+            details: endError.details
+          });
+        }
+        continue;
+      }
+      const event = message.event;
+      if (!event) {
+        continue;
+      }
+      if (event.start?.pid !== void 0) {
+        handlers.onStart?.(event.start.pid);
+        continue;
+      }
+      if (event.data?.stdout) {
+        const raw = base64ToBytes(event.data.stdout);
+        handlers.onStdout?.(new TextDecoder().decode(raw), raw);
+        continue;
+      }
+      if (event.data?.stderr) {
+        const raw = base64ToBytes(event.data.stderr);
+        handlers.onStderr?.(new TextDecoder().decode(raw), raw);
+        continue;
+      }
+      if (event.data?.pty) {
+        const raw = base64ToBytes(event.data.pty);
+        handlers.onPty?.(new TextDecoder().decode(raw), raw);
+        continue;
+      }
+      if (event.end) {
+        return {
+          exitCode: event.end.exitCode ?? event.end.exit_code ?? 0,
+          status: event.end.status || "exited",
+          error: event.end.error
+        };
+      }
+    }
+  }
+  throw new ExecTransportError("exec stream ended without a process end event");
+}
+function concatBytes(left, right) {
+  const merged = new Uint8Array(left.length + right.length);
+  merged.set(left);
+  merged.set(right, left.length);
+  return merged;
+}
+async function responseToExecTransportError(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    try {
+      const payload = await response.json();
+      const nestedError = typeof payload === "object" && payload !== null && "error" in payload ? payload.error : void 0;
+      const code = nestedError?.code || (typeof payload === "object" && payload !== null && "code" in payload ? payload.code : void 0);
+      const message = nestedError?.message || (typeof payload === "object" && payload !== null && "message" in payload ? payload.message : response.statusText || "exec request failed");
+      const details = nestedError?.details ?? payload;
+      return new ExecTransportError(message || "exec request failed", {
+        status: response.status,
+        code,
+        details
+      });
+    } catch (error) {
+      return new ExecTransportError(response.statusText || "exec request failed", {
+        status: response.status,
+        details: error
+      });
+    }
+  }
+  const body = await response.text().catch(() => "");
+  return new ExecTransportError(body || response.statusText || "exec request failed", {
+    status: response.status
+  });
+}
+export {
+  AgentComputer,
+  CommandExitError,
+  CommandHandle,
+  Computer,
+  ComputerCommandsClient,
+  ComputerFilesClient,
+  ComputerGitClient,
+  ComputerImagesClient,
+  ComputerPortsClient,
+  ComputerPtyClient,
+  ComputerSharesClient,
+  ComputerSnapshotsClient,
+  ComputersClient,
+  ExecTransportError,
+  PtySession,
+  PublicApiError,
+  SSHKeysClient,
+  SnapshotsClient,
+  UnsupportedCapabilityError
+};