@finalai/computers 0.1.0

package/dist/modules/client.mjs

@@ -0,0 +1,764 @@
+import * as z from "zod";
+import { computerBrowserAccessRequestSchema, computerBrowserAccessSchema } from "./browser-access.mjs";
+import { computerSnapshotRequestSchema, computerSnapshotResponseSchema } from "./file-snapshots.mjs";
+import { normalizeComputerBase, normalizeComputerImage, normalizeComputerInfo } from "./normalize.mjs";
+import { err, ok } from "./result.mjs";
+import { jsonObjectSchema } from "./json.mjs";
+import { computerScreenSessionSchema } from "./screen.mjs";
+import { createTransport } from "./transport.mjs";
+import {
+  ComputerState,
+  ComputerTokenScope
+} from "./types.mjs";
+const computerFromResponse = (data) => {
+  const response = jsonObjectSchema.safeParse(data);
+  if (!response.success) return null;
+  return normalizeComputerInfo(response.data.computer ?? response.data.vm ?? null);
+};
+const toBase64 = (data) => (data instanceof Uint8Array ? Buffer.from(data) : Buffer.from(data, "utf8")).toString("base64");
+const processStateSchema = z.union([z.literal("running"), z.literal("exited")]);
+const computerProcessSchema = z.object({
+  id: z.string(),
+  bootId: z.string(),
+  command: z.string(),
+  leaderPid: z.number().nullable().default(null),
+  state: processStateSchema,
+  keepsAwake: z.boolean().default(false),
+  createdAtMs: z.number().default(0),
+  updatedAtMs: z.number().default(0),
+  endedAtMs: z.number().nullable().default(null),
+  cpuUsec: z.number().default(0),
+  memoryBytes: z.number().default(0),
+  memoryPeakBytes: z.number().default(0),
+  ioReadBytes: z.number().default(0),
+  ioWriteBytes: z.number().default(0),
+  processCount: z.number().default(0),
+  descendantCount: z.number().optional()
+});
+const processesResponseSchema = z.object({ processes: z.array(computerProcessSchema) });
+const managedProcessSchema = z.object({
+  id: z.string(),
+  bootId: z.string(),
+  pid: z.number().nullable(),
+  state: processStateSchema
+});
+const execResponseSchema = managedProcessSchema.extend({
+  pid: z.number(),
+  state: z.literal("running")
+});
+const outputChunkSchema = z.object({
+  dataB64: z.string(),
+  offset: z.number(),
+  nextOffset: z.number(),
+  eof: z.boolean()
+});
+const processOutputResponseSchema = z.object({
+  stdout: outputChunkSchema,
+  stderr: outputChunkSchema,
+  state: processStateSchema,
+  result: z.object({ exitCode: z.number().nullable(), signal: z.string().nullable() }).nullable()
+});
+const runResponseSchema = processOutputResponseSchema.extend({
+  id: z.string(),
+  bootId: z.string(),
+  pid: z.number(),
+  timedOut: z.boolean(),
+  elapsedMs: z.number()
+});
+const okResponseSchema = z.object({ ok: z.literal(true) });
+const fileReadResponseSchema = z.object({
+  dataB64: z.string(),
+  eof: z.boolean(),
+  offset: z.number().optional()
+});
+const FILE_TRANSFER_CHUNK_BYTES = 1024 * 1024;
+const fileWriteResponseSchema = z.object({ bytesWritten: z.number() });
+const decodeResult = (result, schema, errorMessage) => {
+  if (!result.ok) return result;
+  const parsed = schema.safeParse(result.data);
+  return parsed.success ? ok(parsed.data) : err(errorMessage);
+};
+const resourcePath = () => "/computers";
+const tokenResponseSchema = z.object({ id: z.string(), token: z.string() });
+const PREVIEW_TOKEN_LIFETIME_MS = 60 * 6e4;
+const mintToken = async (transport, opts) => {
+  const body = { name: opts.name };
+  if (opts.scopes != null) body.scopes = opts.scopes;
+  if (opts.expiresAt != null) body.expiresAt = opts.expiresAt.toISOString();
+  if (opts.computerId != null) body.computerId = opts.computerId;
+  return decodeResult(
+    await transport.request({ method: "POST", path: "/tokens", jsonBody: body }),
+    tokenResponseSchema,
+    "unexpected token response shape"
+  );
+};
+const createComputerHandle = (transport, initialInfo) => {
+  let info = initialInfo;
+  const computerPath = `${resourcePath()}/${encodeURIComponent(info.id)}`;
+  const updateFromComputerResponse = (result) => {
+    if (!result.ok) {
+      return result;
+    }
+    const computer = computerFromResponse(result.data);
+    if (computer == null) {
+      return err("unexpected computer response shape");
+    }
+    info = computer;
+    return ok(computer);
+  };
+  const action = async (name) => updateFromComputerResponse(
+    await transport.request({ method: "POST", path: `${computerPath}/actions/${name}` })
+  );
+  const processHandle = (process) => {
+    const path = `${computerPath}/processes/${encodeURIComponent(process.id)}`;
+    let stdoutOffset = 0;
+    let stderrOffset = 0;
+    const readOutput = async (stream, opts = {}) => {
+      const offset = opts.offset ?? (stream === "stdout" ? stdoutOffset : stderrOffset);
+      const result = await transport.request({
+        method: "GET",
+        path: `${path}/output`,
+        query: {
+          bootId: process.bootId,
+          stdoutOffset: String(stream === "stdout" ? offset : 0),
+          stderrOffset: String(stream === "stderr" ? offset : 0),
+          waitMs: String(opts.waitMs ?? 0)
+        }
+      });
+      const parsed = decodeResult(
+        result,
+        processOutputResponseSchema,
+        "unexpected process output response shape"
+      );
+      if (!parsed.ok) return parsed;
+      const chunk = parsed.data[stream];
+      if (opts.offset == null) {
+        if (stream === "stdout") stdoutOffset = chunk.nextOffset;
+        else stderrOffset = chunk.nextOffset;
+      }
+      const state = parsed.data.state;
+      handle.state = state;
+      const dataBytes = Buffer.from(chunk.dataB64, "base64");
+      return ok({
+        data: dataBytes.toString("utf8"),
+        dataBytes,
+        offset: chunk.offset,
+        nextOffset: chunk.nextOffset,
+        eof: chunk.eof,
+        state
+      });
+    };
+    const readBothOutputs = async (opts) => {
+      const parsed = decodeResult(
+        await transport.request({
+          method: "GET",
+          path: `${path}/output`,
+          query: {
+            bootId: process.bootId,
+            stdoutOffset: String(opts.stdoutOffset),
+            stderrOffset: String(opts.stderrOffset),
+            waitMs: String(opts.waitMs ?? 0)
+          }
+        }),
+        processOutputResponseSchema,
+        "unexpected process output response shape"
+      );
+      if (!parsed.ok) return parsed;
+      const state = parsed.data.state;
+      handle.state = state;
+      const chunkFor = (stream) => {
+        const chunk = parsed.data[stream];
+        const dataBytes = Buffer.from(chunk.dataB64, "base64");
+        return {
+          data: dataBytes.toString("utf8"),
+          dataBytes,
+          offset: chunk.offset,
+          nextOffset: chunk.nextOffset,
+          eof: chunk.eof,
+          state
+        };
+      };
+      return ok({
+        stdout: chunkFor("stdout"),
+        stderr: chunkFor("stderr"),
+        state,
+        result: parsed.data.result
+      });
+    };
+    const input = async (body) => decodeResult(
+      await transport.request({
+        method: "POST",
+        path: `${path}/input`,
+        jsonBody: { bootId: process.bootId, ...body }
+      }),
+      okResponseSchema,
+      "unexpected process input response shape"
+    );
+    const handle = {
+      id: process.id,
+      bootId: process.bootId,
+      pid: process.pid,
+      state: process.state,
+      readOutput: readBothOutputs,
+      stdout: { read: (opts) => readOutput("stdout", opts) },
+      stderr: { read: (opts) => readOutput("stderr", opts) },
+      wait: async (opts = {}) => {
+        const deadline = opts.timeoutMs == null ? Number.POSITIVE_INFINITY : Date.now() + opts.timeoutMs;
+        let waitStdoutOffset = stdoutOffset;
+        let waitStderrOffset = stderrOffset;
+        while (true) {
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) return err(`wait timed out after ${opts.timeoutMs}ms`, 504);
+          const result = await transport.request({
+            method: "GET",
+            path: `${path}/output`,
+            query: {
+              bootId: process.bootId,
+              stdoutOffset: String(waitStdoutOffset),
+              stderrOffset: String(waitStderrOffset),
+              waitMs: String(Math.min(3e4, remaining))
+            }
+          });
+          const parsed = decodeResult(
+            result,
+            processOutputResponseSchema,
+            "unexpected process wait response shape"
+          );
+          if (!parsed.ok) return parsed;
+          waitStdoutOffset = parsed.data.stdout.nextOffset;
+          waitStderrOffset = parsed.data.stderr.nextOffset;
+          if (parsed.data.state === "exited") {
+            handle.state = "exited";
+            return ok(parsed.data.result ?? { exitCode: null, signal: null });
+          }
+        }
+      },
+      write: (data) => input({ dataB64: toBase64(data) }),
+      eof: () => input({ eof: true }),
+      resize: (cols, rows) => input({ cols, rows }),
+      signal: (signal) => input({ signal }),
+      terminate: async () => decodeResult(
+        await transport.request({
+          method: "POST",
+          path: `${path}/terminate`,
+          jsonBody: { bootId: process.bootId }
+        }),
+        okResponseSchema,
+        "unexpected process terminate response shape"
+      )
+    };
+    return handle;
+  };
+  const readFileBuffer = async (path, options) => {
+    const chunks = [];
+    let offset = 0;
+    for (; ; ) {
+      const query = {
+        path,
+        offset: String(offset),
+        length: String(FILE_TRANSFER_CHUNK_BYTES)
+      };
+      if (options?.autoResume != null) query.autoResume = String(options.autoResume);
+      const result = await transport.request({
+        method: "GET",
+        path: `${computerPath}/files`,
+        query
+      });
+      if (!result.ok) {
+        return result;
+      }
+      const parsed = fileReadResponseSchema.safeParse(result.data);
+      if (!parsed.success) {
+        return err("unexpected file read response shape");
+      }
+      if (offset > 0 && parsed.data.offset !== offset) {
+        return err("Server does not support ranged file reads; partial contents refused");
+      }
+      const chunk = Buffer.from(parsed.data.dataB64, "base64");
+      chunks.push(chunk);
+      if (parsed.data.eof) {
+        return ok(Buffer.concat(chunks));
+      }
+      if (chunk.length === 0) {
+        return err("File read made no progress before the end of the file");
+      }
+      offset += chunk.length;
+    }
+  };
+  const exec = async (command, opts) => {
+    const result = await transport.request({
+      method: "POST",
+      path: `${computerPath}/exec`,
+      jsonBody: {
+        command,
+        env: opts.env,
+        cwd: opts.cwd,
+        user: opts.user,
+        pty: opts.pty,
+        cols: opts.cols,
+        rows: opts.rows,
+        timeoutMs: opts.timeoutMs,
+        autoResume: opts.autoResume
+      }
+    });
+    if (!result.ok) return result;
+    const parsed = execResponseSchema.safeParse(result.data);
+    return parsed.success ? ok(processHandle(parsed.data)) : err("unexpected exec response shape");
+  };
+  const run = async (command, opts) => {
+    const parsed = decodeResult(
+      await transport.request({
+        method: "POST",
+        path: `${computerPath}/run`,
+        jsonBody: {
+          command,
+          env: opts.env,
+          cwd: opts.cwd,
+          user: opts.user,
+          timeoutMs: opts.timeoutMs,
+          autoResume: opts.autoResume,
+          waitMs: opts.waitMs,
+          readyTimeoutMs: opts.readyTimeoutMs
+        }
+      }),
+      runResponseSchema,
+      "unexpected run response shape"
+    );
+    if (!parsed.ok) return parsed;
+    const { id, bootId, pid, state, result, timedOut, elapsedMs } = parsed.data;
+    const chunkFor = (stream) => {
+      const chunk = parsed.data[stream];
+      const dataBytes = Buffer.from(chunk.dataB64, "base64");
+      return {
+        data: dataBytes.toString("utf8"),
+        dataBytes,
+        offset: chunk.offset,
+        nextOffset: chunk.nextOffset,
+        eof: chunk.eof,
+        state
+      };
+    };
+    return ok({
+      process: processHandle({ id, bootId, pid, state }),
+      output: { stdout: chunkFor("stdout"), stderr: chunkFor("stderr"), state, result },
+      timedOut,
+      elapsedMs
+    });
+  };
+  return {
+    screen: {
+      status: async () => {
+        const result = await transport.request({ method: "GET", path: `${computerPath}/screen` });
+        if (!result.ok) return result;
+        const parsed = z.object({ available: z.boolean() }).safeParse(result.data);
+        return parsed.success ? ok(parsed.data) : err("unexpected screen status response");
+      },
+      open: async (options) => {
+        const result = await transport.request({
+          method: "POST",
+          path: `${computerPath}/screen`,
+          jsonBody: options ?? {}
+        });
+        if (!result.ok) return result;
+        const parsed = computerScreenSessionSchema.safeParse(result.data);
+        return parsed.success ? ok(parsed.data) : err("unexpected screen session response");
+      }
+    },
+    computerUse: {
+      status: async () => {
+        const result = await transport.request({
+          method: "GET",
+          path: `${computerPath}/computer-use`
+        });
+        if (!result.ok) return result;
+        const parsed = z.object({ available: z.boolean(), installed: z.boolean().optional() }).safeParse(result.data);
+        return parsed.success ? ok({
+          available: parsed.data.available,
+          installed: parsed.data.installed ?? parsed.data.available
+        }) : err("unexpected computer-use capability response shape");
+      },
+      available: async () => {
+        const result = await transport.request({
+          method: "GET",
+          path: `${computerPath}/computer-use`
+        });
+        if (!result.ok) return result;
+        const parsed = z.object({ available: z.boolean() }).safeParse(result.data);
+        return parsed.success ? ok(parsed.data.available) : err("unexpected computer-use capability response shape");
+      },
+      open: async (options = {}) => {
+        const result = await transport.request({
+          method: "POST",
+          path: `${computerPath}/computer-use`,
+          jsonBody: {
+            cwd: options.cwd,
+            readyTimeoutMs: options.readyTimeoutMs
+          }
+        });
+        if (!result.ok) return result;
+        const parsed = execResponseSchema.safeParse(result.data);
+        return parsed.success ? ok(processHandle(parsed.data)) : err("unexpected computer-use process response shape");
+      }
+    },
+    id: info.id,
+    name: info.name,
+    getInfo: () => info,
+    refresh: async () => updateFromComputerResponse(await transport.request({ method: "GET", path: computerPath })),
+    refreshActivity: () => action("refresh-activity"),
+    exec: (command, opts = {}) => exec(command, opts),
+    run: (command, opts = {}) => run(command, opts),
+    processes: {
+      list: async () => {
+        const result = await transport.request({
+          method: "GET",
+          path: `${computerPath}/processes`
+        });
+        if (!result.ok) {
+          return result;
+        }
+        const processes = processesResponseSchema.safeParse(result.data);
+        if (!processes.success) {
+          return err("unexpected processes response shape");
+        }
+        return ok(processes.data.processes);
+      },
+      get: async (id, bootId) => {
+        const result = await transport.request({
+          method: "GET",
+          path: `${computerPath}/processes/${encodeURIComponent(id)}`,
+          query: { bootId }
+        });
+        if (!result.ok) return result;
+        const process = z.object({ process: computerProcessSchema }).safeParse(result.data);
+        if (!process.success) return err("unexpected process response shape");
+        return ok(
+          processHandle({
+            id: process.data.process.id,
+            bootId: process.data.process.bootId,
+            pid: process.data.process.leaderPid,
+            state: process.data.process.state
+          })
+        );
+      }
+    },
+    browserAccess: {
+      open: async (options) => {
+        const input = computerBrowserAccessRequestSchema.safeParse(options);
+        if (!input.success) return err("invalid browser access request");
+        return decodeResult(
+          await transport.request({
+            method: "POST",
+            path: `${computerPath}/browser-access`,
+            jsonBody: input.data
+          }),
+          computerBrowserAccessSchema,
+          "unexpected browser access response"
+        );
+      },
+      close: async (tokenId) => decodeResult(
+        await transport.request({
+          method: "DELETE",
+          path: `${computerPath}/browser-access/${encodeURIComponent(tokenId)}`
+        }),
+        okResponseSchema,
+        "unexpected browser access close response"
+      )
+    },
+    files: {
+      snapshot: async (request) => {
+        const parsed = computerSnapshotRequestSchema.safeParse(request);
+        if (!parsed.success) return err("invalid file snapshot request");
+        return decodeResult(
+          await transport.request({
+            method: "POST",
+            path: `${computerPath}/file-snapshots/read`,
+            jsonBody: parsed.data
+          }),
+          computerSnapshotResponseSchema,
+          "unexpected file snapshot response"
+        );
+      },
+      read: async (path, options) => {
+        const result = await readFileBuffer(path, options);
+        return result.ok ? ok(result.data.toString("utf8")) : result;
+      },
+      readBytes: async (path, options) => {
+        const result = await readFileBuffer(path, options);
+        return result.ok ? ok(new Uint8Array(result.data)) : result;
+      },
+      write: async (path, data) => {
+        const bytes = data instanceof Uint8Array ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : Buffer.from(data, "utf8");
+        let bytesWritten = 0;
+        for (let offset = 0; offset === 0 || offset < bytes.length; offset += FILE_TRANSFER_CHUNK_BYTES) {
+          const body = {
+            path,
+            dataB64: bytes.subarray(offset, offset + FILE_TRANSFER_CHUNK_BYTES).toString("base64")
+          };
+          if (offset > 0) body.append = true;
+          const result = await transport.request({
+            method: "PUT",
+            path: `${computerPath}/files`,
+            jsonBody: body
+          });
+          if (!result.ok) {
+            return result;
+          }
+          const parsed = fileWriteResponseSchema.safeParse(result.data);
+          if (!parsed.success) {
+            return err("unexpected file write response shape");
+          }
+          bytesWritten += parsed.data.bytesWritten;
+        }
+        return ok({ bytesWritten });
+      }
+    },
+    getHost: (port) => {
+      if (info.hostname == null) {
+        return null;
+      }
+      return port === 443 ? info.hostname : `${info.hostname}:${port}`;
+    },
+    createPreviewToken: (opts = {}) => mintToken(transport, {
+      name: opts.name ?? `preview ${info.name}`,
+      computerId: info.id,
+      scopes: [ComputerTokenScope.Http],
+      expiresAt: opts.expiresAt ?? new Date(Date.now() + PREVIEW_TOKEN_LIFETIME_MS)
+    }),
+    pause: () => action("pause"),
+    resume: () => action("resume"),
+    start: () => action("start"),
+    stop: () => action("stop"),
+    restart: () => action("restart"),
+    kill: () => action("delete"),
+    settings: async (patch) => updateFromComputerResponse(
+      await transport.request({ method: "PATCH", path: computerPath, jsonBody: patch })
+    )
+  };
+};
+const createComputerClientWithTransport = (transport) => {
+  const baseResourcePath = resourcePath();
+  const getComputer = async (idOrName) => {
+    const result = await transport.request({
+      method: "GET",
+      path: `${baseResourcePath}/${encodeURIComponent(idOrName)}`
+    });
+    if (!result.ok) {
+      return result;
+    }
+    const computer = computerFromResponse(result.data);
+    if (computer == null) {
+      return err("unexpected computer response shape");
+    }
+    return ok(computer);
+  };
+  const createComputer = async (opts) => {
+    const { idempotencyKey, ...body } = opts;
+    const result = await transport.request({
+      method: "POST",
+      path: baseResourcePath,
+      jsonBody: body,
+      headers: idempotencyKey == null ? void 0 : { "idempotency-key": idempotencyKey }
+    });
+    if (!result.ok) {
+      return result;
+    }
+    const computer = computerFromResponse(result.data);
+    if (computer == null) {
+      return err("unexpected computer response shape");
+    }
+    return ok(createComputerHandle(transport, computer));
+  };
+  const connectComputer = async (target) => {
+    const idOrName = "id" in target ? target.id : target.name;
+    const fetched = await getComputer(idOrName);
+    if (!fetched.ok) {
+      return fetched;
+    }
+    let computer = fetched.data;
+    if (target.resumeIfNeeded !== false && (computer.state === ComputerState.Paused || computer.state === ComputerState.Stopped || computer.state === ComputerState.Shelved)) {
+      const resumed = await transport.request({
+        method: "POST",
+        path: `${baseResourcePath}/${encodeURIComponent(computer.id)}/actions/resume`
+      });
+      if (!resumed.ok) {
+        return resumed;
+      }
+      const resumedComputer = computerFromResponse(resumed.data);
+      if (resumedComputer != null) {
+        computer = resumedComputer;
+      }
+    }
+    return ok(createComputerHandle(transport, computer));
+  };
+  const listComputers = async () => {
+    const result = await transport.request({ method: "GET", path: baseResourcePath });
+    if (!result.ok) {
+      return result;
+    }
+    const response = jsonObjectSchema.safeParse(result.data);
+    if (!response.success) {
+      return err("unexpected computer list response shape");
+    }
+    const rawComputers = response.data.computers ?? response.data.vms;
+    if (!Array.isArray(rawComputers)) {
+      return err("unexpected computer list response shape");
+    }
+    const computers = [];
+    for (const raw of rawComputers) {
+      const computer = normalizeComputerInfo(raw);
+      if (computer != null) {
+        computers.push(computer);
+      }
+    }
+    return ok(computers);
+  };
+  const lifecycleAction = async (idOrName, actionName, options = {}) => {
+    const result = await transport.request({
+      method: "POST",
+      path: `${baseResourcePath}/${encodeURIComponent(idOrName)}/actions/${actionName}`,
+      signal: options.signal
+    });
+    if (!result.ok) {
+      return result;
+    }
+    const computer = computerFromResponse(result.data);
+    if (computer == null) {
+      return err("unexpected computer response shape");
+    }
+    return ok(computer);
+  };
+  const deleteComputer = async (idOrName) => lifecycleAction(idOrName, "delete");
+  const pauseComputer = async (idOrName) => lifecycleAction(idOrName, "pause");
+  const resumeComputer = async (idOrName) => lifecycleAction(idOrName, "resume");
+  const stopComputer = async (idOrName, options) => lifecycleAction(idOrName, "stop", options);
+  const stopComputerRetained = async (idOrName) => lifecycleAction(idOrName, "stop-retained");
+  const refreshComputerActivity = async (idOrName) => lifecycleAction(idOrName, "refresh-activity");
+  const withEphemeralComputer = async (opts, fn) => {
+    const created = await createComputer({ ...opts, ephemeral: true });
+    if (!created.ok) {
+      throw new Error(`withEphemeralComputer: create failed: ${created.error}`);
+    }
+    try {
+      return await fn(created.data);
+    } finally {
+      await created.data.kill();
+    }
+  };
+  const imageFromResponse = (data) => {
+    const response = jsonObjectSchema.safeParse(data);
+    if (!response.success) return null;
+    return normalizeComputerImage(response.data.image ?? response.data.version ?? null);
+  };
+  const registerImage = async (opts) => {
+    const { idempotencyKey, ...body } = opts;
+    const result = await transport.request({
+      method: "POST",
+      path: "/images",
+      jsonBody: body,
+      headers: idempotencyKey == null ? void 0 : { "idempotency-key": idempotencyKey }
+    });
+    if (!result.ok) return result;
+    const image = imageFromResponse(result.data);
+    return image == null ? err("unexpected image response shape") : ok(image);
+  };
+  const getImage = async (id) => {
+    const result = await transport.request({
+      method: "GET",
+      path: `/images/${encodeURIComponent(id)}`
+    });
+    if (!result.ok) return result;
+    const image = imageFromResponse(result.data);
+    return image == null ? err("unexpected image response shape") : ok(image);
+  };
+  const listImages = async (opts = {}) => {
+    const query = {};
+    if (opts.lineage != null) query.lineage = opts.lineage;
+    if (opts.state != null) query.state = opts.state;
+    const result = await transport.request({
+      method: "GET",
+      path: "/images",
+      query
+    });
+    if (!result.ok) return result;
+    const response = jsonObjectSchema.safeParse(result.data);
+    const rawImages = response.success ? response.data.images ?? response.data.versions : void 0;
+    if (!Array.isArray(rawImages)) {
+      return err("unexpected image list response shape");
+    }
+    const images = [];
+    for (const raw of rawImages) {
+      const image = normalizeComputerImage(raw);
+      if (image != null) images.push(image);
+    }
+    return ok(images);
+  };
+  const baseFromResponse = (data) => {
+    const response = jsonObjectSchema.safeParse(data);
+    return response.success ? normalizeComputerBase(response.data.base ?? null) : null;
+  };
+  const captureComputer = async (idOrName, options) => {
+    const result = await transport.request({
+      method: "POST",
+      path: `${baseResourcePath}/${encodeURIComponent(idOrName)}/capture`,
+      jsonBody: options
+    });
+    if (!result.ok) return result;
+    const base = baseFromResponse(result.data);
+    return base == null ? err("unexpected base response shape") : ok(base);
+  };
+  const getBase = async (id) => {
+    const result = await transport.request({
+      method: "GET",
+      path: `/bases/${encodeURIComponent(id)}`
+    });
+    if (!result.ok) return result;
+    const base = baseFromResponse(result.data);
+    return base == null ? err("unexpected base response shape") : ok(base);
+  };
+  const setBaseRetention = async (id, retained) => {
+    const result = await transport.request({
+      method: "PATCH",
+      path: `/bases/${encodeURIComponent(id)}`,
+      jsonBody: { retained }
+    });
+    if (!result.ok) return result;
+    const base = baseFromResponse(result.data);
+    return base == null ? err("unexpected base response shape") : ok(base);
+  };
+  const revokeToken = async (id) => {
+    const result = decodeResult(
+      await transport.request({ method: "DELETE", path: `/tokens/${encodeURIComponent(id)}` }),
+      okResponseSchema,
+      "unexpected token revoke response shape"
+    );
+    return result.ok ? ok(void 0) : result;
+  };
+  return {
+    createComputer,
+    connectComputer,
+    registerImage,
+    getImage,
+    listImages,
+    captureComputer,
+    getBase,
+    setBaseRetention,
+    createToken: (opts) => mintToken(transport, opts),
+    revokeToken,
+    pauseComputer,
+    resumeComputer,
+    stopComputer,
+    stopComputerRetained,
+    refreshComputerActivity,
+    listComputers,
+    getComputer,
+    deleteComputer,
+    withEphemeralComputer
+  };
+};
+const createComputerClient = (args) => createComputerClientWithTransport(createTransport(args));
+export {
+  createComputerClient,
+  createComputerClientWithTransport,
+  createComputerHandle
+};
+//# sourceMappingURL=client.mjs.map