TypeScript/Node.js SDK

import { Grasp } from '@grasplabs/grasp';
import { chromium } from 'playwright';

async function main() {
  // Create Grasp instance with API key
  const grasp = new Grasp({
    apiKey: process.env.GRASP_KEY || 'your_api_key_here'
  });

  // Launch a new session
  const session = await grasp.launch({
    browser: {
      type: 'chrome-stable',
      headless: false,
      adblock: true
    },
    keepAliveMS: 300000, // Keep session alive for 5 minutes
    timeout: 3600000,    // Max session duration: 1 hour
    debug: true
  });

  console.log('Session ID:', session.id);

  // Connect to the browser using Playwright
  const browser = await chromium.connectOverCDP(session.browser.getEndpoint(), {
    timeout: 150000,
  });

  // Create page and navigate
  const page = await browser.newPage();
  await page.goto('https://getgrasp.ai/', { waitUntil: 'domcontentloaded' });
  await page.screenshot({ path: 'grasp-ai.png' });

  // Use session services
  await session.files.uploadFile('./local-file.txt', '/home/user/remote-file.txt');
  const fileContent = await session.files.readFile('/home/user/remote-file.txt');
  console.log('File content:', fileContent);

  // Run terminal commands
  const command = await session.terminal.runCommand('ls -la /home/user');
  command.stdout.pipe(process.stdout);
  await command.end();

  // Clean up resources
  await page.close();
  await browser.close();
  await session.close();

  console.log('✅ Task finished.');
}

main();

const grasp = new Grasp({
  apiKey: 'your_api_key_here'
});

const session = await grasp.launch({
  browser: {
    type: 'chrome-stable',
    headless: false,
    adblock: true,
    liveview: true
  },
  keepAliveMS: 300000,
  timeout: 3600000,
  debug: true,
  logLevel: 'debug'
});

const session = await grasp.connect('existing-session-id');

const session = await grasp.launch();
console.log('Session ID:', session.id);

// Use session services
const browser = session.browser;
const terminal = session.terminal;
const files = session.files;
const codeRunner = session.codeRunner;

// Get host for port 3000
const host = session.getHost(3000);

// Close session when done
await session.close();

import { chromium } from 'playwright';

const session = await grasp.launch();
const browser = await chromium.connectOverCDP(session.browser.getEndpoint(), {
  timeout: 150000
});

// Use browser as normal Playwright browser instance
const page = await browser.newPage();
// ... your automation code

await browser.close();
await session.close();

const session = await grasp.launch();
const browser = session.browser;

// Get browser endpoint for Playwright connection
const endpoint = browser.getEndpoint();
const playwright = await chromium.connectOverCDP(endpoint);

// Get live view URLs (experimental)
const streamUrl = await browser.getLiveviewStreamingUrl();
const previewUrl = await browser.getLiveviewPageUrl();

// Download replay video (experimental)
await browser.downloadReplayVideo('./replay.mp4');

const session = await grasp.launch();
const terminal = session.terminal;

// Run a simple command
const command = await terminal.runCommand('ls -la /home/user');

// Pipe output to console
command.stdout.pipe(process.stdout);
command.stderr.pipe(process.stderr);

// Wait for completion
await command.end();

// Run command with options
const command2 = await terminal.runCommand('npm install', {
  cwd: '/home/user/project',
  envs: { NODE_ENV: 'development' },
  timeoutMs: 300000
});

// Get result as JSON
const result = await command2.json();
console.log('Exit code:', result.exitCode);
console.log('Output:', result.stdout);

const session = await grasp.launch();
const files = session.files;

// Upload a file
await files.uploadFile('./local-config.json', '/home/user/config.json');

// Write content to remote file
await files.writeFile('/home/user/script.py', 'print("Hello World")');

// Read file content
const content = await files.readFile('/home/user/config.json');
console.log('Config:', JSON.parse(content));

// Read binary file
const binaryData = await files.readFile('/home/user/image.png', {
  encoding: 'binary'
});

// Download a file
await files.downloadFile('/home/user/output.txt', './downloaded-output.txt');

// Sync downloads directory (experimental)
const localDir = await files.syncDownloadsDirectory('./downloads');
console.log('Downloads synced to:', localDir);

const session = await grasp.launch();
const codeRunner = session.codeRunner;

// Run Python code
const pythonCode = `
import requests
response = requests.get('https://api.github.com/users/octocat')
print(f"Status: {response.status_code}")
print(f"User: {response.json()['name']}")
`;

const pythonResult = await codeRunner.run(pythonCode, {
  timeout: 60000
});
console.log('Python output:', pythonResult.stdout);

// Run JavaScript code
const jsCode = `
const fs = require('fs');
const data = { message: 'Hello from Node.js!' };
fs.writeFileSync('/home/user/downloads/output.json', JSON.stringify(data, null, 2));
console.log('File written successfully');
`;

const jsResult = await codeRunner.run(jsCode, {
  syncDir: './my-outputs'
});
console.log('JavaScript output:', jsResult.stdout);
console.log('Output directory:', jsResult.outputDir);

