@labring/devbox-sdk 1.1.0

package/dist/index.mjs

@@ -0,0 +1,2665 @@
+import yaml from 'js-yaml';
+
+// src/core/constants.ts
+var DEFAULT_CONFIG = {
+  /** Default base URL for Devbox API */
+  BASE_URL: "https://devbox.usw.sealos.io/v1",
+  /** Default HTTP server port for containers */
+  CONTAINER_HTTP_PORT: 3e3,
+  /** Default mock server configuration */
+  MOCK_SERVER: {
+    DEFAULT_URL: "http://localhost:9757",
+    ENV_VAR: "MOCK_SERVER_URL"
+  },
+  /** Default HTTP client settings */
+  HTTP_CLIENT: {
+    TIMEOUT: 3e4,
+    // 30 seconds
+    RETRIES: 3
+  },
+  /** File operation limits */
+  FILE_LIMITS: {
+    MAX_FILE_SIZE: 100 * 1024 * 1024,
+    // 100MB
+    MAX_BATCH_SIZE: 50,
+    // maximum files per batch
+    CHUNK_SIZE: 1024 * 1024
+    // 1MB chunks for streaming
+  },
+  /** Performance targets */
+  PERFORMANCE: {
+    SMALL_FILE_LATENCY_MS: 50,
+    // <50ms for files <1MB
+    LARGE_FILE_THROUGHPUT_MBPS: 15,
+    // >15MB/s for large files
+    CONNECTION_REUSE_RATE: 0.98,
+    // >98% connection reuse
+    STARTUP_TIME_MS: 100
+    // <100ms Bun server startup
+  }
+};
+var API_ENDPOINTS = {
+  /** Devbox management endpoints */
+  DEVBOX: {
+    LIST: "/api/v1/devbox",
+    CREATE: "/api/v1/devbox",
+    GET: "/api/v1/devbox/{name}",
+    UPDATE: "/api/v1/devbox/{name}",
+    DELETE: "/api/v1/devbox/{name}/delete",
+    START: "/api/v1/devbox/{name}/start",
+    PAUSE: "/api/v1/devbox/{name}/pause",
+    RESTART: "/api/v1/devbox/{name}/restart",
+    SHUTDOWN: "/api/v1/devbox/{name}/shutdown",
+    MONITOR: "/api/v1/devbox/{name}/monitor",
+    TEMPLATES: "/api/v1/devbox/templates",
+    PORTS: "/api/v1/devbox/{name}/ports",
+    AUTOSTART: "/api/v1/devbox/{name}/autostart",
+    RELEASE: {
+      LIST: "/api/v1/devbox/{name}/release",
+      CREATE: "/api/v1/devbox/{name}/release",
+      DELETE: "/api/v1/devbox/{name}/release/{tag}",
+      DEPLOY: "/api/v1/devbox/{name}/release/{tag}/deploy"
+    }
+  },
+  /** Container server endpoints */
+  CONTAINER: {
+    HEALTH: "/health",
+    FILES: {
+      WRITE: "/api/v1/files/write",
+      READ: "/api/v1/files/read",
+      LIST: "/api/v1/files/list",
+      DELETE: "/api/v1/files/delete",
+      MOVE: "/api/v1/files/move",
+      RENAME: "/api/v1/files/rename",
+      DOWNLOAD: "/api/v1/files/download",
+      BATCH_UPLOAD: "/api/v1/files/batch-upload",
+      BATCH_DOWNLOAD: "/api/v1/files/batch-download",
+      SEARCH: "/api/v1/files/search",
+      FIND: "/api/v1/files/find",
+      REPLACE: "/api/v1/files/replace"
+    },
+    PROCESS: {
+      EXEC: "/api/v1/process/exec",
+      EXEC_SYNC: "/api/v1/process/exec-sync",
+      EXEC_SYNC_STREAM: "/api/v1/process/sync-stream",
+      LIST: "/api/v1/process/list",
+      STATUS: "/api/v1/process/{process_id}/status",
+      KILL: "/api/v1/process/{process_id}/kill",
+      LOGS: "/api/v1/process/{process_id}/logs"
+    },
+    PORTS: "/api/v1/ports"
+    // Temporarily disabled - ws module removed
+    // WEBSOCKET: '/ws',
+  }
+};
+var ERROR_CODES = {
+  /** Authentication errors */
+  AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED",
+  INVALID_KUBECONFIG: "INVALID_KUBECONFIG",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  INVALID_TOKEN: "INVALID_TOKEN",
+  TOKEN_EXPIRED: "TOKEN_EXPIRED",
+  INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS",
+  /** Connection errors */
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+  /** Devbox errors */
+  DEVBOX_NOT_FOUND: "DEVBOX_NOT_FOUND",
+  DEVBOX_NOT_READY: "DEVBOX_NOT_READY",
+  DEVBOX_CREATION_FAILED: "DEVBOX_CREATION_FAILED",
+  DEVBOX_OPERATION_FAILED: "DEVBOX_OPERATION_FAILED",
+  /** Validation errors */
+  INVALID_REQUEST: "INVALID_REQUEST",
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  INVALID_FIELD_VALUE: "INVALID_FIELD_VALUE",
+  INVALID_JSON_FORMAT: "INVALID_JSON_FORMAT",
+  INVALID_PATH: "INVALID_PATH",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  /** Resource errors */
+  NOT_FOUND: "NOT_FOUND",
+  PROCESS_NOT_FOUND: "PROCESS_NOT_FOUND",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  FILE_NOT_FOUND: "FILE_NOT_FOUND",
+  DIRECTORY_NOT_FOUND: "DIRECTORY_NOT_FOUND",
+  /** State errors */
+  CONFLICT: "CONFLICT",
+  PROCESS_ALREADY_RUNNING: "PROCESS_ALREADY_RUNNING",
+  PROCESS_NOT_RUNNING: "PROCESS_NOT_RUNNING",
+  SESSION_INACTIVE: "SESSION_INACTIVE",
+  RESOURCE_LOCKED: "RESOURCE_LOCKED",
+  PROCESS_ALREADY_TERMINATED: "PROCESS_ALREADY_TERMINATED",
+  /** Operation errors */
+  OPERATION_TIMEOUT: "OPERATION_TIMEOUT",
+  OPERATION_FAILED: "OPERATION_FAILED",
+  EXECUTION_FAILED: "EXECUTION_FAILED",
+  SIGNAL_FAILED: "SIGNAL_FAILED",
+  /** File operation errors */
+  FILE_OPERATION_ERROR: "FILE_OPERATION_ERROR",
+  FILE_TOO_LARGE: "FILE_TOO_LARGE",
+  FILE_TRANSFER_FAILED: "FILE_TRANSFER_FAILED",
+  PATH_TRAVERSAL_DETECTED: "PATH_TRAVERSAL_DETECTED",
+  DIRECTORY_NOT_EMPTY: "DIRECTORY_NOT_EMPTY",
+  DISK_FULL: "DISK_FULL",
+  FILE_LOCKED: "FILE_LOCKED",
+  /** Process errors */
+  PROCESS_START_FAILED: "PROCESS_START_FAILED",
+  INVALID_SIGNAL: "INVALID_SIGNAL",
+  PROCESS_LIMIT_EXCEEDED: "PROCESS_LIMIT_EXCEEDED",
+  /** Session errors */
+  SESSION_CREATION_FAILED: "SESSION_CREATION_FAILED",
+  SESSION_LIMIT_EXCEEDED: "SESSION_LIMIT_EXCEEDED",
+  SESSION_TIMEOUT: "SESSION_TIMEOUT",
+  SHELL_NOT_FOUND: "SHELL_NOT_FOUND",
+  /** WebSocket errors */
+  // Temporarily disabled - ws module removed
+  // WEBSOCKET_CONNECTION_FAILED: 'WEBSOCKET_CONNECTION_FAILED',
+  // INVALID_SUBSCRIPTION: 'INVALID_SUBSCRIPTION',
+  // TARGET_NOT_SUBSCRIBABLE: 'TARGET_NOT_SUBSCRIBABLE',
+  /** Server errors */
+  SERVER_UNAVAILABLE: "SERVER_UNAVAILABLE",
+  HEALTH_CHECK_FAILED: "HEALTH_CHECK_FAILED",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  MAINTENANCE_MODE: "MAINTENANCE_MODE"
+};
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
+
+// src/utils/error.ts
+var DevboxSDKError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "DevboxSDKError";
+  }
+};
+var AuthenticationError = class extends DevboxSDKError {
+  constructor(message, context) {
+    super(message, "AUTHENTICATION_FAILED", context);
+    this.name = "AuthenticationError";
+  }
+};
+var ConnectionError = class extends DevboxSDKError {
+  constructor(message, context) {
+    super(message, "CONNECTION_FAILED", context);
+    this.name = "ConnectionError";
+  }
+};
+var FileOperationError = class extends DevboxSDKError {
+  constructor(message, context, code = ERROR_CODES.FILE_TRANSFER_FAILED) {
+    super(message, code, context);
+    this.name = "FileOperationError";
+  }
+};
+var DevboxNotFoundError = class extends DevboxSDKError {
+  constructor(devboxName, context) {
+    super(`Devbox '${devboxName}' not found`, "DEVBOX_NOT_FOUND", context);
+    this.name = "DevboxNotFoundError";
+  }
+};
+var DevboxNotReadyError = class extends DevboxSDKError {
+  constructor(devboxName, currentStatus, context) {
+    const statusInfo = currentStatus ? ` (current status: ${currentStatus})` : "";
+    super(
+      `Devbox '${devboxName}' is not ready yet${statusInfo}. The devbox may still be starting. Please wait a moment and try again, or use 'await devbox.waitForReady()' to wait until it's fully initialized.`,
+      "DEVBOX_NOT_READY",
+      context
+    );
+    this.name = "DevboxNotReadyError";
+  }
+};
+var ValidationError = class extends DevboxSDKError {
+  constructor(message, context) {
+    super(message, "VALIDATION_ERROR", context);
+    this.name = "ValidationError";
+  }
+};
+function mapServerStatusToErrorCode(status) {
+  switch (status) {
+    case 1404:
+      return ERROR_CODES.FILE_NOT_FOUND;
+    case 1400:
+      return ERROR_CODES.VALIDATION_ERROR;
+    case 1401:
+      return ERROR_CODES.UNAUTHORIZED;
+    case 1403:
+      return ERROR_CODES.INSUFFICIENT_PERMISSIONS;
+    case 1422:
+      return ERROR_CODES.INVALID_REQUEST;
+    case 1500:
+      return ERROR_CODES.INTERNAL_ERROR;
+    case 1409:
+      return ERROR_CODES.CONFLICT;
+    case 1600:
+      return ERROR_CODES.OPERATION_FAILED;
+    case 500:
+      return ERROR_CODES.INTERNAL_ERROR;
+    default:
+      return ERROR_CODES.OPERATION_FAILED;
+  }
+}
+function parseServerResponse(jsonData) {
+  if (jsonData.status !== void 0 && jsonData.status !== 0) {
+    const errorCode = mapServerStatusToErrorCode(jsonData.status);
+    const errorMessage = jsonData.message || "Unknown server error";
+    throw createErrorFromServerResponse(errorMessage, errorCode, void 0);
+  }
+  return jsonData.Data !== void 0 ? jsonData.Data : jsonData;
+}
+function createErrorFromServerResponse(error, code, timestamp) {
+  const errorContext = { timestamp, serverErrorCode: code };
+  switch (code) {
+    case ERROR_CODES.UNAUTHORIZED:
+    case ERROR_CODES.INVALID_TOKEN:
+    case ERROR_CODES.TOKEN_EXPIRED:
+    case ERROR_CODES.INSUFFICIENT_PERMISSIONS:
+      return new AuthenticationError(error, errorContext);
+    case ERROR_CODES.FILE_NOT_FOUND:
+    case ERROR_CODES.DIRECTORY_NOT_FOUND:
+    case ERROR_CODES.FILE_OPERATION_ERROR:
+    case ERROR_CODES.FILE_TOO_LARGE:
+    case ERROR_CODES.FILE_LOCKED:
+    case ERROR_CODES.DIRECTORY_NOT_EMPTY:
+    case ERROR_CODES.DISK_FULL:
+      return new FileOperationError(error, errorContext, code);
+    case ERROR_CODES.INVALID_REQUEST:
+    case ERROR_CODES.MISSING_REQUIRED_FIELD:
+    case ERROR_CODES.INVALID_FIELD_VALUE:
+    case ERROR_CODES.INVALID_JSON_FORMAT:
+    case ERROR_CODES.INVALID_PATH:
+    case ERROR_CODES.INVALID_SIGNAL:
+      return new ValidationError(error, errorContext);
+    case ERROR_CODES.DEVBOX_NOT_FOUND:
+    case ERROR_CODES.PROCESS_NOT_FOUND:
+    case ERROR_CODES.SESSION_NOT_FOUND:
+    case ERROR_CODES.NOT_FOUND:
+      if (code === ERROR_CODES.DEVBOX_NOT_FOUND) {
+        const devboxNameMatch = error.match(/Devbox '([^']+)'/i) || error.match(/devbox[:\s]+([^\s]+)/i);
+        const devboxName = devboxNameMatch?.[1] ?? "unknown";
+        return new DevboxNotFoundError(devboxName, errorContext);
+      }
+      return new DevboxSDKError(error, code || ERROR_CODES.INTERNAL_ERROR, errorContext);
+    default:
+      return new DevboxSDKError(error, code, errorContext);
+  }
+}
+
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  ["INFO" /* INFO */]: 1,
+  ["WARN" /* WARN */]: 2,
+  ["ERROR" /* ERROR */]: 3,
+  ["SILENT" /* SILENT */]: Number.POSITIVE_INFINITY
+  // Highest priority, suppresses all logs
+};
+function getLogLevelFromEnv() {
+  const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+  if (envLevel === "INFO") {
+    return "INFO" /* INFO */;
+  }
+  if (envLevel === "WARN" || envLevel === "WARNING") {
+    return "WARN" /* WARN */;
+  }
+  if (envLevel === "ERROR") {
+    return "ERROR" /* ERROR */;
+  }
+  return "SILENT" /* SILENT */;
+}
+var Logger = class {
+  currentLevel;
+  constructor() {
+    this.currentLevel = getLogLevelFromEnv();
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.currentLevel];
+  }
+  /**
+   * Log info message
+   */
+  info(message, ...args) {
+    if (this.shouldLog("INFO" /* INFO */)) {
+      console.log(`[INFO] ${message}`, ...args);
+    }
+  }
+  /**
+   * Log warning message
+   */
+  warn(message, ...args) {
+    if (this.shouldLog("WARN" /* WARN */)) {
+      console.warn(`[WARN] ${message}`, ...args);
+    }
+  }
+  /**
+   * Log error message
+   */
+  error(message, ...args) {
+    if (this.shouldLog("ERROR" /* ERROR */)) {
+      console.error(`[ERROR] ${message}`, ...args);
+    }
+  }
+};
+var logger = new Logger();
+function parseKubeconfigServerUrl(kubeconfig) {
+  if (!kubeconfig || typeof kubeconfig !== "string") {
+    return null;
+  }
+  try {
+    const config = yaml.load(kubeconfig);
+    if (!config) {
+      return null;
+    }
+    const currentContextName = config["current-context"] || config.currentContext;
+    if (!currentContextName) {
+      return null;
+    }
+    const contexts = config.contexts || [];
+    const currentContext = contexts.find(
+      (ctx) => ctx.name === currentContextName
+    );
+    if (!currentContext || !currentContext.context) {
+      return null;
+    }
+    const clusterName = currentContext.context.cluster;
+    if (!clusterName) {
+      return null;
+    }
+    const clusters = config.clusters || [];
+    const cluster = clusters.find((cl) => cl.name === clusterName);
+    if (!cluster || !cluster.cluster) {
+      return null;
+    }
+    const serverUrl = cluster.cluster.server;
+    if (!serverUrl || typeof serverUrl !== "string") {
+      return null;
+    }
+    try {
+      const url = new URL(serverUrl);
+      url.hostname = `devbox.${url.hostname}`;
+      url.port = "";
+      url.pathname = "";
+      let result = url.toString();
+      if (result.endsWith("/")) {
+        result = result.slice(0, -1);
+      }
+      return result;
+    } catch (_urlError) {
+      return serverUrl;
+    }
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/api/auth.ts
+var KubeconfigAuthenticator = class {
+  token;
+  constructor(kubeconfig) {
+    if (!kubeconfig || typeof kubeconfig !== "string") {
+      throw new DevboxSDKError(
+        "kubeconfig is required and must be a string",
+        ERROR_CODES.INVALID_KUBECONFIG
+      );
+    }
+    this.token = encodeURIComponent(kubeconfig);
+  }
+  getAuthHeaders() {
+    return {
+      Authorization: this.token
+    };
+  }
+};
+
+// src/api/endpoints.ts
+var APIEndpoints = class {
+  baseUrl;
+  constructor(baseUrl = "https://devbox.usw.sealos.io/v1") {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Get the base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Construct URL with parameters
+   */
+  constructUrl(template, params = {}) {
+    let url = template;
+    for (const [key, value] of Object.entries(params)) {
+      url = url.replace(`{${key}}`, encodeURIComponent(value));
+    }
+    const baseUrl = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
+    return `${baseUrl}${url}`;
+  }
+  // Devbox management endpoints
+  devboxList() {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.LIST);
+  }
+  devboxCreate() {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.CREATE);
+  }
+  devboxGet(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.GET, { name });
+  }
+  devboxUpdate(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.UPDATE, { name });
+  }
+  devboxDelete(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.DELETE, { name });
+  }
+  devboxStart(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.START, { name });
+  }
+  devboxPause(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.PAUSE, { name });
+  }
+  devboxRestart(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.RESTART, { name });
+  }
+  devboxShutdown(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.SHUTDOWN, { name });
+  }
+  devboxMonitor(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.MONITOR, { name });
+  }
+  devboxTemplates() {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.TEMPLATES);
+  }
+  devboxPorts(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.PORTS, { name });
+  }
+  devboxAutostart(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.AUTOSTART, { name });
+  }
+  // Release endpoints
+  releaseList(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.RELEASE.LIST, { name });
+  }
+  releaseCreate(name) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.RELEASE.CREATE, { name });
+  }
+  releaseDelete(name, tag) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.RELEASE.DELETE, { name, tag });
+  }
+  releaseDeploy(name, tag) {
+    return this.constructUrl(API_ENDPOINTS.DEVBOX.RELEASE.DEPLOY, { name, tag });
+  }
+  containerHealth(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.HEALTH}`;
+  }
+  filesWrite(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.WRITE}`;
+  }
+  filesRead(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.READ}`;
+  }
+  filesList(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.LIST}`;
+  }
+  filesDelete(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.DELETE}`;
+  }
+  filesBatchUpload(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.BATCH_UPLOAD}`;
+  }
+  filesBatchDownload(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.BATCH_DOWNLOAD}`;
+  }
+  filesSearch(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.SEARCH}`;
+  }
+  filesFind(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.FIND}`;
+  }
+  filesReplace(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.FILES.REPLACE}`;
+  }
+  processExec(baseUrl) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.PROCESS.EXEC}`;
+  }
+  processStatus(baseUrl, pid) {
+    return `${baseUrl}${API_ENDPOINTS.CONTAINER.PROCESS.STATUS.replace("{pid}", pid.toString())}`;
+  }
+  // Temporarily disabled - ws module removed
+  // websocket(baseUrl: string): string {
+  //   return `${baseUrl}${API_ENDPOINTS.CONTAINER.WEBSOCKET}`
+  // }
+};
+
+// src/api/types.ts
+var DevboxRuntime = /* @__PURE__ */ ((DevboxRuntime2) => {
+  DevboxRuntime2["NUXT3"] = "nuxt3";
+  DevboxRuntime2["ANGULAR"] = "angular";
+  DevboxRuntime2["QUARKUS"] = "quarkus";
+  DevboxRuntime2["UBUNTU"] = "ubuntu";
+  DevboxRuntime2["FLASK"] = "flask";
+  DevboxRuntime2["JAVA"] = "java";
+  DevboxRuntime2["CHI"] = "chi";
+  DevboxRuntime2["NET"] = "net";
+  DevboxRuntime2["IRIS"] = "iris";
+  DevboxRuntime2["HEXO"] = "hexo";
+  DevboxRuntime2["PYTHON"] = "python";
+  DevboxRuntime2["DOCUSAURUS"] = "docusaurus";
+  DevboxRuntime2["VITEPRESS"] = "vitepress";
+  DevboxRuntime2["CPP"] = "cpp";
+  DevboxRuntime2["VUE"] = "vue";
+  DevboxRuntime2["NGINX"] = "nginx";
+  DevboxRuntime2["ROCKET"] = "rocket";
+  DevboxRuntime2["DEBIAN_SSH"] = "debian-ssh";
+  DevboxRuntime2["VERT_X"] = "vert.x";
+  DevboxRuntime2["EXPRESS_JS"] = "express.js";
+  DevboxRuntime2["DJANGO"] = "django";
+  DevboxRuntime2["NEXT_JS"] = "next.js";
+  DevboxRuntime2["SEALAF"] = "sealaf";
+  DevboxRuntime2["GO"] = "go";
+  DevboxRuntime2["REACT"] = "react";
+  DevboxRuntime2["PHP"] = "php";
+  DevboxRuntime2["SVELTE"] = "svelte";
+  DevboxRuntime2["C"] = "c";
+  DevboxRuntime2["ASTRO"] = "astro";
+  DevboxRuntime2["UMI"] = "umi";
+  DevboxRuntime2["GIN"] = "gin";
+  DevboxRuntime2["NODE_JS"] = "node.js";
+  DevboxRuntime2["ECHO"] = "echo";
+  DevboxRuntime2["RUST"] = "rust";
+  DevboxRuntime2["TEST_AGENT"] = "node-expt-agent";
+  return DevboxRuntime2;
+})(DevboxRuntime || {});
+
+// src/api/client.ts
+var SealosAPIClient = class {
+  baseUrl;
+  timeout;
+  retries;
+  rejectUnauthorized;
+  getAuthHeaders;
+  constructor(config) {
+    this.baseUrl = config.baseUrl || "https://devbox.usw.sealos.io";
+    this.timeout = config.timeout || 3e4;
+    this.retries = config.retries || 3;
+    this.rejectUnauthorized = config.rejectUnauthorized ?? process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0";
+    this.getAuthHeaders = config.getAuthHeaders;
+    if (!this.rejectUnauthorized) {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+    }
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(path, this.baseUrl);
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    const fetchOptions = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.getAuthHeaders ? this.getAuthHeaders() : {},
+        ...options.headers
+      }
+    };
+    if (options.data) {
+      fetchOptions.body = JSON.stringify(options.data);
+    }
+    let lastError = new Error("Unknown error");
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url.toString(), {
+          ...fetchOptions,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          let errorData = {};
+          try {
+            const contentType2 = response.headers.get("content-type") || "";
+            if (contentType2.includes("application/json")) {
+              errorData = await response.json();
+            } else {
+              const errorText = await response.text().catch(() => "Unable to read error response");
+              try {
+                errorData = JSON.parse(errorText);
+              } catch {
+                errorData = { error: errorText };
+              }
+            }
+          } catch (e) {
+          }
+          const errorMessage = errorData.error || response.statusText;
+          const errorCode = errorData.code || this.getErrorCodeFromStatus(response.status);
+          throw new DevboxSDKError(errorMessage, errorCode, {
+            status: response.status,
+            statusText: response.statusText,
+            timestamp: errorData.timestamp,
+            serverErrorCode: errorData.code
+          });
+        }
+        const contentType = response.headers.get("content-type");
+        const data = contentType?.includes("application/json") ? await response.json() : await response.text();
+        logger.info("Response data:", url.toString(), data);
+        return {
+          data,
+          status: response.status,
+          statusText: response.statusText,
+          headers: Object.fromEntries(response.headers.entries())
+        };
+      } catch (error) {
+        lastError = error;
+        if (attempt === this.retries || !this.shouldRetry(error)) {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 1e3));
+      }
+    }
+    throw lastError;
+  }
+  shouldRetry(error) {
+    if (error instanceof DevboxSDKError) {
+      const nonRetryable4xxCodes = [
+        ERROR_CODES.UNAUTHORIZED,
+        ERROR_CODES.INVALID_TOKEN,
+        ERROR_CODES.TOKEN_EXPIRED,
+        ERROR_CODES.INVALID_REQUEST,
+        ERROR_CODES.MISSING_REQUIRED_FIELD,
+        ERROR_CODES.INVALID_FIELD_VALUE,
+        ERROR_CODES.NOT_FOUND,
+        ERROR_CODES.FILE_NOT_FOUND,
+        ERROR_CODES.PROCESS_NOT_FOUND,
+        ERROR_CODES.SESSION_NOT_FOUND,
+        ERROR_CODES.CONFLICT,
+        ERROR_CODES.VALIDATION_ERROR,
+        ERROR_CODES.AUTHENTICATION_FAILED
+      ];
+      if (nonRetryable4xxCodes.includes(error.code)) {
+        return false;
+      }
+      return [
+        ERROR_CODES.CONNECTION_TIMEOUT,
+        ERROR_CODES.CONNECTION_FAILED,
+        ERROR_CODES.SERVER_UNAVAILABLE,
+        ERROR_CODES.SERVICE_UNAVAILABLE,
+        ERROR_CODES.OPERATION_TIMEOUT,
+        ERROR_CODES.SESSION_TIMEOUT,
+        ERROR_CODES.INTERNAL_ERROR
+      ].includes(error.code);
+    }
+    return error.name === "AbortError" || error.message.includes("fetch");
+  }
+  getErrorCodeFromStatus(status) {
+    switch (status) {
+      case 401:
+        return ERROR_CODES.AUTHENTICATION_FAILED;
+      case 403:
+        return ERROR_CODES.AUTHENTICATION_FAILED;
+      case 404:
+        return ERROR_CODES.DEVBOX_NOT_FOUND;
+      case 408:
+        return ERROR_CODES.CONNECTION_TIMEOUT;
+      case 429:
+        return "TOO_MANY_REQUESTS";
+      case 500:
+        return ERROR_CODES.INTERNAL_ERROR;
+      case 502:
+        return ERROR_CODES.SERVER_UNAVAILABLE;
+      case 503:
+        return ERROR_CODES.SERVICE_UNAVAILABLE;
+      case 504:
+        return ERROR_CODES.CONNECTION_TIMEOUT;
+      default:
+        return ERROR_CODES.INTERNAL_ERROR;
+    }
+  }
+  get(url, options) {
+    return this.request("GET", url, options);
+  }
+  post(url, options) {
+    return this.request("POST", url, options);
+  }
+  put(url, options) {
+    return this.request("PUT", url, options);
+  }
+  delete(url, options) {
+    return this.request("DELETE", url, options);
+  }
+};
+var DevboxAPI = class {
+  httpClient;
+  authenticator;
+  endpoints;
+  constructor(config) {
+    this.authenticator = new KubeconfigAuthenticator(config.kubeconfig);
+    const kubeconfigUrl = parseKubeconfigServerUrl(config.kubeconfig);
+    const baseUrl = config.baseUrl || kubeconfigUrl || "https://devbox.usw.sealos.io";
+    this.httpClient = new SealosAPIClient({
+      baseUrl,
+      timeout: config.timeout,
+      retries: config.retries,
+      rejectUnauthorized: config.rejectUnauthorized,
+      getAuthHeaders: () => this.authenticator.getAuthHeaders()
+    });
+    this.endpoints = new APIEndpoints(baseUrl);
+  }
+  /**
+   * Create a new Devbox instance
+   */
+  async createDevbox(config) {
+    const request = {
+      name: config.name,
+      runtime: config.runtime,
+      resource: config.resource,
+      ports: config.ports?.map((p) => ({ number: p.number, protocol: p.protocol })),
+      env: config.env
+    };
+    try {
+      const response = await this.httpClient.post(this.endpoints.devboxCreate(), {
+        data: request
+      });
+      if (!response || !response.data) {
+        throw new Error(
+          `Invalid API response: response or response.data is undefined. Response: ${JSON.stringify(response)}`
+        );
+      }
+      let createResponse;
+      if (typeof response.data === "object" && "data" in response.data) {
+        const responseData = response.data;
+        if (!responseData.data) {
+          throw new Error(
+            `Invalid API response structure: expected { data: DevboxCreateResponse }, but data field is undefined. Full response: ${JSON.stringify(response.data)}`
+          );
+        }
+        createResponse = responseData.data;
+      } else {
+        createResponse = response.data;
+      }
+      if (!createResponse || !createResponse.name) {
+        throw new Error(
+          `Invalid DevboxCreateResponse: missing 'name' field. Response data: ${JSON.stringify(createResponse)}`
+        );
+      }
+      return this.transformCreateResponseToDevboxInfo(
+        createResponse,
+        config.runtime,
+        config.resource
+      );
+    } catch (error) {
+      throw this.handleAPIError(error, "Failed to create Devbox");
+    }
+  }
+  /**
+   * Get an existing Devbox instance
+   */
+  async getDevbox(name) {
+    try {
+      const response = await this.httpClient.get(this.endpoints.devboxGet(name));
+      const responseData = response.data;
+      return this.transformDetailToDevboxInfo(responseData.data);
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to get Devbox '${name}'`);
+    }
+  }
+  /**
+   * List all Devbox instances
+   */
+  async listDevboxes() {
+    try {
+      const response = await this.httpClient.get(this.endpoints.devboxList());
+      const listResponse = response.data;
+      return listResponse.data.map(this.transformListItemToDevboxInfo);
+    } catch (error) {
+      throw this.handleAPIError(error, "Failed to list Devboxes");
+    }
+  }
+  /**
+   * Start a Devbox instance
+   */
+  async startDevbox(name) {
+    try {
+      await this.httpClient.post(this.endpoints.devboxStart(name), {
+        data: {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to start Devbox '${name}'`);
+    }
+  }
+  /**
+   * Pause a Devbox instance
+   */
+  async pauseDevbox(name) {
+    try {
+      await this.httpClient.post(this.endpoints.devboxPause(name), {
+        data: {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to pause Devbox '${name}'`);
+    }
+  }
+  /**
+   * Restart a Devbox instance
+   */
+  async restartDevbox(name) {
+    try {
+      await this.httpClient.post(this.endpoints.devboxRestart(name), {
+        data: {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to restart Devbox '${name}'`);
+    }
+  }
+  /**
+   * Delete a Devbox instance
+   */
+  async deleteDevbox(name) {
+    try {
+      await this.httpClient.delete(this.endpoints.devboxDelete(name));
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to delete Devbox '${name}'`);
+    }
+  }
+  /**
+   * Update a Devbox instance configuration
+   */
+  async updateDevbox(name, config) {
+    try {
+      await this.httpClient.request("PATCH", this.endpoints.devboxUpdate(name), {
+        data: config
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to update Devbox '${name}'`);
+    }
+  }
+  /**
+   * Shutdown a Devbox instance
+   */
+  async shutdownDevbox(name) {
+    try {
+      await this.httpClient.post(this.endpoints.devboxShutdown(name), {
+        data: {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to shutdown Devbox '${name}'`);
+    }
+  }
+  /**
+   * Get available runtime templates
+   */
+  async getTemplates() {
+    try {
+      const response = await this.httpClient.get(
+        this.endpoints.devboxTemplates()
+      );
+      return response.data.data;
+    } catch (error) {
+      throw this.handleAPIError(error, "Failed to get templates");
+    }
+  }
+  /**
+   * Update port configuration for a Devbox
+   */
+  async updatePorts(name, ports) {
+    try {
+      await this.httpClient.put(this.endpoints.devboxPorts(name), {
+        data: { ports }
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to update ports for '${name}'`);
+    }
+  }
+  /**
+   * Configure autostart for a Devbox
+   */
+  async configureAutostart(name, config) {
+    try {
+      await this.httpClient.post(this.endpoints.devboxAutostart(name), {
+        data: config || {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to configure autostart for '${name}'`);
+    }
+  }
+  /**
+   * List releases for a Devbox
+   */
+  async listReleases(name) {
+    try {
+      const response = await this.httpClient.get(this.endpoints.releaseList(name));
+      const responseData = response.data;
+      return responseData.data || [];
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to list releases for '${name}'`);
+    }
+  }
+  /**
+   * Create a release for a Devbox
+   */
+  async createRelease(name, config) {
+    try {
+      await this.httpClient.post(this.endpoints.releaseCreate(name), {
+        data: config
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to create release for '${name}'`);
+    }
+  }
+  /**
+   * Delete a release
+   */
+  async deleteRelease(name, tag) {
+    try {
+      await this.httpClient.delete(this.endpoints.releaseDelete(name, tag));
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to delete release '${tag}' for '${name}'`);
+    }
+  }
+  /**
+   * Deploy a release
+   */
+  async deployRelease(name, tag) {
+    try {
+      await this.httpClient.post(this.endpoints.releaseDeploy(name, tag), {
+        data: {}
+      });
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to deploy release '${tag}' for '${name}'`);
+    }
+  }
+  /**
+   * Get monitoring data for a Devbox instance
+   */
+  async getMonitorData(name, timeRange) {
+    try {
+      const params = {
+        start: timeRange?.start || Date.now() - 36e5,
+        // Default 1 hour ago
+        end: timeRange?.end || Date.now(),
+        step: timeRange?.step
+      };
+      const response = await this.httpClient.get(this.endpoints.devboxMonitor(name), {
+        params
+      });
+      const dataPoints = response.data;
+      return dataPoints.map(this.transformMonitorData);
+    } catch (error) {
+      throw this.handleAPIError(error, `Failed to get monitor data for '${name}'`);
+    }
+  }
+  /**
+   * Test authentication
+   */
+  async testAuth() {
+    try {
+      await this.httpClient.get(this.endpoints.devboxList());
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  transformSSHInfoToDevboxInfo(sshInfo) {
+    return {
+      name: sshInfo.name,
+      status: sshInfo.status,
+      runtime: sshInfo.runtime,
+      resources: sshInfo.resources,
+      podIP: sshInfo.podIP,
+      ssh: sshInfo.ssh ? {
+        host: sshInfo.ssh.host,
+        port: sshInfo.ssh.port,
+        user: sshInfo.ssh.user,
+        privateKey: sshInfo.ssh.privateKey
+      } : void 0
+    };
+  }
+  transformListItemToDevboxInfo(listItem) {
+    return {
+      name: listItem.name,
+      status: listItem.status,
+      runtime: listItem.runtime,
+      resources: listItem.resources
+    };
+  }
+  /**
+   * Safely convert a string to DevboxRuntime enum
+   * Returns the enum value if valid, otherwise returns a default value
+   */
+  stringToRuntime(value) {
+    if (!value) {
+      return "node-expt-agent" /* TEST_AGENT */;
+    }
+    const runtimeValues = Object.values(DevboxRuntime);
+    if (runtimeValues.includes(value)) {
+      return value;
+    }
+    return "node-expt-agent" /* TEST_AGENT */;
+  }
+  transformCreateResponseToDevboxInfo(createResponse, runtime, resource) {
+    return {
+      name: createResponse.name,
+      status: "Pending",
+      // New devboxes start in Pending state
+      runtime,
+      // Use the runtime from the create request
+      resources: {
+        cpu: resource.cpu,
+        // Use the resource from the create request
+        memory: resource.memory
+        // Use the resource from the create request
+      },
+      ssh: {
+        host: createResponse.domain,
+        port: createResponse.sshPort,
+        user: createResponse.userName,
+        privateKey: createResponse.base64PrivateKey
+      }
+    };
+  }
+  /**
+   * Transform DevboxDetail (actual API response) to DevboxInfo
+   */
+  transformDetailToDevboxInfo(detail) {
+    const runtime = typeof detail.runtime === "string" ? this.stringToRuntime(detail.runtime) : detail.runtime;
+    const ssh = detail.ssh?.privateKey ? {
+      host: detail.ssh.host,
+      port: detail.ssh.port,
+      user: detail.ssh.user,
+      privateKey: detail.ssh.privateKey
+    } : void 0;
+    let podIP;
+    if (detail.pods && detail.pods.length > 0) ;
+    return {
+      name: detail.name,
+      status: detail.status,
+      runtime,
+      resources: detail.resources,
+      podIP,
+      ssh,
+      ports: detail.ports,
+      agentServer: detail.agentServer
+    };
+  }
+  /**
+   * Transform DevboxGetResponse to DevboxInfo (legacy method, kept for backward compatibility)
+   */
+  transformGetResponseToDevboxInfo(getResponse) {
+    const status = typeof getResponse.status === "string" ? getResponse.status : getResponse.status.value;
+    const resources = getResponse.resources || {
+      cpu: getResponse.cpu || 0,
+      memory: getResponse.memory || 0
+    };
+    const runtime = getResponse.runtime ? this.stringToRuntime(getResponse.runtime) : getResponse.iconId ? this.stringToRuntime(getResponse.iconId) : "node-expt-agent" /* TEST_AGENT */;
+    return {
+      name: getResponse.name,
+      status,
+      runtime,
+      resources
+    };
+  }
+  transformMonitorData(dataPoint) {
+    return {
+      cpu: dataPoint.cpu,
+      memory: dataPoint.memory,
+      network: dataPoint.network,
+      disk: dataPoint.disk,
+      timestamp: dataPoint.timestamp
+    };
+  }
+  handleAPIError(error, context) {
+    if (error instanceof DevboxSDKError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new DevboxSDKError(`${context}: ${message}`, ERROR_CODES.INTERNAL_ERROR, {
+      originalError: error
+    });
+  }
+};
+
+// src/http/client.ts
+var DevboxContainerClient = class {
+  baseUrl;
+  timeout;
+  token;
+  constructor(baseUrl, timeout, token) {
+    this.baseUrl = baseUrl;
+    this.timeout = timeout;
+    this.token = token;
+  }
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async post(path, options) {
+    return this.request("POST", path, options);
+  }
+  async put(path, options) {
+    return this.request("PUT", path, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  async request(method, path, options) {
+    const url = new URL(path, this.baseUrl);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    const isFormData = options?.body !== void 0 && options.body instanceof FormData;
+    const fetchOptions = {
+      method,
+      headers: {
+        ...isFormData ? {} : { "Content-Type": "application/json" },
+        ...options?.headers,
+        // Decode base64 token and use as Bearer token
+        Authorization: `Bearer ${Buffer.from(this.token, "base64").toString("utf-8")}`
+      },
+      signal: options?.signal
+    };
+    if (options?.body !== void 0) {
+      if (isFormData) {
+        fetchOptions.body = options.body;
+      } else if (typeof options.body === "string") {
+        fetchOptions.body = options.body;
+      } else if (Buffer.isBuffer(options.body) || options.body instanceof ArrayBuffer || options.body instanceof Uint8Array) {
+        fetchOptions.body = options.body;
+      } else {
+        fetchOptions.body = JSON.stringify(options.body);
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        ...fetchOptions,
+        signal: options?.signal || controller.signal
+      });
+      logger.info("Request URL:", url.toString());
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorData = {};
+        try {
+          const contentType2 = response.headers.get("content-type") || "";
+          if (contentType2.includes("application/json")) {
+            errorData = await response.json();
+          }
+        } catch {
+        }
+        const errorMessage = errorData.error || response.statusText;
+        const errorCode = errorData.code || ERROR_CODES.CONNECTION_FAILED;
+        throw new DevboxSDKError(errorMessage, errorCode, {
+          status: response.status,
+          statusText: response.statusText,
+          timestamp: errorData.timestamp,
+          serverErrorCode: errorData.code
+        });
+      }
+      const contentType = response.headers.get("content-type") || "";
+      let data;
+      if (contentType.includes("application/json")) {
+        const jsonData = await response.json();
+        data = parseServerResponse(jsonData);
+      } else if (contentType.includes("application/octet-stream") || contentType.includes("application/gzip") || contentType.includes("application/x-tar") || contentType.includes("multipart/") || contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
+        const arrayBuffer = await response.arrayBuffer();
+        data = Buffer.from(arrayBuffer);
+      } else {
+        const arrayBuffer = await response.arrayBuffer();
+        data = Buffer.from(arrayBuffer);
+      }
+      return {
+        data,
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        url: response.url
+      };
+    } catch (error) {
+      logger.error("Request failed:", error);
+      clearTimeout(timeoutId);
+      if (error instanceof DevboxSDKError) {
+        throw error;
+      }
+      throw new DevboxSDKError(
+        `Request failed: ${error.message}`,
+        ERROR_CODES.CONNECTION_FAILED,
+        { originalError: error.message }
+      );
+    }
+  }
+};
+
+// src/http/manager.ts
+var ContainerUrlResolver = class {
+  apiClient;
+  cache = /* @__PURE__ */ new Map();
+  CACHE_TTL = 6e4;
+  mockServerUrl;
+  baseUrl;
+  timeout;
+  constructor(config) {
+    this.mockServerUrl = config.mockServerUrl || process.env.MOCK_SERVER_URL;
+    const kubeconfigUrl = config.kubeconfig ? parseKubeconfigServerUrl(config.kubeconfig) : null;
+    this.baseUrl = config.baseUrl || kubeconfigUrl || "https://devbox.usw.sealos.io";
+    this.timeout = config.http?.timeout || 3e4;
+  }
+  setAPIClient(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async executeWithConnection(devboxName, operation) {
+    const devboxInfo = await this.getDevboxInfo(devboxName);
+    const serverUrl = this.extractUrlFromDevboxInfo(devboxInfo);
+    const token = devboxInfo?.agentServer?.token;
+    if (!serverUrl || !token) {
+      throw new DevboxNotReadyError(devboxName, devboxInfo?.status, {
+        hasServerUrl: !!serverUrl,
+        hasToken: !!token,
+        currentStatus: devboxInfo?.status
+      });
+    }
+    const client = new DevboxContainerClient(serverUrl, this.timeout, token);
+    return await operation(client);
+  }
+  async getServerUrl(devboxName) {
+    const configuredUrl = this.getConfiguredServerUrl();
+    if (configuredUrl) {
+      return configuredUrl;
+    }
+    if (!this.apiClient) {
+      throw new DevboxSDKError(
+        "API client not set. Call setAPIClient() first.",
+        ERROR_CODES.INTERNAL_ERROR
+      );
+    }
+    const cached = this.getFromCache(`url:${devboxName}`);
+    if (cached && typeof cached === "string") {
+      return cached;
+    }
+    try {
+      const url = await this.resolveServerUrlFromAPI(devboxName);
+      this.setCache(`url:${devboxName}`, url);
+      return url;
+    } catch (error) {
+      if (error instanceof DevboxSDKError) {
+        throw error;
+      }
+      throw new DevboxSDKError(
+        `Failed to get server URL for '${devboxName}': ${error.message}`,
+        ERROR_CODES.CONNECTION_FAILED,
+        { originalError: error.message }
+      );
+    }
+  }
+  getConfiguredServerUrl() {
+    if (this.mockServerUrl) {
+      return this.mockServerUrl;
+    }
+    return null;
+  }
+  async resolveServerUrlFromAPI(devboxName) {
+    const devboxInfo = await this.getDevboxInfo(devboxName);
+    if (!devboxInfo) {
+      throw new DevboxSDKError(`Devbox '${devboxName}' not found`, ERROR_CODES.DEVBOX_NOT_FOUND);
+    }
+    const url = this.extractUrlFromDevboxInfo(devboxInfo);
+    if (!url) {
+      throw new DevboxSDKError(
+        `Devbox '${devboxName}' does not have an accessible URL`,
+        ERROR_CODES.CONNECTION_FAILED
+      );
+    }
+    return url;
+  }
+  extractUrlFromDevboxInfo(devboxInfo) {
+    if (devboxInfo.agentServer?.url) {
+      const serviceName = devboxInfo.agentServer.url;
+      const urlObj = new URL(this.baseUrl);
+      const domain = urlObj.hostname.replace(/^devbox\./, "");
+      return `${urlObj.protocol}//devbox-${serviceName}-agent.${domain}`;
+    }
+    if (devboxInfo.ports && devboxInfo.ports.length > 0) {
+      const port = devboxInfo.ports[0];
+      if (port?.publicAddress) {
+        return port.publicAddress;
+      }
+      if (port?.privateAddress) {
+        return port.privateAddress;
+      }
+    }
+    if (devboxInfo.podIP) {
+      return `http://${devboxInfo.podIP}:3000`;
+    }
+    return null;
+  }
+  async getDevboxInfo(devboxName) {
+    const cached = this.getFromCache(`devbox:${devboxName}`);
+    if (cached) {
+      return cached;
+    }
+    try {
+      if (!this.apiClient) {
+        throw new Error("API client not set");
+      }
+      const devboxInfo = await this.apiClient.getDevbox(devboxName);
+      this.setCache(`devbox:${devboxName}`, devboxInfo);
+      return devboxInfo;
+    } catch (error) {
+      return null;
+    }
+  }
+  getFromCache(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.timestamp > this.CACHE_TTL) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  setCache(key, data) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  async closeAllConnections() {
+    this.clearCache();
+  }
+  async checkDevboxHealth(devboxName) {
+    try {
+      const devboxInfo = await this.getDevboxInfo(devboxName);
+      const serverUrl = this.extractUrlFromDevboxInfo(devboxInfo);
+      if (!serverUrl) return false;
+      const token = devboxInfo?.agentServer?.token;
+      if (!token) return false;
+      const client = new DevboxContainerClient(serverUrl, this.timeout, token);
+      const response = await client.get("/health");
+      return response.data?.healthStatus === "ok";
+    } catch (error) {
+      return false;
+    }
+  }
+};
+
+// src/core/git/git.ts
+var Git = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Build Git URL with authentication
+   */
+  buildAuthUrl(url, auth) {
+    if (!auth) return url;
+    if (auth.token) {
+      const urlMatch = url.match(/^(https?:\/\/)([^@]+@)?([^\/]+)(\/.+)?$/);
+      if (urlMatch) {
+        const [, protocol, , host, path] = urlMatch;
+        return `${protocol}${auth.token}@${host}${path || ""}`;
+      }
+    }
+    if (auth.username && (auth.password || auth.token)) {
+      const urlMatch = url.match(/^(https?:\/\/)([^\/]+)(\/.+)?$/);
+      if (urlMatch) {
+        const [, protocol, host, path] = urlMatch;
+        const password = auth.password || auth.token || "";
+        return `${protocol}${auth.username}:${password}@${host}${path || ""}`;
+      }
+    }
+    return url;
+  }
+  /**
+   * Setup Git authentication environment variables
+   */
+  setupGitAuth(env = {}, auth) {
+    const gitEnv = { ...env };
+    if (auth?.username) {
+      gitEnv.GIT_USERNAME = auth.username;
+    }
+    if (auth?.password) {
+      gitEnv.GIT_PASSWORD = auth.password;
+    } else if (auth?.token) {
+      gitEnv.GIT_PASSWORD = auth.token;
+    }
+    return gitEnv;
+  }
+  /**
+   * Parse Git branch list output
+   */
+  parseGitBranches(stdout, currentBranch) {
+    const lines = stdout.split("\n").filter(Boolean);
+    const branches = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const isCurrent = trimmed.startsWith("*");
+      const isRemote = trimmed.includes("remotes/");
+      let name = trimmed.replace(/^\*\s*/, "").trim();
+      if (isRemote) {
+        const match = name.match(/^remotes\/[^/]+\/(.+)$/);
+        if (match?.[1]) {
+          name = match[1];
+        } else {
+          continue;
+        }
+      }
+      branches.push({
+        name,
+        isCurrent: name === currentBranch || isCurrent,
+        isRemote,
+        commit: ""
+        // Will be filled by additional git command if needed
+      });
+    }
+    return branches;
+  }
+  /**
+   * Parse Git status output
+   */
+  parseGitStatus(stdout, branchLine) {
+    const lines = stdout.split("\n").filter(Boolean);
+    const staged = [];
+    const modified = [];
+    const untracked = [];
+    const deleted = [];
+    for (const line of lines) {
+      if (line.length < 3) continue;
+      const status = line.substring(0, 2);
+      const file = line.substring(3).trim();
+      if (status[0] === "A" || status[0] === "M" || status[0] === "R" || status[0] === "C") {
+        staged.push(file);
+      }
+      if (status[1] === "M" || status[1] === "D") {
+        modified.push(file);
+      }
+      if (status === "??") {
+        untracked.push(file);
+      }
+      if (status[0] === "D" || status[1] === "D") {
+        deleted.push(file);
+      }
+    }
+    let currentBranch = "main";
+    let ahead = 0;
+    let behind = 0;
+    if (branchLine) {
+      const branchMatch = branchLine.match(/^##\s+([^.]+)/);
+      if (branchMatch?.[1]) {
+        currentBranch = branchMatch[1];
+      }
+      const aheadMatch = branchLine.match(/ahead\s+(\d+)/);
+      if (aheadMatch?.[1]) {
+        ahead = Number.parseInt(aheadMatch[1], 10);
+      }
+      const behindMatch = branchLine.match(/behind\s+(\d+)/);
+      if (behindMatch?.[1]) {
+        behind = Number.parseInt(behindMatch[1], 10);
+      }
+    }
+    const isClean = staged.length === 0 && modified.length === 0 && untracked.length === 0 && deleted.length === 0;
+    return {
+      currentBranch,
+      isClean,
+      ahead,
+      behind,
+      staged,
+      modified,
+      untracked,
+      deleted
+    };
+  }
+  /**
+   * Clone a Git repository
+   */
+  async clone(options) {
+    const args = ["clone"];
+    if (options.branch) {
+      args.push("-b", options.branch);
+    }
+    if (options.depth) {
+      args.push("--depth", String(options.depth));
+    }
+    if (options.commit) {
+      args.push("--single-branch");
+    }
+    const authUrl = this.buildAuthUrl(options.url, options.auth);
+    args.push(authUrl);
+    if (options.targetDir) {
+      args.push(options.targetDir);
+    }
+    const env = this.setupGitAuth({}, options.auth);
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      env,
+      timeout: 300
+      // 5 minutes timeout for clone
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git clone failed: ${result.stderr || result.stdout}`);
+    }
+    if (options.commit && options.targetDir) {
+      await this.deps.execSync({
+        command: "git",
+        args: ["checkout", options.commit],
+        cwd: options.targetDir
+      });
+    }
+  }
+  /**
+   * Pull changes from remote repository
+   */
+  async pull(repoPath, options) {
+    const remote = options?.remote || "origin";
+    if (options?.auth) {
+      const urlResult = await this.deps.execSync({
+        command: "git",
+        args: ["remote", "get-url", remote],
+        cwd: repoPath
+      });
+      if (urlResult.exitCode === 0) {
+        const currentUrl = urlResult.stdout.trim();
+        const authUrl = this.buildAuthUrl(currentUrl, options.auth);
+        await this.deps.execSync({
+          command: "git",
+          args: ["remote", "set-url", remote, authUrl],
+          cwd: repoPath
+        });
+      }
+    }
+    const args = ["pull"];
+    if (options?.branch) {
+      args.push(remote, options.branch);
+    }
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath,
+      timeout: 120
+      // 2 minutes timeout
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git pull failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  /**
+   * Push changes to remote repository
+   */
+  async push(repoPath, options) {
+    const remote = options?.remote || "origin";
+    if (options?.auth) {
+      const urlResult = await this.deps.execSync({
+        command: "git",
+        args: ["remote", "get-url", remote],
+        cwd: repoPath
+      });
+      if (urlResult.exitCode === 0) {
+        const currentUrl = urlResult.stdout.trim();
+        const authUrl = this.buildAuthUrl(currentUrl, options.auth);
+        await this.deps.execSync({
+          command: "git",
+          args: ["remote", "set-url", remote, authUrl],
+          cwd: repoPath
+        });
+      }
+    }
+    const args = ["push"];
+    if (options?.force) {
+      args.push("--force");
+    }
+    if (options?.branch) {
+      args.push(remote, options.branch);
+    } else {
+      args.push(remote);
+    }
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath,
+      timeout: 120
+      // 2 minutes timeout
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git push failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  /**
+   * List all branches
+   */
+  async branches(repoPath) {
+    const currentBranchResult = await this.deps.execSync({
+      command: "git",
+      args: ["rev-parse", "--abbrev-ref", "HEAD"],
+      cwd: repoPath
+    });
+    const currentBranch = currentBranchResult.stdout.trim();
+    const branchesResult = await this.deps.execSync({
+      command: "git",
+      args: ["branch", "-a"],
+      cwd: repoPath
+    });
+    if (branchesResult.exitCode !== 0) {
+      throw new Error(`Git branches failed: ${branchesResult.stderr || branchesResult.stdout}`);
+    }
+    const branches = this.parseGitBranches(branchesResult.stdout, currentBranch);
+    for (const branch of branches) {
+      try {
+        const commitResult = await this.deps.execSync({
+          command: "git",
+          args: ["rev-parse", branch.isRemote ? `origin/${branch.name}` : branch.name],
+          cwd: repoPath
+        });
+        if (commitResult.exitCode === 0) {
+          branch.commit = commitResult.stdout.trim();
+        }
+      } catch {
+      }
+    }
+    return branches;
+  }
+  /**
+   * Create a new branch
+   */
+  async createBranch(repoPath, branchName, checkout = false) {
+    const args = checkout ? ["checkout", "-b", branchName] : ["branch", branchName];
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git create branch failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  /**
+   * Delete a branch
+   */
+  async deleteBranch(repoPath, branchName, force = false, remote = false) {
+    if (remote) {
+      const result = await this.deps.execSync({
+        command: "git",
+        args: ["push", "origin", "--delete", branchName],
+        cwd: repoPath
+      });
+      if (result.exitCode !== 0) {
+        throw new Error(`Git delete remote branch failed: ${result.stderr || result.stdout}`);
+      }
+    } else {
+      const args = force ? ["branch", "-D", branchName] : ["branch", "-d", branchName];
+      const result = await this.deps.execSync({
+        command: "git",
+        args,
+        cwd: repoPath
+      });
+      if (result.exitCode !== 0) {
+        throw new Error(`Git delete branch failed: ${result.stderr || result.stdout}`);
+      }
+    }
+  }
+  /**
+   * Checkout a branch
+   */
+  async checkoutBranch(repoPath, branchName, create = false) {
+    const args = create ? ["checkout", "-b", branchName] : ["checkout", branchName];
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git checkout failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  normalizePath(repoPath, filePath) {
+    const normalize = (p) => {
+      let normalized = p.trim();
+      if (normalized.startsWith("./")) {
+        normalized = normalized.substring(2);
+      }
+      normalized = normalized.replace(/\/$/, "");
+      return normalized;
+    };
+    const normRepo = normalize(repoPath);
+    const normFile = normalize(filePath);
+    if (normFile.startsWith(`${normRepo}/`)) {
+      return normFile.substring(normRepo.length + 1);
+    }
+    if (normFile === normRepo) {
+      return ".";
+    }
+    if (filePath.startsWith("/")) {
+      const repoIndex = filePath.indexOf(normRepo);
+      if (repoIndex !== -1) {
+        const afterRepo = filePath.substring(repoIndex + normRepo.length);
+        if (afterRepo.startsWith("/")) {
+          return afterRepo.substring(1) || ".";
+        }
+      }
+    }
+    return normFile;
+  }
+  /**
+   * Stage files for commit
+   */
+  async add(repoPath, files) {
+    const args = ["add"];
+    if (!files || Array.isArray(files) && files.length === 0) {
+      args.push(".");
+    } else if (typeof files === "string") {
+      args.push(this.normalizePath(repoPath, files));
+    } else {
+      args.push(...files.map((file) => this.normalizePath(repoPath, file)));
+    }
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git add failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  /**
+   * Commit changes
+   */
+  async commit(repoPath, message, author, email, allowEmpty) {
+    const args = ["commit"];
+    if (allowEmpty) {
+      args.push("--allow-empty");
+    }
+    args.push("--author", `${author} <${email}>`);
+    args.push("-m", message);
+    const result = await this.deps.execSync({
+      command: "git",
+      args,
+      cwd: repoPath
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Git commit failed: ${result.stderr || result.stdout}`);
+    }
+  }
+  /**
+   * Get repository status
+   */
+  async status(repoPath) {
+    const porcelainResult = await this.deps.execSync({
+      command: "git",
+      args: ["status", "--porcelain"],
+      cwd: repoPath
+    });
+    const branchResult = await this.deps.execSync({
+      command: "git",
+      args: ["status", "-sb"],
+      cwd: repoPath
+    });
+    if (porcelainResult.exitCode !== 0 || branchResult.exitCode !== 0) {
+      throw new Error(`Git status failed: ${branchResult.stderr || branchResult.stdout}`);
+    }
+    const branchLine = branchResult.stdout.split("\n")[0] || "";
+    return this.parseGitStatus(porcelainResult.stdout, branchLine);
+  }
+};
+
+// src/core/devbox-instance.ts
+var DevboxInstance = class {
+  info;
+  sdk;
+  git;
+  constructor(info, sdk) {
+    this.info = info;
+    this.sdk = sdk;
+    this.git = new Git({
+      execSync: (options) => this.execSync(options)
+    });
+  }
+  // Properties
+  get name() {
+    return this.info.name;
+  }
+  get status() {
+    return this.info.status;
+  }
+  get runtime() {
+    return this.info.runtime;
+  }
+  get resources() {
+    return this.info.resources;
+  }
+  get serverUrl() {
+    if (!this.info.podIP) {
+      throw new Error(`Devbox '${this.name}' does not have a pod IP address`);
+    }
+    return `http://${this.info.podIP}:3000`;
+  }
+  // Lifecycle operations
+  async start() {
+    const apiClient = this.sdk.getAPIClient();
+    await apiClient.startDevbox(this.name);
+    await this.refreshInfo();
+  }
+  async pause() {
+    const apiClient = this.sdk.getAPIClient();
+    await apiClient.pauseDevbox(this.name);
+    await this.refreshInfo();
+  }
+  async restart() {
+    const apiClient = this.sdk.getAPIClient();
+    await apiClient.restartDevbox(this.name);
+    await this.refreshInfo();
+  }
+  async shutdown() {
+    const apiClient = this.sdk.getAPIClient();
+    await apiClient.shutdownDevbox(this.name);
+    await this.refreshInfo();
+  }
+  async delete() {
+    const apiClient = this.sdk.getAPIClient();
+    await apiClient.deleteDevbox(this.name);
+  }
+  /**
+   * Refresh the instance information from the API
+   */
+  async refreshInfo() {
+    const apiClient = this.sdk.getAPIClient();
+    this.info = await apiClient.getDevbox(this.name);
+  }
+  async writeFile(path, content, options) {
+    this.validatePath(path);
+    const urlResolver = this.sdk.getUrlResolver();
+    await urlResolver.executeWithConnection(this.name, async (client) => {
+      const contentSize = Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content, "utf-8");
+      const LARGE_FILE_THRESHOLD = 1 * 1024 * 1024;
+      const useBinaryMode = contentSize > LARGE_FILE_THRESHOLD;
+      if (Buffer.isBuffer(content)) {
+        if (options?.encoding === "base64") {
+          const base64Content = content.toString("base64");
+          await client.post("/api/v1/files/write", {
+            body: {
+              path,
+              content: base64Content,
+              encoding: "base64"
+            }
+          });
+        } else {
+          await client.post("/api/v1/files/write", {
+            params: { path },
+            headers: {
+              "Content-Type": "application/octet-stream"
+            },
+            body: content
+            // Direct binary data
+          });
+        }
+      } else {
+        if (useBinaryMode && !options?.encoding) {
+          const buffer = Buffer.from(content, "utf-8");
+          await client.post("/api/v1/files/write", {
+            params: { path },
+            headers: {
+              "Content-Type": "application/octet-stream"
+            },
+            body: buffer
+          });
+        } else if (options?.encoding === "base64") {
+          const base64Content = Buffer.from(content, "utf-8").toString("base64");
+          await client.post("/api/v1/files/write", {
+            body: {
+              path,
+              content: base64Content,
+              encoding: "base64"
+            }
+          });
+        } else {
+          await client.post("/api/v1/files/write", {
+            body: {
+              path,
+              content
+            }
+          });
+        }
+      }
+    });
+  }
+  async readFile(path, options) {
+    this.validatePath(path);
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.get("/api/v1/files/read", {
+        params: { path, ...options }
+      });
+      if (Buffer.isBuffer(response.data)) {
+        return response.data;
+      }
+      if (typeof response.data === "string") {
+        return Buffer.from(response.data, "utf-8");
+      }
+      if (response.data instanceof ArrayBuffer) {
+        return Buffer.from(new Uint8Array(response.data));
+      }
+      if (response.data instanceof Uint8Array) {
+        return Buffer.from(response.data);
+      }
+      const dataType = typeof response.data;
+      const dataConstructor = response.data?.constructor?.name || "unknown";
+      throw new Error(
+        `Failed to read file: unexpected response format (type: ${dataType}, constructor: ${dataConstructor})`
+      );
+    });
+  }
+  /**
+   * Validate file path to prevent directory traversal attacks
+   */
+  validatePath(path) {
+    if (!path || path.length === 0) {
+      throw new Error("Path cannot be empty");
+    }
+    if (path.endsWith("/") || path.endsWith("\\")) {
+      throw new Error("Path cannot end with a directory separator");
+    }
+    const normalized = path.replace(/\\/g, "/");
+    if (normalized.includes("../") || normalized.includes("..\\")) {
+      throw new Error(`Path traversal detected: ${path}`);
+    }
+    if (normalized.startsWith("/") && (normalized.startsWith("/../") || normalized === "/..")) {
+      throw new Error(`Invalid absolute path: ${path}`);
+    }
+  }
+  async deleteFile(path) {
+    this.validatePath(path);
+    const urlResolver = this.sdk.getUrlResolver();
+    await urlResolver.executeWithConnection(this.name, async (client) => {
+      await client.post("/api/v1/files/delete", {
+        body: { path }
+      });
+    });
+  }
+  async listFiles(path) {
+    this.validatePath(path);
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.get("/api/v1/files/list", {
+        params: { path }
+      });
+      return response.data;
+    });
+  }
+  async uploadFiles(files, options) {
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const formData = new FormData();
+      let targetDir;
+      const relativePaths = [];
+      const filePaths = Object.keys(files);
+      if (options?.targetDir) {
+        targetDir = options.targetDir.replace(/\/+$/, "") || ".";
+        for (const filePath of filePaths) {
+          if (filePath.startsWith(`${targetDir}/`)) {
+            relativePaths.push(filePath.slice(targetDir.length + 1));
+          } else if (filePath === targetDir) {
+            relativePaths.push("");
+          } else {
+            relativePaths.push(filePath);
+          }
+        }
+      } else {
+        if (filePaths.length === 0) {
+          targetDir = ".";
+        } else {
+          const dirParts = filePaths.map((path) => {
+            const parts = path.split("/");
+            return parts.slice(0, -1);
+          });
+          if (dirParts.length > 0 && dirParts[0] && dirParts[0].length > 0) {
+            const commonPrefix = [];
+            const minLength = Math.min(...dirParts.map((p) => p.length));
+            const firstDirParts = dirParts[0];
+            for (let i = 0; i < minLength; i++) {
+              const segment = firstDirParts[i];
+              if (segment && dirParts.every((p) => p[i] === segment)) {
+                commonPrefix.push(segment);
+              } else {
+                break;
+              }
+            }
+            targetDir = commonPrefix.length > 0 ? commonPrefix.join("/") : ".";
+          } else {
+            targetDir = ".";
+          }
+          const normalizedTargetDir = targetDir === "." ? "" : targetDir;
+          for (const filePath of filePaths) {
+            if (normalizedTargetDir && filePath.startsWith(`${normalizedTargetDir}/`)) {
+              relativePaths.push(filePath.slice(normalizedTargetDir.length + 1));
+            } else {
+              relativePaths.push(filePath);
+            }
+          }
+        }
+      }
+      formData.append("targetDir", targetDir);
+      let index = 0;
+      for (const [filePath, content] of Object.entries(files)) {
+        const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+        const relativePath = relativePaths[index++] || filePath.split("/").pop() || "file";
+        const fullPath = targetDir === "." ? relativePath : `${targetDir}/${relativePath}`;
+        const uint8Array = new Uint8Array(buffer);
+        const file = new File([uint8Array], fullPath);
+        formData.append("files", file);
+      }
+      const response = await client.post("/api/v1/files/batch-upload", {
+        body: formData
+      });
+      return response.data;
+    });
+  }
+  async moveFile(source, destination, overwrite = false) {
+    this.validatePath(source);
+    this.validatePath(destination);
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(API_ENDPOINTS.CONTAINER.FILES.MOVE, {
+        body: {
+          source,
+          destination,
+          overwrite
+        }
+      });
+      return response.data;
+    });
+  }
+  /**
+   * Rename a file or directory
+   * @param oldPath Current file or directory path
+   * @param newPath New file or directory path
+   * @returns Rename operation response
+   */
+  async renameFile(oldPath, newPath) {
+    this.validatePath(oldPath);
+    this.validatePath(newPath);
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(API_ENDPOINTS.CONTAINER.FILES.RENAME, {
+        body: {
+          oldPath,
+          newPath
+        }
+      });
+      return response.data;
+    });
+  }
+  /**
+   * Search for files by filename pattern (case-insensitive substring match)
+   * @param options Search options including directory and pattern
+   * @returns List of matching file paths
+   */
+  async searchFiles(options) {
+    if (!options.pattern || options.pattern.trim().length === 0) {
+      throw new Error("Pattern cannot be empty");
+    }
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(
+        API_ENDPOINTS.CONTAINER.FILES.SEARCH,
+        {
+          body: {
+            dir: options.dir || ".",
+            pattern: options.pattern
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Find files by content keyword (searches inside text files)
+   * @param options Find options including directory and keyword
+   * @returns List of file paths containing the keyword
+   */
+  async findInFiles(options) {
+    if (!options.keyword || options.keyword.trim().length === 0) {
+      throw new Error("Keyword cannot be empty");
+    }
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(
+        API_ENDPOINTS.CONTAINER.FILES.FIND,
+        {
+          body: {
+            dir: options.dir || ".",
+            keyword: options.keyword
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Replace text in multiple files
+   * @param options Replace options including file paths, from text, and to text
+   * @returns Replacement results for each file
+   */
+  async replaceInFiles(options) {
+    if (!options.from || options.from.trim().length === 0) {
+      throw new Error("'from' string cannot be empty");
+    }
+    if (!options.files || options.files.length === 0) {
+      throw new Error("At least one file path is required");
+    }
+    for (const filePath of options.files) {
+      this.validatePath(filePath);
+    }
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(
+        API_ENDPOINTS.CONTAINER.FILES.REPLACE,
+        {
+          body: {
+            files: options.files,
+            from: options.from,
+            to: options.to
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Download a single file
+   * @param path File path to download
+   * @returns Buffer containing file content
+   */
+  async downloadFile(path) {
+    this.validatePath(path);
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.get(
+        `${API_ENDPOINTS.CONTAINER.FILES.DOWNLOAD}?path=${encodeURIComponent(path)}`
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Download multiple files with format options
+   * @param paths Array of file paths to download
+   * @param options Download options including format
+   * @returns Buffer containing downloaded files (tar.gz, tar, or multipart format)
+   */
+  async downloadFiles(paths, options) {
+    if (!paths || paths.length === 0) {
+      throw new Error("At least one file path is required");
+    }
+    for (const path of paths) {
+      this.validatePath(path);
+    }
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const headers = {};
+      if (options?.format) {
+        switch (options.format) {
+          case "tar.gz":
+            headers.Accept = "application/gzip";
+            break;
+          case "tar":
+            headers.Accept = "application/x-tar";
+            break;
+          case "multipart":
+            headers.Accept = "multipart/mixed";
+            break;
+        }
+      }
+      const response = await client.post(API_ENDPOINTS.CONTAINER.FILES.BATCH_DOWNLOAD, {
+        body: { paths, format: options?.format },
+        headers: Object.keys(headers).length > 0 ? headers : void 0
+      });
+      return response.data;
+    });
+  }
+  /**
+   * Get listening ports on the system
+   * @returns Ports response with list of listening ports (3000-9999 range)
+   */
+  async getPorts() {
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.get(API_ENDPOINTS.CONTAINER.PORTS);
+      return response.data;
+    });
+  }
+  /**
+   * Get preview link for a specific port
+   * @param port Port number to get preview link for
+   * @returns Preview URL information
+   */
+  async getPreviewLink(port) {
+    await this.refreshInfo();
+    if (!this.info.agentServer?.url) {
+      throw new Error(
+        `No agentServer URL available for Devbox '${this.name}'. Cannot generate preview link.`
+      );
+    }
+    const serviceName = this.info.agentServer.url;
+    const urlResolver = this.sdk.getUrlResolver();
+    const baseUrl = urlResolver.baseUrl;
+    const urlObj = new URL(baseUrl);
+    const domain = urlObj.hostname.replace(/^devbox\./, "");
+    const url = `${urlObj.protocol}//devbox-${serviceName}-${port}.${domain}`;
+    const protocol = urlObj.protocol.replace(":", "");
+    return {
+      url,
+      port,
+      protocol
+    };
+  }
+  // Temporarily disabled - ws module removed
+  // File watching (instance method)
+  // async watchFiles(
+  //   path: string,
+  //   callback: (event: FileChangeEvent) => void
+  // ): Promise<FileWatchWebSocket> {
+  //   const urlResolver = this.sdk.getUrlResolver()
+  //   const serverUrl = await urlResolver.getServerUrl(this.name)
+  //   const { default: WebSocket } = await import('ws')
+  //   const ws = new WebSocket(`ws://${serverUrl.replace('http://', '')}/ws`) as unknown as FileWatchWebSocket
+  //   ws.onopen = () => {
+  //     const watchRequest: WatchRequest = { type: 'watch', path }
+  //     ws.send(JSON.stringify(watchRequest))
+  //   }
+  //   ws.onmessage = (event: any) => {
+  //     try {
+  //       const data = typeof event.data === 'string' ? event.data : event.data?.toString() || ''
+  //       const fileEvent = JSON.parse(data) as FileChangeEvent
+  //       callback(fileEvent)
+  //     } catch (error) {
+  //       console.error('Failed to parse file watch event:', error)
+  //     }
+  //   }
+  //   return ws
+  // }
+  // Process execution
+  /**
+   * Execute a process asynchronously
+   * All commands are automatically executed through shell (sh -c) for consistent behavior
+   * This ensures environment variables, pipes, redirections, etc. work as expected
+   * @param options Process execution options
+   * @returns Process execution response with process_id and pid
+   */
+  async executeCommand(options) {
+    const urlResolver = this.sdk.getUrlResolver();
+    let fullCommand = options.command;
+    if (options.args && options.args.length > 0) {
+      fullCommand = `${options.command} ${options.args.join(" ")}`;
+    }
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(
+        API_ENDPOINTS.CONTAINER.PROCESS.EXEC,
+        {
+          body: {
+            command: "sh",
+            args: ["-c", fullCommand],
+            cwd: options.cwd,
+            env: options.env,
+            timeout: options.timeout
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Execute a process synchronously and wait for completion
+   * All commands are automatically executed through shell (sh -c) for consistent behavior
+   * This ensures environment variables, pipes, redirections, etc. work as expected
+   * @param options Process execution options
+   * @returns Synchronous execution response with stdout, stderr, and exit code
+   */
+  async execSync(options) {
+    const urlResolver = this.sdk.getUrlResolver();
+    let fullCommand = options.command;
+    if (options.args && options.args.length > 0) {
+      fullCommand = `${options.command} ${options.args.join(" ")}`;
+    }
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.post(
+        API_ENDPOINTS.CONTAINER.PROCESS.EXEC_SYNC,
+        {
+          body: {
+            command: "sh",
+            args: ["-c", fullCommand],
+            cwd: options.cwd,
+            env: options.env,
+            timeout: options.timeout
+          }
+        }
+      );
+      return response.data;
+    });
+  }
+  /**
+   * Execute code directly (Node.js or Python)
+   * @param code Code string to execute
+   * @param options Code execution options
+   * @returns Synchronous execution response with stdout, stderr, and exit code
+   */
+  async codeRun(code, options) {
+    const language = options?.language || this.detectLanguage(code);
+    const command = this.buildCodeCommand(code, language, options?.argv);
+    return this.execSync({
+      command,
+      cwd: options?.cwd,
+      env: options?.env,
+      timeout: options?.timeout
+    });
+  }
+  /**
+   * Detect programming language from code string
+   * @param code Code string to analyze
+   * @returns Detected language ('node' or 'python')
+   */
+  detectLanguage(code) {
+    if (/\bdef\s+\w+\(|^\s*import\s+\w+|print\s*\(|:\s*$/.test(code)) {
+      return "python";
+    }
+    if (/\brequire\s*\(|module\.exports|console\.log/.test(code)) {
+      return "node";
+    }
+    return "node";
+  }
+  /**
+   * Build shell command to execute code
+   * Note: sh -c wrapper is now handled by wrapCommandWithShell
+   * @param code Code string to execute
+   * @param language Programming language ('node' or 'python')
+   * @param argv Command line arguments
+   * @returns Shell command string (without sh -c wrapper)
+   */
+  buildCodeCommand(code, language, argv) {
+    const base64Code = Buffer.from(code).toString("base64");
+    const argvStr = argv && argv.length > 0 ? ` ${argv.join(" ")}` : "";
+    if (language === "python") {
+      return `python3 -u -c "exec(__import__(\\"base64\\").b64decode(\\"${base64Code}\\").decode())"${argvStr}`;
+    }
+    return `echo ${base64Code} | base64 --decode | node -e "$(cat)"${argvStr}`;
+  }
+  /**
+   * Execute a process synchronously with streaming output (SSE)
+   * @param options Process execution options
+   * @returns ReadableStream for Server-Sent Events
+   */
+  async execSyncStream(options) {
+    const urlResolver = this.sdk.getUrlResolver();
+    const serverUrl = await urlResolver.getServerUrl(this.name);
+    const endpoint = API_ENDPOINTS.CONTAINER.PROCESS.EXEC_SYNC_STREAM;
+    const url = `${serverUrl}${endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+        Authorization: "Bearer 1234"
+        // TODO: remove this
+      },
+      body: JSON.stringify({
+        command: options.command,
+        args: options.args,
+        cwd: options.cwd,
+        env: options.env,
+        shell: options.shell,
+        timeout: options.timeout
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body;
+  }
+  /**
+   * List all processes
+   * @returns List of all processes with their metadata
+   */
+  async listProcesses() {
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const response = await client.get(API_ENDPOINTS.CONTAINER.PROCESS.LIST);
+      return response.data;
+    });
+  }
+  /**
+   * Get process status by process_id
+   * @param processId Process ID (string)
+   * @returns Process status response
+   */
+  async getProcessStatus(processId) {
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const endpoint = API_ENDPOINTS.CONTAINER.PROCESS.STATUS.replace("{process_id}", processId);
+      const response = await client.get(endpoint);
+      return response.data;
+    });
+  }
+  /**
+   * Kill a process by process_id
+   * @param processId Process ID (string)
+   * @param options Optional kill options (signal)
+   */
+  async killProcess(processId, options) {
+    const urlResolver = this.sdk.getUrlResolver();
+    await urlResolver.executeWithConnection(this.name, async (client) => {
+      const endpoint = API_ENDPOINTS.CONTAINER.PROCESS.KILL.replace("{process_id}", processId);
+      await client.post(endpoint, {
+        params: options?.signal ? { signal: options.signal } : void 0
+      });
+    });
+  }
+  /**
+   * Get process logs by process_id
+   * @param processId Process ID (string)
+   * @param stream Enable log streaming (default: false)
+   * @returns Process logs response
+   */
+  async getProcessLogs(processId, stream = false) {
+    const urlResolver = this.sdk.getUrlResolver();
+    return await urlResolver.executeWithConnection(this.name, async (client) => {
+      const endpoint = API_ENDPOINTS.CONTAINER.PROCESS.LOGS.replace("{process_id}", processId);
+      const response = await client.get(endpoint, {
+        params: { stream }
+      });
+      return response.data;
+    });
+  }
+  // Monitoring
+  async getMonitorData(timeRange) {
+    return await this.sdk.getMonitorData(this.name, timeRange);
+  }
+  // Health check
+  async isHealthy() {
+    try {
+      const urlResolver = this.sdk.getUrlResolver();
+      return await urlResolver.checkDevboxHealth(this.name);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Wait for the Devbox to be ready and healthy
+   * @param timeoutOrOptions Timeout in milliseconds (for backward compatibility) or options object
+   * @param checkInterval Check interval in milliseconds (for backward compatibility, ignored if first param is options)
+   */
+  async waitForReady(timeoutOrOptions, checkInterval = 2e3) {
+    const options = typeof timeoutOrOptions === "number" ? {
+      timeout: timeoutOrOptions,
+      checkInterval,
+      // For backward compatibility: if explicitly called with numbers, use fixed interval
+      useExponentialBackoff: false
+    } : timeoutOrOptions ?? {
+      // Default: use exponential backoff when called without params
+      useExponentialBackoff: true
+    };
+    const {
+      timeout = 3e5,
+      // 5 minutes
+      checkInterval: fixedInterval,
+      useExponentialBackoff = fixedInterval === void 0,
+      initialCheckInterval = 200,
+      // 0.2 seconds - faster initial checks
+      maxCheckInterval = 5e3,
+      // 5 seconds
+      backoffMultiplier = 1.5
+    } = options;
+    const startTime = Date.now();
+    let currentInterval = useExponentialBackoff ? initialCheckInterval : fixedInterval ?? 2e3;
+    let checkCount = 0;
+    let lastStatus = this.status;
+    while (Date.now() - startTime < timeout) {
+      try {
+        await this.refreshInfo();
+        if (this.status === "Running") {
+          const healthy = await this.isHealthy();
+          if (healthy) {
+            return;
+          }
+          if (lastStatus !== "Running") {
+            currentInterval = Math.min(initialCheckInterval * 2, 1e3);
+            checkCount = 1;
+          }
+        } else if (lastStatus !== this.status) {
+          currentInterval = initialCheckInterval;
+          checkCount = 0;
+        }
+        lastStatus = this.status;
+      } catch {
+      }
+      if (useExponentialBackoff) {
+        currentInterval = Math.min(
+          initialCheckInterval * backoffMultiplier ** checkCount,
+          maxCheckInterval
+        );
+        checkCount++;
+      }
+      await new Promise((resolve) => setTimeout(resolve, currentInterval));
+    }
+    throw new Error(`Devbox '${this.name}' did not become ready within ${timeout}ms`);
+  }
+  /**
+   * Get detailed information about the instance
+   */
+  async getDetailedInfo() {
+    await this.refreshInfo();
+    return { ...this.info };
+  }
+};
+
+// src/core/devbox-sdk.ts
+var DevboxSDK = class {
+  apiClient;
+  urlResolver;
+  constructor(config) {
+    this.apiClient = new DevboxAPI({
+      kubeconfig: config.kubeconfig,
+      baseUrl: config.baseUrl,
+      timeout: config.http?.timeout,
+      retries: config.http?.retries,
+      rejectUnauthorized: config.http?.rejectUnauthorized
+    });
+    this.urlResolver = new ContainerUrlResolver(config);
+    this.urlResolver.setAPIClient(this.apiClient);
+  }
+  /**
+   * Create a new Devbox instance (async, returns immediately without waiting)
+   * @param config Devbox creation configuration
+   * @returns DevboxInstance (may not be ready immediately - use waitForReady() if needed)
+   * @description This method returns immediately after creating the Devbox without waiting for it to be ready.
+   * The returned instance may not be ready for file operations or commands.
+   * Use `createDevbox()` (default behavior) or call `waitForReady()` on the instance if you need to wait.
+   */
+  async createDevboxAsync(config) {
+    const devboxInfo = await this.apiClient.createDevbox(config);
+    return new DevboxInstance(devboxInfo, this);
+  }
+  /**
+   * Create a new Devbox instance
+   * @param config Devbox creation configuration
+   * @param options Creation options (waitUntilReady defaults to true)
+   * @returns DevboxInstance (ready for use if waitUntilReady is true)
+   * @description By default, this method waits for the Devbox to be fully ready before returning.
+   * Set `options.waitUntilReady = false` to return immediately without waiting.
+   */
+  async createDevbox(config, options = {}) {
+    const {
+      waitUntilReady = true,
+      timeout = 18e4,
+      // 3 minutes
+      checkInterval,
+      useExponentialBackoff = true,
+      initialCheckInterval = 200,
+      // 0.2 seconds - faster initial checks
+      maxCheckInterval = 5e3,
+      // 5 seconds
+      backoffMultiplier = 1.5
+    } = options;
+    const instance = await this.createDevboxAsync(config);
+    if (waitUntilReady) {
+      await instance.waitForReady({
+        timeout,
+        checkInterval,
+        useExponentialBackoff,
+        initialCheckInterval,
+        maxCheckInterval,
+        backoffMultiplier
+      });
+    }
+    return instance;
+  }
+  async getDevbox(name) {
+    const devboxInfo = await this.apiClient.getDevbox(name);
+    return new DevboxInstance(devboxInfo, this);
+  }
+  async listDevboxes() {
+    const devboxes = await this.apiClient.listDevboxes();
+    return devboxes.map((info) => new DevboxInstance(info, this));
+  }
+  async getMonitorData(devboxName, timeRange) {
+    return await this.apiClient.getMonitorData(devboxName, timeRange);
+  }
+  async close() {
+    await this.urlResolver.closeAllConnections();
+  }
+  getAPIClient() {
+    return this.apiClient;
+  }
+  getUrlResolver() {
+    return this.urlResolver;
+  }
+};
+
+// src/index.ts
+var VERSION = "1.0.0";
+var index_default = DevboxSDK;
+
+export { API_ENDPOINTS, AuthenticationError, ConnectionError, ContainerUrlResolver, DEFAULT_CONFIG, DevboxAPI, DevboxContainerClient, DevboxInstance, DevboxNotFoundError, DevboxNotReadyError, DevboxRuntime, DevboxSDK, DevboxSDKError, ERROR_CODES, FileOperationError, HTTP_STATUS, VERSION, ValidationError, index_default as default };