instavm 0.11.0 → 0.15.0

package/dist/index.mjs

@@ -1,5 +1,3 @@
-"use strict";
-
 // src/client/HTTPClient.ts
 import axios from "axios";
 
@@ -139,7 +137,7 @@ var HTTPClient = class {
       timeout: config.timeout,
       headers: {
         "Content-Type": "application/json",
-        "User-Agent": "instavm-js-sdk/0.11.0"
+        "User-Agent": "instavm-js-sdk/0.15.0"
       }
     });
     this.setupInterceptors();
@@ -912,10 +910,14 @@ var BrowserManager = class {
 
 // src/utils/path.ts
 function encodePathSegment(value) {
-  return encodeURIComponent(String(value));
+  const segment = String(value);
+  if (segment === "." || segment === "..") {
+    throw new Error("Path traversal not allowed in path segment");
+  }
+  return encodeURIComponent(segment);
 }
-function encodePathSegments(path) {
-  const segments = path.replace(/^\/+/, "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+function encodePathSegments(path2) {
+  const segments = path2.replace(/^\/+/, "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
   if (segments.some((segment) => segment === "..")) {
     throw new Error("Path traversal not allowed in proxy path");
   }
@@ -1015,6 +1017,37 @@ var VMsManager = class {
       headers: { "X-API-Key": this.httpClient.apiKey }
     });
   }
+  async mountVolume(vmId, payload, wait = true) {
+    this.ensureCloud("VM volume mount");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.request({
+      method: "POST",
+      url: `/v1/vms/${safeVmId}/volumes`,
+      params: { wait },
+      data: payload,
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+  async listVolumes(vmId) {
+    this.ensureCloud("VM volume listing");
+    const safeVmId = encodePathSegment(vmId);
+    return this.httpClient.get(
+      `/v1/vms/${safeVmId}/volumes`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async unmountVolume(vmId, volumeId, mountPath, wait = true) {
+    this.ensureCloud("VM volume unmount");
+    const safeVmId = encodePathSegment(vmId);
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.request({
+      method: "DELETE",
+      url: `/v1/vms/${safeVmId}/volumes/${safeVolumeId}`,
+      params: { mount_path: mountPath, wait },
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
 };
 
 // src/client/SnapshotsManager.ts
@@ -1187,10 +1220,10 @@ var ComputerUseManager = class {
       { "X-API-Key": this.httpClient.apiKey }
     );
   }
-  async proxy(sessionId, path, method = "GET", options = {}) {
+  async proxy(sessionId, path2, method = "GET", options = {}) {
     this.ensureCloud("Computer-use proxy");
     const safeSessionId = encodePathSegment(sessionId);
-    const cleanPath = encodePathSegments(path);
+    const cleanPath = encodePathSegments(path2);
     return this.httpClient.request({
       method,
       url: `/v1/computeruse/${safeSessionId}/${cleanPath}`,
@@ -1199,23 +1232,39 @@ var ComputerUseManager = class {
       headers: { "X-API-Key": this.httpClient.apiKey }
     });
   }
-  async get(sessionId, path, params) {
-    return this.proxy(sessionId, path, "GET", { params });
+  async get(sessionId, path2, params) {
+    return this.proxy(sessionId, path2, "GET", { params });
   }
-  async post(sessionId, path, body) {
-    return this.proxy(sessionId, path, "POST", { body });
+  async post(sessionId, path2, body) {
+    return this.proxy(sessionId, path2, "POST", { body });
   }
-  async put(sessionId, path, body) {
-    return this.proxy(sessionId, path, "PUT", { body });
+  async put(sessionId, path2, body) {
+    return this.proxy(sessionId, path2, "PUT", { body });
   }
-  async patch(sessionId, path, body) {
-    return this.proxy(sessionId, path, "PATCH", { body });
+  async patch(sessionId, path2, body) {
+    return this.proxy(sessionId, path2, "PATCH", { body });
   }
-  async delete(sessionId, path, params) {
-    return this.proxy(sessionId, path, "DELETE", { params });
+  async delete(sessionId, path2, params) {
+    return this.proxy(sessionId, path2, "DELETE", { params });
   }
-  async options(sessionId, path, params) {
-    return this.proxy(sessionId, path, "OPTIONS", { params });
+  async options(sessionId, path2, params) {
+    return this.proxy(sessionId, path2, "OPTIONS", { params });
+  }
+  async head(sessionId, path2, params) {
+    return this.proxy(sessionId, path2, "HEAD", { params });
+  }
+  /**
+   * Get the VNC WebSocket URL for a computer-use session.
+   * Returns the URL to connect to; the actual connection requires a WebSocket client.
+   */
+  async vncWebsockify(sessionId) {
+    this.ensureCloud("Computer-use VNC websockify");
+    const safeSessionId = encodePathSegment(sessionId);
+    return this.httpClient.get(
+      `/v1/computeruse/${safeSessionId}/vnc/websockify`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
   }
 };
 
@@ -1417,8 +1466,164 @@ var WebhooksManager = class {
   }
 };
 
-// src/client/InstaVM.ts
+// src/client/VolumesManager.ts
+import fs from "fs";
+import path from "path";
 import FormData from "form-data";
+var VolumesManager = 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("Volume creation");
+    return this.httpClient.post(
+      "/v1/volumes",
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async list(refreshUsage = false) {
+    this.ensureCloud("Volume listing");
+    return this.httpClient.get(
+      "/v1/volumes",
+      { refresh_usage: refreshUsage },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async get(volumeId, refreshUsage = false) {
+    this.ensureCloud("Volume lookup");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.get(
+      `/v1/volumes/${safeVolumeId}`,
+      { refresh_usage: refreshUsage },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async update(volumeId, payload) {
+    this.ensureCloud("Volume update");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.patch(
+      `/v1/volumes/${safeVolumeId}`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async delete(volumeId) {
+    this.ensureCloud("Volume deletion");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.delete(
+      `/v1/volumes/${safeVolumeId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async createCheckpoint(volumeId, payload = {}) {
+    this.ensureCloud("Volume checkpoint creation");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.post(
+      `/v1/volumes/${safeVolumeId}/checkpoints`,
+      payload,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async listCheckpoints(volumeId) {
+    this.ensureCloud("Volume checkpoint listing");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.get(
+      `/v1/volumes/${safeVolumeId}/checkpoints`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async deleteCheckpoint(volumeId, checkpointId) {
+    this.ensureCloud("Volume checkpoint deletion");
+    const safeVolumeId = encodePathSegment(volumeId);
+    const safeCheckpointId = encodePathSegment(checkpointId);
+    return this.httpClient.delete(
+      `/v1/volumes/${safeVolumeId}/checkpoints/${safeCheckpointId}`,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async uploadFile(volumeId, payload) {
+    this.ensureCloud("Volume file upload");
+    if (!payload.path || payload.path.trim().length === 0) {
+      throw new Error("payload.path is required");
+    }
+    const hasFilePath = typeof payload.filePath === "string" && payload.filePath.length > 0;
+    const hasFileContent = payload.fileContent !== void 0;
+    if (hasFilePath === hasFileContent) {
+      throw new Error("Provide exactly one of payload.filePath or payload.fileContent");
+    }
+    const safeVolumeId = encodePathSegment(volumeId);
+    const formData = new FormData();
+    if (hasFilePath) {
+      const sourcePath = payload.filePath;
+      const filename = payload.filename || path.basename(sourcePath);
+      formData.append("file", fs.createReadStream(sourcePath), { filename });
+    } else {
+      const filename = payload.filename || "upload.bin";
+      const raw = payload.fileContent;
+      const buffer = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+      formData.append("file", buffer, { filename });
+    }
+    formData.append("path", payload.path);
+    if (payload.overwrite !== void 0) {
+      formData.append("overwrite", String(payload.overwrite));
+    }
+    return this.httpClient.postFormData(
+      `/v1/volumes/${safeVolumeId}/files/upload`,
+      formData
+    );
+  }
+  async downloadFile(volumeId, path2) {
+    this.ensureCloud("Volume file download");
+    const safeVolumeId = encodePathSegment(volumeId);
+    const response = await this.httpClient.post(
+      `/v1/volumes/${safeVolumeId}/files/download`,
+      { path: path2 },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+    return {
+      path: response.path,
+      filename: response.filename,
+      size: response.size,
+      content: Buffer.from(response.content || "", "base64")
+    };
+  }
+  async listFiles(volumeId, options = {}) {
+    this.ensureCloud("Volume file listing");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.get(
+      `/v1/volumes/${safeVolumeId}/files`,
+      {
+        prefix: options.prefix ?? "",
+        recursive: options.recursive ?? true,
+        limit: options.limit ?? 1e3
+      },
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  async deleteFile(volumeId, targetPath) {
+    this.ensureCloud("Volume file deletion");
+    const safeVolumeId = encodePathSegment(volumeId);
+    return this.httpClient.request({
+      method: "DELETE",
+      url: `/v1/volumes/${safeVolumeId}/files`,
+      params: { path: targetPath },
+      headers: { "X-API-Key": this.httpClient.apiKey }
+    });
+  }
+};
+
+// src/client/InstaVM.ts
+import FormData2 from "form-data";
 var InstaVM = class {
   constructor(apiKey, options = {}) {
     this._sessionId = null;
@@ -1449,6 +1654,7 @@ var InstaVM = class {
     this.apiKeys = new APIKeysManager(this.httpClient, this.local);
     this.audit = new AuditManager(this.httpClient, this.local);
     this.webhooks = new WebhooksManager(this.httpClient, this.local);
+    this.volumes = new VolumesManager(this.httpClient, this.local);
   }
   /**
    * Ensure operation is not called in local mode
@@ -1612,7 +1818,7 @@ var InstaVM = class {
     if (!sessionId) {
       throw new SessionError("Session ID not set. Please create a session first using createSession().");
     }
-    const formData = new FormData();
+    const formData = new FormData2();
     for (const file of files) {
       if (Buffer.isBuffer(file.content)) {
         formData.append("files", file.content, file.name);
@@ -1724,6 +1930,49 @@ var InstaVM = class {
       return false;
     }
   }
+  /**
+   * Get the app URL for a session
+   *
+   * @param sessionId - Session ID (uses current session if not provided)
+   * @param port - Port to expose (1-65535, default: 80)
+   */
+  async getSessionAppUrl(sessionId, port) {
+    this.ensureNotLocal("Session app URL");
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("Session ID not set. Please create a session first.");
+    }
+    const params = {};
+    if (port !== void 0) {
+      params.port = port;
+    }
+    return this.httpClient.get(
+      `/v1/sessions/app-url/${targetSessionId}`,
+      params,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  /**
+   * List sandbox records with optional filtering
+   *
+   * @param options.metadata - JSON-serializable metadata filters
+   * @param options.limit - Maximum number of results (1-1000, default: 100)
+   */
+  async listSandboxes(options = {}) {
+    this.ensureNotLocal("Sandbox listing");
+    const params = {};
+    if (options.metadata !== void 0) {
+      params.metadata = JSON.stringify(options.metadata);
+    }
+    if (options.limit !== void 0) {
+      params.limit = options.limit;
+    }
+    return this.httpClient.get(
+      "/v1/sessions/sandboxes",
+      params,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
   /**
    * Get usage statistics for a session
    */
@@ -1735,7 +1984,9 @@ var InstaVM = class {
     }
     try {
       const response = await this.httpClient.get(
-        `/v1/sessions/usage/${targetSessionId}`
+        `/v1/sessions/usage/${targetSessionId}`,
+        void 0,
+        { "X-API-Key": this.httpClient.apiKey }
       );
       return {
         sessionsUsed: response.sessions_used || 0,
@@ -1751,6 +2002,32 @@ var InstaVM = class {
       );
     }
   }
+  /**
+   * Get the current user profile.
+   */
+  async getCurrentUser() {
+    this.ensureNotLocal("User profile lookup");
+    return this.httpClient.get(
+      "/v1/me",
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
+  /**
+   * Get the current status of a session.
+   */
+  async getSessionStatus(sessionId) {
+    this.ensureNotLocal("Session management");
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("Session ID not set. Please create a session first.");
+    }
+    return this.httpClient.get(
+      `/v1/sessions/status/${targetSessionId}`,
+      void 0,
+      { "X-API-Key": this.httpClient.apiKey }
+    );
+  }
   /**
    * Download a file from the remote VM
    */
@@ -1996,6 +2273,7 @@ export {
   SnapshotsManager,
   UnsupportedOperationError,
   VMsManager,
+  VolumesManager,
   WebhooksManager
 };
 //# sourceMappingURL=index.mjs.map