instavm 0.2.1 → 0.2.2

package/dist/index.d.ts

@@ -0,0 +1,424 @@
+import FormData from 'form-data';
+import { EventEmitter } from 'eventemitter3';
+
+interface ApiResponse<T = any> {
+    success?: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+interface HttpClientConfig {
+    baseURL: string;
+    timeout: number;
+    maxRetries: number;
+    retryDelay: number;
+    apiKey: string;
+}
+interface RequestConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    url: string;
+    headers?: Record<string, string>;
+    data?: any;
+    params?: Record<string, any>;
+    timeout?: number;
+}
+interface RetryConfig {
+    retries: number;
+    retryDelay: number;
+    retryCondition?: (error: any) => boolean;
+}
+
+/**
+ * HTTP client with authentication, retry logic, and error handling
+ */
+declare class HTTPClient {
+    private client;
+    private config;
+    get apiKey(): string;
+    constructor(config: HttpClientConfig);
+    private setupInterceptors;
+    /**
+     * Make an HTTP request with retry logic
+     */
+    request<T = any>(requestConfig: RequestConfig): Promise<T>;
+    /**
+     * POST request with JSON body
+     */
+    post<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * POST request for code execution (X-API-Key header is automatically added)
+     */
+    postExecution<T = any>(url: string, data: any, headers?: Record<string, string>): Promise<T>;
+    /**
+     * POST request with form data (for file uploads)
+     */
+    postFormData<T = any>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(url: string, headers?: Record<string, string>): Promise<T>;
+}
+
+interface BrowserSessionOptions {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    userAgent?: string;
+}
+interface BrowserSessionInfo {
+    sessionId: string;
+    status: 'active' | 'inactive' | 'closed';
+    createdAt: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    userAgent?: string;
+}
+interface NavigateOptions {
+    waitTimeout?: number;
+    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle';
+}
+interface NavigationResult {
+    success: boolean;
+    url: string;
+    title?: string;
+    status?: number;
+}
+interface ClickOptions {
+    timeout?: number;
+    button?: 'left' | 'right' | 'middle';
+    clickCount?: number;
+    force?: boolean;
+}
+interface TypeOptions {
+    timeout?: number;
+    delay?: number;
+    clear?: boolean;
+}
+interface FillOptions {
+    timeout?: number;
+    force?: boolean;
+}
+interface ScrollOptions {
+    x?: number;
+    y?: number;
+    behavior?: 'auto' | 'smooth';
+}
+interface ScreenshotOptions {
+    fullPage?: boolean;
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+type WaitCondition = {
+    type: 'visible';
+    selector: string;
+} | {
+    type: 'hidden';
+    selector: string;
+} | {
+    type: 'attached';
+    selector: string;
+} | {
+    type: 'detached';
+    selector: string;
+} | {
+    type: 'timeout';
+    ms: number;
+};
+interface ExtractedElement {
+    text?: string;
+    href?: string;
+    src?: string;
+    class?: string;
+    id?: string;
+    tagName?: string;
+    [attribute: string]: any;
+}
+interface ExtractOptions {
+    attributes?: string[];
+    maxResults?: number;
+}
+
+/**
+ * Browser session for automation
+ */
+declare class BrowserSession extends EventEmitter {
+    readonly sessionId: string;
+    private httpClient;
+    private _isActive;
+    constructor(sessionId: string, httpClient: HTTPClient);
+    /**
+     * Navigate to a URL
+     */
+    navigate(url: string, options?: NavigateOptions): Promise<NavigationResult>;
+    /**
+     * Click an element
+     */
+    click(selector: string, options?: ClickOptions): Promise<void>;
+    /**
+     * Type text into an element
+     */
+    type(selector: string, text: string, options?: TypeOptions): Promise<void>;
+    /**
+     * Fill a form field
+     */
+    fill(selector: string, value: string, options?: FillOptions): Promise<void>;
+    /**
+     * Scroll the page
+     */
+    scroll(options?: ScrollOptions): Promise<void>;
+    /**
+     * Take a screenshot
+     */
+    screenshot(options?: ScreenshotOptions): Promise<string>;
+    /**
+     * Extract elements from the page
+     */
+    extractElements(selector: string, attributes?: string[], options?: ExtractOptions): Promise<ExtractedElement[]>;
+    /**
+     * Wait for a condition
+     */
+    wait(condition: WaitCondition, timeout?: number): Promise<void>;
+    /**
+     * Close the browser session
+     */
+    close(): Promise<void>;
+    /**
+     * Check if session is active
+     */
+    get isActive(): boolean;
+    /**
+     * Ensure session is active before operations
+     */
+    private ensureActive;
+}
+
+/**
+ * Browser automation manager
+ */
+declare class BrowserManager {
+    private httpClient;
+    private activeSessions;
+    constructor(httpClient: HTTPClient);
+    /**
+     * Create a new browser session
+     */
+    createSession(options?: BrowserSessionOptions): Promise<BrowserSession>;
+    /**
+     * Get information about a specific session
+     */
+    getSession(sessionId: string): Promise<BrowserSessionInfo>;
+    /**
+     * List all browser sessions
+     */
+    listSessions(): Promise<BrowserSessionInfo[]>;
+    /**
+     * Get a locally tracked session
+     */
+    getLocalSession(sessionId: string): BrowserSession | undefined;
+    /**
+     * Get all locally tracked sessions
+     */
+    getLocalSessions(): BrowserSession[];
+    /**
+     * Close all active sessions
+     */
+    closeAllSessions(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    dispose(): Promise<void>;
+}
+
+interface ExecuteOptions {
+    language?: 'python' | 'bash';
+    timeout?: number;
+    sessionId?: string;
+}
+interface ExecutionResult {
+    output: string;
+    success: boolean;
+    executionTime: number;
+    sessionId?: string;
+    error?: string;
+}
+interface AsyncExecutionResult {
+    taskId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    output?: string;
+    success?: boolean;
+    executionTime?: number;
+    sessionId?: string;
+    error?: string;
+}
+interface FileUpload {
+    name: string;
+    content: Buffer | string;
+    path?: string;
+}
+interface UploadOptions {
+    sessionId?: string;
+    remotePath?: string;
+    recursive?: boolean;
+}
+interface UploadResult {
+    success: boolean;
+    files: string[];
+    message?: string;
+}
+interface UsageStats {
+    sessionsUsed: number;
+    executionTime: number;
+    quotaRemaining: number;
+    quotaLimit: number;
+}
+
+interface InstaVMOptions {
+    baseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+/**
+ * Main InstaVM client class
+ */
+declare class InstaVM {
+    private httpClient;
+    private _sessionId;
+    readonly browser: BrowserManager;
+    constructor(apiKey: string, options?: InstaVMOptions);
+    /**
+     * Execute code synchronously
+     */
+    execute(command: string, options?: ExecuteOptions): Promise<ExecutionResult>;
+    /**
+     * Execute code asynchronously
+     */
+    executeAsync(command: string, options?: ExecuteOptions): Promise<AsyncExecutionResult>;
+    /**
+     * Upload files to the execution environment
+     */
+    upload(files: FileUpload[], options?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Create a new execution session
+     */
+    createSession(): Promise<string>;
+    /**
+     * Close a session
+     */
+    closeSession(sessionId?: string): Promise<void>;
+    /**
+     * Get usage statistics for a session
+     */
+    getUsage(sessionId?: string): Promise<UsageStats>;
+    /**
+     * Get the current session ID
+     */
+    get sessionId(): string | null;
+    /**
+     * Clean up resources
+     */
+    dispose(): Promise<void>;
+}
+
+/**
+ * Base error class for all InstaVM SDK errors
+ */
+declare class InstaVMError extends Error {
+    readonly name: string;
+    readonly code?: string;
+    readonly statusCode?: number;
+    readonly response?: any;
+    constructor(message: string, options?: {
+        code?: string;
+        statusCode?: number;
+        response?: any;
+        cause?: Error;
+    });
+}
+/**
+ * Authentication-related errors (401, invalid API key, etc.)
+ */
+declare class AuthenticationError extends InstaVMError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Rate limiting errors (429)
+ */
+declare class RateLimitError extends InstaVMError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number, options?: any);
+}
+/**
+ * Quota/usage limit exceeded errors
+ */
+declare class QuotaExceededError extends InstaVMError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Network-related errors (timeouts, connection issues, 5xx errors)
+ */
+declare class NetworkError extends InstaVMError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Code execution errors
+ */
+declare class ExecutionError extends InstaVMError {
+    readonly executionOutput?: string;
+    readonly executionTime?: number;
+    constructor(message: string, executionOutput?: string, executionTime?: number, options?: any);
+}
+/**
+ * Session management errors
+ */
+declare class SessionError extends InstaVMError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Browser automation base error
+ */
+declare class BrowserError extends InstaVMError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Browser session management errors
+ */
+declare class BrowserSessionError extends BrowserError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Browser interaction errors (click, type, etc.)
+ */
+declare class BrowserInteractionError extends BrowserError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Browser timeout errors
+ */
+declare class BrowserTimeoutError extends BrowserError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Browser navigation errors
+ */
+declare class BrowserNavigationError extends BrowserError {
+    constructor(message?: string, options?: any);
+}
+/**
+ * Element not found errors
+ */
+declare class ElementNotFoundError extends BrowserError {
+    readonly selector?: string;
+    constructor(message?: string, selector?: string, options?: any);
+}
+
+export { type ApiResponse, type AsyncExecutionResult, AuthenticationError, BrowserError, BrowserInteractionError, BrowserManager, BrowserNavigationError, BrowserSession, BrowserSessionError, type BrowserSessionInfo, type BrowserSessionOptions, BrowserTimeoutError, type ClickOptions, ElementNotFoundError, type ExecuteOptions, ExecutionError, type ExecutionResult, type ExtractOptions, type ExtractedElement, type FileUpload, type FillOptions, type HttpClientConfig, InstaVM, InstaVMError, type InstaVMOptions, type NavigateOptions, type NavigationResult, NetworkError, QuotaExceededError, RateLimitError, type RequestConfig, type RetryConfig, type ScreenshotOptions, type ScrollOptions, SessionError, type TypeOptions, type UploadOptions, type UploadResult, type UsageStats, type WaitCondition };

package/dist/index.js

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,92 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.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/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -173,6 +262,14 @@ 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;
@@ -184,7 +281,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/${getPackageVersion()}`
       }
     });
     this.setupInterceptors();
@@ -192,7 +289,7 @@ var HTTPClient = class {
   setupInterceptors() {
     this.client.interceptors.request.use(
       (config) => {
-        if (config.url?.includes("/browser/")) {
+        if (!config.headers["X-API-Key"] && !config.url?.includes("/v1/sessions/session")) {
           config.headers["X-API-Key"] = this.config.apiKey;
         }
         return config;
@@ -281,18 +378,14 @@ var HTTPClient = class {
     });
   }
   /**
-   * POST request for code execution (uses X-API-Key header like Python client)
+   * POST request for code execution (X-API-Key header is automatically added)
    */
   async postExecution(url, data, headers) {
-    const requestHeaders = {
-      "X-API-Key": this.config.apiKey,
-      ...headers
-    };
     return this.request({
       method: "POST",
       url,
       data,
-      headers: requestHeaders
+      headers
     });
   }
   /**