@slicervm/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,743 @@
+import http from 'http';
+import https from 'https';
+import { URL } from 'url';
+import os from 'os';
+import path from 'path';
+
+// src/types.ts
+var ExecStdioText = "text";
+var ExecStdioBase64 = "base64";
+var SecretExistsError = class extends Error {
+  constructor(name) {
+    super(`secret already exists: ${name}`);
+    this.name = "SecretExistsError";
+  }
+};
+var SlicerAPIError = class extends Error {
+  status;
+  method;
+  path;
+  body;
+  constructor(method, path2, status, body) {
+    super(`slicer ${method} ${path2} failed: ${status} ${body}`);
+    this.name = "SlicerAPIError";
+    this.method = method;
+    this.path = path2;
+    this.status = status;
+    this.body = body;
+  }
+};
+var MiB = (n) => n * 1024 * 1024;
+var GiB = (n) => n * 1024 * 1024 * 1024;
+var NonRootUser = 4294967295;
+function resolveTransport(baseURL) {
+  const trimmed = baseURL.trim();
+  if (!trimmed) throw new Error("Slicer baseURL is required");
+  let candidate = trimmed;
+  if (candidate.startsWith("unix://")) candidate = candidate.slice("unix://".length);
+  if (candidate.startsWith("~/")) candidate = path.join(os.homedir(), candidate.slice(2));
+  const socketLike = candidate.startsWith("/") || candidate.startsWith("./") || candidate.startsWith("../") || candidate.endsWith(".sock");
+  if (socketLike) return { kind: "socket", socketPath: candidate };
+  return { kind: "net", url: new URL(trimmed) };
+}
+var TransportClient = class {
+  transport;
+  token;
+  userAgent;
+  constructor(opts) {
+    this.transport = resolveTransport(opts.baseURL);
+    this.token = opts.token;
+    this.userAgent = opts.userAgent ?? "slicer-sdk-ts/0.1.0";
+  }
+  agent() {
+    return this.transport.kind === "net" && this.transport.url.protocol === "https:" ? https : http;
+  }
+  buildRequestOptions(method, reqPath, extraHeaders = {}) {
+    const headers = {
+      "User-Agent": this.userAgent,
+      ...extraHeaders
+    };
+    if (this.token) headers["Authorization"] = `Bearer ${this.token}`;
+    if (this.transport.kind === "socket") {
+      return {
+        socketPath: this.transport.socketPath,
+        method,
+        path: reqPath,
+        headers,
+        setHost: true
+      };
+    }
+    const u = this.transport.url;
+    return {
+      protocol: u.protocol,
+      hostname: u.hostname,
+      port: u.port || (u.protocol === "https:" ? 443 : 80),
+      method,
+      path: reqPath,
+      headers
+    };
+  }
+  /** Buffered JSON request. Rejects on non-2xx via SlicerAPIError. */
+  request(method, reqPath, body) {
+    return new Promise((resolve, reject) => {
+      const payload = body === void 0 ? void 0 : Buffer.from(JSON.stringify(body));
+      const headers = {};
+      if (payload) {
+        headers["Content-Type"] = "application/json";
+        headers["Content-Length"] = String(payload.length);
+      }
+      const req = this.agent().request(
+        this.buildRequestOptions(method, reqPath, headers),
+        (res) => {
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            const status = res.statusCode ?? 0;
+            if (status < 200 || status >= 300) {
+              reject(new SlicerAPIError(method, reqPath, status, raw));
+              return;
+            }
+            if (!raw) {
+              resolve(void 0);
+              return;
+            }
+            try {
+              resolve(JSON.parse(raw));
+            } catch {
+              resolve(raw);
+            }
+          });
+          res.on("error", reject);
+        }
+      );
+      req.on("error", reject);
+      if (payload) req.write(payload);
+      req.end();
+    });
+  }
+  /** Raw-bytes request (for binary cp endpoints). */
+  requestRaw(method, reqPath, body, contentType = "application/octet-stream") {
+    return new Promise((resolve, reject) => {
+      const headers = {};
+      if (body) {
+        headers["Content-Type"] = contentType;
+        headers["Content-Length"] = String(body.length);
+      }
+      const req = this.agent().request(
+        this.buildRequestOptions(method, reqPath, headers),
+        (res) => {
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => {
+            const out = Buffer.concat(chunks);
+            const status = res.statusCode ?? 0;
+            if (status < 200 || status >= 300) {
+              reject(new SlicerAPIError(method, reqPath, status, out.toString("utf8")));
+              return;
+            }
+            resolve(out);
+          });
+          res.on("error", reject);
+        }
+      );
+      req.on("error", reject);
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+  /** Streaming request producing a Node Readable of the response body. */
+  requestStreamRaw(method, reqPath, body, contentType = "application/octet-stream") {
+    return new Promise((resolve, reject) => {
+      const headers = {};
+      if (body instanceof Buffer) {
+        headers["Content-Type"] = contentType;
+        headers["Content-Length"] = String(body.length);
+      } else if (body) {
+        headers["Content-Type"] = contentType;
+        headers["Transfer-Encoding"] = "chunked";
+      }
+      const req = this.agent().request(
+        this.buildRequestOptions(method, reqPath, headers),
+        (res) => {
+          const status = res.statusCode ?? 0;
+          if (status < 200 || status >= 300) {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on(
+              "end",
+              () => reject(
+                new SlicerAPIError(method, reqPath, status, Buffer.concat(chunks).toString("utf8"))
+              )
+            );
+            return;
+          }
+          resolve(res);
+        }
+      );
+      req.on("error", reject);
+      if (body instanceof Buffer) {
+        req.write(body);
+        req.end();
+      } else if (body) {
+        body.pipe(req);
+      } else {
+        req.end();
+      }
+    });
+  }
+  /** Yields decoded JSON frames from an NDJSON response (one JSON object per line). */
+  async *requestNDJSON(method, reqPath, body) {
+    const res = await this.requestStreamRaw(method, reqPath, body);
+    res.setEncoding("utf8");
+    let buffer = "";
+    for await (const chunk of res) {
+      buffer += chunk;
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (!line) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+        }
+      }
+    }
+    const trailing = buffer.trim();
+    if (trailing) {
+      try {
+        yield JSON.parse(trailing);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/wire.ts
+function hostGroupFromWire(w) {
+  return {
+    name: w.name ?? "",
+    count: w.count ?? 0,
+    ramBytes: w.ram_bytes ?? 0,
+    cpus: w.cpus ?? 0,
+    arch: w.arch ?? "",
+    ...w.gpu_count !== void 0 && { gpuCount: w.gpu_count }
+  };
+}
+function vmFromWire(w) {
+  return {
+    hostname: w.hostname,
+    ip: w.ip,
+    createdAt: w.created_at,
+    ...w.hostgroup !== void 0 && { hostGroup: w.hostgroup },
+    ...w.ram_bytes !== void 0 && { ramBytes: w.ram_bytes },
+    ...w.cpus !== void 0 && { cpus: w.cpus },
+    ...w.arch !== void 0 && { arch: w.arch },
+    ...w.tags !== void 0 && { tags: w.tags },
+    ...w.status !== void 0 && { status: w.status },
+    ...w.persistent !== void 0 && { persistent: w.persistent }
+  };
+}
+function createVMReqToWire(r) {
+  const o = {};
+  if (r.ramBytes !== void 0) o.ram_bytes = r.ramBytes;
+  if (r.cpus !== void 0) o.cpus = r.cpus;
+  if (r.gpuCount !== void 0) o.gpu_count = r.gpuCount;
+  if (r.persistent !== void 0) o.persistent = r.persistent;
+  if (r.diskImage !== void 0) o.disk_image = r.diskImage;
+  if (r.importUser !== void 0) o.import_user = r.importUser;
+  if (r.sshKeys !== void 0) o.ssh_keys = r.sshKeys;
+  if (r.userdata !== void 0) o.userdata = r.userdata;
+  if (r.ip !== void 0) o.ip = r.ip;
+  if (r.tags !== void 0) o.tags = r.tags;
+  if (r.secrets !== void 0) o.secrets = r.secrets;
+  return o;
+}
+function createVMResFromWire(w) {
+  return {
+    hostname: w.hostname,
+    ip: w.ip,
+    createdAt: w.created_at,
+    ...w.hostgroup !== void 0 && { hostGroup: w.hostgroup },
+    ...w.arch !== void 0 && { arch: w.arch }
+  };
+}
+function agentHealthFromWire(w) {
+  return {
+    ...w.hostname !== void 0 && { hostname: w.hostname },
+    ...w.agent_uptime !== void 0 && { agentUptime: w.agent_uptime },
+    ...w.agent_version !== void 0 && { agentVersion: w.agent_version },
+    ...w.system_uptime !== void 0 && { systemUptime: w.system_uptime },
+    ...w.userdata_ran !== void 0 && { userdataRan: w.userdata_ran }
+  };
+}
+function fsEntryFromWire(w) {
+  return { name: w.name, type: w.type, size: w.size, mtime: w.mtime, mode: w.mode };
+}
+function vmStatFromWire(w) {
+  return {
+    hostname: w.hostname,
+    ip: w.ip,
+    createdAt: w.created_at,
+    ...w.snapshot !== void 0 && { snapshot: w.snapshot },
+    ...w.error !== void 0 && { error: w.error }
+  };
+}
+function secretFromWire(w) {
+  return {
+    name: w.name,
+    size: w.size,
+    permissions: w.permissions,
+    ...w.uid !== void 0 && { uid: w.uid },
+    ...w.gid !== void 0 && { gid: w.gid },
+    ...w.modified_at !== void 0 && { modifiedAt: w.modified_at }
+  };
+}
+
+// src/vm.ts
+var VMFileSystem = class {
+  constructor(transport, hostname) {
+    this.transport = transport;
+    this.hostname = hostname;
+  }
+  transport;
+  hostname;
+  async readDir(path2) {
+    const q = new URLSearchParams({ path: path2 });
+    const wire = await this.transport.request(
+      "GET",
+      `/vm/${encodeURIComponent(this.hostname)}/fs/readdir?${q.toString()}`
+    );
+    return (wire ?? []).map(fsEntryFromWire);
+  }
+  async stat(path2) {
+    const q = new URLSearchParams({ path: path2 });
+    try {
+      const wire = await this.transport.request(
+        "GET",
+        `/vm/${encodeURIComponent(this.hostname)}/fs/stat?${q.toString()}`
+      );
+      return fsEntryFromWire(wire);
+    } catch (err) {
+      if (err instanceof SlicerAPIError && err.status === 404) return null;
+      throw err;
+    }
+  }
+  async exists(path2) {
+    return await this.stat(path2) !== null;
+  }
+  async mkdir(req) {
+    await this.transport.request(
+      "POST",
+      `/vm/${encodeURIComponent(this.hostname)}/fs/mkdir`,
+      {
+        path: req.path,
+        ...req.recursive !== void 0 && { recursive: req.recursive },
+        ...req.mode !== void 0 && { mode: req.mode }
+      }
+    );
+  }
+  async remove(path2, recursive = false) {
+    const q = new URLSearchParams({ path: path2, recursive: String(recursive) });
+    await this.transport.request(
+      "DELETE",
+      `/vm/${encodeURIComponent(this.hostname)}/fs/remove?${q.toString()}`
+    );
+  }
+  async readFile(path2) {
+    const q = new URLSearchParams({ path: path2, mode: "binary" });
+    return this.transport.requestRaw(
+      "GET",
+      `/vm/${encodeURIComponent(this.hostname)}/cp?${q.toString()}`
+    );
+  }
+  async writeFile(path2, content, opts = {}) {
+    const q = new URLSearchParams({ path: path2, mode: "binary" });
+    if (opts.uid !== void 0) q.set("uid", String(opts.uid));
+    if (opts.gid !== void 0) q.set("gid", String(opts.gid));
+    if (opts.permissions) q.set("permissions", opts.permissions);
+    const body = typeof content === "string" ? Buffer.from(content) : content;
+    await this.transport.requestRaw(
+      "POST",
+      `/vm/${encodeURIComponent(this.hostname)}/cp?${q.toString()}`,
+      body
+    );
+  }
+  /** Upload a tar archive, expanded into the VM at `path`. */
+  async tarTo(path2, tar) {
+    const q = new URLSearchParams({ path: path2, mode: "tar" });
+    if (tar instanceof Buffer) {
+      await this.transport.requestRaw(
+        "POST",
+        `/vm/${encodeURIComponent(this.hostname)}/cp?${q.toString()}`,
+        tar,
+        "application/x-tar"
+      );
+      return;
+    }
+    const res = await this.transport.requestStreamRaw(
+      "POST",
+      `/vm/${encodeURIComponent(this.hostname)}/cp?${q.toString()}`,
+      tar,
+      "application/x-tar"
+    );
+    for await (const _ of res) void _;
+  }
+  /** Download `path` from the VM as a tar archive. */
+  async tarFrom(path2) {
+    const q = new URLSearchParams({ path: path2, mode: "tar" });
+    return this.transport.requestRaw(
+      "GET",
+      `/vm/${encodeURIComponent(this.hostname)}/cp?${q.toString()}`
+    );
+  }
+};
+var VM = class {
+  hostname;
+  hostGroup;
+  ip;
+  createdAt;
+  arch;
+  fs;
+  transport;
+  constructor(transport, init) {
+    this.transport = transport;
+    this.hostname = init.hostname;
+    this.hostGroup = init.hostGroup;
+    if (init.ip !== void 0) this.ip = init.ip;
+    if (init.createdAt !== void 0) this.createdAt = init.createdAt;
+    if (init.arch !== void 0) this.arch = init.arch;
+    this.fs = new VMFileSystem(transport, this.hostname);
+  }
+  // --- lifecycle --------------------------------------------------------
+  async delete() {
+    await this.transport.request(
+      "DELETE",
+      `/hostgroup/${encodeURIComponent(this.hostGroup)}/nodes/${encodeURIComponent(
+        this.hostname
+      )}`
+    );
+  }
+  // --- health / logs ----------------------------------------------------
+  async health() {
+    const wire = await this.transport.request(
+      "GET",
+      `/vm/${encodeURIComponent(this.hostname)}/health`
+    );
+    return agentHealthFromWire(wire);
+  }
+  async logs() {
+    return this.transport.request("GET", `/vm/${encodeURIComponent(this.hostname)}/logs`);
+  }
+  async waitForAgent(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 12e4;
+    const intervalMs = opts.intervalMs ?? 500;
+    const deadline = Date.now() + timeoutMs;
+    let lastErr;
+    while (Date.now() < deadline) {
+      try {
+        return await this.health();
+      } catch (err) {
+        lastErr = err;
+        await sleep(intervalMs);
+      }
+    }
+    throw new Error(
+      `agent for ${this.hostname} did not become ready within ${timeoutMs}ms: ${errMsg(lastErr)}`
+    );
+  }
+  async waitForUserdata(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 12e4;
+    const intervalMs = opts.intervalMs ?? 500;
+    const deadline = Date.now() + timeoutMs;
+    let last;
+    let lastErr;
+    while (Date.now() < deadline) {
+      try {
+        last = await this.health();
+        if (last.userdataRan) return last;
+      } catch (err) {
+        lastErr = err;
+      }
+      await sleep(intervalMs);
+    }
+    throw new Error(
+      `userdata for ${this.hostname} did not complete within ${timeoutMs}ms${lastErr ? `: ${errMsg(lastErr)}` : ""}`
+    );
+  }
+  // --- power ------------------------------------------------------------
+  async shutdown(req = {}) {
+    await this.transport.request(
+      "POST",
+      `/vm/${encodeURIComponent(this.hostname)}/shutdown`,
+      req
+    );
+  }
+  async pause() {
+    await this.transport.request("POST", `/vm/${encodeURIComponent(this.hostname)}/pause`);
+  }
+  async resume() {
+    await this.transport.request("POST", `/vm/${encodeURIComponent(this.hostname)}/resume`);
+  }
+  async relaunch() {
+    await this.transport.request("POST", `/vm/${encodeURIComponent(this.hostname)}/relaunch`);
+  }
+  /** Mac-only on current daemons. Throws `SlicerAPIError 404` on Linux. */
+  async suspend() {
+    await this.transport.request("POST", `/vm/${encodeURIComponent(this.hostname)}/suspend`);
+  }
+  /** Mac-only on current daemons. Throws `SlicerAPIError 404` on Linux. */
+  async restore() {
+    await this.transport.request("POST", `/vm/${encodeURIComponent(this.hostname)}/restore`);
+  }
+  // --- exec -------------------------------------------------------------
+  /**
+   * Streaming exec — yields NDJSON frames (`started`, `stdout`, `stderr`, `exit`).
+   * When `req.stdio === 'base64'`, each frame's `data`/`stdout`/`stderr` string
+   * fields are preserved as-is (base64-encoded) and the SDK populates decoded
+   * `dataBytes`/`stdoutBytes`/`stderrBytes` Buffers alongside for convenience.
+   */
+  async *exec(req) {
+    const { path: path2, body } = buildExecPath(this.hostname, req, false);
+    for await (const frame of this.transport.requestNDJSON("POST", path2, body)) {
+      if (frame.encoding === "base64") {
+        if (frame.data) frame.dataBytes = Buffer.from(frame.data, "base64");
+        if (frame.stdout) frame.stdoutBytes = Buffer.from(frame.stdout, "base64");
+        if (frame.stderr) frame.stderrBytes = Buffer.from(frame.stderr, "base64");
+      }
+      yield frame;
+    }
+  }
+  async execBuffered(req) {
+    if (req.stdin !== void 0) {
+      throw new Error("stdin is not supported by execBuffered; use exec() instead");
+    }
+    const { path: path2, body } = buildExecPath(this.hostname, req, true);
+    const raw = await this.transport.requestRaw("POST", path2, body);
+    const text = raw.toString("utf8");
+    const parsed = text ? JSON.parse(text) : {};
+    const common = {
+      exitCode: parsed.exit_code ?? 0,
+      ...parsed.pid !== void 0 && { pid: parsed.pid },
+      ...parsed.started_at !== void 0 && { startedAt: parsed.started_at },
+      ...parsed.ended_at !== void 0 && { endedAt: parsed.ended_at },
+      ...parsed.signal !== void 0 && { signal: parsed.signal },
+      ...parsed.error !== void 0 && { error: parsed.error }
+    };
+    if (req.stdio === "base64" || parsed.encoding === "base64") {
+      return {
+        stdout: Buffer.from(parsed.stdout ?? "", "base64"),
+        stderr: Buffer.from(parsed.stderr ?? "", "base64"),
+        encoding: "base64",
+        ...common
+      };
+    }
+    return {
+      stdout: parsed.stdout ?? "",
+      stderr: parsed.stderr ?? "",
+      ...parsed.encoding !== void 0 && { encoding: parsed.encoding },
+      ...common
+    };
+  }
+};
+function buildExecPath(hostname, req, buffered) {
+  const q = new URLSearchParams();
+  if (req.command) q.set("cmd", req.command);
+  for (const a of req.args ?? []) q.append("args", a);
+  for (const e of req.env ?? []) q.append("env", e);
+  if (req.uid !== void 0) q.set("uid", String(req.uid));
+  if (req.gid !== void 0) q.set("gid", String(req.gid));
+  if (req.cwd) q.set("cwd", req.cwd);
+  if (req.shell) q.set("shell", req.shell);
+  if (req.permissions) q.set("permissions", req.permissions);
+  if (req.stdio) q.set("stdio", req.stdio);
+  if (buffered) q.set("buffered", "true");
+  let body;
+  if (req.stdin !== void 0) {
+    q.set("stdin", "true");
+    body = typeof req.stdin === "string" ? Buffer.from(req.stdin) : req.stdin;
+  }
+  return {
+    path: `/vm/${encodeURIComponent(hostname)}/exec?${q.toString()}`,
+    body
+  };
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/namespaces.ts
+var HostGroupsAPI = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list() {
+    const wire = await this.transport.request("GET", "/hostgroup");
+    return (wire ?? []).map(hostGroupFromWire);
+  }
+  /** Convenience lookup (no single-group endpoint exists on the daemon). */
+  async find(name) {
+    return (await this.list()).find((g) => g.name === name);
+  }
+  async listVMs(name, opts = {}) {
+    const q = buildListQuery(opts);
+    const wire = await this.transport.request(
+      "GET",
+      `/hostgroup/${encodeURIComponent(name)}/nodes${q}`
+    );
+    return (wire ?? []).map(vmFromWire);
+  }
+};
+var VMsAPI = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async create(hostGroup, req = {}, opts = {}) {
+    const qs = new URLSearchParams();
+    if (opts.wait) qs.set("wait", opts.wait);
+    if (opts.waitTimeoutSec !== void 0) qs.set("timeout", `${opts.waitTimeoutSec}s`);
+    const query = qs.toString() ? `?${qs.toString()}` : "";
+    const wire = await this.transport.request(
+      "POST",
+      `/hostgroup/${encodeURIComponent(hostGroup)}/nodes${query}`,
+      createVMReqToWire(req)
+    );
+    const res = createVMResFromWire(wire);
+    return new VM(this.transport, {
+      hostname: res.hostname,
+      hostGroup: res.hostGroup ?? hostGroup,
+      ...res.ip !== void 0 && { ip: res.ip },
+      ...res.createdAt !== void 0 && { createdAt: res.createdAt },
+      ...res.arch !== void 0 && { arch: res.arch }
+    });
+  }
+  /**
+   * Build a VM handle for an existing VM given its hostgroup + hostname. No
+   * request is issued — use `health()` or `getInfo()` to verify reachability.
+   */
+  attach(hostGroup, hostname) {
+    return new VM(this.transport, { hostname, hostGroup });
+  }
+  /** Look up a VM by hostname across all host groups. Returns `undefined` if not found. */
+  async get(hostname) {
+    const all = await this.list();
+    const found = all.find((v) => v.hostname === hostname);
+    if (!found) return void 0;
+    return new VM(this.transport, {
+      hostname: found.hostname,
+      hostGroup: found.hostGroup ?? "",
+      ...found.ip !== void 0 && { ip: found.ip },
+      ...found.createdAt !== void 0 && { createdAt: found.createdAt },
+      ...found.arch !== void 0 && { arch: found.arch }
+    });
+  }
+  /** Return raw VM metadata across all host groups. */
+  async list(opts = {}) {
+    const q = buildListQuery(opts);
+    const wire = await this.transport.request("GET", `/nodes${q}`);
+    return (wire ?? []).map(vmFromWire);
+  }
+  async stats() {
+    const raw = await this.transport.request("GET", "/nodes/stats");
+    return (raw ?? []).map(vmStatFromWire);
+  }
+  /**
+   * Raw response accessor — bypasses the VM handle. Useful when you only
+   * want the create metadata without a handle.
+   */
+  async createRaw(hostGroup, req = {}, opts = {}) {
+    const qs = new URLSearchParams();
+    if (opts.wait) qs.set("wait", opts.wait);
+    if (opts.waitTimeoutSec !== void 0) qs.set("timeout", `${opts.waitTimeoutSec}s`);
+    const query = qs.toString() ? `?${qs.toString()}` : "";
+    const wire = await this.transport.request(
+      "POST",
+      `/hostgroup/${encodeURIComponent(hostGroup)}/nodes${query}`,
+      createVMReqToWire(req)
+    );
+    return createVMResFromWire(wire);
+  }
+};
+var SecretsAPI = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async list() {
+    const wire = await this.transport.request("GET", "/secrets");
+    return (wire ?? []).map(secretFromWire);
+  }
+  async create(req) {
+    const body = {
+      name: req.name,
+      data: Buffer.from(req.data).toString("base64"),
+      ...req.permissions !== void 0 && { permissions: req.permissions },
+      ...req.uid !== void 0 && { uid: req.uid },
+      ...req.gid !== void 0 && { gid: req.gid }
+    };
+    try {
+      await this.transport.request("POST", "/secrets", body);
+    } catch (err) {
+      if (err instanceof SlicerAPIError && err.status === 409) {
+        throw new SecretExistsError(req.name);
+      }
+      throw err;
+    }
+  }
+  async patch(name, req) {
+    const body = {
+      data: Buffer.from(req.data).toString("base64"),
+      ...req.permissions !== void 0 && { permissions: req.permissions },
+      ...req.uid !== void 0 && { uid: req.uid },
+      ...req.gid !== void 0 && { gid: req.gid }
+    };
+    await this.transport.request("PATCH", `/secrets/${encodeURIComponent(name)}`, body);
+  }
+  async delete(name) {
+    await this.transport.request("DELETE", `/secrets/${encodeURIComponent(name)}`);
+  }
+};
+function buildListQuery(opts) {
+  const qs = new URLSearchParams();
+  if (opts.tag) qs.set("tag", opts.tag);
+  if (opts.tagPrefix) qs.set("tag_prefix", opts.tagPrefix);
+  const s = qs.toString();
+  return s ? `?${s}` : "";
+}
+
+// src/client.ts
+var SlicerClient = class _SlicerClient {
+  transport;
+  hostGroups;
+  vms;
+  secrets;
+  constructor(opts) {
+    this.transport = new TransportClient(opts);
+    this.hostGroups = new HostGroupsAPI(this.transport);
+    this.vms = new VMsAPI(this.transport);
+    this.secrets = new SecretsAPI(this.transport);
+  }
+  static fromEnv(overrides = {}) {
+    const baseURL = overrides.baseURL ?? process.env.SLICER_URL;
+    if (!baseURL) throw new Error("SLICER_URL is required (or pass baseURL)");
+    const token = overrides.token ?? process.env.SLICER_TOKEN ?? void 0;
+    return new _SlicerClient({
+      baseURL,
+      ...token !== void 0 && { token },
+      ...overrides.userAgent !== void 0 && { userAgent: overrides.userAgent }
+    });
+  }
+  async getInfo() {
+    return this.transport.request("GET", "/info");
+  }
+};
+
+export { ExecStdioBase64, ExecStdioText, GiB, HostGroupsAPI, MiB, NonRootUser, SecretExistsError, SecretsAPI, SlicerAPIError, SlicerClient, VM, VMFileSystem, VMsAPI, resolveTransport };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map