instavm 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,495 @@
+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 (uses X-API-Key header like Python client)
+     */
+    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>;
+    /**
+     * POST request that returns raw binary data (for file downloads)
+     */
+    postRaw(url: string, data?: any, headers?: Record<string, string>): Promise<ArrayBuffer>;
+}
+
+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;
+}
+interface ExtractContentOptions {
+    includeInteractive?: boolean;
+    includeAnchors?: boolean;
+    maxAnchors?: number;
+}
+interface InteractiveElement {
+    type: 'button' | 'link' | 'input' | 'select' | 'textarea';
+    selector: string;
+    text?: string;
+    label?: string;
+    placeholder?: string;
+    value?: string;
+}
+interface ContentAnchor {
+    text: string;
+    selector: string;
+}
+interface ExtractedContent {
+    readableContent: {
+        content: string;
+        title?: string;
+        byline?: string;
+        excerpt?: string;
+        siteName?: string;
+    };
+    interactiveElements?: InteractiveElement[];
+    contentAnchors?: ContentAnchor[];
+}
+
+/**
+ * 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[]>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    extractContent(options?: ExtractContentOptions): Promise<ExtractedContent>;
+    /**
+     * 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 DownloadOptions {
+    sessionId?: string;
+}
+interface DownloadResult {
+    success: boolean;
+    filename: string;
+    content: Buffer;
+    size: 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>;
+    /**
+     * Download a file from the remote VM
+     */
+    download(filename: string, options?: DownloadOptions): Promise<DownloadResult>;
+    /**
+     * 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, type ContentAnchor, type DownloadOptions, type DownloadResult, ElementNotFoundError, type ExecuteOptions, ExecutionError, type ExecutionResult, type ExtractContentOptions, type ExtractOptions, type ExtractedContent, type ExtractedElement, type FileUpload, type FillOptions, type HttpClientConfig, InstaVM, InstaVMError, type InstaVMOptions, type InteractiveElement, 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

@@ -331,6 +331,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
@@ -557,6 +582,59 @@ var BrowserSession = class extends import_eventemitter3.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
    */
@@ -948,6 +1026,34 @@ var InstaVM = class {
       );
     }
   }
+  /**
+   * Download a file from the remote VM
+   */
+  async download(filename, options = {}) {
+    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
    */