instavm 0.2.1 → 0.3.0

package/README.md

@@ -75,6 +75,29 @@ const execution = await client.execute('python /remote/path/script.py', {
 console.log(execution.output);
 ```
 
+### File Download
+
+```typescript
+import { InstaVM } from 'instavm';
+import fs from 'fs';
+
+const client = new InstaVM('your_api_key');
+
+// Create a file in the remote environment
+await client.execute(`
+import pandas as pd
+df = pd.DataFrame({'name': ['Alice', 'Bob'], 'age': [25, 30]})
+df.to_csv('data.csv', index=False)
+`);
+
+// Download the file
+const result = await client.download('data.csv');
+console.log(`Downloaded ${result.size} bytes`);
+
+// Save to local file
+fs.writeFileSync('local-data.csv', result.content);
+```
+
 ### Error Handling
 
 ```typescript
@@ -432,6 +455,39 @@ console.log('Articles:', articles);
 console.log('Form fields:', formData);
 ```
 
+### LLM-Friendly Content Extraction
+
+```typescript
+// Extract clean, LLM-optimized content from a webpage
+const content = await session.extractContent({
+    includeInteractive: true,  // Include clickable/typeable elements
+    includeAnchors: true,       // Include content-to-selector mappings
+    maxAnchors: 50              // Limit number of anchors
+});
+
+// Get clean article text (no ads, no navigation, no scripts)
+console.log('Title:', content.readableContent.title);
+console.log('Article:', content.readableContent.content);
+console.log('Author:', content.readableContent.byline);
+
+// Find interactive elements (buttons, links, inputs)
+const loginButton = content.interactiveElements?.find(
+    el => el.text?.toLowerCase().includes('login')
+);
+if (loginButton) {
+    await session.click(loginButton.selector);
+}
+
+// Use content anchors to map text to selectors
+// Perfect for LLM agents that need to "read then click"
+const signupLink = content.contentAnchors?.find(
+    anchor => anchor.text.toLowerCase().includes('sign up')
+);
+if (signupLink) {
+    await session.click(signupLink.selector);
+}
+```
+
 ## Error Handling Reference
 
 ### Error Types
@@ -495,7 +551,8 @@ class InstaVM {
     
     // File operations
     upload(files: FileUpload[], options?: UploadOptions): Promise<UploadResult>
-    
+    download(filename: string, options?: DownloadOptions): Promise<DownloadResult>
+
     // Session management
     createSession(): Promise<string>
     closeSession(sessionId?: string): Promise<void>
@@ -565,7 +622,8 @@ class BrowserSession extends EventEmitter {
     // Data extraction
     screenshot(options?: ScreenshotOptions): Promise<string>
     extractElements(selector: string, attributes?: string[]): Promise<ExtractedElement[]>
-    
+    extractContent(options?: ExtractContentOptions): Promise<ExtractedContent>
+
     // Utilities
     wait(condition: WaitCondition, timeout?: number): Promise<void>
     close(): Promise<void>
@@ -750,11 +808,14 @@ main().catch(console.error);
 # Install dependencies
 npm install
 
-# Run unit tests
-npm test
+# Run unit tests (no API key required)
+npm run test:unit
 
 # Run integration tests (requires API key)
-INSTAVM_API_KEY=your_key npm run test:integration
+INSTAVM_API_KEY=your_api_key npm run test:integration
+
+# Run all tests
+npm test
 
 # Build the package
 npm run build
@@ -763,6 +824,8 @@ npm run build
 npm run type-check
 ```
 
+**Note:** Integration tests require a valid InstaVM API key. Set the `INSTAVM_API_KEY` environment variable before running integration tests. Unit tests do not require an API key.
+
 ### Contributing
 
 This is an official SDK. For issues and feature requests, please use the GitHub repository.
@@ -782,6 +845,22 @@ All rights reserved. No redistribution or modification permitted.
 
 ## Changelog
 
+### Version 0.3.0
+
+- ✅ **NEW**: File download functionality - Download files from remote VM
+- ✅ **NEW**: LLM-friendly content extraction - Extract clean, readable content with interactive element mapping
+- ✅ Enhanced browser automation with content anchors for intelligent LLM agents
+- ✅ Full API parity with Python SDK
+
+### Version 0.2.1
+
+- ✅ Bug fixes and improvements
+
+### Version 0.2.0
+
+- ✅ Enhanced session management
+- ✅ Improved error handling
+
 ### Version 0.1.0
 
 - ✅ Code execution fully functional (Python, Bash)

package/dist/index.d.mts

@@ -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 };