instavm 0.8.1 → 0.11.0

package/dist/index.js

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  APIKeysManager: () => APIKeysManager,
+  AuditManager: () => AuditManager,
   AuthenticationError: () => AuthenticationError,
   BrowserError: () => BrowserError,
   BrowserInteractionError: () => BrowserInteractionError,
@@ -39,6 +41,8 @@ __export(index_exports, {
   BrowserSession: () => BrowserSession,
   BrowserSessionError: () => BrowserSessionError,
   BrowserTimeoutError: () => BrowserTimeoutError,
+  ComputerUseManager: () => ComputerUseManager,
+  CustomDomainsManager: () => CustomDomainsManager,
   ElementNotFoundError: () => ElementNotFoundError,
   ExecutionError: () => ExecutionError,
   InstaVM: () => InstaVM,
@@ -47,7 +51,11 @@ __export(index_exports, {
   QuotaExceededError: () => QuotaExceededError,
   RateLimitError: () => RateLimitError,
   SessionError: () => SessionError,
-  UnsupportedOperationError: () => UnsupportedOperationError
+  SharesManager: () => SharesManager,
+  SnapshotsManager: () => SnapshotsManager,
+  UnsupportedOperationError: () => UnsupportedOperationError,
+  VMsManager: () => VMsManager,
+  WebhooksManager: () => WebhooksManager
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -190,7 +198,7 @@ var HTTPClient = class {
       timeout: config.timeout,
       headers: {
         "Content-Type": "application/json",
-        "User-Agent": "instavm-js-sdk/0.1.0"
+        "User-Agent": "instavm-js-sdk/0.11.0"
       }
     });
     this.setupInterceptors();
@@ -211,7 +219,7 @@ var HTTPClient = class {
         const axiosError = error;
         const status = axiosError.response?.status;
         const data = axiosError.response?.data;
-        const message = data?.message || data?.error || axiosError.message;
+        const message = data?.message || data?.error || data?.detail || axiosError.message;
         switch (status) {
           case 401:
             throw new AuthenticationError(message, {
@@ -223,14 +231,16 @@ var HTTPClient = class {
               statusCode: status,
               response: data
             });
-          case 429:
+          case 429: {
             const retryAfter = parseInt(
               axiosError.response?.headers["retry-after"] || "60"
             );
-            throw new RateLimitError(message, retryAfter, {
+            const rateLimitMessage = data?.detail || message;
+            throw new RateLimitError(rateLimitMessage, retryAfter, {
               statusCode: status,
               response: data
             });
+          }
           case 500:
           case 502:
           case 503:
@@ -308,6 +318,7 @@ var HTTPClient = class {
    */
   async postFormData(url, formData, headers) {
     const requestHeaders = {
+      "X-API-Key": this.config.apiKey,
       ...formData.getHeaders(),
       ...headers
     };
@@ -359,6 +370,39 @@ var HTTPClient = class {
       headers
     });
   }
+  /**
+   * PUT request
+   */
+  async put(url, data, headers) {
+    return this.request({
+      method: "PUT",
+      url,
+      data,
+      headers
+    });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(url, data, headers) {
+    return this.request({
+      method: "PATCH",
+      url,
+      data,
+      headers
+    });
+  }
+  /**
+   * OPTIONS request
+   */
+  async options(url, headers, params) {
+    return this.request({
+      method: "OPTIONS",
+      url,
+      headers,
+      params
+    });
+  }
   /**
    * POST request that returns raw binary data (for file downloads)
    */
@@ -925,13 +969,525 @@ var BrowserManager = class {
   }
 };
 
+// src/utils/path.ts
+function encodePathSegment(value) {
+  return encodeURIComponent(String(value));
+}
+function encodePathSegments(path) {
+  const segments = path.replace(/^\/+/, "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+  if (segments.some((segment) => segment === "..")) {
+    throw new Error("Path traversal not allowed in proxy path");
+  }
+  return segments.map((segment) => encodeURIComponent(segment)).join("/");
+}
+
+// src/client/VMsManager.ts
+var VMsManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async create(payload = {}, wait = true) {
+    this.ensureCloud("VM creation");
+    return this.httpClient.request({
+      method: "POST",
+      url: "/v1/vms",
+      params: { wait },
+      data: payload,
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+  async list() {
+    this.ensureCloud("VM listing");
+    return this.httpClient.get(
+      "/v1/vms",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async listAll() {
+    return this.listAllRecords();
+  }
+  /**
+   * Calls GET /v1/vms/ (trailing slash), a distinct route from GET /v1/vms.
+   */
+  async listAllRecords() {
+    this.ensureCloud("VM listing");
+    return this.httpClient.get(
+      "/v1/vms/",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async get(itemId) {
+    this.ensureCloud("VM lookup");
+    const safeItemId = encodePathSegment(itemId);
+    return this.httpClient.get(
+      `/v1/vms/${safeItemId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async update(vmId, payload = {}) {
+    this.ensureCloud("VM update");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.patch(
+      `/v1/vms/${safeVmId}`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async delete(vmId) {
+    this.ensureCloud("VM deletion");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.delete(
+      `/v1/vms/${safeVmId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async clone(vmId, payload = {}, wait = true) {
+    this.ensureCloud("VM clone");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.request({
+      method: "POST",
+      url: `/v1/vms/${safeVmId}/clone`,
+      params: { wait },
+      data: payload,
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+  async snapshot(vmId, payload = {}, wait = true) {
+    this.ensureCloud("VM snapshot");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.request({
+      method: "POST",
+      url: `/v1/vms/${safeVmId}/snapshot`,
+      params: { wait },
+      data: payload,
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+};
+
+// src/client/SnapshotsManager.ts
+var SnapshotsManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async create(payload) {
+    this.ensureCloud("Snapshot creation");
+    return this.httpClient.post(
+      "/v1/snapshots",
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async list(options = {}) {
+    this.ensureCloud("Snapshot listing");
+    return this.httpClient.get(
+      "/v1/snapshots",
+      options,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async get(snapshotId) {
+    this.ensureCloud("Snapshot lookup");
+    const safeSnapshotId = encodePathSegment(snapshotId);
+    return this.httpClient.get(
+      `/v1/snapshots/${safeSnapshotId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async delete(snapshotId) {
+    this.ensureCloud("Snapshot deletion");
+    const safeSnapshotId = encodePathSegment(snapshotId);
+    return this.httpClient.delete(
+      `/v1/snapshots/${safeSnapshotId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
+// src/client/SharesManager.ts
+var SharesManager = class {
+  constructor(httpClient, local = false, getSessionId = () => null) {
+    this.httpClient = httpClient;
+    this.local = local;
+    this.getSessionId = getSessionId;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async create(payload) {
+    this.ensureCloud("Share creation");
+    const body = { ...payload };
+    if (!body.session_id && !body.vm_id) {
+      const sid = this.getSessionId();
+      if (!sid) {
+        throw new SessionError(
+          "Provide session_id/vm_id or create a session before creating a share."
+        );
+      }
+      body.session_id = sid;
+    }
+    return this.httpClient.post(
+      "/v1/shares",
+      body,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async update(shareId, payload) {
+    this.ensureCloud("Share update");
+    const safeShareId = encodePathSegment(shareId);
+    return this.httpClient.patch(
+      `/v1/shares/${safeShareId}`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
+// src/client/CustomDomainsManager.ts
+var CustomDomainsManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async create(payload) {
+    this.ensureCloud("Custom domain creation");
+    return this.httpClient.post(
+      "/v1/custom-domains",
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async list() {
+    this.ensureCloud("Custom domain listing");
+    return this.httpClient.get(
+      "/v1/custom-domains",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async health(domainId) {
+    this.ensureCloud("Custom domain health");
+    const safeDomainId = encodePathSegment(domainId);
+    return this.httpClient.get(
+      `/v1/custom-domains/${safeDomainId}/health`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async verify(domainId) {
+    this.ensureCloud("Custom domain verification");
+    const safeDomainId = encodePathSegment(domainId);
+    return this.httpClient.post(
+      `/v1/custom-domains/${safeDomainId}/verify`,
+      {},
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async delete(domainId) {
+    this.ensureCloud("Custom domain deletion");
+    const safeDomainId = encodePathSegment(domainId);
+    return this.httpClient.delete(
+      `/v1/custom-domains/${safeDomainId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
+// src/client/ComputerUseManager.ts
+var ComputerUseManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async viewerUrl(sessionId) {
+    this.ensureCloud("Computer-use viewer URL");
+    const safeSessionId = encodePathSegment(sessionId);
+    return this.httpClient.get(
+      `/v1/computeruse/${safeSessionId}/viewer-url`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async proxy(sessionId, path, method = "GET", options = {}) {
+    this.ensureCloud("Computer-use proxy");
+    const safeSessionId = encodePathSegment(sessionId);
+    const cleanPath = encodePathSegments(path);
+    return this.httpClient.request({
+      method,
+      url: `/v1/computeruse/${safeSessionId}/${cleanPath}`,
+      params: options.params,
+      data: options.body,
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+  async get(sessionId, path, params) {
+    return this.proxy(sessionId, path, "GET", { params });
+  }
+  async post(sessionId, path, body) {
+    return this.proxy(sessionId, path, "POST", { body });
+  }
+  async put(sessionId, path, body) {
+    return this.proxy(sessionId, path, "PUT", { body });
+  }
+  async patch(sessionId, path, body) {
+    return this.proxy(sessionId, path, "PATCH", { body });
+  }
+  async delete(sessionId, path, params) {
+    return this.proxy(sessionId, path, "DELETE", { params });
+  }
+  async options(sessionId, path, params) {
+    return this.proxy(sessionId, path, "OPTIONS", { params });
+  }
+};
+
+// src/client/APIKeysManager.ts
+var APIKeysManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async create(payload = {}) {
+    this.ensureCloud("API key creation");
+    return this.httpClient.post(
+      "/v1/api-keys/",
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async list() {
+    this.ensureCloud("API key listing");
+    return this.httpClient.get(
+      "/v1/api-keys/",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async get(itemId) {
+    this.ensureCloud("API key lookup");
+    const safeItemId = encodePathSegment(itemId);
+    return this.httpClient.get(
+      `/v1/api-keys/${safeItemId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async update(itemId, payload) {
+    this.ensureCloud("API key update");
+    const safeItemId = encodePathSegment(itemId);
+    return this.httpClient.patch(
+      `/v1/api-keys/${safeItemId}`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async delete(itemId) {
+    this.ensureCloud("API key deletion");
+    const safeItemId = encodePathSegment(itemId);
+    return this.httpClient.delete(
+      `/v1/api-keys/${safeItemId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
+// src/client/AuditManager.ts
+var AuditManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async catalog() {
+    this.ensureCloud("Audit catalog");
+    return this.httpClient.get(
+      "/v1/audit/catalog",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async events(query = {}) {
+    this.ensureCloud("Audit event listing");
+    return this.httpClient.get(
+      "/v1/audit/events",
+      query,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async getEvent(eventId) {
+    this.ensureCloud("Audit event lookup");
+    const safeEventId = encodePathSegment(eventId);
+    return this.httpClient.get(
+      `/v1/audit/events/${safeEventId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
+// src/client/WebhooksManager.ts
+var WebhooksManager = class {
+  constructor(httpClient, local = false) {
+    this.httpClient = httpClient;
+    this.local = local;
+  }
+  ensureCloud(operation) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operation} is not supported in local mode.`
+      );
+    }
+  }
+  async createEndpoint(payload) {
+    this.ensureCloud("Webhook endpoint creation");
+    return this.httpClient.post(
+      "/v1/webhooks/endpoints",
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async listEndpoints() {
+    this.ensureCloud("Webhook endpoint listing");
+    return this.httpClient.get(
+      "/v1/webhooks/endpoints",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async getEndpoint(endpointId) {
+    this.ensureCloud("Webhook endpoint lookup");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.get(
+      `/v1/webhooks/endpoints/${safeEndpointId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async updateEndpoint(endpointId, payload) {
+    this.ensureCloud("Webhook endpoint update");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.patch(
+      `/v1/webhooks/endpoints/${safeEndpointId}`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async deleteEndpoint(endpointId) {
+    this.ensureCloud("Webhook endpoint deletion");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.delete(
+      `/v1/webhooks/endpoints/${safeEndpointId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async rotateSecret(endpointId) {
+    this.ensureCloud("Webhook secret rotation");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.post(
+      `/v1/webhooks/endpoints/${safeEndpointId}/rotate-secret`,
+      {},
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async sendTestEvent(endpointId) {
+    this.ensureCloud("Webhook test event");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.post(
+      `/v1/webhooks/endpoints/${safeEndpointId}/test`,
+      {},
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async verifyEndpoint(endpointId) {
+    this.ensureCloud("Webhook endpoint verification");
+    const safeEndpointId = encodePathSegment(endpointId);
+    return this.httpClient.post(
+      `/v1/webhooks/endpoints/${safeEndpointId}/verify`,
+      {},
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async listDeliveries(query = {}) {
+    this.ensureCloud("Webhook delivery listing");
+    return this.httpClient.get(
+      "/v1/webhooks/deliveries",
+      query,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async replayDelivery(deliveryId) {
+    this.ensureCloud("Webhook delivery replay");
+    const safeDeliveryId = encodePathSegment(deliveryId);
+    return this.httpClient.post(
+      `/v1/webhooks/deliveries/${safeDeliveryId}/replay`,
+      {},
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+};
+
 // src/client/InstaVM.ts
 var import_form_data = __toESM(require("form-data"));
 var InstaVM = class {
   constructor(apiKey, options = {}) {
     this._sessionId = null;
+    this._vmUsed = false;
     this.local = options.local || false;
     this.timeout = options.timeout || 3e5;
+    this.memory_mb = options.memory_mb;
+    this.cpu_count = options.cpu_count;
+    this.metadata = options.metadata;
+    this.env = options.env;
     if (!this.local && !apiKey) {
       throw new AuthenticationError("API key is required for cloud mode");
     }
@@ -944,6 +1500,14 @@ var InstaVM = class {
     };
     this.httpClient = new HTTPClient(config);
     this.browser = new BrowserManager(this.httpClient, this.local);
+    this.vms = new VMsManager(this.httpClient, this.local);
+    this.snapshots = new SnapshotsManager(this.httpClient, this.local);
+    this.shares = new SharesManager(this.httpClient, this.local, () => this._sessionId);
+    this.customDomains = new CustomDomainsManager(this.httpClient, this.local);
+    this.computerUse = new ComputerUseManager(this.httpClient, this.local);
+    this.apiKeys = new APIKeysManager(this.httpClient, this.local);
+    this.audit = new AuditManager(this.httpClient, this.local);
+    this.webhooks = new WebhooksManager(this.httpClient, this.local);
   }
   /**
    * Ensure operation is not called in local mode
@@ -989,10 +1553,16 @@ var InstaVM = class {
       if (response.session_id) {
         this._sessionId = response.session_id;
       }
+      if (!this.local) {
+        this._vmUsed = true;
+      }
       return {
-        output: response.stdout || response.output || "",
+        stdout: response.stdout || "",
+        stderr: response.stderr || "",
         success: response.success !== false,
-        executionTime: response.execution_time || 0,
+        executionTime: response.execution_time,
+        cpuTime: response.cpu_time,
+        createdAt: response.created_at,
         sessionId: response.session_id,
         error: response.error
       };
@@ -1029,6 +1599,7 @@ var InstaVM = class {
       if (response.session_id) {
         this._sessionId = response.session_id;
       }
+      this._vmUsed = true;
       return {
         taskId: response.task_id,
         status: response.status || "pending",
@@ -1048,11 +1619,58 @@ var InstaVM = class {
       );
     }
   }
+  /**
+   * Poll for async task result
+   *
+   * @param taskId - The task ID from executeAsync
+   * @param pollInterval - Seconds between polls (default: 1)
+   * @param timeout - Maximum seconds to wait (default: 60)
+   * @returns Task result with stdout, stderr, execution time, etc.
+   * @throws Error if task doesn't complete within timeout
+   */
+  async getTaskResult(taskId, pollInterval = 1, timeout = 60) {
+    this.ensureNotLocal("Async task result retrieval");
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout * 1e3) {
+      try {
+        const response = await this.httpClient.get(
+          `/v1/executions/${taskId}`,
+          void 0,
+          { "X-API-Key": this.httpClient.apiKey }
+        );
+        if (response.is_complete) {
+          return {
+            stdout: response.serialized_stdout || "",
+            stderr: response.serialized_stderr || "",
+            cpuTime: response.cpu_time,
+            executionTime: response.execution_time,
+            createdAt: response.created_at
+          };
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3));
+      } catch (error) {
+        if (error instanceof AuthenticationError || error instanceof RateLimitError || error instanceof NetworkError) {
+          throw error;
+        }
+        if (Date.now() - startTime >= timeout * 1e3) {
+          throw new ExecutionError(
+            `Failed to get task result: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval * 1e3));
+      }
+    }
+    throw new ExecutionError(`Task ${taskId} timed out after ${timeout}s`);
+  }
   /**
    * Upload files to the execution environment
    */
   async upload(files, options = {}) {
     this.ensureNotLocal("File upload");
+    const sessionId = options.sessionId || this._sessionId;
+    if (!sessionId) {
+      throw new SessionError("Session ID not set. Please create a session first using createSession().");
+    }
     const formData = new import_form_data.default();
     for (const file of files) {
       if (Buffer.isBuffer(file.content)) {
@@ -1064,9 +1682,7 @@ var InstaVM = class {
         formData.append("paths", file.path);
       }
     }
-    if (options.sessionId || this._sessionId) {
-      formData.append("session_id", options.sessionId || this._sessionId);
-    }
+    formData.append("session_id", sessionId);
     if (options.remotePath) {
       formData.append("remote_path", options.remotePath);
     }
@@ -1097,10 +1713,26 @@ var InstaVM = class {
   async createSession() {
     this.ensureNotLocal("Session management");
     try {
-      const response = await this.httpClient.post("/v1/sessions/session", {
+      const requestBody = {
         api_key: this.httpClient.apiKey,
         vm_lifetime_seconds: Math.floor(this.timeout / 1e3)
-      });
+      };
+      if (this.memory_mb !== void 0) {
+        requestBody.memory_mb = this.memory_mb;
+      }
+      if (this.cpu_count !== void 0) {
+        requestBody.vcpu_count = this.cpu_count;
+      }
+      if (this.metadata !== void 0) {
+        requestBody.metadata = this.metadata;
+      }
+      if (this.env !== void 0) {
+        requestBody.env = this.env;
+      }
+      const response = await this.httpClient.post(
+        "/v1/sessions/session",
+        requestBody
+      );
       if (response.session_id) {
         this._sessionId = response.session_id;
         return response.session_id;
@@ -1127,6 +1759,30 @@ var InstaVM = class {
       this._sessionId = null;
     }
   }
+  /**
+   * Check if current session is still active by checking VM status
+   *
+   * @returns true if session is active, false otherwise
+   */
+  async isSessionActive(sessionId) {
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      return false;
+    }
+    try {
+      const response = await this.httpClient.get(
+        `/v1/sessions/status/${targetSessionId}`,
+        void 0,
+        { "X-API-Key": this.httpClient.apiKey }
+      );
+      return response.vm_status === "active";
+    } catch (error) {
+      if (error instanceof SessionError || error instanceof AuthenticationError || error instanceof NetworkError) {
+        return false;
+      }
+      return false;
+    }
+  }
   /**
    * Get usage statistics for a session
    */
@@ -1190,11 +1846,185 @@ var InstaVM = class {
   get sessionId() {
     return this._sessionId;
   }
+  /**
+   * Kill the VM associated with a session
+   *
+   * @param sessionId - The session UUID whose VM should be killed. If not provided, uses current sessionId
+   * @returns Result containing success message and killed VM ID
+   */
+  async kill(sessionId) {
+    this.ensureNotLocal("VM kill operation");
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("Session ID not set. Please provide a sessionId or start a session first.");
+    }
+    try {
+      const response = await this.httpClient.post(
+        "/kill",
+        { session_id: targetSessionId },
+        { "X-API-Key": this.httpClient.apiKey }
+      );
+      if (!sessionId && this._sessionId === targetSessionId) {
+        this._sessionId = null;
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof Error && "statusCode" in error) {
+        const statusCode = error.statusCode;
+        if (statusCode === 403) {
+          throw new AuthenticationError("You don't own this session", { cause: error });
+        }
+        if (statusCode === 404) {
+          throw new SessionError("Session not found or no VM assigned to session (has execute() been called?)", { cause: error });
+        }
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SessionError(
+        `Failed to kill VM: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  // --- Egress Policy Methods ---
+  /**
+   * Set egress policy for a session
+   */
+  async setSessionEgress(options = {}, sessionId) {
+    this.ensureNotLocal("Egress policy management");
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("Session ID not set. Please create a session first.");
+    }
+    const response = await this.httpClient.post(
+      `/v1/egress/session/${targetSessionId}`,
+      {
+        allow_public_repos: options.allowPackageManagers ?? true,
+        allow_http: options.allowHttp ?? true,
+        allow_https: options.allowHttps ?? true,
+        allowed_domains: options.allowedDomains ?? [],
+        allowed_cidrs: options.allowedCidrs ?? []
+      },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return response;
+  }
+  /**
+   * Get egress policy for a session
+   */
+  async getSessionEgress(sessionId) {
+    this.ensureNotLocal("Egress policy management");
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("Session ID not set. Please create a session first.");
+    }
+    const response = await this.httpClient.get(
+      `/v1/egress/session/${targetSessionId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return {
+      allowPackageManagers: response.allow_public_repos,
+      allowHttp: response.allow_http,
+      allowHttps: response.allow_https,
+      allowedDomains: response.allowed_domains || [],
+      allowedCidrs: response.allowed_cidrs || []
+    };
+  }
+  /**
+   * Set egress policy for a specific VM
+   */
+  async setVmEgress(vmId, options = {}) {
+    this.ensureNotLocal("Egress policy management");
+    const response = await this.httpClient.post(
+      `/v1/egress/vm/${vmId}`,
+      {
+        allow_public_repos: options.allowPackageManagers ?? true,
+        allow_http: options.allowHttp ?? true,
+        allow_https: options.allowHttps ?? true,
+        allowed_domains: options.allowedDomains ?? [],
+        allowed_cidrs: options.allowedCidrs ?? []
+      },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return response;
+  }
+  /**
+   * Get egress policy for a specific VM
+   */
+  async getVmEgress(vmId) {
+    this.ensureNotLocal("Egress policy management");
+    const response = await this.httpClient.get(
+      `/v1/egress/vm/${vmId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return {
+      allowPackageManagers: response.allow_public_repos,
+      allowHttp: response.allow_http,
+      allowHttps: response.allow_https,
+      allowedDomains: response.allowed_domains || [],
+      allowedCidrs: response.allowed_cidrs || []
+    };
+  }
+  // --- SSH Key Methods ---
+  /**
+   * Add an SSH public key
+   */
+  async addSshKey(publicKey) {
+    this.ensureNotLocal("SSH key management");
+    const response = await this.httpClient.post(
+      "/v1/ssh-keys",
+      { public_key: publicKey },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return {
+      id: response.id,
+      fingerprint: response.fingerprint,
+      keyType: response.key_type,
+      comment: response.comment ?? null,
+      createdAt: response.created_at
+    };
+  }
+  /**
+   * List all active SSH keys
+   */
+  async listSshKeys() {
+    this.ensureNotLocal("SSH key management");
+    const response = await this.httpClient.get(
+      "/v1/ssh-keys",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    const keys = response.keys || [];
+    return keys.map((k) => ({
+      id: k.id,
+      fingerprint: k.fingerprint,
+      keyType: k.key_type,
+      comment: k.comment ?? null,
+      createdAt: k.created_at
+    }));
+  }
+  /**
+   * Delete an SSH key by ID
+   */
+  async deleteSshKey(keyId) {
+    this.ensureNotLocal("SSH key management");
+    const response = await this.httpClient.delete(
+      `/v1/ssh-keys/${keyId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return response;
+  }
   /**
    * Clean up resources
    */
   async dispose() {
-    if (this._sessionId) {
+    if (this._sessionId && !this.local && this._vmUsed) {
+      try {
+        await this.kill();
+      } catch (e) {
+      }
+    } else if (this._sessionId) {
       await this.closeSession();
     }
     await this.browser.dispose();
@@ -1202,6 +2032,8 @@ var InstaVM = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIKeysManager,
+  AuditManager,
   AuthenticationError,
   BrowserError,
   BrowserInteractionError,
@@ -1210,6 +2042,8 @@ var InstaVM = class {
   BrowserSession,
   BrowserSessionError,
   BrowserTimeoutError,
+  ComputerUseManager,
+  CustomDomainsManager,
   ElementNotFoundError,
   ExecutionError,
   InstaVM,
@@ -1218,6 +2052,10 @@ var InstaVM = class {
   QuotaExceededError,
   RateLimitError,
   SessionError,
-  UnsupportedOperationError
+  SharesManager,
+  SnapshotsManager,
+  UnsupportedOperationError,
+  VMsManager,
+  WebhooksManager
 });
 //# sourceMappingURL=index.js.map