instavm 0.2.2 → 0.4.0

package/dist/index.mjs

@@ -1,94 +1,4 @@
 "use strict";
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "instavm",
-      version: "0.2.2",
-      description: "Official JavaScript SDK for InstaVM API",
-      main: "dist/index.js",
-      module: "dist/index.mjs",
-      types: "dist/index.d.ts",
-      exports: {
-        ".": {
-          types: "./dist/index.d.ts",
-          import: "./dist/index.mjs",
-          require: "./dist/index.js"
-        },
-        "./integrations/openai": {
-          types: "./dist/integrations/openai.d.ts",
-          import: "./dist/integrations/openai.mjs",
-          require: "./dist/integrations/openai.js"
-        }
-      },
-      files: [
-        "dist"
-      ],
-      scripts: {
-        dev: "tsup --watch",
-        build: "tsup",
-        "type-check": "tsc --noEmit",
-        test: "vitest",
-        "test:unit": "vitest run tests/unit",
-        "test:integration": "vitest run tests/integration",
-        "test:watch": "vitest --watch",
-        "test:coverage": "vitest --coverage",
-        lint: "eslint src --ext .ts,.tsx",
-        "lint:fix": "eslint src --ext .ts,.tsx --fix",
-        format: "prettier --write src/**/*.ts",
-        prepublishOnly: "npm run build && npm run test:unit",
-        clean: "rm -rf dist"
-      },
-      keywords: [
-        "instavm",
-        "api",
-        "sdk",
-        "browser-automation",
-        "code-execution",
-        "microvm",
-        "cloud"
-      ],
-      author: "InstaVM",
-      license: "UNLICENSED",
-      repository: {
-        type: "git",
-        url: "https://github.com/instavm/js.git"
-      },
-      bugs: {
-        url: "https://github.com/instavm/js/issues"
-      },
-      homepage: "https://github.com/instavm/js#readme",
-      engines: {
-        node: ">=16.0.0"
-      },
-      dependencies: {
-        axios: "^1.7.9",
-        eventemitter3: "^5.0.1",
-        "form-data": "^4.0.1",
-        ws: "^8.18.0"
-      },
-      devDependencies: {
-        "@types/node": "^22.10.5",
-        "@types/ws": "^8.5.13",
-        "@typescript-eslint/eslint-plugin": "^8.18.2",
-        "@typescript-eslint/parser": "^8.18.2",
-        "@vitest/coverage-v8": "^2.1.8",
-        eslint: "^9.18.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.2.1",
-        prettier: "^3.4.2",
-        tsup: "^8.3.5",
-        typescript: "^5.7.2",
-        vitest: "^2.1.8"
-      }
-    };
-  }
-});
 
 // src/client/HTTPClient.ts
 import axios from "axios";
@@ -171,6 +81,11 @@ var ElementNotFoundError = class extends BrowserError {
     this.selector = selector;
   }
 };
