@declaw/sdk 1.1.5 → 1.1.7

package/dist/index.d.cts

@@ -1113,10 +1113,63 @@ declare class Sandbox {
     /**
      * Kill this sandbox.
      *
+     * Returns once the kill has been accepted by the server. The per-VM
+     * teardown (firecracker shutdown + netns + iptables cleanup) runs in
+     * the background. Pass `{ wait: true }` to block until the teardown
+     * has fully completed.
+     *
      * @param requestTimeout - Optional per-request timeout in milliseconds.
-     * @returns True if the sandbox was killed, false if it was already dead.
+     * @returns True if the sandbox was killed (or queued); false if the
+     *   server reported it was already dead.
      */
     kill(requestTimeout?: number): Promise<boolean>;
+    kill(opts?: {
+        requestTimeout?: number;
+        wait?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Kill many sandboxes in a single request. Server fans out internally
+     * with bounded concurrency, eliminating per-id round-trip overhead.
+     *
+     * @param ids - sandbox IDs to kill.
+     * @param opts.wait - If true, wait for each VM's teardown to finish
+     *   before returning. Default is false (server returns 202 once the
+     *   request is queued).
+     * @param opts.requestTimeout - Per-request timeout in milliseconds.
+     * @returns Map of sandbox-id → outcome. Outcome is `{killed: true}`
+     *   (wait=true), `{queued: true}` (default), or `{error: string}` if
+     *   the server reported a per-id failure.
+     */
+    static killMany(ids: string[], opts?: {
+        wait?: boolean;
+        requestTimeout?: number;
+        config?: ConnectionConfig;
+    }): Promise<Record<string, {
+        killed?: boolean;
+        queued?: boolean;
+        error?: string;
+    }>>;
+    /**
+     * Kill a sandbox by id without first connecting. Sends a single
+     * `DELETE /sandboxes/:id?async=true` and skips the metadata fetch
+     * `Sandbox.connect(id).kill()` would otherwise pay. Useful for bulk
+     * cleanup paths that only have the id.
+     *
+     * @param sandboxId - the sandbox to kill.
+     * @param opts.wait - if true, block until the server finishes the
+     *   per-VM teardown. Default is false: server returns 202 once the
+     *   kill is queued.
+     * @param opts.requestTimeout - per-request timeout in milliseconds.
+     * @param opts.config - override the default ConnectionConfig.
+     * @returns true if the kill was accepted (default) or completed
+     *   (wait=true); false if the server reported the sandbox was
+     *   already dead.
+     */
+    static kill(sandboxId: string, opts?: {
+        wait?: boolean;
+        requestTimeout?: number;
+        config?: ConnectionConfig;
+    }): Promise<boolean>;
     /**
      * Check if this sandbox is currently running.
      *

package/dist/index.d.ts

@@ -1113,10 +1113,63 @@ declare class Sandbox {
     /**
      * Kill this sandbox.
      *
+     * Returns once the kill has been accepted by the server. The per-VM
+     * teardown (firecracker shutdown + netns + iptables cleanup) runs in
+     * the background. Pass `{ wait: true }` to block until the teardown
+     * has fully completed.
+     *
      * @param requestTimeout - Optional per-request timeout in milliseconds.
-     * @returns True if the sandbox was killed, false if it was already dead.
+     * @returns True if the sandbox was killed (or queued); false if the
+     *   server reported it was already dead.
      */
     kill(requestTimeout?: number): Promise<boolean>;
+    kill(opts?: {
+        requestTimeout?: number;
+        wait?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Kill many sandboxes in a single request. Server fans out internally
+     * with bounded concurrency, eliminating per-id round-trip overhead.
+     *
+     * @param ids - sandbox IDs to kill.
+     * @param opts.wait - If true, wait for each VM's teardown to finish
+     *   before returning. Default is false (server returns 202 once the
+     *   request is queued).
+     * @param opts.requestTimeout - Per-request timeout in milliseconds.
+     * @returns Map of sandbox-id → outcome. Outcome is `{killed: true}`
+     *   (wait=true), `{queued: true}` (default), or `{error: string}` if
+     *   the server reported a per-id failure.
+     */
+    static killMany(ids: string[], opts?: {
+        wait?: boolean;
+        requestTimeout?: number;
+        config?: ConnectionConfig;
+    }): Promise<Record<string, {
+        killed?: boolean;
+        queued?: boolean;
+        error?: string;
+    }>>;
+    /**
+     * Kill a sandbox by id without first connecting. Sends a single
+     * `DELETE /sandboxes/:id?async=true` and skips the metadata fetch
+     * `Sandbox.connect(id).kill()` would otherwise pay. Useful for bulk
+     * cleanup paths that only have the id.
+     *
+     * @param sandboxId - the sandbox to kill.
+     * @param opts.wait - if true, block until the server finishes the
+     *   per-VM teardown. Default is false: server returns 202 once the
+     *   kill is queued.
+     * @param opts.requestTimeout - per-request timeout in milliseconds.
+     * @param opts.config - override the default ConnectionConfig.
+     * @returns true if the kill was accepted (default) or completed
+     *   (wait=true); false if the server reported the sandbox was
+     *   already dead.
+     */
+    static kill(sandboxId: string, opts?: {
+        wait?: boolean;
+        requestTimeout?: number;
+        config?: ConnectionConfig;
+    }): Promise<boolean>;
     /**
      * Check if this sandbox is currently running.
      *

package/dist/index.js

@@ -127,11 +127,6 @@ function getDispatcher() {
       if (process.env.DECLAW_SDK_DISABLE_DISPATCHER) {
         return void 0;
       }
-      const origEmit = process.emitWarning;
-      process.emitWarning = ((warning, ...rest) => {
-        if (rest[0] === "UNDICI-H2") return;
-        return origEmit.call(process, warning, ...rest);
-      });
       const undici = await import("undici");
       const connOverride = parseInt(process.env.DECLAW_SDK_CONNECTIONS || "", 10);
       const connections = Number.isFinite(connOverride) && connOverride > 0 ? connOverride : 64;
@@ -2025,16 +2020,67 @@ var Sandbox = class _Sandbox {
       nextToken: data.next_token ?? void 0
     };
   }
+  async kill(arg) {
+    const opts = typeof arg === "number" ? { requestTimeout: arg } : arg ?? {};
+    const wait = opts.wait === true;
+    const path = wait ? `/sandboxes/${this._sandboxId}` : `/sandboxes/${this._sandboxId}?async=true`;
+    const data = await this._client.delete(path, {
+      timeout: opts.requestTimeout
+    });
+    if (!wait) {
+      return data.queued ?? true;
+    }
+    return data.killed ?? false;
+  }
   /**
-   * Kill this sandbox.
+   * Kill many sandboxes in a single request. Server fans out internally
+   * with bounded concurrency, eliminating per-id round-trip overhead.
    *
-   * @param requestTimeout - Optional per-request timeout in milliseconds.
-   * @returns True if the sandbox was killed, false if it was already dead.
+   * @param ids - sandbox IDs to kill.
+   * @param opts.wait - If true, wait for each VM's teardown to finish
+   *   before returning. Default is false (server returns 202 once the
+   *   request is queued).
+   * @param opts.requestTimeout - Per-request timeout in milliseconds.
+   * @returns Map of sandbox-id → outcome. Outcome is `{killed: true}`
+   *   (wait=true), `{queued: true}` (default), or `{error: string}` if
+   *   the server reported a per-id failure.
    */
-  async kill(requestTimeout) {
-    const data = await this._client.delete(`/sandboxes/${this._sandboxId}`, {
-      timeout: requestTimeout
+  static async killMany(ids, opts) {
+    if (!ids || ids.length === 0) return {};
+    const config = opts?.config ?? new ConnectionConfig();
+    const client = getSharedClient(config);
+    const path = opts?.wait ? "/sandboxes/kill-many" : "/sandboxes/kill-many?async=true";
+    const data = await client.post(path, {
+      json: { sandbox_ids: ids },
+      timeout: opts?.requestTimeout
+    });
+    return data.results ?? {};
+  }
+  /**
+   * Kill a sandbox by id without first connecting. Sends a single
+   * `DELETE /sandboxes/:id?async=true` and skips the metadata fetch
+   * `Sandbox.connect(id).kill()` would otherwise pay. Useful for bulk
+   * cleanup paths that only have the id.
+   *
+   * @param sandboxId - the sandbox to kill.
+   * @param opts.wait - if true, block until the server finishes the
+   *   per-VM teardown. Default is false: server returns 202 once the
+   *   kill is queued.
+   * @param opts.requestTimeout - per-request timeout in milliseconds.
+   * @param opts.config - override the default ConnectionConfig.
+   * @returns true if the kill was accepted (default) or completed
+   *   (wait=true); false if the server reported the sandbox was
+   *   already dead.
+   */
+  static async kill(sandboxId, opts) {
+    const config = opts?.config ?? new ConnectionConfig();
+    const client = getSharedClient(config);
+    const wait = opts?.wait === true;
+    const path = wait ? `/sandboxes/${sandboxId}` : `/sandboxes/${sandboxId}?async=true`;
+    const data = await client.delete(path, {
+      timeout: opts?.requestTimeout
     });
+    if (!wait) return data.queued ?? true;
     return data.killed ?? false;
   }
   /**