computesdk 1.10.0 → 1.10.2

package/dist/index.mjs

@@ -1,847 +1,3111 @@
-// src/types/sandbox.ts
-import { Sandbox } from "@computesdk/client";
-import {
-  CommandExitError,
-  isCommandExitError
-} from "@computesdk/client";
-
-// src/provider-config.ts
-var PROVIDER_AUTH = {
-  e2b: [["E2B_API_KEY"]],
-  modal: [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
-  railway: [["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]],
-  daytona: [["DAYTONA_API_KEY"]],
-  vercel: [
-    ["VERCEL_OIDC_TOKEN"],
-    ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]
-  ],
-  runloop: [["RUNLOOP_API_KEY"]],
-  cloudflare: [["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]],
-  codesandbox: [["CSB_API_KEY"]],
-  blaxel: [["BL_API_KEY", "BL_WORKSPACE"]]
-};
-var PROVIDER_NAMES = Object.keys(PROVIDER_AUTH);
-var PROVIDER_HEADERS = {
-  e2b: {
-    apiKey: "X-E2B-API-Key"
-  },
-  modal: {
-    tokenId: "X-Modal-Token-Id",
-    tokenSecret: "X-Modal-Token-Secret"
-  },
-  railway: {
-    apiToken: "X-Railway-API-Token"
-  },
-  daytona: {
-    apiKey: "X-Daytona-API-Key"
-  },
-  vercel: {
-    oidcToken: "X-Vercel-OIDC-Token",
-    token: "X-Vercel-Token",
-    teamId: "X-Vercel-Team-Id",
-    projectId: "X-Vercel-Project-Id"
-  },
-  runloop: {
-    apiKey: "X-Runloop-API-Key"
-  },
-  cloudflare: {
-    apiToken: "X-Cloudflare-API-Token",
-    accountId: "X-Cloudflare-Account-Id"
-  },
-  codesandbox: {
-    apiKey: "X-CSB-API-Key"
-  },
-  blaxel: {
-    apiKey: "X-BL-API-Key",
-    workspace: "X-BL-Workspace"
-  }
-};
-var PROVIDER_ENV_MAP = {
-  e2b: {
-    E2B_API_KEY: "apiKey"
-  },
-  modal: {
-    MODAL_TOKEN_ID: "tokenId",
-    MODAL_TOKEN_SECRET: "tokenSecret"
-  },
-  railway: {
-    RAILWAY_API_KEY: "apiToken",
-    RAILWAY_PROJECT_ID: "projectId",
-    RAILWAY_ENVIRONMENT_ID: "environmentId"
-  },
-  daytona: {
-    DAYTONA_API_KEY: "apiKey"
-  },
-  vercel: {
-    VERCEL_OIDC_TOKEN: "oidcToken",
-    VERCEL_TOKEN: "token",
-    VERCEL_TEAM_ID: "teamId",
-    VERCEL_PROJECT_ID: "projectId"
-  },
-  runloop: {
-    RUNLOOP_API_KEY: "apiKey"
-  },
-  cloudflare: {
-    CLOUDFLARE_API_TOKEN: "apiToken",
-    CLOUDFLARE_ACCOUNT_ID: "accountId"
-  },
-  codesandbox: {
-    CSB_API_KEY: "apiKey"
-  },
-  blaxel: {
-    BL_API_KEY: "apiKey",
-    BL_WORKSPACE: "workspace"
-  }
-};
-var PROVIDER_DASHBOARD_URLS = {
-  e2b: "https://e2b.dev/dashboard",
-  modal: "https://modal.com/settings",
-  railway: "https://railway.app/account/tokens",
-  daytona: "https://daytona.io/dashboard",
-  vercel: "https://vercel.com/account/tokens",
-  runloop: "https://runloop.ai/dashboard",
-  cloudflare: "https://dash.cloudflare.com/profile/api-tokens",
-  codesandbox: "https://codesandbox.io/dashboard/settings",
-  blaxel: "https://blaxel.ai/dashboard"
-};
-function isValidProvider(name) {
-  return name in PROVIDER_AUTH;
+// src/client/protocol.ts
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2[MessageType2["Subscribe"] = 1] = "Subscribe";
+  MessageType2[MessageType2["Unsubscribe"] = 2] = "Unsubscribe";
+  MessageType2[MessageType2["Data"] = 3] = "Data";
+  MessageType2[MessageType2["Error"] = 4] = "Error";
+  MessageType2[MessageType2["Connected"] = 5] = "Connected";
+  return MessageType2;
+})(MessageType || {});
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function getValueSize(value) {
+  if (typeof value === "string") {
+    return textEncoder.encode(value).length;
+  } else if (typeof value === "number") {
+    return 8;
+  } else if (typeof value === "boolean") {
+    return 1;
+  } else if (value instanceof Uint8Array) {
+    return value.length;
+  }
+  return 0;
 }
-function buildProviderHeaders(provider, config) {
-  const headers = {};
-  const headerMap = PROVIDER_HEADERS[provider];
-  for (const [configKey, headerName] of Object.entries(headerMap)) {
-    const value = config[configKey];
-    if (value) {
-      headers[headerName] = value;
+function encodeKeyValue(data) {
+  let totalSize = 2;
+  const fields = Object.entries(data);
+  for (const [key, value] of fields) {
+    const keyBytes = textEncoder.encode(key);
+    totalSize += 2;
+    totalSize += keyBytes.length;
+    totalSize += 1;
+    totalSize += 4;
+    totalSize += getValueSize(value);
+  }
+  const buffer = new Uint8Array(totalSize);
+  const view = new DataView(buffer.buffer);
+  let offset = 0;
+  view.setUint16(offset, fields.length, false);
+  offset += 2;
+  for (const [key, value] of fields) {
+    const keyBytes = textEncoder.encode(key);
+    view.setUint16(offset, keyBytes.length, false);
+    offset += 2;
+    buffer.set(keyBytes, offset);
+    offset += keyBytes.length;
+    if (typeof value === "string") {
+      buffer[offset] = 1 /* String */;
+      offset++;
+      const valueBytes = textEncoder.encode(value);
+      view.setUint32(offset, valueBytes.length, false);
+      offset += 4;
+      buffer.set(valueBytes, offset);
+      offset += valueBytes.length;
+    } else if (typeof value === "number") {
+      buffer[offset] = 2 /* Number */;
+      offset++;
+      view.setUint32(offset, 8, false);
+      offset += 4;
+      view.setFloat64(offset, value, false);
+      offset += 8;
+    } else if (typeof value === "boolean") {
+      buffer[offset] = 3 /* Boolean */;
+      offset++;
+      view.setUint32(offset, 1, false);
+      offset += 4;
+      buffer[offset] = value ? 1 : 0;
+      offset++;
+    } else if (value instanceof Uint8Array) {
+      buffer[offset] = 4 /* Bytes */;
+      offset++;
+      view.setUint32(offset, value.length, false);
+      offset += 4;
+      buffer.set(value, offset);
+      offset += value.length;
+    } else {
+      throw new Error(`Unsupported value type for key ${key}: ${typeof value}`);
     }
   }
-  return headers;
+  return buffer;
 }
-function getProviderConfigFromEnv(provider) {
-  const config = {};
-  const envMap = PROVIDER_ENV_MAP[provider];
-  for (const [envVar, configKey] of Object.entries(envMap)) {
-    const value = process.env[envVar];
-    if (value) {
-      config[configKey] = value;
+function decodeKeyValue(data) {
+  if (data.length < 2) {
+    throw new Error("Data too short for key-value encoding");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const result = {};
+  let offset = 0;
+  const numFields = view.getUint16(offset, false);
+  offset += 2;
+  for (let i = 0; i < numFields; i++) {
+    if (offset + 2 > data.length) {
+      throw new Error(`Invalid key length at field ${i}`);
+    }
+    const keyLen = view.getUint16(offset, false);
+    offset += 2;
+    if (offset + keyLen > data.length) {
+      throw new Error(`Key data truncated at field ${i}`);
+    }
+    const key = textDecoder.decode(data.slice(offset, offset + keyLen));
+    offset += keyLen;
+    if (offset + 1 > data.length) {
+      throw new Error(`Invalid value type at field ${i}`);
+    }
+    const valueType = data[offset];
+    offset++;
+    if (offset + 4 > data.length) {
+      throw new Error(`Invalid value length at field ${i}`);
+    }
+    const valueLen = view.getUint32(offset, false);
+    offset += 4;
+    if (offset + valueLen > data.length) {
+      throw new Error(`Value data truncated at field ${i}`);
+    }
+    const valueData = data.slice(offset, offset + valueLen);
+    offset += valueLen;
+    switch (valueType) {
+      case 1 /* String */:
+        result[key] = textDecoder.decode(valueData);
+        break;
+      case 2 /* Number */:
+        if (valueData.length !== 8) {
+          throw new Error(`Invalid number length for field ${key}`);
+        }
+        const valueView = new DataView(valueData.buffer, valueData.byteOffset);
+        result[key] = valueView.getFloat64(0, false);
+        break;
+      case 3 /* Boolean */:
+        if (valueData.length !== 1) {
+          throw new Error(`Invalid boolean length for field ${key}`);
+        }
+        result[key] = valueData[0] !== 0;
+        break;
+      case 4 /* Bytes */:
+        result[key] = valueData;
+        break;
+      default:
+        throw new Error(`Unknown value type 0x${valueType.toString(16)} for field ${key}`);
     }
   }
-  return config;
+  return result;
 }
-function isProviderAuthComplete(provider) {
-  const authOptions = PROVIDER_AUTH[provider];
-  for (const option of authOptions) {
-    const allPresent = option.every((envVar) => !!process.env[envVar]);
-    if (allPresent) return true;
+function encodeBinaryMessage(message) {
+  let messageType;
+  let channel = "";
+  let msgType = "";
+  let data = {};
+  if (message.type === "subscribe") {
+    messageType = 1 /* Subscribe */;
+    channel = message.channel || "";
+    msgType = "subscribe";
+    data = {};
+  } else if (message.type === "unsubscribe") {
+    messageType = 2 /* Unsubscribe */;
+    channel = message.channel || "";
+    msgType = "unsubscribe";
+    data = {};
+  } else {
+    messageType = 3 /* Data */;
+    channel = message.channel || "";
+    msgType = message.type || "";
+    data = message.data || message;
+  }
+  const channelBytes = encodeUTF8(channel);
+  const msgTypeBytes = encodeUTF8(msgType);
+  let dataBytes;
+  if (data === void 0 || data === null) {
+    dataBytes = new Uint8Array(0);
+  } else if (typeof data === "string") {
+    dataBytes = encodeUTF8(data);
+  } else if (data instanceof Uint8Array) {
+    dataBytes = data;
+  } else if (typeof data === "object") {
+    dataBytes = encodeKeyValue(data);
+  } else {
+    throw new Error(`Unsupported data type: ${typeof data}`);
+  }
+  const totalSize = 1 + 2 + channelBytes.length + 2 + msgTypeBytes.length + 4 + dataBytes.length;
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  let offset = 0;
+  view.setUint8(offset, messageType);
+  offset += 1;
+  view.setUint16(offset, channelBytes.length, false);
+  offset += 2;
+  const uint8View = new Uint8Array(buffer);
+  uint8View.set(channelBytes, offset);
+  offset += channelBytes.length;
+  view.setUint16(offset, msgTypeBytes.length, false);
+  offset += 2;
+  uint8View.set(msgTypeBytes, offset);
+  offset += msgTypeBytes.length;
+  view.setUint32(offset, dataBytes.length, false);
+  offset += 4;
+  uint8View.set(dataBytes, offset);
+  return buffer;
+}
+function decodeBinaryMessage(buffer) {
+  const arrayBuffer = buffer instanceof Uint8Array ? buffer.buffer : buffer;
+  const view = new DataView(arrayBuffer);
+  const uint8View = new Uint8Array(arrayBuffer);
+  let offset = 0;
+  const messageType = view.getUint8(offset);
+  offset += 1;
+  const channelLength = view.getUint16(offset, false);
+  offset += 2;
+  const channelBytes = uint8View.slice(offset, offset + channelLength);
+  const channel = decodeUTF8(channelBytes);
+  offset += channelLength;
+  const msgTypeLength = view.getUint16(offset, false);
+  offset += 2;
+  const msgTypeBytes = uint8View.slice(offset, offset + msgTypeLength);
+  const msgType = decodeUTF8(msgTypeBytes);
+  offset += msgTypeLength;
+  const dataLength = view.getUint32(offset, false);
+  offset += 4;
+  const dataBytes = uint8View.slice(offset, offset + dataLength);
+  const shouldTryKeyValue = ["terminal:input", "terminal:resize", "file:changed", "terminal:output", "signal", "test"].includes(msgType);
+  let data;
+  if (dataBytes.length === 0) {
+    data = {};
+  } else if (shouldTryKeyValue) {
+    try {
+      data = decodeKeyValue(dataBytes);
+    } catch {
+      data = dataBytes;
+    }
+  } else {
+    data = dataBytes;
   }
-  return false;
+  if (messageType === 1 /* Subscribe */ || messageType === 2 /* Unsubscribe */) {
+    return {
+      type: msgType,
+      channel
+    };
+  }
+  return {
+    type: msgType,
+    channel,
+    data
+  };
 }
-function getMissingEnvVars(provider) {
-  const authOptions = PROVIDER_AUTH[provider];
-  let bestOption = null;
-  for (const option of authOptions) {
-    const missing = [];
-    let presentCount = 0;
-    for (const envVar of option) {
-      if (process.env[envVar]) {
-        presentCount++;
-      } else {
-        missing.push(envVar);
-      }
+function encodeUTF8(str) {
+  if (typeof TextEncoder !== "undefined") {
+    const encoder = new TextEncoder();
+    return encoder.encode(str);
+  }
+  const utf8 = [];
+  for (let i = 0; i < str.length; i++) {
+    let charcode = str.charCodeAt(i);
+    if (charcode < 128) {
+      utf8.push(charcode);
+    } else if (charcode < 2048) {
+      utf8.push(192 | charcode >> 6, 128 | charcode & 63);
+    } else if (charcode < 55296 || charcode >= 57344) {
+      utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+    } else {
+      i++;
+      charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+      utf8.push(
+        240 | charcode >> 18,
+        128 | charcode >> 12 & 63,
+        128 | charcode >> 6 & 63,
+        128 | charcode & 63
+      );
     }
-    if (missing.length === 0) return [];
-    if (!bestOption || presentCount > bestOption.presentCount) {
-      bestOption = { presentCount, missing };
+  }
+  return new Uint8Array(utf8);
+}
+function decodeUTF8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    const decoder = new TextDecoder();
+    return decoder.decode(bytes);
+  }
+  let str = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const c = bytes[i++];
+    if (c < 128) {
+      str += String.fromCharCode(c);
+    } else if (c < 224) {
+      str += String.fromCharCode((c & 31) << 6 | bytes[i++] & 63);
+    } else if (c < 240) {
+      str += String.fromCharCode((c & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63);
+    } else {
+      const c2 = (c & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
+      const c3 = c2 - 65536;
+      str += String.fromCharCode(55296 | c3 >> 10, 56320 | c3 & 1023);
     }
   }
-  return bestOption?.missing ?? [];
+  return str;
+}
+function isBinaryData(data) {
+  return data instanceof ArrayBuffer || data instanceof Uint8Array || data instanceof Blob;
+}
+async function blobToArrayBuffer(blob) {
+  if (blob.arrayBuffer) {
+    return blob.arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
 }
 
-// src/constants.ts
-var GATEWAY_URL = "https://gateway.computesdk.com";
-var PROVIDER_PRIORITY = [
-  "e2b",
-  "railway",
-  "daytona",
-  "modal",
-  "runloop",
-  "vercel",
-  "cloudflare",
-  "codesandbox",
-  "blaxel"
-];
-var PROVIDER_ENV_VARS = {
-  e2b: ["E2B_API_KEY"],
-  railway: ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"],
-  daytona: ["DAYTONA_API_KEY"],
-  modal: ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"],
-  runloop: ["RUNLOOP_API_KEY"],
-  vercel: ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"],
-  cloudflare: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"],
-  codesandbox: ["CSB_API_KEY"],
-  blaxel: ["BL_API_KEY", "BL_WORKSPACE"]
-};
-
-// src/providers/gateway.ts
-import { Sandbox as ClientSandbox } from "@computesdk/client";
-
-// src/factory.ts
-import { cmd } from "@computesdk/cmd";
-var UnsupportedFileSystem = class {
-  constructor(providerName) {
-    this.providerName = providerName;
+// src/client/websocket.ts
+var WebSocketManager = class {
+  constructor(config) {
+    this.ws = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.subscribedChannels = /* @__PURE__ */ new Set();
+    this.isManualClose = false;
+    this.config = {
+      url: config.url,
+      WebSocket: config.WebSocket,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectDelay: config.reconnectDelay ?? 1e3,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 5,
+      debug: config.debug ?? false,
+      protocol: config.protocol ?? "binary"
+    };
   }
-  async readFile(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  /**
+   * Connect to WebSocket server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.isManualClose = false;
+        this.log("Connecting to WebSocket URL:", this.config.url);
+        this.ws = new this.config.WebSocket(this.config.url);
+        this.ws.onopen = () => {
+          this.log("Connected to WebSocket server");
+          this.reconnectAttempts = 0;
+          if (this.subscribedChannels.size > 0) {
+            this.log("Resubscribing to channels:", Array.from(this.subscribedChannels));
+            this.subscribedChannels.forEach((channel) => {
+              this.sendRaw({ type: "subscribe", channel });
+            });
+          }
+          this.emit("open");
+          resolve();
+        };
+        this.ws.onmessage = async (event) => {
+          try {
+            let message;
+            if (this.config.protocol === "binary" && isBinaryData(event.data)) {
+              let buffer;
+              if (event.data instanceof Blob) {
+                buffer = await blobToArrayBuffer(event.data);
+              } else {
+                buffer = event.data;
+              }
+              message = decodeBinaryMessage(buffer);
+              this.log("Received binary message:", message);
+            } else {
+              message = JSON.parse(event.data);
+              this.log("Received JSON message:", message);
+            }
+            this.handleMessage(message);
+          } catch (error) {
+            this.log("Failed to parse message:", error);
+          }
+        };
+        this.ws.onerror = (error) => {
+          this.log("WebSocket error:", error);
+          this.emit("error", error);
+          reject(error);
+        };
+        this.ws.onclose = () => {
+          this.log("WebSocket connection closed");
+          this.emit("close");
+          if (this.config.autoReconnect && !this.isManualClose) {
+            this.attemptReconnect();
+          }
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
   }
-  async writeFile(_path, _content) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.isManualClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
   }
-  async mkdir(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  /**
+   * Check if WebSocket is connected
+   */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
   }
-  async readdir(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  /**
+   * Attempt to reconnect to WebSocket server
+   */
+  attemptReconnect() {
+    if (this.config.maxReconnectAttempts > 0 && this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      this.log("Max reconnection attempts reached");
+      this.emit("reconnect-failed");
+      return;
+    }
+    this.reconnectAttempts++;
+    this.log(`Reconnecting... (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch((error) => {
+        this.log("Reconnection failed:", error);
+      });
+    }, this.config.reconnectDelay);
   }
-  async exists(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  // ============================================================================
+  // Channel Subscription
+  // ============================================================================
+  /**
+   * Subscribe to a channel
+   * @param channel - Channel name (e.g., 'terminal:term_abc123', 'watcher:watcher_xyz789', 'signals')
+   */
+  subscribe(channel) {
+    this.subscribedChannels.add(channel);
+    this.sendRaw({ type: "subscribe", channel });
+    this.log("Subscribed to channel:", channel);
   }
-  async remove(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribe(channel) {
+    this.subscribedChannels.delete(channel);
+    this.sendRaw({ type: "unsubscribe", channel });
+    this.log("Unsubscribed from channel:", channel);
   }
-};
-var SupportedFileSystem = class {
-  constructor(sandbox, methods, allMethods) {
-    this.sandbox = sandbox;
-    this.methods = methods;
-    this.allMethods = allMethods;
+  /**
+   * Get list of subscribed channels
+   */
+  getSubscribedChannels() {
+    return Array.from(this.subscribedChannels);
   }
-  async readFile(path) {
-    return this.methods.readFile(this.sandbox, path, this.allMethods.runCommand);
+  // ============================================================================
+  // Message Sending
+  // ============================================================================
+  /**
+   * Send raw message to server
+   */
+  sendRaw(message) {
+    if (!this.isConnected()) {
+      throw new Error("WebSocket is not connected");
+    }
+    if (this.config.protocol === "binary") {
+      const buffer = encodeBinaryMessage(message);
+      this.ws.send(buffer);
+      this.log("Sent binary message:", message);
+    } else {
+      this.ws.send(JSON.stringify(message));
+      this.log("Sent JSON message:", message);
+    }
   }
-  async writeFile(path, content) {
-    return this.methods.writeFile(this.sandbox, path, content, this.allMethods.runCommand);
+  /**
+   * Send input to a terminal (sent as-is, not encoded)
+   */
+  sendTerminalInput(terminalId, input) {
+    this.sendRaw({
+      type: "terminal:input",
+      data: { terminal_id: terminalId, input }
+    });
   }
-  async mkdir(path) {
-    return this.methods.mkdir(this.sandbox, path, this.allMethods.runCommand);
+  /**
+   * Resize terminal window
+   */
+  resizeTerminal(terminalId, cols, rows) {
+    this.sendRaw({
+      type: "terminal:resize",
+      data: { terminal_id: terminalId, cols, rows }
+    });
   }
-  async readdir(path) {
-    return this.methods.readdir(this.sandbox, path, this.allMethods.runCommand);
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
   }
-  async exists(path) {
-    return this.methods.exists(this.sandbox, path, this.allMethods.runCommand);
+  /**
+   * Unregister event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.eventHandlers.delete(event);
+      }
+    }
   }
-  async remove(path) {
-    return this.methods.remove(this.sandbox, path, this.allMethods.runCommand);
+  /**
+   * Unregister all event handlers for an event
+   */
+  offAll(event) {
+    this.eventHandlers.delete(event);
   }
-};
-var GeneratedSandbox = class {
-  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod, providerInstance) {
-    this.sandbox = sandbox;
-    this.methods = methods;
-    this.config = config;
-    this.destroyMethod = destroyMethod;
-    this.providerInstance = providerInstance;
-    this.sandboxId = sandboxId;
-    this.provider = providerName;
-    if (methods.filesystem) {
-      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem, methods);
-    } else {
-      this.filesystem = new UnsupportedFileSystem(providerName);
+  /**
+   * Emit event to registered handlers
+   */
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          this.log("Error in event handler:", error);
+        }
+      });
     }
   }
-  getInstance() {
-    if (this.methods.getInstance) {
-      return this.methods.getInstance(this.sandbox);
+  /**
+   * Handle incoming message
+   */
+  handleMessage(message) {
+    this.emit(message.type, message);
+    if ("channel" in message && message.channel) {
+      this.emit(message.channel, message);
     }
-    return this.sandbox;
   }
-  async runCode(code, runtime) {
-    return await this.methods.runCode(this.sandbox, code, runtime, this.config);
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+  /**
+   * Log debug message if debug mode is enabled
+   */
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[WebSocketManager]", ...args);
+    }
   }
-  async runCommand(commandOrArray, argsOrOptions, maybeOptions) {
-    let command;
-    let args;
-    let options;
-    if (Array.isArray(commandOrArray)) {
-      [command, ...args] = commandOrArray;
-      options = argsOrOptions;
-    } else {
-      command = commandOrArray;
-      args = Array.isArray(argsOrOptions) ? argsOrOptions : [];
-      options = Array.isArray(argsOrOptions) ? maybeOptions : argsOrOptions;
-    }
-    const baseCommand = args.length > 0 ? [command, ...args] : [command];
-    if (options?.cwd || options?.background) {
-      const wrappedCommand = cmd(baseCommand, {
-        cwd: options.cwd,
-        background: options.background
-      });
-      const [wrappedCmd, ...wrappedArgs] = wrappedCommand;
-      return await this.methods.runCommand(this.sandbox, wrappedCmd, wrappedArgs, void 0);
+  /**
+   * Get current connection state
+   */
+  getState() {
+    if (!this.ws) return "closed";
+    switch (this.ws.readyState) {
+      case WebSocket.CONNECTING:
+        return "connecting";
+      case WebSocket.OPEN:
+        return "open";
+      case WebSocket.CLOSING:
+        return "closing";
+      case WebSocket.CLOSED:
+        return "closed";
+      default:
+        return "closed";
     }
-    return await this.methods.runCommand(this.sandbox, command, args, options);
   }
-  async getInfo() {
-    return await this.methods.getInfo(this.sandbox);
+  /**
+   * Get reconnection attempt count
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
   }
-  async getUrl(options) {
-    return await this.methods.getUrl(this.sandbox, options);
+};
+
+// src/client/resources/command.ts
+var Command = class {
+  constructor(data) {
+    this.id = data.cmdId;
+    this.terminalId = data.terminalId;
+    this.command = data.command;
+    this._status = data.status;
+    this._stdout = data.stdout;
+    this._stderr = data.stderr;
+    this._exitCode = data.exitCode;
+    this._durationMs = data.durationMs;
+    this._startedAt = data.startedAt;
+    this._finishedAt = data.finishedAt;
   }
-  getProvider() {
-    return this.providerInstance;
+  get status() {
+    return this._status;
   }
-  async kill() {
-    await this.destroy();
+  get stdout() {
+    return this._stdout;
   }
-  async destroy() {
-    await this.destroyMethod(this.config, this.sandboxId);
+  get stderr() {
+    return this._stderr;
   }
-};
-function getEffectiveMode(config, defaultMode) {
-  if (config.mode) {
-    return config.mode;
+  get exitCode() {
+    return this._exitCode;
   }
-  return defaultMode;
-}
-var GeneratedSandboxManager = class {
-  constructor(config, providerName, methods, providerInstance, defaultMode) {
-    this.config = config;
-    this.providerName = providerName;
-    this.methods = methods;
-    this.providerInstance = providerInstance;
-    this.effectiveMode = getEffectiveMode(config, defaultMode);
+  get durationMs() {
+    return this._durationMs;
   }
-  async create(options) {
-    const optionsWithDefaults = { runtime: "node", ...options };
-    const result = await this.methods.create(this.config, optionsWithDefaults);
-    return new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
+  get startedAt() {
+    return this._startedAt;
   }
-  async getById(sandboxId) {
-    const result = await this.methods.getById(this.config, sandboxId);
-    if (!result) {
-      return null;
-    }
-    return new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
+  get finishedAt() {
+    return this._finishedAt;
   }
-  async list() {
-    const results = await this.methods.list(this.config);
-    return results.map((result) => new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    ));
-  }
-  async destroy(sandboxId) {
-    await this.methods.destroy(this.config, sandboxId);
-  }
-  async findOrCreate(options) {
-    if (!this.methods.findOrCreate) {
-      throw new Error(
-        `Provider '${this.providerName}' does not support findOrCreate.
-This feature requires gateway provider with named sandbox support.`
-      );
-    }
-    const result = await this.methods.findOrCreate(this.config, options);
-    return new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
+  /**
+   * Set the wait handler (called by TerminalCommands)
+   * @internal
+   */
+  setWaitHandler(handler) {
+    this.waitHandler = handler;
   }
-  async find(options) {
-    if (!this.methods.find) {
-      throw new Error(
-        `Provider '${this.providerName}' does not support find.
-This feature requires gateway provider with named sandbox support.`
-      );
+  /**
+   * Set the retrieve handler (called by TerminalCommands)
+   * @internal
+   */
+  setRetrieveHandler(handler) {
+    this.retrieveHandler = handler;
+  }
+  /**
+   * Wait for the command to complete
+   * @param timeout - Optional timeout in seconds (0 = no timeout)
+   * @returns This command with updated status
+   */
+  async wait(timeout) {
+    if (!this.waitHandler) {
+      throw new Error("Wait handler not set");
     }
-    const result = await this.methods.find(this.config, options);
-    if (!result) {
-      return null;
-    }
-    return new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
+    const response = await this.waitHandler(timeout);
+    this.updateFromResponse(response);
+    return this;
   }
-  async extendTimeout(sandboxId, options) {
-    if (!this.methods.extendTimeout) {
-      throw new Error(
-        `Provider '${this.providerName}' does not support extendTimeout.
-This feature requires gateway provider with timeout extension support.`
-      );
+  /**
+   * Refresh the command status from the server
+   * @returns This command with updated status
+   */
+  async refresh() {
+    if (!this.retrieveHandler) {
+      throw new Error("Retrieve handler not set");
     }
-    await this.methods.extendTimeout(this.config, sandboxId, options);
+    const response = await this.retrieveHandler();
+    this.updateFromResponse(response);
+    return this;
+  }
+  /**
+   * Update internal state from API response
+   */
+  updateFromResponse(response) {
+    this._status = response.data.status;
+    this._stdout = response.data.stdout;
+    this._stderr = response.data.stderr;
+    this._exitCode = response.data.exit_code;
+    this._durationMs = response.data.duration_ms;
+    this._finishedAt = response.data.finished_at;
   }
 };
-var GeneratedTemplateManager = class {
-  constructor(config, methods) {
-    this.config = config;
-    this.methods = methods;
+
+// src/client/resources/terminal-command.ts
+var TerminalCommand = class {
+  constructor(terminalId, handlers) {
+    this.terminalId = terminalId;
+    this.runHandler = handlers.run;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.waitHandler = handlers.wait;
   }
-  async create(options) {
-    return await this.methods.create(this.config, options);
+  /**
+   * Run a command in the terminal
+   * @param command - The command to execute
+   * @param options - Execution options
+   * @param options.background - If true, returns immediately without waiting for completion
+   * @returns Command object with results or status
+   */
+  async run(command, options) {
+    const response = await this.runHandler(command, options?.background);
+    const cmd2 = new Command({
+      cmdId: response.data.cmd_id || "",
+      terminalId: this.terminalId,
+      command: response.data.command,
+      status: response.data.status || (options?.background ? "running" : "completed"),
+      stdout: response.data.stdout,
+      stderr: response.data.stderr,
+      exitCode: response.data.exit_code,
+      durationMs: response.data.duration_ms,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    cmd2.setWaitHandler((timeout) => this.waitHandler(cmd2.id, timeout));
+    cmd2.setRetrieveHandler(() => this.retrieveHandler(cmd2.id));
+    return cmd2;
   }
-  async list(options) {
-    return await this.methods.list(this.config, options);
+  /**
+   * List all commands executed in this terminal
+   * @returns Array of Command objects
+   */
+  async list() {
+    const response = await this.listHandler();
+    return response.data.commands.map((item) => {
+      const cmd2 = new Command({
+        cmdId: item.cmd_id,
+        terminalId: this.terminalId,
+        command: item.command,
+        status: item.status,
+        stdout: "",
+        // Not included in list response
+        stderr: "",
+        // Not included in list response
+        exitCode: item.exit_code,
+        durationMs: item.duration_ms,
+        startedAt: item.started_at,
+        finishedAt: item.finished_at
+      });
+      cmd2.setWaitHandler((timeout) => this.waitHandler(cmd2.id, timeout));
+      cmd2.setRetrieveHandler(() => this.retrieveHandler(cmd2.id));
+      return cmd2;
+    });
   }
-  async delete(templateId) {
-    return await this.methods.delete(this.config, templateId);
+  /**
+   * Retrieve a specific command by ID
+   * @param cmdId - The command ID
+   * @returns Command object with full details
+   */
+  async retrieve(cmdId) {
+    const response = await this.retrieveHandler(cmdId);
+    const cmd2 = new Command({
+      cmdId: response.data.cmd_id,
+      terminalId: this.terminalId,
+      command: response.data.command,
+      status: response.data.status,
+      stdout: response.data.stdout,
+      stderr: response.data.stderr,
+      exitCode: response.data.exit_code,
+      durationMs: response.data.duration_ms,
+      startedAt: response.data.started_at,
+      finishedAt: response.data.finished_at
+    });
+    cmd2.setWaitHandler((timeout) => this.waitHandler(cmd2.id, timeout));
+    cmd2.setRetrieveHandler(() => this.retrieveHandler(cmd2.id));
+    return cmd2;
   }
 };
-var GeneratedSnapshotManager = class {
-  constructor(config, methods) {
-    this.config = config;
-    this.methods = methods;
+
+// src/client/terminal.ts
+function decodeBase64(str) {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    return window.atob(str);
+  } else if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "base64").toString("utf-8");
+  }
+  throw new Error("No base64 decoding available");
+}
+var TerminalInstance = class {
+  constructor(id, pty, status, channel, ws, encoding = "raw") {
+    this._eventHandlers = /* @__PURE__ */ new Map();
+    this._id = id;
+    this._pty = pty;
+    this._status = status === "active" ? "running" : status;
+    this._channel = channel;
+    this._ws = ws;
+    this._encoding = encoding;
+    this.command = new TerminalCommand(id, {
+      run: async (command, background) => {
+        if (!this._executeHandler) {
+          throw new Error("Execute handler not set");
+        }
+        return this._executeHandler(command, background);
+      },
+      list: async () => {
+        if (!this._listCommandsHandler) {
+          throw new Error("List commands handler not set");
+        }
+        return this._listCommandsHandler();
+      },
+      retrieve: async (cmdId) => {
+        if (!this._retrieveCommandHandler) {
+          throw new Error("Retrieve command handler not set");
+        }
+        return this._retrieveCommandHandler(cmdId);
+      },
+      wait: async (cmdId, timeout) => {
+        if (!this._waitCommandHandler) {
+          throw new Error("Wait command handler not set");
+        }
+        return this._waitCommandHandler(cmdId, timeout);
+      }
+    });
+    if (this._pty && this._ws && this._channel) {
+      this._ws.subscribe(this._channel);
+      this.setupWebSocketHandlers();
+    }
+  }
+  /**
+   * Set up WebSocket event handlers (PTY mode only)
+   */
+  setupWebSocketHandlers() {
+    if (!this._ws || !this._channel) {
+      return;
+    }
+    this._ws.on("terminal:output", (msg) => {
+      if (msg.channel === this._channel) {
+        const encoding = msg.data.encoding || this._encoding;
+        const output = encoding === "base64" ? decodeBase64(msg.data.output) : msg.data.output;
+        this.emit("output", output);
+      }
+    });
+    this._ws.on("terminal:error", (msg) => {
+      if (msg.channel === this._channel) {
+        this.emit("error", msg.data.error);
+      }
+    });
+    this._ws.on("terminal:destroyed", (msg) => {
+      if (msg.channel === this._channel) {
+        this._status = "stopped";
+        this.emit("destroyed");
+        this.cleanup();
+      }
+    });
+  }
+  /**
+   * Terminal ID
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Get terminal ID (deprecated, use .id property)
+   * @deprecated Use .id property instead
+   */
+  getId() {
+    return this._id;
   }
-  async create(sandboxId, options) {
-    return await this.methods.create(this.config, sandboxId, options);
+  /**
+   * Terminal status
+   */
+  get status() {
+    return this._status;
   }
-  async list(options) {
-    return await this.methods.list(this.config, options);
+  /**
+   * Get terminal status (deprecated, use .status property)
+   * @deprecated Use .status property instead
+   */
+  getStatus() {
+    return this._status;
   }
-  async delete(snapshotId) {
-    return await this.methods.delete(this.config, snapshotId);
+  /**
+   * Terminal channel (null for exec mode)
+   */
+  get channel() {
+    return this._channel;
   }
-};
-var GeneratedProvider = class {
-  constructor(config, providerConfig) {
-    this.name = providerConfig.name;
-    this.sandbox = new GeneratedSandboxManager(
-      config,
-      providerConfig.name,
-      providerConfig.methods.sandbox,
-      this,
-      providerConfig.defaultMode ?? "gateway"
-    );
-    if (providerConfig.methods.template) {
-      this.template = new GeneratedTemplateManager(config, providerConfig.methods.template);
+  /**
+   * Get terminal channel (deprecated, use .channel property)
+   * @deprecated Use .channel property instead
+   */
+  getChannel() {
+    return this._channel;
+  }
+  /**
+   * Whether this is a PTY terminal
+   */
+  get pty() {
+    return this._pty;
+  }
+  /**
+   * Get terminal PTY mode (deprecated, use .pty property)
+   * @deprecated Use .pty property instead
+   */
+  isPTY() {
+    return this._pty;
+  }
+  /**
+   * Check if terminal is running
+   */
+  isRunning() {
+    return this._status === "running";
+  }
+  /**
+   * Write input to the terminal (PTY mode only)
+   */
+  write(input) {
+    if (!this._pty) {
+      throw new Error("write() is only available for PTY terminals. Use commands.run() for exec mode terminals.");
     }
-    if (providerConfig.methods.snapshot) {
-      this.snapshot = new GeneratedSnapshotManager(config, providerConfig.methods.snapshot);
+    if (!this._ws) {
+      throw new Error("WebSocket not available");
     }
+    if (!this.isRunning()) {
+      console.warn('[Terminal] Warning: Terminal status is not "running", but attempting to write anyway. Status:', this._status);
+    }
+    this._ws.sendTerminalInput(this._id, input);
   }
-  getSupportedRuntimes() {
-    return ["node", "python"];
+  /**
+   * Resize terminal window (PTY mode only)
+   */
+  resize(cols, rows) {
+    if (!this._pty) {
+      throw new Error("resize() is only available for PTY terminals");
+    }
+    if (!this._ws) {
+      throw new Error("WebSocket not available");
+    }
+    if (!this.isRunning()) {
+      throw new Error("Terminal is not running");
+    }
+    this._ws.resizeTerminal(this._id, cols, rows);
   }
-};
-function createProvider(providerConfig) {
-  return (config) => {
-    return new GeneratedProvider(config, providerConfig);
-  };
-}
-
-// src/compute-daemon/lifecycle.ts
-async function waitForComputeReady(client, options = {}) {
-  const maxRetries = options.maxRetries ?? 30;
-  const initialDelayMs = options.initialDelayMs ?? 500;
-  const maxDelayMs = options.maxDelayMs ?? 5e3;
-  const backoffFactor = options.backoffFactor ?? 1.5;
-  let lastError = null;
-  let currentDelay = initialDelayMs;
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      await client.health();
-      if (process.env.COMPUTESDK_DEBUG) {
-        console.log(`[Lifecycle] Sandbox ready after ${i + 1} attempt${i === 0 ? "" : "s"}`);
-      }
-      return;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (i === maxRetries - 1) {
-        throw new Error(
-          `Sandbox failed to become ready after ${maxRetries} attempts.
-Last error: ${lastError.message}
-
-Possible causes:
-  1. Sandbox failed to start (check provider dashboard for errors)
-  2. Network connectivity issues between your app and the sandbox
-  3. Sandbox is taking longer than expected to initialize
-  4. Invalid sandbox URL or authentication credentials
-
-Troubleshooting:
-  - Check sandbox logs in your provider dashboard
-  - Verify your network connection
-  - Try increasing maxRetries if initialization is slow
-  - Enable debug mode: export COMPUTESDK_DEBUG=1`
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, currentDelay));
-      currentDelay = Math.min(currentDelay * backoffFactor, maxDelayMs);
+  /**
+   * Set execute command handler (called by Sandbox)
+   * @internal
+   */
+  setExecuteHandler(handler) {
+    this._executeHandler = handler;
+  }
+  /**
+   * Set list commands handler (called by Sandbox)
+   * @internal
+   */
+  setListCommandsHandler(handler) {
+    this._listCommandsHandler = handler;
+  }
+  /**
+   * Set retrieve command handler (called by Sandbox)
+   * @internal
+   */
+  setRetrieveCommandHandler(handler) {
+    this._retrieveCommandHandler = handler;
+  }
+  /**
+   * Set wait command handler (called by Sandbox)
+   * @internal
+   */
+  setWaitCommandHandler(handler) {
+    this._waitCommandHandler = handler;
+  }
+  /**
+   * Set destroy handler (called by Sandbox)
+   * @internal
+   */
+  setDestroyHandler(handler) {
+    this._destroyHandler = handler;
+  }
+  /**
+   * Execute a command in the terminal (deprecated, use command.run())
+   * @deprecated Use terminal.command.run() instead
+   */
+  async execute(command, options) {
+    if (!this._executeHandler) {
+      throw new Error("Execute handler not set");
     }
+    return this._executeHandler(command, options?.background);
   }
-}
-
-// src/utils.ts
-function calculateBackoff(attempt, baseDelay = 1e3, jitterMax = 100) {
-  return baseDelay * Math.pow(2, attempt) + Math.random() * jitterMax;
-}
-
-// src/providers/gateway.ts
-import { Sandbox as Sandbox2 } from "@computesdk/client";
-var DEFAULT_GATEWAY_URL = "https://gateway.computesdk.com";
-var DEFAULT_REQUEST_TIMEOUT = 3e4;
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_RETRY_DELAY = 1e3;
-var DEFAULT_RETRYABLE_STATUSES = [408, 429, 502, 503, 504];
-var hasWarnedAboutMissingToken = false;
-var GatewayError = class extends Error {
-  constructor(message, statusCode, provider, sandboxId, requestId) {
-    super(message);
-    this.statusCode = statusCode;
-    this.provider = provider;
-    this.sandboxId = sandboxId;
-    this.requestId = requestId;
-    this.name = "GatewayError";
+  /**
+   * Destroy the terminal
+   */
+  async destroy() {
+    if (!this._destroyHandler) {
+      throw new Error("Destroy handler not set");
+    }
+    await this._destroyHandler();
+    this.cleanup();
   }
-};
-async function gatewayFetch(url, config, options = {}) {
-  const timeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
-  const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
-  const retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY;
-  const retryableStatuses = config.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES;
-  let lastError = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const startTime = Date.now();
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const response = await fetch(url, {
-        ...options,
-        signal: controller.signal,
-        headers: {
-          "Content-Type": "application/json",
-          "X-ComputeSDK-API-Key": config.apiKey,
-          "X-Provider": config.provider,
-          ...config.providerHeaders || {},
-          ...options.headers
-        }
-      });
-      clearTimeout(timeoutId);
-      const duration = Date.now() - startTime;
-      if (process.env.COMPUTESDK_DEBUG) {
-        console.log(`[Gateway] ${options.method || "GET"} ${url} - ${response.status} (${duration}ms)`);
-      }
-      if (!response.ok) {
-        if (response.status === 404) {
-          return { success: false };
-        }
-        const errorText = await response.text().catch(() => response.statusText);
-        const requestId = response.headers.get("x-request-id");
-        const isRetryable = retryableStatuses.includes(response.status);
-        const shouldRetry = isRetryable && attempt < maxRetries;
-        if (shouldRetry) {
-          const delay = calculateBackoff(attempt, retryDelay);
-          if (process.env.COMPUTESDK_DEBUG) {
-            console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (status: ${response.status})...`);
-          }
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          continue;
-        }
-        let errorMessage = `Gateway API error: ${errorText}`;
-        if (response.status === 401) {
-          errorMessage = `Invalid ComputeSDK API key.
-
-Check your COMPUTESDK_API_KEY environment variable.
-Get your key at: https://computesdk.com/dashboard`;
-        } else if (response.status === 403) {
-          errorMessage = `Access forbidden. Your API key may not have permission to use provider "${config.provider}".
-
-Visit https://computesdk.com/dashboard to check your plan.`;
-        } else if (response.status === 429) {
-          errorMessage = `Rate limit exceeded. Please try again in a moment.
-
-If this persists, visit https://computesdk.com/dashboard to upgrade your plan.`;
-        } else if (response.status >= 500) {
-          errorMessage = `Gateway server error (${response.status}). This is temporary - please try again.
-
-If this persists, check status at https://status.computesdk.com`;
-        }
-        throw new GatewayError(
-          errorMessage,
-          response.status,
-          config.provider,
-          void 0,
-          requestId || void 0
-        );
-      }
-      return response.json();
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof GatewayError) {
-        lastError = error;
-        throw error;
-      }
-      if (error instanceof Error && error.name === "AbortError") {
-        const timeoutError = new GatewayError(
-          `Request timed out after ${timeout}ms.
-
-The gateway may be experiencing high load or network issues.
-Check your connection and try again.`,
-          408,
-          config.provider
-        );
-        if (attempt < maxRetries) {
-          const delay = calculateBackoff(attempt, retryDelay);
-          if (process.env.COMPUTESDK_DEBUG) {
-            console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (timeout)...`);
-          }
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          lastError = timeoutError;
-          continue;
-        }
-        throw timeoutError;
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    if (this._ws && this._channel) {
+      this._ws.unsubscribe(this._channel);
+    }
+    this._eventHandlers.clear();
+  }
+  /**
+   * Register event handler
+   */
+  on(event, handler) {
+    if (!this._eventHandlers.has(event)) {
+      this._eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unregister event handler
+   */
+  off(event, handler) {
+    const handlers = this._eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this._eventHandlers.delete(event);
       }
-      const networkError = new GatewayError(
-        `Failed to connect to gateway: ${error instanceof Error ? error.message : String(error)}
-
-Check your internet connection and gateway URL.`,
-        0,
-        config.provider
-      );
-      if (attempt < maxRetries) {
-        const delay = calculateBackoff(attempt, retryDelay);
-        if (process.env.COMPUTESDK_DEBUG) {
-          console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (network error)...`);
+    }
+  }
+  /**
+   * Emit event to registered handlers
+   */
+  emit(event, ...args) {
+    const handlers = this._eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error("Error in terminal event handler:", error);
         }
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        lastError = networkError;
-        continue;
-      }
-      throw networkError;
+      });
     }
   }
-  throw lastError || new Error("Max retries exceeded");
+};
+
+// src/client/file-watcher.ts
+function decodeBase642(str) {
+  if (typeof window !== "undefined" && typeof window.atob === "function") {
+    return window.atob(str);
+  } else if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "base64").toString("utf-8");
+  }
+  throw new Error("No base64 decoding available");
 }
-var gateway = createProvider({
-  name: "gateway",
-  methods: {
-    sandbox: {
-      create: async (config, options) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes`, config, {
-          method: "POST",
-          body: JSON.stringify(options || {})
-        });
-        if (!result.success || !result.data) {
-          throw new Error(`Gateway returned invalid response: ${JSON.stringify(result)}`);
-        }
-        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
-        if (process.env.COMPUTESDK_DEBUG) {
-          console.log(`[Gateway] Sandbox created:`, {
-            sandboxId,
-            url,
-            hasToken: !!token,
-            tokenPrefix: token ? token.substring(0, 10) + "..." : "none",
-            provider
-          });
-        }
-        if (!token && !hasWarnedAboutMissingToken) {
-          hasWarnedAboutMissingToken = true;
-          console.warn(
-            `[Gateway] No token received from gateway for sandbox ${sandboxId}. Falling back to API key for authentication. This may indicate the gateway is running an outdated version. Check gateway deployment at ${config.gatewayUrl || DEFAULT_GATEWAY_URL}`
-          );
-        }
-        const sandbox = new ClientSandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          // Use token from gateway, fallback to API key
-          metadata: {
-            ...metadata,
-            ...name && { name },
-            ...namespace && { namespace }
-          },
-          WebSocket: globalThis.WebSocket
+var FileWatcher = class {
+  constructor(id, path, status, channel, includeContent, ignored, ws, encoding = "raw") {
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.id = id;
+    this.path = path;
+    this.status = status;
+    this.channel = channel;
+    this.includeContent = includeContent;
+    this.ignored = ignored;
+    this.encoding = encoding;
+    this.ws = ws;
+    this.ws.subscribe(this.channel);
+    this.setupWebSocketHandlers();
+  }
+  /**
+   * Set up WebSocket event handlers
+   */
+  setupWebSocketHandlers() {
+    this.ws.on("file:changed", (msg) => {
+      if (msg.channel === this.channel) {
+        const encoding = msg.data.encoding || this.encoding;
+        const content = msg.data.content && encoding === "base64" ? decodeBase642(msg.data.content) : msg.data.content;
+        this.emit("change", {
+          event: msg.data.event,
+          path: msg.data.path,
+          content
         });
-        await waitForComputeReady(sandbox);
-        return { sandbox, sandboxId };
-      },
-      getById: async (config, sandboxId) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}`, config);
-        if (!result.success || !result.data) {
-          return null;
-        }
-        const { url, token, provider, metadata } = result.data;
-        if (!token && !hasWarnedAboutMissingToken) {
-          hasWarnedAboutMissingToken = true;
-          console.warn(
-            `[Gateway] No token received when reconnecting to sandbox ${sandboxId}. Falling back to API key for authentication. This may indicate the gateway is running an outdated version.`
-          );
-        }
-        const sandbox = new ClientSandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          // Use token from gateway, fallback to API key
-          metadata,
-          WebSocket: globalThis.WebSocket
-        });
-        await waitForComputeReady(sandbox);
-        return { sandbox, sandboxId };
-      },
-      list: async () => {
-        throw new Error(
-          "Gateway provider does not support listing sandboxes. Use getById() with a known sandbox ID instead."
-        );
-      },
-      destroy: async (config, sandboxId) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-          method: "DELETE"
-        });
-      },
-      findOrCreate: async (config, options) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const { name: requestedName, namespace: requestedNamespace, ...restOptions } = options;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/find-or-create`, config, {
-          method: "POST",
-          body: JSON.stringify({
-            namespace: requestedNamespace || "default",
-            name: requestedName,
-            ...restOptions
-          })
-        });
-        if (!result.success || !result.data) {
-          throw new Error(`Gateway returned invalid response: ${JSON.stringify(result)}`);
-        }
-        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
-        if (process.env.COMPUTESDK_DEBUG) {
-          console.log(`[Gateway] Named sandbox found/created:`, {
-            sandboxId,
-            name,
-            namespace,
-            url,
-            hasToken: !!token,
-            provider
-          });
-        }
-        const sandbox = new ClientSandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata: {
-            ...metadata,
-            name,
-            namespace
-          },
-          WebSocket: globalThis.WebSocket
-        });
-        await waitForComputeReady(sandbox);
-        return { sandbox, sandboxId };
-      },
-      find: async (config, options) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const result = await gatewayFetch(`${gatewayUrl}/v1/sandboxes/find`, config, {
-          method: "POST",
-          body: JSON.stringify({
-            namespace: options.namespace || "default",
-            name: options.name
-          })
-        });
-        if (!result.success || !result.data) {
-          return null;
+      }
+    });
+    this.ws.on("watcher:destroyed", (msg) => {
+      if (msg.channel === this.channel) {
+        this.status = "stopped";
+        this.emit("destroyed");
+        this.cleanup();
+      }
+    });
+  }
+  /**
+   * Get watcher ID
+   */
+  getId() {
+    return this.id;
+  }
+  /**
+   * Get watched path
+   */
+  getPath() {
+    return this.path;
+  }
+  /**
+   * Get watcher status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get watcher channel
+   */
+  getChannel() {
+    return this.channel;
+  }
+  /**
+   * Check if content is included in events
+   */
+  isIncludingContent() {
+    return this.includeContent;
+  }
+  /**
+   * Get ignored patterns
+   */
+  getIgnoredPatterns() {
+    return [...this.ignored];
+  }
+  /**
+   * Check if watcher is active
+   */
+  isActive() {
+    return this.status === "active";
+  }
+  /**
+   * Set destroy handler (called by client)
+   */
+  setDestroyHandler(handler) {
+    this.destroyWatcher = handler;
+  }
+  /**
+   * Destroy the watcher
+   */
+  async destroy() {
+    if (!this.destroyWatcher) {
+      throw new Error("Destroy handler not set");
+    }
+    await this.destroyWatcher();
+    this.cleanup();
+  }
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    this.ws.unsubscribe(this.channel);
+    this.eventHandlers.clear();
+  }
+  /**
+   * Register event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unregister event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.eventHandlers.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit event to registered handlers
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error("Error in file watcher event handler:", error);
         }
-        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
-        if (process.env.COMPUTESDK_DEBUG) {
-          console.log(`[Gateway] Named sandbox found:`, {
-            sandboxId,
-            name,
-            namespace,
-            url
-          });
+      });
+    }
+  }
+};
+
+// src/client/signal-service.ts
+var SignalService = class {
+  constructor(status, channel, ws) {
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.status = status;
+    this.channel = channel;
+    this.ws = ws;
+    this.ws.subscribe(this.channel);
+    this.setupWebSocketHandlers();
+  }
+  /**
+   * Set up WebSocket event handlers
+   */
+  setupWebSocketHandlers() {
+    this.ws.on("signal", (msg) => {
+      if (msg.channel === this.channel) {
+        const event = {
+          signal: msg.data.signal,
+          ...msg.data.port && { port: msg.data.port },
+          ...msg.data.url && { url: msg.data.url },
+          ...msg.data.message && { message: msg.data.message }
+        };
+        if (msg.data.signal === "port" || msg.data.signal === "server-ready") {
+          this.emit("port", event);
+        } else if (msg.data.signal === "error") {
+          this.emit("error", event);
         }
-        const sandbox = new ClientSandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata: {
-            ...metadata,
-            name,
-            namespace
-          },
-          WebSocket: globalThis.WebSocket
-        });
-        await waitForComputeReady(sandbox);
-        return { sandbox, sandboxId };
-      },
-      extendTimeout: async (config, sandboxId, options) => {
-        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-        const duration = options?.duration ?? 9e5;
-        if (process.env.COMPUTESDK_DEBUG) {
-          console.log(`[Gateway] Extending timeout for sandbox ${sandboxId} by ${duration}ms`);
+        this.emit("signal", event);
+      }
+    });
+  }
+  /**
+   * Get service status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get service channel
+   */
+  getChannel() {
+    return this.channel;
+  }
+  /**
+   * Check if service is active
+   */
+  isActive() {
+    return this.status === "active";
+  }
+  /**
+   * Set stop handler (called by client)
+   */
+  setStopHandler(handler) {
+    this.stopService = handler;
+  }
+  /**
+   * Stop the signal service
+   */
+  async stop() {
+    if (!this.stopService) {
+      throw new Error("Stop handler not set");
+    }
+    await this.stopService();
+    this.cleanup();
+  }
+  /**
+   * Clean up resources
+   */
+  cleanup() {
+    this.status = "stopped";
+    this.ws.unsubscribe(this.channel);
+    this.eventHandlers.clear();
+  }
+  /**
+   * Register event handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unregister event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.eventHandlers.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit event to registered handlers
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error("Error in signal service event handler:", error);
         }
-        await gatewayFetch(`${gatewayUrl}/v1/sandboxes/${sandboxId}/extend`, config, {
-          method: "POST",
-          body: JSON.stringify({ duration })
-        });
-      },
-      // All operations delegate directly to ClientSandbox
-      runCode: async (sandbox, code, runtime) => sandbox.runCode(code, runtime),
-      runCommand: async (sandbox, command, args) => sandbox.runCommand(command, args),
-      getUrl: async (sandbox, options) => sandbox.getUrl(options),
-      getInfo: async (sandbox) => {
-        const info = await sandbox.getInfo();
-        return {
-          id: info.id,
-          provider: info.provider,
-          runtime: info.runtime,
-          status: info.status,
-          createdAt: info.createdAt,
-          timeout: info.timeout,
-          metadata: info.metadata || {}
-        };
-      },
-      // Filesystem delegates directly to ClientSandbox
-      filesystem: {
-        readFile: async (sandbox, path) => sandbox.filesystem.readFile(path),
-        writeFile: async (sandbox, path, content) => sandbox.filesystem.writeFile(path, content),
-        mkdir: async (sandbox, path) => sandbox.filesystem.mkdir(path),
-        readdir: async (sandbox, path) => sandbox.filesystem.readdir(path),
-        exists: async (sandbox, path) => sandbox.filesystem.exists(path),
-        remove: async (sandbox, path) => sandbox.filesystem.remove(path)
-      },
-      // getInstance returns the ClientSandbox directly
-      getInstance: (sandbox) => sandbox
+      });
     }
   }
-});
+};
+
+// src/client/index.ts
+import { cmd, escapeArgs, mkdir, test } from "@computesdk/cmd";
+
+// src/client/resources/terminal.ts
+var Terminal = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.destroyHandler = handlers.destroy;
+  }
+  /**
+   * Create a new terminal session
+   *
+   * @param options - Terminal creation options
+   * @param options.shell - Shell to use (e.g., '/bin/bash') - PTY mode only
+   * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
+   * @param options.pty - Terminal mode: true = PTY (interactive), false = exec (command tracking)
+   * @returns TerminalInstance
+   */
+  async create(options) {
+    return this.createHandler(options);
+  }
+  /**
+   * List all active terminals
+   * @returns Array of terminal responses
+   */
+  async list() {
+    return this.listHandler();
+  }
+  /**
+   * Retrieve a specific terminal by ID
+   * @param id - The terminal ID
+   * @returns Terminal response
+   */
+  async retrieve(id) {
+    return this.retrieveHandler(id);
+  }
+  /**
+   * Destroy a terminal by ID
+   * @param id - The terminal ID
+   */
+  async destroy(id) {
+    return this.destroyHandler(id);
+  }
+};
+
+// src/client/resources/server.ts
+var Server = class {
+  constructor(handlers) {
+    this.startHandler = handlers.start;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.stopHandler = handlers.stop;
+    this.restartHandler = handlers.restart;
+    this.updateStatusHandler = handlers.updateStatus;
+  }
+  /**
+   * Start a new managed server
+   * @param options - Server configuration
+   * @param options.slug - Unique server slug (URL-safe identifier)
+   * @param options.command - Command to start the server
+   * @param options.path - Working directory (optional)
+   * @param options.env_file - Path to env file (optional)
+   * @returns Server info
+   */
+  async start(options) {
+    const response = await this.startHandler(options);
+    return response.data.server;
+  }
+  /**
+   * List all managed servers
+   * @returns Array of server info
+   */
+  async list() {
+    const response = await this.listHandler();
+    return response.data.servers;
+  }
+  /**
+   * Retrieve a specific server by slug
+   * @param slug - The server slug
+   * @returns Server info
+   */
+  async retrieve(slug) {
+    const response = await this.retrieveHandler(slug);
+    return response.data.server;
+  }
+  /**
+   * Stop a server by slug
+   * @param slug - The server slug
+   */
+  async stop(slug) {
+    await this.stopHandler(slug);
+  }
+  /**
+   * Restart a server by slug
+   * @param slug - The server slug
+   * @returns Server info
+   */
+  async restart(slug) {
+    const response = await this.restartHandler(slug);
+    return response.data.server;
+  }
+  /**
+   * Update server status (internal use)
+   * @param slug - The server slug
+   * @param status - New status
+   */
+  async updateStatus(slug, status) {
+    await this.updateStatusHandler(slug, status);
+  }
+};
+
+// src/client/resources/watcher.ts
+var Watcher = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.destroyHandler = handlers.destroy;
+  }
+  /**
+   * Create a new file watcher
+   * @param path - Path to watch
+   * @param options - Watcher options
+   * @param options.includeContent - Include file content in change events
+   * @param options.ignored - Patterns to ignore
+   * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
+   * @returns FileWatcher instance
+   */
+  async create(path, options) {
+    return this.createHandler(path, options);
+  }
+  /**
+   * List all active file watchers
+   * @returns Array of watcher info
+   */
+  async list() {
+    const response = await this.listHandler();
+    return response.data.watchers;
+  }
+  /**
+   * Retrieve a specific watcher by ID
+   * @param id - The watcher ID
+   * @returns Watcher info
+   */
+  async retrieve(id) {
+    const response = await this.retrieveHandler(id);
+    return response.data;
+  }
+  /**
+   * Destroy a watcher by ID
+   * @param id - The watcher ID
+   */
+  async destroy(id) {
+    return this.destroyHandler(id);
+  }
+};
+
+// src/client/resources/session-token.ts
+var SessionToken = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.revokeHandler = handlers.revoke;
+  }
+  /**
+   * Create a new session token (requires access token)
+   * @param options - Token configuration
+   * @param options.description - Description for the token
+   * @param options.expiresIn - Expiration time in seconds (default: 7 days)
+   * @returns Session token info including the token value
+   */
+  async create(options) {
+    const response = await this.createHandler(options);
+    return {
+      id: response.id,
+      token: response.token,
+      description: response.description,
+      createdAt: response.createdAt,
+      expiresAt: response.expiresAt
+    };
+  }
+  /**
+   * List all session tokens
+   * @returns Array of session token info
+   */
+  async list() {
+    const response = await this.listHandler();
+    return response.data.tokens.map((t) => ({
+      id: t.id,
+      description: t.description,
+      createdAt: t.created_at,
+      expiresAt: t.expires_at,
+      lastUsedAt: t.last_used_at
+    }));
+  }
+  /**
+   * Retrieve a specific session token by ID
+   * @param id - The token ID
+   * @returns Session token info
+   */
+  async retrieve(id) {
+    const response = await this.retrieveHandler(id);
+    return {
+      id: response.id,
+      description: response.description,
+      createdAt: response.createdAt,
+      expiresAt: response.expiresAt
+    };
+  }
+  /**
+   * Revoke a session token
+   * @param id - The token ID to revoke
+   */
+  async revoke(id) {
+    return this.revokeHandler(id);
+  }
+};
+
+// src/client/resources/magic-link.ts
+var MagicLink = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+  }
+  /**
+   * Create a magic link for browser authentication (requires access token)
+   *
+   * Magic links are one-time URLs that automatically create a session token
+   * and set it as a cookie in the user's browser.
+   *
+   * @param options - Magic link configuration
+   * @param options.redirectUrl - URL to redirect to after authentication
+   * @returns Magic link info including the URL
+   */
+  async create(options) {
+    const response = await this.createHandler(options);
+    return {
+      url: response.data.magic_url,
+      expiresAt: response.data.expires_at,
+      redirectUrl: response.data.redirect_url
+    };
+  }
+};
+
+// src/client/resources/signal.ts
+var Signal = class {
+  constructor(handlers) {
+    this.startHandler = handlers.start;
+    this.statusHandler = handlers.status;
+    this.stopHandler = handlers.stop;
+    this.emitPortHandler = handlers.emitPort;
+    this.emitErrorHandler = handlers.emitError;
+    this.emitServerReadyHandler = handlers.emitServerReady;
+  }
+  /**
+   * Start the signal service
+   * @returns SignalService instance with event handling
+   */
+  async start() {
+    return this.startHandler();
+  }
+  /**
+   * Get the signal service status
+   * @returns Signal service status info
+   */
+  async status() {
+    const response = await this.statusHandler();
+    return {
+      status: response.data.status,
+      channel: response.data.channel,
+      wsUrl: response.data.ws_url
+    };
+  }
+  /**
+   * Stop the signal service
+   */
+  async stop() {
+    return this.stopHandler();
+  }
+  /**
+   * Emit a port signal
+   * @param port - Port number
+   * @param type - Signal type ('open' or 'close')
+   * @param url - URL associated with the port
+   */
+  async emitPort(port, type, url) {
+    await this.emitPortHandler(port, type, url);
+  }
+  /**
+   * Emit an error signal
+   * @param message - Error message
+   */
+  async emitError(message) {
+    await this.emitErrorHandler(message);
+  }
+  /**
+   * Emit a server ready signal
+   * @param port - Port number
+   * @param url - Server URL
+   */
+  async emitServerReady(port, url) {
+    await this.emitServerReadyHandler(port, url);
+  }
+};
+
+// src/client/resources/file.ts
+var File = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.destroyHandler = handlers.destroy;
+    this.batchWriteHandler = handlers.batchWrite;
+    this.existsHandler = handlers.exists;
+  }
+  /**
+   * Create a new file with optional content
+   * @param path - File path
+   * @param content - File content (optional)
+   * @returns File info
+   */
+  async create(path, content) {
+    const response = await this.createHandler(path, content);
+    return response.data.file;
+  }
+  /**
+   * List files at the specified path
+   * @param path - Directory path (default: '/')
+   * @returns Array of file info
+   */
+  async list(path = "/") {
+    const response = await this.listHandler(path);
+    return response.data.files;
+  }
+  /**
+   * Retrieve file content
+   * @param path - File path
+   * @returns File content as string
+   */
+  async retrieve(path) {
+    return this.retrieveHandler(path);
+  }
+  /**
+   * Destroy (delete) a file or directory
+   * @param path - File or directory path
+   */
+  async destroy(path) {
+    return this.destroyHandler(path);
+  }
+  /**
+   * Batch file operations (write or delete multiple files)
+   *
+   * Features:
+   * - Deduplication: Last operation wins per path
+   * - File locking: Prevents race conditions
+   * - Deterministic ordering: Alphabetical path sorting
+   * - Partial failure handling: Returns per-file results
+   *
+   * @param files - Array of file operations
+   * @returns Results for each file operation
+   */
+  async batchWrite(files) {
+    const response = await this.batchWriteHandler(files);
+    return response.data.results;
+  }
+  /**
+   * Check if a file exists
+   * @param path - File path
+   * @returns True if file exists
+   */
+  async exists(path) {
+    return this.existsHandler(path);
+  }
+};
+
+// src/client/resources/env.ts
+var Env = class {
+  constructor(handlers) {
+    this.retrieveHandler = handlers.retrieve;
+    this.updateHandler = handlers.update;
+    this.removeHandler = handlers.remove;
+    this.existsHandler = handlers.exists;
+  }
+  /**
+   * Retrieve environment variables from a file
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @returns Key-value map of environment variables
+   */
+  async retrieve(file) {
+    const response = await this.retrieveHandler(file);
+    return response.data.variables;
+  }
+  /**
+   * Update (merge) environment variables in a file
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @param variables - Key-value pairs to set
+   * @returns Keys that were updated
+   */
+  async update(file, variables) {
+    const response = await this.updateHandler(file, variables);
+    return response.data.keys;
+  }
+  /**
+   * Remove environment variables from a file
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @param keys - Keys to remove
+   * @returns Keys that were removed
+   */
+  async remove(file, keys) {
+    const response = await this.removeHandler(file, keys);
+    return response.data.keys;
+  }
+  /**
+   * Check if an environment file exists
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @returns True if file exists
+   */
+  async exists(file) {
+    return this.existsHandler(file);
+  }
+};
+
+// src/client/resources/auth.ts
+var Auth = class {
+  constructor(handlers) {
+    this.statusHandler = handlers.status;
+    this.infoHandler = handlers.info;
+  }
+  /**
+   * Check authentication status
+   * @returns Authentication status info
+   */
+  async status() {
+    const response = await this.statusHandler();
+    return {
+      authenticated: response.data.authenticated,
+      tokenType: response.data.token_type,
+      expiresAt: response.data.expires_at
+    };
+  }
+  /**
+   * Get authentication information and usage instructions
+   * @returns Authentication info
+   */
+  async info() {
+    const response = await this.infoHandler();
+    return {
+      message: response.data.message,
+      instructions: response.data.instructions,
+      endpoints: {
+        createSessionToken: response.data.endpoints.create_session_token,
+        listSessionTokens: response.data.endpoints.list_session_tokens,
+        getSessionToken: response.data.endpoints.get_session_token,
+        revokeSessionToken: response.data.endpoints.revoke_session_token,
+        createMagicLink: response.data.endpoints.create_magic_link,
+        authStatus: response.data.endpoints.auth_status,
+        authInfo: response.data.endpoints.auth_info
+      }
+    };
+  }
+};
+
+// src/client/resources/run.ts
+var Run = class {
+  constructor(handlers) {
+    this.codeHandler = handlers.code;
+    this.commandHandler = handlers.command;
+  }
+  /**
+   * Execute code with automatic language detection
+   *
+   * Supports: python, python3, node, javascript, js, bash, sh, ruby
+   *
+   * @param code - The code to execute
+   * @param options - Execution options
+   * @param options.language - Programming language (auto-detected if not specified)
+   * @returns Code execution result with output, exit code, and detected language
+   */
+  async code(code, options) {
+    return this.codeHandler(code, options);
+  }
+  /**
+   * Execute a shell command
+   *
+   * @param command - The command to execute
+   * @param options - Execution options
+   * @param options.shell - Shell to use (optional)
+   * @param options.background - Run in background (optional)
+   * @returns Command execution result with stdout, stderr, exit code, and duration
+   */
+  async command(command, options) {
+    return this.commandHandler(command, options);
+  }
+};
+
+// src/client/resources/child.ts
+var Child = class {
+  constructor(handlers) {
+    this.createHandler = handlers.create;
+    this.listHandler = handlers.list;
+    this.retrieveHandler = handlers.retrieve;
+    this.destroyHandler = handlers.destroy;
+  }
+  /**
+   * Create a new child sandbox
+   * @returns Child sandbox info including URL and subdomain
+   */
+  async create() {
+    return this.createHandler();
+  }
+  /**
+   * List all child sandboxes
+   * @returns Array of child sandbox info
+   */
+  async list() {
+    const response = await this.listHandler();
+    return response.sandboxes;
+  }
+  /**
+   * Retrieve a specific child sandbox by subdomain
+   * @param subdomain - The child subdomain (e.g., 'sandbox-12345')
+   * @returns Child sandbox info
+   */
+  async retrieve(subdomain) {
+    return this.retrieveHandler(subdomain);
+  }
+  /**
+   * Destroy (delete) a child sandbox
+   * @param subdomain - The child subdomain
+   * @param options - Destroy options
+   * @param options.deleteFiles - Whether to delete the child's files (default: false)
+   */
+  async destroy(subdomain, options) {
+    return this.destroyHandler(subdomain, options?.deleteFiles ?? false);
+  }
+};
+
+// src/client/types.ts
+var CommandExitError = class extends Error {
+  constructor(result) {
+    super(`Command exited with code ${result.exitCode}`);
+    this.result = result;
+    this.name = "CommandExitError";
+  }
+};
+function isCommandExitError(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "CommandExitError" && "result" in error;
+}
+
+// src/client/index.ts
+var Sandbox = class {
+  constructor(config) {
+    this._token = null;
+    this._ws = null;
+    this.sandboxId = config.sandboxId;
+    this.provider = config.provider;
+    let sandboxUrlResolved = config.sandboxUrl;
+    let tokenFromUrl = null;
+    let sandboxUrlFromUrl = null;
+    if (typeof window !== "undefined" && window.location && typeof localStorage !== "undefined") {
+      const params = new URLSearchParams(window.location.search);
+      tokenFromUrl = params.get("session_token");
+      sandboxUrlFromUrl = params.get("sandbox_url");
+      let urlChanged = false;
+      if (tokenFromUrl) {
+        params.delete("session_token");
+        localStorage.setItem("session_token", tokenFromUrl);
+        urlChanged = true;
+      }
+      if (sandboxUrlFromUrl) {
+        params.delete("sandbox_url");
+        localStorage.setItem("sandbox_url", sandboxUrlFromUrl);
+        urlChanged = true;
+      }
+      if (urlChanged) {
+        const search = params.toString() ? `?${params.toString()}` : "";
+        const newUrl = `${window.location.pathname}${search}${window.location.hash}`;
+        window.history.replaceState({}, "", newUrl);
+      }
+      if (!config.sandboxUrl) {
+        sandboxUrlResolved = sandboxUrlFromUrl || localStorage.getItem("sandbox_url") || "";
+      }
+    }
+    this.config = {
+      sandboxUrl: (sandboxUrlResolved || "").replace(/\/$/, ""),
+      // Remove trailing slash
+      sandboxId: config.sandboxId || "",
+      provider: config.provider || "",
+      token: config.token || "",
+      headers: config.headers || {},
+      timeout: config.timeout || 3e4,
+      protocol: config.protocol || "binary",
+      metadata: config.metadata
+    };
+    this.WebSocketImpl = config.WebSocket || globalThis.WebSocket;
+    if (!this.WebSocketImpl) {
+      throw new Error(
+        'WebSocket is not available. In Node.js, pass WebSocket implementation:\nimport WebSocket from "ws";\nnew Sandbox({ sandboxUrl: "...", WebSocket })'
+      );
+    }
+    if (config.token) {
+      this._token = config.token;
+    } else if (tokenFromUrl) {
+      this._token = tokenFromUrl;
+    } else if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      this._token = localStorage.getItem("session_token");
+    }
+    this.filesystem = {
+      readFile: async (path) => this.readFile(path),
+      writeFile: async (path, content) => {
+        await this.writeFile(path, content);
+      },
+      mkdir: async (path) => {
+        await this.runCommand(mkdir(path));
+      },
+      readdir: async (path) => {
+        const response = await this.listFiles(path);
+        return response.data.files.map((f) => ({
+          name: f.name,
+          type: f.is_dir ? "directory" : "file",
+          size: f.size,
+          modified: new Date(f.modified_at)
+        }));
+      },
+      exists: async (path) => {
+        const result = await this.runCommand(test.exists(path));
+        return result.exitCode === 0;
+      },
+      remove: async (path) => {
+        await this.deleteFile(path);
+      }
+    };
+    this.terminal = new Terminal({
+      create: async (options) => this.createTerminal(options),
+      list: async () => this.listTerminals(),
+      retrieve: async (id) => this.getTerminal(id),
+      destroy: async (id) => {
+        await this.request(`/terminals/${id}`, { method: "DELETE" });
+      }
+    });
+    this.run = new Run({
+      code: async (code, options) => {
+        const result = await this.runCodeRequest(code, options?.language);
+        return {
+          output: result.data.output,
+          exitCode: result.data.exit_code,
+          language: result.data.language
+        };
+      },
+      command: async (command, options) => {
+        const result = await this.runCommandRequest({ command, shell: options?.shell, background: options?.background });
+        return {
+          stdout: result.data.stdout,
+          stderr: result.data.stderr,
+          exitCode: result.data.exit_code ?? 0,
+          durationMs: result.data.duration_ms ?? 0
+        };
+      }
+    });
+    this.server = new Server({
+      start: async (options) => this.startServer(options),
+      list: async () => this.listServers(),
+      retrieve: async (slug) => this.getServer(slug),
+      stop: async (slug) => {
+        await this.stopServer(slug);
+      },
+      restart: async (slug) => this.restartServer(slug),
+      updateStatus: async (slug, status) => {
+        await this.updateServerStatus(slug, status);
+      }
+    });
+    this.watcher = new Watcher({
+      create: async (path, options) => this.createWatcher(path, options),
+      list: async () => this.listWatchers(),
+      retrieve: async (id) => this.getWatcher(id),
+      destroy: async (id) => {
+        await this.request(`/watchers/${id}`, { method: "DELETE" });
+      }
+    });
+    this.sessionToken = new SessionToken({
+      create: async (options) => this.createSessionToken(options),
+      list: async () => this.listSessionTokens(),
+      retrieve: async (id) => this.getSessionToken(id),
+      revoke: async (id) => this.revokeSessionToken(id)
+    });
+    this.magicLink = new MagicLink({
+      create: async (options) => this.createMagicLink(options)
+    });
+    this.signal = new Signal({
+      start: async () => this.startSignals(),
+      status: async () => this.getSignalStatus(),
+      stop: async () => {
+        await this.request("/signals/stop", { method: "POST" });
+      },
+      emitPort: async (port, type, url) => this.emitPortSignal(port, type, url),
+      emitError: async (message) => this.emitErrorSignal(message),
+      emitServerReady: async (port, url) => this.emitServerReadySignal(port, url)
+    });
+    this.file = new File({
+      create: async (path, content) => this.createFile(path, content),
+      list: async (path) => this.listFiles(path),
+      retrieve: async (path) => this.readFile(path),
+      destroy: async (path) => this.deleteFile(path),
+      batchWrite: async (files) => this.batchWriteFiles(files),
+      exists: async (path) => this.checkFileExists(path)
+    });
+    this.env = new Env({
+      retrieve: async (file) => this.getEnv(file),
+      update: async (file, variables) => this.setEnv(file, variables),
+      remove: async (file, keys) => this.deleteEnv(file, keys),
+      exists: async (file) => this.checkEnvFile(file)
+    });
+    this.auth = new Auth({
+      status: async () => this.getAuthStatus(),
+      info: async () => this.getAuthInfo()
+    });
+    this.child = new Child({
+      create: async () => this.createSandbox(),
+      list: async () => this.listSandboxes(),
+      retrieve: async (subdomain) => this.getSandbox(subdomain),
+      destroy: async (subdomain, deleteFiles) => this.deleteSandbox(subdomain, deleteFiles)
+    });
+  }
+  /**
+   * Get or create internal WebSocket manager
+   */
+  async ensureWebSocket() {
+    if (!this._ws || this._ws.getState() === "closed") {
+      this._ws = new WebSocketManager({
+        url: this.getWebSocketUrl(),
+        WebSocket: this.WebSocketImpl,
+        autoReconnect: true,
+        debug: false,
+        protocol: this.config.protocol
+      });
+      await this._ws.connect();
+    }
+    return this._ws;
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  async request(endpoint, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const headers = {
+        ...this.config.headers
+      };
+      if (options.body) {
+        headers["Content-Type"] = "application/json";
+      }
+      if (this._token) {
+        headers["Authorization"] = `Bearer ${this._token}`;
+      }
+      const response = await fetch(`${this.config.sandboxUrl}${endpoint}`, {
+        ...options,
+        headers: {
+          ...headers,
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 204) {
+        return void 0;
+      }
+      const text = await response.text();
+      let data;
+      try {
+        data = JSON.parse(text);
+      } catch (jsonError) {
+        throw new Error(
+          `Failed to parse JSON response from ${endpoint}: ${jsonError instanceof Error ? jsonError.message : String(jsonError)}
+Response body (first 200 chars): ${text.substring(0, 200)}${text.length > 200 ? "..." : ""}`
+        );
+      }
+      if (!response.ok) {
+        const error = data.error || response.statusText;
+        if (response.status === 403 && endpoint.startsWith("/auth/")) {
+          if (endpoint.includes("/session_tokens") || endpoint.includes("/magic-links")) {
+            throw new Error(
+              `Access token required. This operation requires an access token, not a session token.
+API request failed (${response.status}): ${error}`
+            );
+          }
+        }
+        throw new Error(`API request failed (${response.status}): ${error}`);
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  // ============================================================================
+  // Health Check
+  // ============================================================================
+  /**
+   * Check service health
+   */
+  async health() {
+    return this.request("/health");
+  }
+  // ============================================================================
+  // Authentication
+  // ============================================================================
+  /**
+   * Create a session token (requires access token)
+   *
+   * Session tokens are delegated credentials that can authenticate API requests
+   * without exposing your access token. Only access tokens can create session tokens.
+   *
+   * @param options - Token configuration
+   * @throws {Error} 403 Forbidden if called with a session token
+   */
+  async createSessionToken(options) {
+    return this.request("/auth/session_tokens", {
+      method: "POST",
+      body: JSON.stringify(options || {})
+    });
+  }
+  /**
+   * List all session tokens (requires access token)
+   *
+   * @throws {Error} 403 Forbidden if called with a session token
+   */
+  async listSessionTokens() {
+    return this.request("/auth/session_tokens");
+  }
+  /**
+   * Get details of a specific session token (requires access token)
+   *
+   * @param tokenId - The token ID
+   * @throws {Error} 403 Forbidden if called with a session token
+   */
+  async getSessionToken(tokenId) {
+    return this.request(`/auth/session_tokens/${tokenId}`);
+  }
+  /**
+   * Revoke a session token (requires access token)
+   *
+   * @param tokenId - The token ID to revoke
+   * @throws {Error} 403 Forbidden if called with a session token
+   */
+  async revokeSessionToken(tokenId) {
+    return this.request(`/auth/session_tokens/${tokenId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Generate a magic link for browser authentication (requires access token)
+   *
+   * Magic links are one-time URLs that automatically create a session token
+   * and set it as a cookie in the user's browser. This provides an easy way
+   * to authenticate users in browser-based applications.
+   *
+   * The generated link:
+   * - Expires after 5 minutes or first use (whichever comes first)
+   * - Automatically creates a new session token (7 day expiry)
+   * - Sets the session token as an HttpOnly cookie
+   * - Redirects to the specified URL
+   *
+   * @param options - Magic link configuration
+   * @throws {Error} 403 Forbidden if called with a session token
+   */
+  async createMagicLink(options) {
+    return this.request("/auth/magic-links", {
+      method: "POST",
+      body: JSON.stringify(options || {})
+    });
+  }
+  /**
+   * Check authentication status
+   * Does not require authentication
+   */
+  async getAuthStatus() {
+    return this.request("/auth/status");
+  }
+  /**
+   * Get authentication information and usage instructions
+   * Does not require authentication
+   */
+  async getAuthInfo() {
+    return this.request("/auth/info");
+  }
+  /**
+   * Set authentication token manually
+   * @param token - Access token or session token
+   */
+  setToken(token) {
+    this._token = token;
+  }
+  /**
+   * Get current authentication token
+   */
+  getToken() {
+    return this._token;
+  }
+  /**
+   * Get current sandbox URL
+   */
+  getSandboxUrl() {
+    return this.config.sandboxUrl;
+  }
+  // ============================================================================
+  // Command Execution
+  // ============================================================================
+  /**
+   * Execute a one-off command without creating a persistent terminal
+   * 
+   * @example
+   * ```typescript
+   * // Synchronous execution (waits for completion)
+   * const result = await sandbox.execute({ command: 'npm test' });
+   * console.log(result.data.exit_code);
+   * 
+   * // Background execution (returns immediately)
+   * const result = await sandbox.execute({ 
+   *   command: 'npm install',
+   *   background: true 
+   * });
+   * // Use result.data.terminal_id and result.data.cmd_id to track
+   * const cmd = await sandbox.getCommand(result.data.terminal_id!, result.data.cmd_id!);
+   * ```
+   */
+  async execute(options) {
+    return this.request("/execute", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Execute code with automatic language detection (POST /run/code)
+   *
+   * @param code - The code to execute
+   * @param language - Programming language (optional - auto-detects if not specified)
+   * @returns Code execution result with output, exit code, and detected language
+   *
+   * @example
+   * ```typescript
+   * // Auto-detect language
+   * const result = await sandbox.runCodeRequest('print("Hello")');
+   * console.log(result.data.output); // "Hello\n"
+   * console.log(result.data.language); // "python"
+   *
+   * // Explicit language
+   * const result = await sandbox.runCodeRequest('console.log("Hi")', 'node');
+   * ```
+   */
+  async runCodeRequest(code, language) {
+    const body = { code };
+    if (language) {
+      body.language = language;
+    }
+    return this.request("/run/code", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Execute a shell command (POST /run/command)
+   *
+   * @param options - Command options
+   * @param options.command - The command to execute
+   * @param options.shell - Shell to use (optional)
+   * @param options.background - Run in background (optional)
+   * @returns Command execution result
+   *
+   * @example
+   * ```typescript
+   * const result = await sandbox.runCommandRequest({ command: 'ls -la' });
+   * console.log(result.data.stdout);
+   * ```
+   */
+  async runCommandRequest(options) {
+    return this.request("/run/command", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  // ============================================================================
+  // File Operations
+  // ============================================================================
+  /**
+   * List files at the specified path
+   */
+  async listFiles(path = "/") {
+    const params = new URLSearchParams({ path });
+    return this.request(`/files?${params}`);
+  }
+  /**
+   * Create a new file with optional content
+   */
+  async createFile(path, content) {
+    return this.request("/files", {
+      method: "POST",
+      body: JSON.stringify({ path, content })
+    });
+  }
+  /**
+   * Get file metadata (without content)
+   */
+  async getFile(path) {
+    return this.request(`/files/${encodeURIComponent(path)}`);
+  }
+  /**
+   * Read file content
+   */
+  async readFile(path) {
+    const params = new URLSearchParams({ content: "true" });
+    const pathWithoutLeadingSlash = path.startsWith("/") ? path.slice(1) : path;
+    const segments = pathWithoutLeadingSlash.split("/");
+    const encodedPath = segments.map((s) => encodeURIComponent(s)).join("/");
+    const response = await this.request(
+      `/files/${encodedPath}?${params}`
+    );
+    return response.data.content || "";
+  }
+  /**
+   * Write file content (creates or updates)
+   */
+  async writeFile(path, content) {
+    return this.request("/files", {
+      method: "POST",
+      body: JSON.stringify({ path, content })
+    });
+  }
+  /**
+   * Delete a file or directory
+   */
+  async deleteFile(path) {
+    return this.request(`/files/${encodeURIComponent(path)}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Check if a file exists (HEAD request)
+   * @returns true if file exists, false otherwise
+   */
+  async checkFileExists(path) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      const headers = {
+        ...this.config.headers
+      };
+      if (this._token) {
+        headers["Authorization"] = `Bearer ${this._token}`;
+      }
+      const response = await fetch(
+        `${this.config.sandboxUrl}/files/${encodeURIComponent(path)}`,
+        {
+          method: "HEAD",
+          headers,
+          signal: controller.signal
+        }
+      );
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Batch file operations (write or delete multiple files)
+   *
+   * Features:
+   * - Deduplication: Last operation wins per path
+   * - File locking: Prevents race conditions
+   * - Deterministic ordering: Alphabetical path sorting
+   * - Partial failure handling: Returns 207 Multi-Status with per-file results
+   *
+   * @param files - Array of file operations
+   * @returns Results for each file operation
+   *
+   * @example
+   * ```typescript
+   * // Write multiple files
+   * const results = await sandbox.batchWriteFiles([
+   *   { path: '/app/file1.txt', operation: 'write', content: 'Hello' },
+   *   { path: '/app/file2.txt', operation: 'write', content: 'World' },
+   * ]);
+   *
+   * // Mixed operations (write and delete)
+   * const results = await sandbox.batchWriteFiles([
+   *   { path: '/app/new.txt', operation: 'write', content: 'New file' },
+   *   { path: '/app/old.txt', operation: 'delete' },
+   * ]);
+   * ```
+   */
+  async batchWriteFiles(files) {
+    return this.request("/files/batch", {
+      method: "POST",
+      body: JSON.stringify({ files })
+    });
+  }
+  // ============================================================================
+  // Terminal Management
+  // ============================================================================
+  /**
+   * Create a new persistent terminal session
+   * 
+   * Terminal Modes:
+   * - **PTY mode** (pty: true): Interactive shell with real-time WebSocket streaming
+   *   - Use for: Interactive shells, vim/nano, real-time output
+   *   - Methods: write(), resize(), on('output')
+   * 
+   * - **Exec mode** (pty: false, default): Command tracking with HTTP polling
+   *   - Use for: CI/CD, automation, command tracking, exit codes
+   *   - Methods: execute(), getCommand(), listCommands(), waitForCommand()
+   * 
+   * @example
+   * ```typescript
+   * // PTY mode - Interactive shell
+   * const pty = await sandbox.createTerminal({ pty: true, shell: '/bin/bash' });
+   * pty.on('output', (data) => console.log(data));
+   * pty.write('npm install\n');
+   * 
+   * // Exec mode - Command tracking
+   * const exec = await sandbox.createTerminal({ pty: false });
+   * const result = await exec.execute('npm test', { background: true });
+   * const cmd = await sandbox.waitForCommand(exec.getId(), result.data.cmd_id);
+   * console.log(cmd.data.exit_code);
+   * 
+   * // Backward compatible - creates PTY terminal
+   * const terminal = await sandbox.createTerminal('/bin/bash');
+   * ```
+   * 
+   * @param options - Terminal creation options
+   * @param options.shell - Shell to use (e.g., '/bin/bash', '/bin/sh') - PTY mode only
+   * @param options.encoding - Encoding for terminal I/O: 'raw' (default) or 'base64' (binary-safe)
+   * @param options.pty - Terminal mode: true = PTY (interactive shell), false = exec (command tracking, default)
+   * @returns Terminal instance with event handling
+   */
+  async createTerminal(shellOrOptions, encoding) {
+    let pty;
+    let shell;
+    let enc;
+    if (typeof shellOrOptions === "string") {
+      pty = true;
+      shell = shellOrOptions;
+      enc = encoding;
+    } else {
+      pty = shellOrOptions?.pty ?? false;
+      enc = shellOrOptions?.encoding;
+      shell = shellOrOptions?.shell;
+    }
+    const body = {};
+    if (shell) body.shell = shell;
+    if (enc) body.encoding = enc;
+    if (pty !== void 0) body.pty = pty;
+    const response = await this.request("/terminals", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    let ws = null;
+    if (response.data.pty) {
+      ws = await this.ensureWebSocket();
+      await new Promise((resolve) => {
+        const handler = (msg) => {
+          if (msg.data?.id === response.data.id) {
+            if (ws) ws.off("terminal:created", handler);
+            resolve();
+          }
+        };
+        if (ws) {
+          ws.on("terminal:created", handler);
+          setTimeout(() => {
+            if (ws) ws.off("terminal:created", handler);
+            resolve();
+          }, 5e3);
+        } else {
+          resolve();
+        }
+      });
+    }
+    const terminal = new TerminalInstance(
+      response.data.id,
+      response.data.pty,
+      response.data.status,
+      response.data.channel || null,
+      ws,
+      response.data.encoding || "raw"
+    );
+    const terminalId = response.data.id;
+    terminal.setExecuteHandler(async (command, background) => {
+      return this.request(`/terminals/${terminalId}/execute`, {
+        method: "POST",
+        body: JSON.stringify({ command, background })
+      });
+    });
+    terminal.setListCommandsHandler(async () => {
+      return this.request(`/terminals/${terminalId}/commands`);
+    });
+    terminal.setRetrieveCommandHandler(async (cmdId) => {
+      return this.request(`/terminals/${terminalId}/commands/${cmdId}`);
+    });
+    terminal.setWaitCommandHandler(async (cmdId, timeout) => {
+      const params = timeout ? new URLSearchParams({ timeout: timeout.toString() }) : "";
+      const endpoint = `/terminals/${terminalId}/commands/${cmdId}/wait${params ? `?${params}` : ""}`;
+      return this.request(endpoint);
+    });
+    terminal.setDestroyHandler(async () => {
+      await this.request(`/terminals/${terminalId}`, {
+        method: "DELETE"
+      });
+    });
+    return terminal;
+  }
+  /**
+   * List all active terminals (fetches from API)
+   */
+  async listTerminals() {
+    const response = await this.request("/terminals");
+    return response.data.terminals;
+  }
+  /**
+   * Get terminal by ID
+   */
+  async getTerminal(id) {
+    return this.request(`/terminals/${id}`);
+  }
+  // ============================================================================
+  // Command Tracking (Exec Mode Terminals)
+  // ============================================================================
+  /**
+   * List all commands executed in a terminal (exec mode only)
+   * @param terminalId - The terminal ID
+   * @returns List of all commands with their status
+   * @throws {Error} If terminal is in PTY mode (command tracking not available)
+   */
+  async listCommands(terminalId) {
+    return this.request(`/terminals/${terminalId}/commands`);
+  }
+  /**
+   * Get details of a specific command execution (exec mode only)
+   * @param terminalId - The terminal ID
+   * @param cmdId - The command ID
+   * @returns Command execution details including stdout, stderr, and exit code
+   * @throws {Error} If terminal is in PTY mode or command not found
+   */
+  async getCommand(terminalId, cmdId) {
+    return this.request(`/terminals/${terminalId}/commands/${cmdId}`);
+  }
+  /**
+   * Wait for a command to complete (HTTP long-polling, exec mode only)
+   * @param terminalId - The terminal ID
+   * @param cmdId - The command ID
+   * @param timeout - Optional timeout in seconds (0 = no timeout)
+   * @returns Command execution details when completed
+   * @throws {Error} If terminal is in PTY mode, command not found, or timeout occurs
+   */
+  async waitForCommand(terminalId, cmdId, timeout) {
+    const params = timeout ? new URLSearchParams({ timeout: timeout.toString() }) : "";
+    const endpoint = `/terminals/${terminalId}/commands/${cmdId}/wait${params ? `?${params}` : ""}`;
+    return this.request(endpoint);
+  }
+  // ============================================================================
+  // File Watchers
+  // ============================================================================
+  /**
+   * Create a new file watcher with WebSocket integration
+   * @param path - Path to watch
+   * @param options - Watcher options
+   * @param options.includeContent - Include file content in change events
+   * @param options.ignored - Patterns to ignore
+   * @param options.encoding - Encoding for file content: 'raw' (default) or 'base64' (binary-safe)
+   * @returns FileWatcher instance with event handling
+   */
+  async createWatcher(path, options) {
+    const ws = await this.ensureWebSocket();
+    const response = await this.request("/watchers", {
+      method: "POST",
+      body: JSON.stringify({ path, ...options })
+    });
+    const watcher = new FileWatcher(
+      response.data.id,
+      response.data.path,
+      response.data.status,
+      response.data.channel,
+      response.data.includeContent,
+      response.data.ignored,
+      ws,
+      response.data.encoding || "raw"
+    );
+    watcher.setDestroyHandler(async () => {
+      await this.request(`/watchers/${response.data.id}`, {
+        method: "DELETE"
+      });
+    });
+    return watcher;
+  }
+  /**
+   * List all active file watchers (fetches from API)
+   */
+  async listWatchers() {
+    return this.request("/watchers");
+  }
+  /**
+   * Get file watcher by ID
+   */
+  async getWatcher(id) {
+    return this.request(`/watchers/${id}`);
+  }
+  // ============================================================================
+  // Signal Service
+  // ============================================================================
+  /**
+   * Start the signal service with WebSocket integration
+   * @returns SignalService instance with event handling
+   */
+  async startSignals() {
+    const ws = await this.ensureWebSocket();
+    const response = await this.request("/signals/start", {
+      method: "POST"
+    });
+    const signalService = new SignalService(
+      response.data.status,
+      response.data.channel,
+      ws
+    );
+    signalService.setStopHandler(async () => {
+      await this.request("/signals/stop", {
+        method: "POST"
+      });
+    });
+    return signalService;
+  }
+  /**
+   * Get the signal service status (fetches from API)
+   */
+  async getSignalStatus() {
+    return this.request("/signals/status");
+  }
+  /**
+   * Emit a port signal
+   */
+  async emitPortSignal(port, type, url) {
+    return this.request("/signals/port", {
+      method: "POST",
+      body: JSON.stringify({ port, type, url })
+    });
+  }
+  /**
+   * Emit a port signal (alternative endpoint using path parameters)
+   */
+  async emitPortSignalAlt(port, type) {
+    return this.request(`/signals/port/${port}/${type}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Emit an error signal
+   */
+  async emitErrorSignal(message) {
+    return this.request("/signals/error", {
+      method: "POST",
+      body: JSON.stringify({ message })
+    });
+  }
+  /**
+   * Emit a server ready signal
+   */
+  async emitServerReadySignal(port, url) {
+    return this.request("/signals/server-ready", {
+      method: "POST",
+      body: JSON.stringify({ port, url })
+    });
+  }
+  // ============================================================================
+  // Environment Variables
+  // ============================================================================
+  /**
+   * Get environment variables from a .env file
+   * @param file - Path to the .env file (relative to sandbox root)
+   */
+  async getEnv(file) {
+    const params = new URLSearchParams({ file });
+    return this.request(`/env?${params}`);
+  }
+  /**
+   * Set (merge) environment variables in a .env file
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @param variables - Key-value pairs to set
+   */
+  async setEnv(file, variables) {
+    const params = new URLSearchParams({ file });
+    return this.request(`/env?${params}`, {
+      method: "POST",
+      body: JSON.stringify({ variables })
+    });
+  }
+  /**
+   * Delete environment variables from a .env file
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @param keys - Keys to delete
+   */
+  async deleteEnv(file, keys) {
+    const params = new URLSearchParams({ file });
+    return this.request(`/env?${params}`, {
+      method: "DELETE",
+      body: JSON.stringify({ keys })
+    });
+  }
+  /**
+   * Check if an environment file exists (HEAD request)
+   * @param file - Path to the .env file (relative to sandbox root)
+   * @returns true if file exists, false otherwise
+   */
+  async checkEnvFile(file) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      const headers = {
+        ...this.config.headers
+      };
+      if (this._token) {
+        headers["Authorization"] = `Bearer ${this._token}`;
+      }
+      const params = new URLSearchParams({ file });
+      const response = await fetch(`${this.config.sandboxUrl}/env?${params}`, {
+        method: "HEAD",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  // ============================================================================
+  // Server Management
+  // ============================================================================
+  /**
+   * List all managed servers
+   */
+  async listServers() {
+    return this.request("/servers");
+  }
+  /**
+   * Start a new managed server
+   * @param options - Server configuration
+   */
+  async startServer(options) {
+    return this.request("/servers", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Get information about a specific server
+   * @param slug - Server slug
+   */
+  async getServer(slug) {
+    return this.request(`/servers/${encodeURIComponent(slug)}`);
+  }
+  /**
+   * Stop a managed server
+   * @param slug - Server slug
+   */
+  async stopServer(slug) {
+    return this.request(
+      `/servers/${encodeURIComponent(slug)}`,
+      {
+        method: "DELETE"
+      }
+    );
+  }
+  /**
+   * Restart a managed server
+   * @param slug - Server slug
+   */
+  async restartServer(slug) {
+    return this.request(
+      `/servers/${encodeURIComponent(slug)}/restart`,
+      {
+        method: "POST"
+      }
+    );
+  }
+  /**
+   * Update server status (internal use)
+   * @param slug - Server slug
+   * @param status - New server status
+   */
+  async updateServerStatus(slug, status) {
+    return this.request(
+      `/servers/${encodeURIComponent(slug)}/status`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({ status })
+      }
+    );
+  }
+  // ============================================================================
+  // Sandbox Management
+  // ============================================================================
+  /**
+   * Create a new sandbox environment
+   */
+  async createSandbox() {
+    return this.request("/sandboxes", {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  /**
+   * List all sandboxes
+   */
+  async listSandboxes() {
+    return this.request("/sandboxes");
+  }
+  /**
+   * Get sandbox details
+   */
+  async getSandbox(subdomain) {
+    return this.request(`/sandboxes/${subdomain}`);
+  }
+  /**
+   * Delete a sandbox
+   */
+  async deleteSandbox(subdomain, deleteFiles = false) {
+    const params = new URLSearchParams({ delete_files: String(deleteFiles) });
+    return this.request(`/sandboxes/${subdomain}?${params}`, {
+      method: "DELETE"
+    });
+  }
+  // ============================================================================
+  // WebSocket Connection (Internal)
+  // ============================================================================
+  /**
+   * Get WebSocket URL for real-time communication
+   * @private
+   */
+  getWebSocketUrl() {
+    const wsProtocol = this.config.sandboxUrl.startsWith("https") ? "wss" : "ws";
+    const url = this.config.sandboxUrl.replace(/^https?:/, `${wsProtocol}:`);
+    const params = new URLSearchParams();
+    if (this._token) {
+      params.set("token", this._token);
+    }
+    params.set("protocol", this.config.protocol || "binary");
+    const queryString = params.toString();
+    return `${url}/ws${queryString ? `?${queryString}` : ""}`;
+  }
+  // ============================================================================
+  // Sandbox Interface Implementation
+  // ============================================================================
+  /**
+   * Execute code in the sandbox (convenience method)
+   *
+   * Delegates to sandbox.run.code() - prefer using that directly for new code.
+   *
+   * @param code - The code to execute
+   * @param language - Programming language (auto-detected if not specified)
+   * @returns Code execution result
+   */
+  async runCode(code, language) {
+    return this.run.code(code, language ? { language } : void 0);
+  }
+  /**
+   * Execute shell command in the sandbox (convenience method)
+   *
+   * Delegates to sandbox.run.command() - prefer using that directly for new code.
+   *
+   * @param command - The command to execute (string or array form)
+   * @param argsOrOptions - Arguments array or options object
+   * @param maybeOptions - Options when using (command, args, options) form
+   * @returns Command execution result
+   */
+  async runCommand(commandOrArray, argsOrOptions, maybeOptions) {
+    let commandParts;
+    let options;
+    if (Array.isArray(commandOrArray)) {
+      commandParts = commandOrArray;
+      options = argsOrOptions;
+    } else {
+      const args = Array.isArray(argsOrOptions) ? argsOrOptions : [];
+      commandParts = [commandOrArray, ...args];
+      options = Array.isArray(argsOrOptions) ? maybeOptions : argsOrOptions;
+    }
+    const finalCommand = cmd(commandParts, options);
+    const fullCommand = escapeArgs(finalCommand);
+    return this.run.command(fullCommand, { background: options?.background });
+  }
+  /**
+   * Get server information
+   * Returns details about the server including auth status, main subdomain, sandbox count, and version
+   */
+  async getServerInfo() {
+    return this.request("/info");
+  }
+  /**
+   * Get sandbox information
+   */
+  async getInfo() {
+    return {
+      id: this.sandboxId || "",
+      provider: this.provider || "",
+      runtime: "node",
+      status: "running",
+      createdAt: /* @__PURE__ */ new Date(),
+      timeout: this.config.timeout,
+      metadata: this.config.metadata
+    };
+  }
+  /**
+   * Get URL for accessing sandbox on a specific port (Sandbox interface method)
+   */
+  async getUrl(options) {
+    const protocol = options.protocol || "https";
+    const url = new URL(this.config.sandboxUrl);
+    const parts = url.hostname.split(".");
+    const subdomain = parts[0];
+    const baseDomain = parts.slice(1).join(".");
+    const previewDomain = baseDomain.replace("sandbox.computesdk.com", "preview.computesdk.com");
+    return `${protocol}://${subdomain}-${options.port}.${previewDomain}`;
+  }
+  /**
+   * Get provider instance
+   * Note: Not available when using Sandbox directly - only available through gateway provider
+   */
+  getProvider() {
+    throw new Error(
+      "getProvider() is not available on Sandbox. This method is only available when using provider sandboxes through the gateway."
+    );
+  }
+  /**
+   * Get native provider instance
+   * Returns the Sandbox itself since this IS the sandbox implementation
+   */
+  getInstance() {
+    return this;
+  }
+  /**
+   * Destroy the sandbox (Sandbox interface method)
+   */
+  async destroy() {
+    await this.disconnect();
+  }
+  /**
+   * Disconnect WebSocket
+   *
+   * Note: This only disconnects the WebSocket. Terminals, watchers, and signals
+   * will continue running on the server until explicitly destroyed via their
+   * respective destroy() methods or the DELETE endpoints.
+   */
+  async disconnect() {
+    if (this._ws) {
+      this._ws.disconnect();
+      this._ws = null;
+    }
+  }
+};
+
+// src/provider-config.ts
+var PROVIDER_AUTH = {
+  e2b: [["E2B_API_KEY"]],
+  modal: [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
+  railway: [["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]],
+  daytona: [["DAYTONA_API_KEY"]],
+  vercel: [
+    ["VERCEL_OIDC_TOKEN"],
+    ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]
+  ],
+  runloop: [["RUNLOOP_API_KEY"]],
+  cloudflare: [["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]],
+  codesandbox: [["CSB_API_KEY"]],
+  blaxel: [["BL_API_KEY", "BL_WORKSPACE"]]
+};
+var PROVIDER_NAMES = Object.keys(PROVIDER_AUTH);
+var PROVIDER_HEADERS = {
+  e2b: {
+    apiKey: "X-E2B-API-Key"
+  },
+  modal: {
+    tokenId: "X-Modal-Token-Id",
+    tokenSecret: "X-Modal-Token-Secret"
+  },
+  railway: {
+    apiToken: "X-Railway-API-Token"
+  },
+  daytona: {
+    apiKey: "X-Daytona-API-Key"
+  },
+  vercel: {
+    oidcToken: "X-Vercel-OIDC-Token",
+    token: "X-Vercel-Token",
+    teamId: "X-Vercel-Team-Id",
+    projectId: "X-Vercel-Project-Id"
+  },
+  runloop: {
+    apiKey: "X-Runloop-API-Key"
+  },
+  cloudflare: {
+    apiToken: "X-Cloudflare-API-Token",
+    accountId: "X-Cloudflare-Account-Id"
+  },
+  codesandbox: {
+    apiKey: "X-CSB-API-Key"
+  },
+  blaxel: {
+    apiKey: "X-BL-API-Key",
+    workspace: "X-BL-Workspace"
+  }
+};
+var PROVIDER_ENV_MAP = {
+  e2b: {
+    E2B_API_KEY: "apiKey"
+  },
+  modal: {
+    MODAL_TOKEN_ID: "tokenId",
+    MODAL_TOKEN_SECRET: "tokenSecret"
+  },
+  railway: {
+    RAILWAY_API_KEY: "apiToken",
+    RAILWAY_PROJECT_ID: "projectId",
+    RAILWAY_ENVIRONMENT_ID: "environmentId"
+  },
+  daytona: {
+    DAYTONA_API_KEY: "apiKey"
+  },
+  vercel: {
+    VERCEL_OIDC_TOKEN: "oidcToken",
+    VERCEL_TOKEN: "token",
+    VERCEL_TEAM_ID: "teamId",
+    VERCEL_PROJECT_ID: "projectId"
+  },
+  runloop: {
+    RUNLOOP_API_KEY: "apiKey"
+  },
+  cloudflare: {
+    CLOUDFLARE_API_TOKEN: "apiToken",
+    CLOUDFLARE_ACCOUNT_ID: "accountId"
+  },
+  codesandbox: {
+    CSB_API_KEY: "apiKey"
+  },
+  blaxel: {
+    BL_API_KEY: "apiKey",
+    BL_WORKSPACE: "workspace"
+  }
+};
+var PROVIDER_DASHBOARD_URLS = {
+  e2b: "https://e2b.dev/dashboard",
+  modal: "https://modal.com/settings",
+  railway: "https://railway.app/account/tokens",
+  daytona: "https://daytona.io/dashboard",
+  vercel: "https://vercel.com/account/tokens",
+  runloop: "https://runloop.ai/dashboard",
+  cloudflare: "https://dash.cloudflare.com/profile/api-tokens",
+  codesandbox: "https://codesandbox.io/dashboard/settings",
+  blaxel: "https://blaxel.ai/dashboard"
+};
+function isValidProvider(name) {
+  return name in PROVIDER_AUTH;
+}
+function buildProviderHeaders(provider, config) {
+  const headers = {};
+  const headerMap = PROVIDER_HEADERS[provider];
+  for (const [configKey, headerName] of Object.entries(headerMap)) {
+    const value = config[configKey];
+    if (value) {
+      headers[headerName] = value;
+    }
+  }
+  return headers;
+}
+function getProviderConfigFromEnv(provider) {
+  const config = {};
+  const envMap = PROVIDER_ENV_MAP[provider];
+  for (const [envVar, configKey] of Object.entries(envMap)) {
+    const value = process.env[envVar];
+    if (value) {
+      config[configKey] = value;
+    }
+  }
+  return config;
+}
+function isProviderAuthComplete(provider) {
+  const authOptions = PROVIDER_AUTH[provider];
+  for (const option of authOptions) {
+    const allPresent = option.every((envVar) => !!process.env[envVar]);
+    if (allPresent) return true;
+  }
+  return false;
+}
+function getMissingEnvVars(provider) {
+  const authOptions = PROVIDER_AUTH[provider];
+  let bestOption = null;
+  for (const option of authOptions) {
+    const missing = [];
+    let presentCount = 0;
+    for (const envVar of option) {
+      if (process.env[envVar]) {
+        presentCount++;
+      } else {
+        missing.push(envVar);
+      }
+    }
+    if (missing.length === 0) return [];
+    if (!bestOption || presentCount > bestOption.presentCount) {
+      bestOption = { presentCount, missing };
+    }
+  }
+  return bestOption?.missing ?? [];
+}
+
+// src/constants.ts
+var GATEWAY_URL = "https://gateway.computesdk.com";
+var PROVIDER_PRIORITY = [
+  "e2b",
+  "railway",
+  "daytona",
+  "modal",
+  "runloop",
+  "vercel",
+  "cloudflare",
+  "codesandbox",
+  "blaxel"
+];
+var PROVIDER_ENV_VARS = {
+  e2b: ["E2B_API_KEY"],
+  railway: ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"],
+  daytona: ["DAYTONA_API_KEY"],
+  modal: ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"],
+  runloop: ["RUNLOOP_API_KEY"],
+  vercel: ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"],
+  cloudflare: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"],
+  codesandbox: ["CSB_API_KEY"],
+  blaxel: ["BL_API_KEY", "BL_WORKSPACE"]
+};
 
 // src/auto-detect.ts
 function isGatewayModeEnabled() {
@@ -1018,12 +3282,13 @@ Check your COMPUTESDK_GATEWAY_URL environment variable.`
     console.log(`\u{1F310} Gateway: ${gatewayUrl}`);
     console.log(`\u{1F511} Provider headers:`, Object.keys(providerHeaders).join(", "));
   }
-  return gateway({
-    gatewayUrl,
+  const config = {
     apiKey: computesdkApiKey,
+    gatewayUrl,
     provider,
     providerHeaders
-  });
+  };
+  return config;
 }
 
 // src/explicit-config.ts
@@ -1085,7 +3350,7 @@ function buildConfigExample(provider, authOptions) {
   });
   return options.join("\n\n");
 }
-function createProviderFromConfig(config) {
+function createConfigFromExplicit(config) {
   if (!config.apiKey) {
     throw new Error(
       `Missing ComputeSDK API key. The 'apiKey' field is required.
@@ -1095,213 +3360,302 @@ Get your API key at: https://computesdk.com/dashboard`
   }
   validateProviderConfig(config);
   const providerHeaders = buildProviderHeaders2(config);
-  return gateway({
+  return {
     apiKey: config.apiKey,
+    gatewayUrl: config.gatewayUrl || GATEWAY_URL,
     provider: config.provider,
     providerHeaders
-  });
+  };
+}
+
+// src/compute-daemon/lifecycle.ts
+async function waitForComputeReady(client, options = {}) {
+  const maxRetries = options.maxRetries ?? 30;
+  const initialDelayMs = options.initialDelayMs ?? 500;
+  const maxDelayMs = options.maxDelayMs ?? 5e3;
+  const backoffFactor = options.backoffFactor ?? 1.5;
+  let lastError = null;
+  let currentDelay = initialDelayMs;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      await client.health();
+      if (process.env.COMPUTESDK_DEBUG) {
+        console.log(`[Lifecycle] Sandbox ready after ${i + 1} attempt${i === 0 ? "" : "s"}`);
+      }
+      return;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i === maxRetries - 1) {
+        throw new Error(
+          `Sandbox failed to become ready after ${maxRetries} attempts.
+Last error: ${lastError.message}
+
+Possible causes:
+  1. Sandbox failed to start (check provider dashboard for errors)
+  2. Network connectivity issues between your app and the sandbox
+  3. Sandbox is taking longer than expected to initialize
+  4. Invalid sandbox URL or authentication credentials
+
+Troubleshooting:
+  - Check sandbox logs in your provider dashboard
+  - Verify your network connection
+  - Try increasing maxRetries if initialization is slow
+  - Enable debug mode: export COMPUTESDK_DEBUG=1`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, currentDelay));
+      currentDelay = Math.min(currentDelay * backoffFactor, maxDelayMs);
+    }
+  }
 }
 
 // src/compute.ts
+async function gatewayFetch(url, config, options = {}) {
+  const timeout = 3e4;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        "X-ComputeSDK-API-Key": config.apiKey,
+        "X-Provider": config.provider,
+        ...config.providerHeaders,
+        ...options.headers
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      if (response.status === 404) {
+        return { success: false };
+      }
+      const errorText = await response.text().catch(() => response.statusText);
+      let errorMessage = `Gateway API error: ${errorText}`;
+      if (response.status === 401) {
+        errorMessage = `Invalid ComputeSDK API key. Check your COMPUTESDK_API_KEY environment variable.`;
+      } else if (response.status === 403) {
+        errorMessage = `Access forbidden. Your API key may not have permission to use provider "${config.provider}".`;
+      }
+      throw new Error(errorMessage);
+    }
+    return await response.json();
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
 var ComputeManager = class {
   constructor() {
     this.config = null;
     this.autoConfigured = false;
     this.sandbox = {
       /**
-       * Create a sandbox from a provider (or default provider if configured)
-       *
-       * @example
-       * ```typescript
-       * import { e2b } from '@computesdk/e2b'
-       * import { compute } from 'computesdk'
-       *
-       * // With explicit provider
-       * const sandbox = await compute.sandbox.create({
-       *   provider: e2b({ apiKey: 'your-key' })
-       * })
-       *
-        * // With default provider
-        * compute.setConfig({ defaultProvider: e2b({ apiKey: 'your-key' }) })
-        * const sandbox = await compute.sandbox.create()
-       * ```
+       * Create a new sandbox
        */
-      create: async (params) => {
-        const provider = params && "provider" in params && params.provider ? params.provider : this.getDefaultProvider();
-        const options = params?.options;
-        return await provider.sandbox.create(options);
+      create: async (options) => {
+        const config = this.getGatewayConfig();
+        const result = await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes`, config, {
+          method: "POST",
+          body: JSON.stringify(options || {})
+        });
+        if (!result.success || !result.data) {
+          throw new Error(`Gateway returned invalid response`);
+        }
+        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
+        const sandbox = new Sandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata: {
+            ...metadata,
+            ...name && { name },
+            ...namespace && { namespace }
+          },
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return sandbox;
       },
       /**
-       * Get an existing sandbox by ID from a provider (or default provider if configured)
+       * Get an existing sandbox by ID
        */
-      getById: async (providerOrSandboxId, sandboxId) => {
-        if (typeof providerOrSandboxId === "string") {
-          const provider = this.getDefaultProvider();
-          return await provider.sandbox.getById(providerOrSandboxId);
-        } else {
-          if (!sandboxId) {
-            throw new Error("sandboxId is required when provider is specified");
-          }
-          return await providerOrSandboxId.sandbox.getById(sandboxId);
+      getById: async (sandboxId) => {
+        const config = this.getGatewayConfig();
+        const result = await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config);
+        if (!result.success || !result.data) {
+          return null;
         }
+        const { url, token, provider, metadata } = result.data;
+        const sandbox = new Sandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata,
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return sandbox;
       },
       /**
-       * List all active sandboxes from a provider (or default provider if configured)
+       * List all active sandboxes
        */
-      list: async (provider) => {
-        const actualProvider = provider || this.getDefaultProvider();
-        return await actualProvider.sandbox.list();
+      list: async () => {
+        throw new Error(
+          "The gateway does not support listing sandboxes. Use getById() with a known sandbox ID instead."
+        );
       },
       /**
-       * Destroy a sandbox via a provider (or default provider if configured)
+       * Destroy a sandbox
        */
-      destroy: async (providerOrSandboxId, sandboxId) => {
-        if (typeof providerOrSandboxId === "string") {
-          const provider = this.getDefaultProvider();
-          return await provider.sandbox.destroy(providerOrSandboxId);
-        } else {
-          if (!sandboxId) {
-            throw new Error("sandboxId is required when provider is specified");
-          }
-          return await providerOrSandboxId.sandbox.destroy(sandboxId);
-        }
+      destroy: async (sandboxId) => {
+        const config = this.getGatewayConfig();
+        await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
+          method: "DELETE"
+        });
       },
       /**
        * Find existing or create new sandbox by (namespace, name)
-       *
-       * @example
-       * ```typescript
-       * // Find or create sandbox for a user's project
-       * const sandbox = await compute.sandbox.findOrCreate({
-       *   name: 'my-app',
-       *   namespace: 'user-123',
-       *   timeout: 1800000
-       * });
-       * ```
        */
       findOrCreate: async (options) => {
-        const provider = this.getDefaultProvider();
-        if (!provider.sandbox.findOrCreate) {
-          throw new Error(
-            `Provider '${provider.name}' does not support findOrCreate.
-This feature requires gateway provider with named sandbox support.`
-          );
+        const config = this.getGatewayConfig();
+        const { name, namespace, ...restOptions } = options;
+        const result = await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes/find-or-create`, config, {
+          method: "POST",
+          body: JSON.stringify({
+            namespace: namespace || "default",
+            name,
+            ...restOptions
+          })
+        });
+        if (!result.success || !result.data) {
+          throw new Error(`Gateway returned invalid response`);
         }
-        return await provider.sandbox.findOrCreate(options);
+        const { sandboxId, url, token, provider, metadata } = result.data;
+        const sandbox = new Sandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata: {
+            ...metadata,
+            name: result.data.name,
+            namespace: result.data.namespace
+          },
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return sandbox;
       },
       /**
        * Find existing sandbox by (namespace, name) without creating
-       *
-       * @example
-       * ```typescript
-       * // Find existing sandbox
-       * const sandbox = await compute.sandbox.find({
-       *   name: 'my-app',
-       *   namespace: 'user-123'
-       * });
-       * 
-       * if (sandbox) {
-       *   console.log('Found sandbox:', sandbox.sandboxId);
-       * }
-       * ```
        */
       find: async (options) => {
-        const provider = this.getDefaultProvider();
-        if (!provider.sandbox.find) {
-          throw new Error(
-            `Provider '${provider.name}' does not support find.
-This feature requires gateway provider with named sandbox support.`
-          );
+        const config = this.getGatewayConfig();
+        const result = await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes/find`, config, {
+          method: "POST",
+          body: JSON.stringify({
+            namespace: options.namespace || "default",
+            name: options.name
+          })
+        });
+        if (!result.success || !result.data) {
+          return null;
         }
-        return await provider.sandbox.find(options);
+        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
+        const sandbox = new Sandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          metadata: {
+            ...metadata,
+            name,
+            namespace
+          },
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return sandbox;
       },
       /**
        * Extend sandbox timeout/expiration
-       *
-       * @example
-       * ```typescript
-       * // Extend timeout by 15 minutes (default)
-       * await compute.sandbox.extendTimeout('sandbox-123');
-       * 
-       * // Extend timeout by custom duration
-       * await compute.sandbox.extendTimeout('sandbox-123', {
-       *   duration: 1800000 // 30 minutes
-       * });
-       * ```
        */
       extendTimeout: async (sandboxId, options) => {
-        const provider = this.getDefaultProvider();
-        if (!provider.sandbox.extendTimeout) {
-          throw new Error(
-            `Provider '${provider.name}' does not support extendTimeout.
-This feature requires gateway provider with timeout extension support.`
-          );
-        }
-        return await provider.sandbox.extendTimeout(sandboxId, options);
+        const config = this.getGatewayConfig();
+        const duration = options?.duration ?? 9e5;
+        await gatewayFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}/extend`, config, {
+          method: "POST",
+          body: JSON.stringify({ duration })
+        });
       }
     };
   }
-  /**
-   * Set default configuration with generic type preservation
-   */
-  setConfig(config) {
-    if (!config.defaultProvider && !config.provider) {
-      throw new Error("Either defaultProvider or provider must be specified in setConfig");
-    }
-    if (config.defaultProvider && config.provider) {
-      console.warn("Both defaultProvider and provider specified in setConfig. Using defaultProvider. The provider key is deprecated, please use defaultProvider instead.");
-    }
-    const actualProvider = config.defaultProvider || config.provider;
-    this.config = {
-      provider: actualProvider,
-      defaultProvider: actualProvider
-    };
-  }
-  /**
-   * Get current configuration
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Clear current configuration
-   */
-  clearConfig() {
-    this.config = null;
-  }
   /**
    * Lazy auto-configure from environment if not explicitly configured
    */
   ensureConfigured() {
     if (this.config) return;
     if (this.autoConfigured) return;
-    const provider = autoConfigureCompute();
+    const config = autoConfigureCompute();
     this.autoConfigured = true;
-    if (provider) {
-      this.config = {
-        provider,
-        defaultProvider: provider
-      };
+    if (config) {
+      this.config = config;
     }
   }
   /**
-   * Get the default provider, throwing if not configured
+   * Get gateway config, throwing if not configured
    */
-  getDefaultProvider() {
+  getGatewayConfig() {
     this.ensureConfigured();
-    const provider = this.config?.defaultProvider || this.config?.provider;
-    if (!provider) {
+    if (!this.config) {
       throw new Error(
-        "No default provider configured.\n\nOptions:\n1. Zero-config mode: Set COMPUTESDK_API_KEY and provider credentials (e.g., E2B_API_KEY)\n2. Explicit mode: Call compute.setConfig({ defaultProvider }) or pass provider to create()\n\nDocs: https://computesdk.com/docs/quickstart"
+        `No ComputeSDK configuration found.
+
+Options:
+1. Zero-config: Set COMPUTESDK_API_KEY and provider credentials (e.g., E2B_API_KEY)
+2. Explicit: Call compute.setConfig({ provider: "e2b", apiKey: "...", e2b: { apiKey: "..." } })
+3. Use provider directly: import { e2b } from '@computesdk/e2b'
+
+Docs: https://computesdk.com/docs/quickstart`
       );
     }
-    return provider;
+    return this.config;
+  }
+  /**
+   * Explicitly configure the compute singleton
+   * 
+   * @example
+   * ```typescript
+   * import { compute } from 'computesdk';
+   * 
+   * compute.setConfig({
+   *   provider: 'e2b',
+   *   apiKey: 'computesdk_xxx',
+   *   e2b: { apiKey: 'e2b_xxx' }
+   * });
+   * 
+   * const sandbox = await compute.sandbox.create();
+   * ```
+   */
+  setConfig(config) {
+    const gatewayConfig = createConfigFromExplicit(config);
+    this.config = gatewayConfig;
+    this.autoConfigured = false;
   }
 };
 var singletonInstance = new ComputeManager();
 function computeFactory(config) {
-  const provider = createProviderFromConfig(config);
-  return createCompute({ provider });
+  const gatewayConfig = createConfigFromExplicit(config);
+  const manager = new ComputeManager();
+  manager["config"] = gatewayConfig;
+  return manager;
 }
 var compute = new Proxy(
   computeFactory,
@@ -1319,256 +3673,12 @@ var compute = new Proxy(
     }
   }
 );
-function createCompute(config) {
-  const manager = new ComputeManager();
-  if (!config) {
-    return manager;
-  }
-  const actualProvider = config.defaultProvider || config.provider;
-  manager["config"] = {
-    provider: actualProvider,
-    defaultProvider: actualProvider
-  };
-  const api = {
-    setConfig: (cfg) => createCompute(cfg),
-    getConfig: () => manager.getConfig(),
-    clearConfig: () => manager.clearConfig(),
-    sandbox: {
-      create: async (params) => {
-        const sandbox = await manager.sandbox.create(params);
-        return sandbox;
-      },
-      getById: async (sandboxId) => {
-        const sandbox = await manager.sandbox.getById(sandboxId);
-        if (!sandbox) return null;
-        return sandbox;
-      },
-      list: async () => {
-        const sandboxes = await manager.sandbox.list();
-        return sandboxes;
-      },
-      destroy: async (sandboxId) => {
-        return await manager.sandbox.destroy(sandboxId);
-      },
-      findOrCreate: async (options) => {
-        const sandbox = await manager.sandbox.findOrCreate(options);
-        return sandbox;
-      },
-      find: async (options) => {
-        const sandbox = await manager.sandbox.find(options);
-        if (!sandbox) return null;
-        return sandbox;
-      },
-      extendTimeout: async (sandboxId, options) => {
-        return await manager.sandbox.extendTimeout(sandboxId, options);
-      }
-    }
-  };
-  return api;
-}
-
-// src/request-handler.ts
-async function executeAction(body, provider) {
-  try {
-    const { action, sandboxId } = body;
-    if (action === "compute.sandbox.create") {
-      const sandbox2 = await compute.sandbox.create({
-        provider,
-        options: body.options || { runtime: "python" }
-      });
-      return {
-        success: true,
-        sandboxId: sandbox2.sandboxId,
-        provider: provider.name
-      };
-    }
-    if (action === "compute.sandbox.list") {
-      const sandboxes = await compute.sandbox.list(provider);
-      return {
-        success: true,
-        sandboxId: "",
-        provider: provider.name,
-        sandboxes: sandboxes.map((sb) => ({
-          sandboxId: sb.sandboxId,
-          provider: sb.provider
-        }))
-      };
-    }
-    if (action === "compute.sandbox.destroy") {
-      if (!sandboxId) {
-        throw new Error("sandboxId is required for destroy action");
-      }
-      await compute.sandbox.destroy(provider, sandboxId);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name
-      };
-    }
-    if (!sandboxId) {
-      throw new Error("sandboxId is required for this action");
-    }
-    const sandbox = await compute.sandbox.getById(provider, sandboxId);
-    if (!sandbox) {
-      throw new Error(`Sandbox ${sandboxId} not found`);
-    }
-    if (action === "compute.sandbox.getInfo") {
-      const result = await sandbox.getInfo();
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        info: {
-          id: result.id,
-          provider: result.provider,
-          runtime: result.runtime,
-          status: result.status,
-          createdAt: result.createdAt.toISOString(),
-          timeout: result.timeout,
-          metadata: result.metadata
-        }
-      };
-    }
-    if (action === "compute.sandbox.runCode") {
-      if (!body.code) throw new Error("code is required");
-      const result = await sandbox.runCode(body.code, body.runtime);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        result: {
-          output: result.output,
-          exitCode: result.exitCode,
-          language: result.language
-        }
-      };
-    }
-    if (action === "compute.sandbox.runCommand") {
-      if (!body.command) throw new Error("command is required");
-      const result = await sandbox.runCommand(body.command, body.args, body.commandOptions);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        result: {
-          stdout: result.stdout,
-          stderr: result.stderr,
-          exitCode: result.exitCode,
-          durationMs: result.durationMs
-        }
-      };
-    }
-    if (action === "compute.sandbox.filesystem.readFile") {
-      if (!body.path) throw new Error("path is required");
-      const result = await sandbox.filesystem.readFile(body.path);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        fileContent: result
-      };
-    }
-    if (action === "compute.sandbox.filesystem.writeFile") {
-      if (!body.path) throw new Error("path is required");
-      if (body.content === void 0) throw new Error("content is required");
-      await sandbox.filesystem.writeFile(body.path, body.content);
-      return { success: true, sandboxId, provider: provider.name };
-    }
-    if (action === "compute.sandbox.filesystem.mkdir") {
-      if (!body.path) throw new Error("path is required");
-      await sandbox.filesystem.mkdir(body.path);
-      return { success: true, sandboxId, provider: provider.name };
-    }
-    if (action === "compute.sandbox.filesystem.readdir") {
-      if (!body.path) throw new Error("path is required");
-      const result = await sandbox.filesystem.readdir(body.path);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        files: result.map((entry) => ({
-          name: entry.name,
-          path: entry.path,
-          isDirectory: entry.isDirectory,
-          size: entry.size,
-          lastModified: entry.lastModified.toISOString()
-        }))
-      };
-    }
-    if (action === "compute.sandbox.filesystem.exists") {
-      if (!body.path) throw new Error("path is required");
-      const result = await sandbox.filesystem.exists(body.path);
-      return {
-        success: true,
-        sandboxId,
-        provider: provider.name,
-        exists: result
-      };
-    }
-    if (action === "compute.sandbox.filesystem.remove") {
-      if (!body.path) throw new Error("path is required");
-      await sandbox.filesystem.remove(body.path);
-      return { success: true, sandboxId, provider: provider.name };
-    }
-    throw new Error(`Unknown action: ${action}`);
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error occurred",
-      sandboxId: body.sandboxId || "",
-      provider: provider.name
-    };
-  }
-}
-async function handleComputeRequest(paramsOrRequestOrBody, provider) {
-  if (typeof paramsOrRequestOrBody === "object" && "request" in paramsOrRequestOrBody && "provider" in paramsOrRequestOrBody) {
-    const params = paramsOrRequestOrBody;
-    return await executeAction(params.request, params.provider);
-  }
-  if (!provider) {
-    throw new Error("Provider is required when not using object-style API");
-  }
-  const requestOrBody = paramsOrRequestOrBody;
-  try {
-    let body;
-    if (requestOrBody instanceof Request) {
-      if (requestOrBody.method !== "POST") {
-        return Response.json({
-          success: false,
-          error: "Only POST requests are supported",
-          sandboxId: "",
-          provider: provider.name
-        }, { status: 405 });
-      }
-      try {
-        body = await requestOrBody.json();
-      } catch (parseError) {
-        return Response.json({
-          success: false,
-          error: "Invalid JSON in request body",
-          sandboxId: "",
-          provider: provider.name
-        }, { status: 400 });
-      }
-    } else {
-      body = requestOrBody;
-    }
-    const result = await executeAction(body, provider);
-    return Response.json(result, {
-      status: result.success ? 200 : 500
-    });
-  } catch (error) {
-    return Response.json({
-      success: false,
-      error: error instanceof Error ? error.message : "Request handling failed",
-      sandboxId: "",
-      provider: provider.name
-    }, { status: 500 });
-  }
-}
 export {
   CommandExitError,
+  FileWatcher,
   GATEWAY_URL,
+  Sandbox as GatewaySandbox,
+  MessageType,
   PROVIDER_AUTH,
   PROVIDER_DASHBOARD_URLS,
   PROVIDER_ENV_MAP,
@@ -1577,19 +3687,17 @@ export {
   PROVIDER_NAMES,
   PROVIDER_PRIORITY,
   Sandbox,
+  SignalService,
+  TerminalInstance,
   autoConfigureCompute,
   buildProviderHeaders,
-  calculateBackoff,
   compute,
-  createCompute,
-  createProvider,
-  createProviderFromConfig,
+  decodeBinaryMessage,
   detectProvider,
-  gateway,
+  encodeBinaryMessage,
   getMissingEnvVars,
   getProviderConfigFromEnv,
   getProviderHeaders,
-  handleComputeRequest,
   isCommandExitError,
   isGatewayModeEnabled,
   isProviderAuthComplete,