@lizard-build/sdk 0.1.40 → 0.1.41

package/dist/index.mjs

@@ -450,12 +450,12 @@ var Process = class {
     this.config = config;
   }
   /**
-   * Execute a command inside the microVM and wait for it to complete.
+   * Execute a command inside the sandbox and wait for it to complete.
    *
    * The command runs in a shell inside the Lizard sandbox and returns
    * stdout, stderr, and the exit code when it finishes.
    *
-   * @param cmd Shell command to run inside the microVM.
+   * @param cmd Shell command to run inside the sandbox.
    * @param opts Optional execution options — environment variables, working
    *   directory, user, and timeout.
    *
@@ -587,18 +587,19 @@ var Fs = class {
     this.config = config;
   }
   /**
-   * Write a file into the microVM filesystem.
+   * Write a file into the sandbox filesystem.
    *
    * Creates parent directories automatically if they don't exist.
+   * Byte input must contain valid UTF-8; arbitrary binary uploads are unsupported.
    *
    * @example
    * ```ts
    * await sandbox.fs.write('/app/index.js', 'console.log("hello")')
    * ```
    *
-   * @example Write binary data:
+   * @example Write UTF-8 bytes:
    * ```ts
-   * await sandbox.fs.write('/app/data.bin', buffer)
+   * await sandbox.fs.write('/app/notes.txt', new TextEncoder().encode('hello'))
    * ```
    */
   async write(path, data, opts) {
@@ -611,7 +612,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
   }
   /**
-   * Read a file from the microVM filesystem.
+   * Read a file from the sandbox filesystem.
    *
    * @returns The file contents as a UTF-8 string.
    *
@@ -628,14 +629,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
     return res.text();
   }
-  /**
-   * List files and directories at the given path inside the microVM.
-   *
-   * @example
-   * ```ts
-   * const entries = await sandbox.fs.list('/app')
-   * ```
-   */
+  /** Read a file as bytes. */
   async readBytes(path, opts) {
     const url = new URL(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files`);
     url.searchParams.set("path", path);
@@ -644,6 +638,14 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
     return new Uint8Array(await res.arrayBuffer());
   }
+  /**
+   * List files and directories at the given path inside the sandbox.
+   *
+   * @example
+   * ```ts
+   * const entries = await sandbox.fs.list('/app')
+   * ```
+   */
   async list(path, opts) {
     const url = new URL(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files/list`);
     url.searchParams.set("path", path);
@@ -653,7 +655,7 @@ var Fs = class {
     return res.json();
   }
   /**
-   * Remove a file or directory from the microVM filesystem.
+   * Remove a file or directory from the sandbox filesystem.
    */
   async remove(path, opts) {
     const res = await fetch(`${this.config.apiUrl}/api/sandboxes/${this.sandboxId}/files`, {
@@ -664,7 +666,7 @@ var Fs = class {
     if (!res.ok) await handleApiError(res);
   }
   /**
-   * Create a directory (and any missing parents) inside the microVM.
+   * Create a directory (and any missing parents) inside the sandbox.
    */
   async makeDir(path, opts) {
     await this.execInternal(`mkdir -p ${JSON.stringify(path)}`, opts?.user);
@@ -892,11 +894,7 @@ var Sandbox = class extends SandboxClient {
    * Verifies the sandbox exists and is reachable, then returns a handle to it.
    * Throws `NotFoundError` if it has been killed or has expired.
    *
-   * This used to call `resume` first, on the assumption that a sandbox you are
-   * reconnecting to might be paused. Sandboxes are pods now and pause/resume is a
-   * `501` on every one of them, so that call turned every `connect()` into an
-   * error against a perfectly healthy sandbox. Connecting does not need to change
-   * a sandbox's state, so it no longer tries to.
+   * Connecting reads sandbox metadata without changing its state.
    *
    * @example
    * ```ts
@@ -921,29 +919,25 @@ var Sandbox = class extends SandboxClient {
   /**
    * Kill the sandbox and release its resources immediately.
    *
-   * @returns `true` if the microVM was terminated, `false` if it was already gone.
+   * @returns `true` if the sandbox was terminated, `false` if it was already gone.
    */
   async kill(opts) {
     return SandboxClient.killSandbox(this.sandboxId, this.resolveOpts(opts));
   }
   /**
-   * Pause the sandbox by freezing it in place.
+   * Request sandbox pause. The Kubernetes backend returns HTTP 501.
    *
-   * @deprecated Not implemented for the current runtime — always throws
-   * `LizardError` with HTTP 501. Sandboxes run as pods, and the equivalent is a CRIU
-   * checkpoint of the pod, which is not built. To park work across a gap, put it on a
-   * {@link Volume} and create a fresh sandbox on that volume later; the volume is the
-   * part that is meant to outlive a sandbox.
+   * @deprecated Unsupported on Kubernetes. Save files to a {@link Volume}
+   * and attach it to a new sandbox instead.
    */
   async pause(opts) {
     return SandboxClient.pauseSandbox(this.sandboxId, this.resolveOpts(opts));
   }
   /**
-   * Resume a paused sandbox.
+   * Request sandbox resume. The Kubernetes backend returns HTTP 501.
    *
-   * @deprecated Not implemented for the current runtime — always throws
-   * `LizardError` with HTTP 501. See {@link pause}. `Sandbox.connect()` no longer
-   * calls this, so reconnecting to a running sandbox works without it.
+   * @deprecated Unsupported on Kubernetes. Use {@link Sandbox.connect} to
+   * reconnect to a running sandbox.
    */
   async resume(opts) {
     return SandboxClient.resumeSandbox(this.sandboxId, this.resolveOpts(opts));
@@ -963,25 +957,27 @@ var Sandbox = class extends SandboxClient {
     return SandboxClient.setTimeoutSandbox(this.sandboxId, timeoutMs, this.resolveOpts(opts));
   }
   /**
-   * Get the public HTTPS URL for a port exposed inside the sandbox.
+   * Register a public HTTPS route and return its hostname without a scheme.
    *
-   * Useful for accessing HTTP servers started inside the microVM from your
+   * Useful for accessing HTTP servers started inside the sandbox from your
    * agent or tests without additional tunneling.
    *
    * @example
    * ```ts
-   * await sandbox.process.exec('npx -y serve -p 3000 &')
-   * const url = sandbox.getHost(3000)
-   * // https://{sandboxId}-3000.sandbox.{region}.onlizard.com
+   * // Start an HTTP server on port 3000 before exposing it.
+   * const hostname = await sandbox.getHost(3000)
+   * console.log(`https://${hostname}`)
    * ```
    */
   async getHost(port, opts) {
     const { hostname } = await SandboxClient.exposeSandboxPort(this.sandboxId, port, this.resolveOpts(opts));
     return hostname;
   }
+  /** Fork is unsupported on Kubernetes; the backend returns HTTP 501. */
   fork(opts = {}) {
     return new PlatformClient(this.resolveOpts()).post(`/api/sandboxes/${this.sandboxId}/fork`, { count: opts.count ?? 1, timeoutMs: opts.timeoutMs ?? 0 });
   }
+  /** Snapshot creation is unsupported on Kubernetes; the backend returns HTTP 501. */
   snapshot(name) {
     return new PlatformClient(this.resolveOpts()).post(`/api/sandboxes/${this.sandboxId}/snapshot`, { name });
   }
@@ -994,6 +990,7 @@ var Sandbox = class extends SandboxClient {
   static snapshots(projectId, opts) {
     return new PlatformClient(opts ?? {}).get(`/api/projects/${projectId}/snapshots`);
   }
+  /** Snapshot restore is unsupported on Kubernetes; the backend returns HTTP 501. */
   static async restore(snapshotId, opts) {
     const result = await new PlatformClient(opts ?? {}).post(`/api/sandbox-snapshots/${encodeURIComponent(snapshotId)}/fork`, { timeoutMs: opts?.timeoutMs ?? 0 });
     return new this({ ...opts, sandboxId: result.sandboxId ?? result.id });
@@ -1106,7 +1103,7 @@ var AddonsAPI = class {
     });
     return this.get(projectId, addonId);
   }
-  /** Restart an addon VM. */
+  /** Restart an addon. */
   redeploy(projectId, addonId) {
     return this.client.post(`/api/projects/${projectId}/addons/${addonId}/redeploy`, {});
   }
@@ -1708,8 +1705,7 @@ var CodeSandbox = class extends Sandbox {
    *
    * @returns Execution result with stdout, stderr, results, and any error.
    *
-   * @throws {ExecutionError} if you pass neither language nor context and no
-   *   default context exists — which cannot happen in normal usage.
+   * Code errors appear in `execution.error`; request failures throw.
    *
    * @example
    * ```ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lizard-build/sdk",
-  "version": "0.1.40",
-  "description": "TypeScript SDK for Lizard apps, managed databases, storage and Linux sandboxes.",
+  "version": "0.1.41",
+  "description": "TypeScript SDK for Lizard: Kubernetes sandboxes, code execution and cloud apps.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -24,8 +24,8 @@
   "keywords": [
     "sandbox",
     "sandboxes",
-    "microvm",
-    "firecracker",
+    "kubernetes",
+    "containers",
     "ai-agents",
     "code-interpreter",
     "code-execution",