// Run Playwright code with automatic injection
const playwrightCode = `
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()  # This will be auto-injected with CDP connection
    page = browser.new_page()
    page.goto('https://example.com')
    page.screenshot(path='/home/user/downloads/example.png')
    browser.close()
`;

const playwrightResult = await codeRunner.run(playwrightCode, {
  inject: true,  // Automatically inject browser connection
  timeout: 120000
});
console.log('Playwright execution completed');

import { Grasp } from '@grasplabs/grasp';
import { chromium } from 'playwright';

async function multiplePages() {
  const grasp = new Grasp();
  const session = await grasp.launch({
    browser: { type: 'chrome-stable' },
    timeout: 3600000,
  });

  const browser = await chromium.connectOverCDP(session.browser.getEndpoint(), {
    timeout: 150000,
  });

  // Create multiple contexts for isolation
  const context1 = await browser.newContext();
  const context2 = await browser.newContext();

  // Pages in different contexts
  const page1 = await context1.newPage();
  const page2 = await context2.newPage();

  // Navigate to different sites
  await Promise.all([
    page1.goto('https://example.com'),
    page2.goto('https://httpbin.org/json')
  ]);

  // Take screenshots and save to downloads
  await Promise.all([
    page1.screenshot({ path: '/home/user/downloads/example.png' }),
    page2.screenshot({ path: '/home/user/downloads/httpbin.png' })
  ]);

  // Download screenshots to local
  await session.files.downloadFile('/home/user/downloads/example.png', './example.png');
  await session.files.downloadFile('/home/user/downloads/httpbin.png', './httpbin.png');

  // Clean up
  await context1.close();
  await context2.close();
  await browser.close();
  await session.close();
}

import { Grasp } from '@grasplabs/grasp';
import { chromium } from 'playwright';

async function robustAutomation() {
  const grasp = new Grasp();
  let session;
  let browser;
  
  try {
    session = await grasp.launch({
      browser: { type: 'chrome-stable' },
      timeout: 300000,
    });

    browser = await chromium.connectOverCDP(session.browser.getEndpoint(), {
      timeout: 150000,
    });

    const page = await browser.newPage();
    
    // Set timeouts
    page.setDefaultTimeout(30000);
    page.setDefaultNavigationTimeout(60000);
    
    await page.goto('https://example.com');
    
    // Wait for element with error handling
    try {
      await page.waitForSelector('#some-element', { timeout: 10000 });
      await page.click('#some-element');
    } catch (error) {
      console.log('Element not found, continuing with alternative flow');
      // Alternative action
      await page.click('body');
    }
    
    // Take screenshot for debugging and download
    await page.screenshot({ path: '/home/user/downloads/debug.png' });
    await session.files.downloadFile('/home/user/downloads/debug.png', './debug.png');
    
  } catch (error) {
    console.error('Automation failed:', error);
    
    // Take error screenshot if browser is available
    if (browser && session) {
      try {
        const page = await browser.newPage();
        await page.screenshot({ path: '/home/user/downloads/error.png' });
        await session.files.downloadFile('/home/user/downloads/error.png', './error.png');
      } catch (screenshotError) {
        console.error('Failed to take error screenshot:', screenshotError);
      }
    }
    
    throw error;
  } finally {
    // Cleanup
    if (browser) {
      await browser.close();
    }
    if (session) {
      await session.close();
    }
  }
}

import { Grasp } from '@grasplabs/grasp';
import { chromium } from 'playwright';

class BrowserManager {
  private grasp: Grasp;
  private session: any;
  private browser: any;

  constructor() {
    this.grasp = new Grasp();
  }

  async initialize() {
    this.session = await this.grasp.launch({
      browser: { type: 'chrome-stable' },
      timeout: 3600000,
    });

    this.browser = await chromium.connectOverCDP(this.session.browser.getEndpoint(), {
      timeout: 150000,
    });
  }

  async cleanup() {
    if (this.browser) {
      await this.browser.close();
      this.browser = null;
    }
    if (this.session) {
      await this.session.close();
      this.session = null;
    }
  }

  async withPage<T>(callback: (page: any) => Promise<T>): Promise<T> {
    const page = await this.browser.newPage();
    try {
      return await callback(page);
    } finally {
      await page.close();
    }
  }

  // Access to session services
  get files() {
    return this.session?.files;
  }

  get terminal() {
    return this.session?.terminal;
  }

  get codeRunner() {
    return this.session?.codeRunner;
  }
}

// Usage
const manager = new BrowserManager();
try {
  await manager.initialize();
  
  const result = await manager.withPage(async (page) => {
    await page.goto('https://example.com');
    await page.screenshot({ path: '/home/user/downloads/example.png' });
    return await page.title();
  });
  
  console.log('Page title:', result);
  
  // Download the screenshot
  await manager.files.downloadFile('/home/user/downloads/example.png', './example.png');
} finally {
  await manager.cleanup();
}