+var UnsupportedOperationError = class extends InstaVMError {
+  constructor(message = "Operation not supported", options) {
+    super(message, options);
+  }
+};
 
 // src/utils/retry.ts
 function defaultRetryCondition(error) {
@@ -213,14 +128,6 @@ async function withRetry(fn, options) {
 }
 
 // src/client/HTTPClient.ts
-function getPackageVersion() {
-  try {
-    const packageJson = require_package();
-    return packageJson.version || "0.1.0";
-  } catch {
-    return "0.1.0";
-  }
-}
 var HTTPClient = class {
   get apiKey() {
     return this.config.apiKey;
@@ -232,7 +139,7 @@ var HTTPClient = class {
       timeout: config.timeout,
       headers: {
         "Content-Type": "application/json",
-        "User-Agent": `instavm-js-sdk/${getPackageVersion()}`
+        "User-Agent": "instavm-js-sdk/0.1.0"
       }
     });
     this.setupInterceptors();
@@ -240,7 +147,7 @@ var HTTPClient = class {
   setupInterceptors() {
     this.client.interceptors.request.use(
       (config) => {
-        if (!config.headers["X-API-Key"] && !config.url?.includes("/v1/sessions/session")) {
+        if (config.url?.includes("/browser/")) {
           config.headers["X-API-Key"] = this.config.apiKey;
         }
         return config;
@@ -329,14 +236,18 @@ var HTTPClient = class {
     });
   }
   /**
-   * POST request for code execution (X-API-Key header is automatically added)
+   * POST request for code execution (uses X-API-Key header like Python client)
    */
   async postExecution(url, data, headers) {
+    const requestHeaders = {
+      "X-API-Key": this.config.apiKey,
+      ...headers
+    };
     return this.request({
       method: "POST",
       url,
       data,
-      headers
+      headers: requestHeaders
     });
   }
   /**
@@ -375,6 +286,31 @@ var HTTPClient = class {
       headers
     });
   }
+  /**
+   * POST request that returns raw binary data (for file downloads)
+   */
+  async postRaw(url, data, headers) {
+    const requestHeaders = {
+      "X-API-Key": this.config.apiKey,
+      ...headers
+    };
+    const axiosConfig = {
+      method: "POST",
+      url,
+      data,
+      headers: requestHeaders,
+      responseType: "arraybuffer",
+      timeout: this.config.timeout
+    };
+    const makeRequest = async () => {
+      const response = await this.client.request(axiosConfig);
+      return response.data;
+    };
+    return withRetry(makeRequest, {
+      retries: this.config.maxRetries,
+      retryDelay: this.config.retryDelay
+    });
+  }
 };
 
 // src/client/BrowserSession.ts
@@ -601,6 +537,59 @@ var BrowserSession = class extends EventEmitter {
       );
     }
   }
+  /**
+   * Extract LLM-friendly content from the current page
+   *
+   * Returns clean article content, interactive elements, and content anchors
+   * for intelligent browser automation with LLMs.
+   *
+   * @param options - Content extraction options
+   * @returns Extracted content with readable text, interactive elements, and content anchors
+   *
+   * @example
+   * ```typescript
+   * const content = await session.extractContent();
+   *
+   * // LLM reads clean content
+   * const article = content.readableContent.content;
+   *
+   * // LLM finds "Sign Up" in content and uses anchors to get selector
+   * const signUpAnchor = content.contentAnchors?.find(
+   *   anchor => anchor.text.toLowerCase().includes('sign up')
+   * );
+   * if (signUpAnchor) {
+   *   await session.click(signUpAnchor.selector);
+   * }
+   * ```
+   */
+  async extractContent(options = {}) {
+    this.ensureActive();
+    const requestData = {
+      session_id: this.sessionId,
+      include_interactive: options.includeInteractive !== false,
+      include_anchors: options.includeAnchors !== false,
+      max_anchors: options.maxAnchors ?? 50
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/content",
+        requestData
+      );
+      return {
+        readableContent: {
+          ...response.readable_content || {},
+          content: response.readable_content?.content || ""
+        },
+        interactiveElements: response.interactive_elements,
+        contentAnchors: response.content_anchors
+      };
+    } catch (error) {
+      throw new BrowserInteractionError(
+        `Content extraction failed: ${getErrorMessage(error)}`,
+        { cause: error }
+      );
+    }
+  }
   /**
    * Wait for a condition
    */
@@ -672,14 +661,20 @@ var BrowserSession = class extends EventEmitter {
 
 // src/client/BrowserManager.ts
 var BrowserManager = class {
-  constructor(httpClient) {
+  constructor(httpClient, local = false) {
     this.activeSessions = /* @__PURE__ */ new Map();
     this.httpClient = httpClient;
+    this.local = local;
   }
   /**
    * Create a new browser session
    */
   async createSession(options = {}) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        "Browser session management is not supported in local mode. Use navigate() or extractContent() with URL directly."
+      );
+    }
     const requestData = {
       viewport_width: options.viewportWidth || 1920,
       viewport_height: options.viewportHeight || 1080,
@@ -778,6 +773,77 @@ var BrowserManager = class {
     );
     this.activeSessions.clear();
   }
+  /**
+   * Navigate to a URL (local mode support - no session required)
+   */
+  async navigate(url, options = {}) {
+    if (!this.local) {
+      throw new UnsupportedOperationError(
+        "navigate() without session is only supported in local mode. In cloud mode, create a session first."
+      );
+    }
+    const requestData = {
+      url,
+      wait_timeout: options.waitTimeout || 3e4
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/navigate",
+        requestData
+      );
+      return {
+        success: response.success !== false,
+        url: response.url || url,
+        title: response.title,
+        status: response.status
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BrowserNavigationError(
+        `Navigation failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Extract LLM-friendly content (local mode support - no session required)
+   */
+  async extractContent(options = {}) {
+    if (!this.local) {
+      throw new UnsupportedOperationError(
+        "extractContent() without session is only supported in local mode. In cloud mode, create a session first."
+      );
+    }
+    if (!options.url) {
+      throw new BrowserInteractionError("url is required in local mode");
+    }
+    const requestData = {
+      url: options.url,
+      include_interactive: options.includeInteractive !== false,
+      include_anchors: options.includeAnchors !== false,
+      max_anchors: options.maxAnchors ?? 50
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/content",
+        requestData
+      );
+      return {
+        readableContent: {
+          ...response.readable_content || {},
+          content: response.readable_content?.content || ""
+        },
+        interactiveElements: response.interactive_elements,
+        contentAnchors: response.content_anchors
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BrowserInteractionError(
+        `Content extraction failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
   /**
    * Clean up resources
    */
@@ -791,34 +857,47 @@ import FormData from "form-data";
 var InstaVM = class {
   constructor(apiKey, options = {}) {
     this._sessionId = null;
-    if (!apiKey) {
-      throw new Error("API key is required");
+    this.local = options.local || false;
+    if (!this.local && !apiKey) {
+      throw new AuthenticationError("API key is required for cloud mode");
     }
     const config = {
-      baseURL: options.baseURL || "https://api.instavm.io",
+      baseURL: this.local ? options.localURL || "http://coderunner.local:8222" : options.baseURL || "https://api.instavm.io",
       timeout: options.timeout || 3e5,
       // 5 minutes
       maxRetries: options.maxRetries || 3,
       retryDelay: options.retryDelay || 1e3,
-      apiKey
+      apiKey: apiKey || ""
     };
     this.httpClient = new HTTPClient(config);
-    this.browser = new BrowserManager(this.httpClient);
+    this.browser = new BrowserManager(this.httpClient, this.local);
+  }
+  /**
+   * Ensure operation is not called in local mode
+   */
+  ensureNotLocal(operationName) {
+    if (this.local) {
+      throw new UnsupportedOperationError(
+        `${operationName} is not supported in local mode. This operation is only available when using the cloud API.`
+      );
+    }
   }
   /**
    * Execute code synchronously
    */
   async execute(command, options = {}) {
     let sessionId = options.sessionId || this._sessionId;
-    if (!sessionId) {
+    if (!this.local && !sessionId) {
       sessionId = await this.createSession();
     }
     const requestData = {
       command,
       language: options.language || "python",
-      timeout: options.timeout || 15,
-      session_id: sessionId
+      timeout: options.timeout || 15
     };
+    if (!this.local && sessionId) {
+      requestData.session_id = sessionId;
+    }
     try {
       const response = await this.httpClient.postExecution(
         "/execute",
@@ -848,6 +927,7 @@ var InstaVM = class {
    * Execute code asynchronously
    */
   async executeAsync(command, options = {}) {
+    this.ensureNotLocal("Async execution");
     let sessionId = options.sessionId || this._sessionId;
     if (!sessionId) {
       sessionId = await this.createSession();
@@ -889,6 +969,7 @@ var InstaVM = class {
    * Upload files to the execution environment
    */
   async upload(files, options = {}) {
+    this.ensureNotLocal("File upload");
     const formData = new FormData();
     for (const file of files) {
       if (Buffer.isBuffer(file.content)) {
@@ -931,6 +1012,7 @@ var InstaVM = class {
    * Create a new execution session
    */
   async createSession() {
+    this.ensureNotLocal("Session management");
     try {
       const response = await this.httpClient.post("/v1/sessions/session", {
         api_key: this.httpClient.apiKey
@@ -970,6 +1052,7 @@ var InstaVM = class {
    * Get usage statistics for a session
    */
   async getUsage(sessionId) {
+    this.ensureNotLocal("Usage tracking");
     const targetSessionId = sessionId || this._sessionId;
     if (!targetSessionId) {
       throw new SessionError("No active session to get usage for");
@@ -992,6 +1075,35 @@ var InstaVM = class {
       );
     }
   }
+  /**
+   * Download a file from the remote VM
+   */
+  async download(filename, options = {}) {
+    this.ensureNotLocal("File download");
+    const targetSessionId = options.sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("No active session to download from");
+    }
+    try {
+      const response = await this.httpClient.postRaw("/download", {
+        filename,
+        session_id: targetSessionId
+      });
+      const content = Buffer.from(response);
+      return {
+        success: true,
+        filename,
+        content,
+        size: content.length
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SessionError(
+        `File download failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
   /**
    * Get the current session ID
    */
@@ -1024,6 +1136,7 @@ export {
   NetworkError,
   QuotaExceededError,
   RateLimitError,
-  SessionError
+  SessionError,
+  UnsupportedOperationError
 };
 //# sourceMappingURL=index.mjs.map