glidercli 0.2.0 → 0.3.0

package/lib/bextract.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * bextract.js - Extract content from multiple browser tabs in parallel via Glider
+ * 
+ * Usage:
+ *   bextract                          # Extract from all connected tabs
+ *   bextract --sessions s1,s2,s3      # Extract from specific sessions
+ *   bextract --exclude session-1      # Exclude specific sessions
+ *   bextract --js 'document.title'    # Custom JS expression
+ *   bextract --selector '.content'    # Extract specific element
+ * 
+ * Options:
+ *   --js <expr>         JavaScript expression to evaluate (default: document.body.innerText)
+ *   --selector <sel>    CSS selector to extract
+ *   --sessions <list>   Comma-separated session IDs
+ *   --exclude <list>    Comma-separated sessions to exclude
+ *   --limit <n>         Max characters per result (default: 10000)
+ *   --timeout <ms>      Timeout per extraction (default: 15000)
+ *   --json              Output as JSON
+ *   --quiet             Suppress progress output
+ * 
+ * Examples:
+ *   bextract --exclude session-1 --limit 5000
+ *   bextract --js 'document.title' --json
+ *   bextract --selector 'article' --sessions session-2,session-3
+ */
+
+const WebSocket = require('ws');
+const http = require('http');
+
+const RELAY_URL = process.env.RELAY_URL || 'ws://127.0.0.1:19988/cdp';
+const DEFAULT_LIMIT = 10000;
+const DEFAULT_TIMEOUT = 15000;
+
+async function getTargets() {
+  return new Promise((resolve) => {
+    http.get('http://127.0.0.1:19988/targets', (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(JSON.parse(data)));
+    }).on('error', () => resolve([]));
+  });
+}
+
+async function extractFromSession(sessionId, jsExpr, options = {}) {
+  const { timeout = DEFAULT_TIMEOUT, limit = DEFAULT_LIMIT } = options;
+  
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(RELAY_URL);
+    let resolved = false;
+    
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        ws.close();
+        reject(new Error(`Timeout for ${sessionId}`));
+      }
+    }, timeout);
+    
+    ws.on('open', () => {
+      ws.send(JSON.stringify({
+        id: 1,
+        sessionId,
+        method: 'Runtime.evaluate',
+        params: { 
+          expression: jsExpr,
+          returnByValue: true 
+        }
+      }));
+    });
+    
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data.toString());
+      if (msg.id === 1 && !resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        ws.close();
+        
+        if (msg.error) {
+          reject(new Error(msg.error.message));
+        } else {
+          let value = msg.result?.result?.value;
+          if (typeof value === 'string' && value.length > limit) {
+            value = value.substring(0, limit) + `\n... [truncated at ${limit} chars]`;
+          }
+          resolve(value);
+        }
+      }
+    });
+    
+    ws.on('error', (err) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  });
+}
+
+async function extractParallel(sessions, jsExpr, options = {}) {
+  const { quiet = false } = options;
+  const results = {};
+  
+  const promises = sessions.map(async ({ sessionId, url }) => {
+    try {
+      if (!quiet) console.error(`[bextract] Extracting from ${sessionId}...`);
+      const content = await extractFromSession(sessionId, jsExpr, options);
+      results[sessionId] = { url, content, error: null };
+    } catch (err) {
+      results[sessionId] = { url, content: null, error: err.message };
+    }
+  });
+  
+  await Promise.all(promises);
+  return results;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  let jsExpr = 'document.body.innerText';
+  let selector = null;
+  let sessions = null;
+  let exclude = [];
+  let limit = DEFAULT_LIMIT;
+  let timeout = DEFAULT_TIMEOUT;
+  let outputJson = false;
+  let quiet = false;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--js' || arg === '-e') {
+      jsExpr = args[++i];
+    } else if (arg === '--selector' || arg === '-s') {
+      selector = args[++i];
+    } else if (arg === '--sessions') {
+      sessions = args[++i].split(',');
+    } else if (arg === '--exclude' || arg === '-x') {
+      exclude = args[++i].split(',');
+    } else if (arg === '--limit' || arg === '-l') {
+      limit = parseInt(args[++i], 10);
+    } else if (arg === '--timeout' || arg === '-t') {
+      timeout = parseInt(args[++i], 10);
+    } else if (arg === '--json' || arg === '-j') {
+      outputJson = true;
+    } else if (arg === '--quiet' || arg === '-q') {
+      quiet = true;
+    } else if (arg === '--help' || arg === '-h') {
+      console.log(`
+bextract - Extract content from multiple browser tabs in parallel
+
+Usage:
+  bextract                          # Extract from all connected tabs
+  bextract --sessions s1,s2,s3      # Extract from specific sessions
+  bextract --exclude session-1      # Exclude specific sessions
+  bextract --js 'document.title'    # Custom JS expression
+  bextract --selector '.content'    # Extract specific element
+
+Options:
+  -e, --js <expr>       JavaScript expression (default: document.body.innerText)
+  -s, --selector <sel>  CSS selector to extract
+  --sessions <list>     Comma-separated session IDs
+  -x, --exclude <list>  Sessions to exclude
+  -l, --limit <n>       Max chars per result (default: ${DEFAULT_LIMIT})
+  -t, --timeout <ms>    Timeout per extraction (default: ${DEFAULT_TIMEOUT})
+  -j, --json            Output as JSON
+  -q, --quiet           Suppress progress output
+  -h, --help            Show this help
+`);
+      process.exit(0);
+    }
+  }
+  
+  // Build JS expression
+  if (selector) {
+    jsExpr = `document.querySelector('${selector}')?.innerText || ''`;
+  }
+  
+  try {
+    // Get targets
+    const targets = await getTargets();
+    if (targets.length === 0) {
+      console.error('Error: No browser tabs connected. Click extension icon on tabs first.');
+      process.exit(1);
+    }
+    
+    // Filter sessions
+    let filteredTargets = targets;
+    if (sessions) {
+      filteredTargets = targets.filter(t => sessions.includes(t.sessionId));
+    }
+    if (exclude.length > 0) {
+      filteredTargets = filteredTargets.filter(t => !exclude.includes(t.sessionId));
+    }
+    
+    if (filteredTargets.length === 0) {
+      console.error('Error: No matching sessions found');
+      process.exit(1);
+    }
+    
+    if (!quiet) {
+      console.error(`[bextract] Extracting from ${filteredTargets.length} tabs in parallel...`);
+    }
+    
+    // Extract in parallel
+    const results = await extractParallel(
+      filteredTargets.map(t => ({ sessionId: t.sessionId, url: t.targetInfo?.url })),
+      jsExpr,
+      { limit, timeout, quiet }
+    );
+    
+    // Output
+    if (outputJson) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      for (const [sessionId, data] of Object.entries(results)) {
+        console.log(`\n${'='.repeat(60)}`);
+        console.log(`SESSION: ${sessionId}`);
+        console.log(`URL: ${data.url}`);
+        console.log('='.repeat(60));
+        if (data.error) {
+          console.log(`ERROR: ${data.error}`);
+        } else {
+          console.log(data.content);
+        }
+      }
+    }
+    
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/bfetch.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * fetch-via-browser.js
+ * Fetch URLs using your authenticated browser session via CDP relay
+ * 
+ * Usage:
+ *   ./fetch-via-browser.js <url> [--output file.json]
+ *   ./fetch-via-browser.js https://www.reddit.com/r/programming.json
+ */
+
+const WebSocket = require('ws');
+
+const RELAY_URL = process.env.RELAY_URL || 'ws://127.0.0.1:19988/cdp';
+
+class BrowserFetcher {
+  constructor() {
+    this.ws = null;
+    this.messageId = 0;
+    this.pending = new Map();
+    this.sessionId = null;
+    this.targetId = null;
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(RELAY_URL);
+      
+      this.ws.on('open', () => {
+        console.error('[fetcher] Connected to relay');
+        resolve();
+      });
+      
+      this.ws.on('error', (err) => {
+        reject(new Error(`Connection failed: ${err.message}`));
+      });
+      
+      this.ws.on('message', (data) => {
+        const msg = JSON.parse(data.toString());
+        
+        // Response to our command
+        if (msg.id !== undefined) {
+          const pending = this.pending.get(msg.id);
+          if (pending) {
+            this.pending.delete(msg.id);
+            if (msg.error) {
+              pending.reject(new Error(msg.error.message));
+            } else {
+              pending.resolve(msg.result);
+            }
+          }
+          return;
+        }
+        
+        // Event
+        if (msg.method === 'Target.attachedToTarget') {
+          if (!this.sessionId) {
+            this.sessionId = msg.params.sessionId;
+            this.targetId = msg.params.targetInfo.targetId;
+            console.error(`[fetcher] Got target: ${msg.params.targetInfo.url}`);
+          }
+        }
+      });
+    });
+  }
+
+  async send(method, params = {}, sessionId = null) {
+    const id = ++this.messageId;
+    const msg = { id, method, params };
+    if (sessionId) msg.sessionId = sessionId;
+    
+    this.ws.send(JSON.stringify(msg));
+    
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timeout: ${method}`));
+      }, 30000);
+      
+      this.pending.set(id, {
+        resolve: (result) => { clearTimeout(timer); resolve(result); },
+        reject: (error) => { clearTimeout(timer); reject(error); }
+      });
+    });
+  }
+
+  async init() {
+    // Initialize connection to browser
+    await this.send('Target.setAutoAttach', {
+      autoAttach: true,
+      waitForDebuggerOnStart: false,
+      flatten: true
+    });
+    
+    // Wait for target
+    if (!this.sessionId) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    
+    if (!this.sessionId) {
+      throw new Error('No browser tab connected. Click the extension icon on a tab first.');
+    }
+    
+    // Enable Runtime for evaluation
+    await this.send('Runtime.enable', {}, this.sessionId);
+  }
+
+  async fetch(url) {
+    console.error(`[fetcher] Fetching: ${url}`);
+    
+    // Use browser's fetch API with its cookies
+    const script = `
+      (async () => {
+        const response = await fetch(${JSON.stringify(url)}, {
+          credentials: 'include',
+          headers: {
+            'Accept': 'application/json, text/plain, */*'
+          }
+        });
+        
+        const contentType = response.headers.get('content-type') || '';
+        const status = response.status;
+        
+        let body;
+        if (contentType.includes('application/json')) {
+          body = await response.json();
+        } else {
+          body = await response.text();
+        }
+        
+        return { status, contentType, body };
+      })()
+    `;
+    
+    const result = await this.send('Runtime.evaluate', {
+      expression: script,
+      awaitPromise: true,
+      returnByValue: true
+    }, this.sessionId);
+    
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.text || 'Evaluation failed');
+    }
+    
+    return result.result.value;
+  }
+
+  async navigate(url) {
+    console.error(`[fetcher] Navigating to: ${url}`);
+    await this.send('Page.navigate', { url }, this.sessionId);
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+
+  async getPageContent() {
+    const result = await this.send('Runtime.evaluate', {
+      expression: 'document.documentElement.outerHTML',
+      returnByValue: true
+    }, this.sessionId);
+    return result.result.value;
+  }
+
+  async screenshot(path) {
+    const result = await this.send('Page.captureScreenshot', {
+      format: 'png'
+    }, this.sessionId);
+    
+    const fs = require('fs');
+    fs.writeFileSync(path, Buffer.from(result.data, 'base64'));
+    console.error(`[fetcher] Screenshot saved: ${path}`);
+  }
+
+  close() {
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Usage: fetch-via-browser [options] <url>
+
+Fetch URLs using your authenticated browser session.
+Requires the relay server running and extension connected.
+
+Options:
+  --output, -o <file>  Save output to file
+  --raw                Output raw response (don't pretty-print JSON)
+  --navigate           Navigate to URL instead of fetching via XHR
+  --screenshot <file>  Take screenshot after fetching
+  --help, -h           Show this help
+
+Examples:
+  fetch-via-browser https://www.reddit.com/r/programming.json
+  fetch-via-browser -o result.json https://www.reddit.com/user/spez/about.json
+  fetch-via-browser --navigate --screenshot shot.png https://old.reddit.com/r/webdev
+`);
+    process.exit(0);
+  }
+  
+  let url = null;
+  let outputFile = null;
+  let raw = false;
+  let navigate = false;
+  let screenshot = null;
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--output' || args[i] === '-o') {
+      outputFile = args[++i];
+    } else if (args[i] === '--raw') {
+      raw = true;
+    } else if (args[i] === '--navigate') {
+      navigate = true;
+    } else if (args[i] === '--screenshot') {
+      screenshot = args[++i];
+    } else if (!args[i].startsWith('-')) {
+      url = args[i];
+    }
+  }
+  
+  if (!url) {
+    console.error('Error: URL required');
+    process.exit(1);
+  }
+  
+  const fetcher = new BrowserFetcher();
+  
+  try {
+    await fetcher.connect();
+    await fetcher.init();
+    
+    let result;
+    
+    if (navigate) {
+      await fetcher.navigate(url);
+      result = await fetcher.getPageContent();
+    } else {
+      result = await fetcher.fetch(url);
+    }
+    
+    if (screenshot) {
+      await fetcher.screenshot(screenshot);
+    }
+    
+    // Output
+    let output;
+    if (typeof result === 'object') {
+      if (result.body && typeof result.body === 'object') {
+        output = raw ? JSON.stringify(result.body) : JSON.stringify(result.body, null, 2);
+      } else {
+        output = raw ? JSON.stringify(result) : JSON.stringify(result, null, 2);
+      }
+    } else {
+      output = result;
+    }
+    
+    if (outputFile) {
+      require('fs').writeFileSync(outputFile, output);
+      console.error(`[fetcher] Saved to: ${outputFile}`);
+    } else {
+      console.log(output);
+    }
+    
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    fetcher.close();
+  }
+}
+
+main();

package/lib/bserve.js

@@ -33,6 +33,18 @@ const server = http.createServer((req, res) => {
   } else if (req.url === '/targets') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(Array.from(connectedTargets.values())));
+  } else if (req.url === '/attach' && req.method === 'POST') {
+    // Trigger extension to attach active tab
+    (async () => {
+      try {
+        const result = await sendToExtension({ method: 'attachActiveTab', params: {} });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(result));
+      } catch (e) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    })();
   } else if (req.url === '/cdp' && req.method === 'POST') {
     // HTTP POST endpoint for CDP commands
     let body = '';
@@ -111,6 +123,8 @@ function handleExtensionConnection(ws) {
 }
 
 function handleExtensionMessage(msg) {
+  console.log('[relay] Extension message:', JSON.stringify(msg).slice(0, 200));
+  
   // Response to our request
   if (msg.id !== undefined) {
     const pending = pendingRequests.get(msg.id);
@@ -235,6 +249,24 @@ async function sendToExtension({ method, params, timeout = 30000 }) {
 }
 
 async function routeCDPCommand({ method, params, sessionId }) {
+  // Target.* commands that operate at browser level don't need sessionId
+  const browserLevelCommands = [
+    'Target.createTarget',
+    'Target.closeTarget', 
+    'Target.activateTarget',
+    'Target.getTargets',
+    'Target.setAutoAttach',
+    'Target.setDiscoverTargets',
+    'Target.attachToTarget',
+    'Target.getTargetInfo',
+    'Browser.getVersion'
+  ];
+  
+  // Auto-pick first session only for session-scoped commands
+  if (!sessionId && connectedTargets.size > 0 && !browserLevelCommands.includes(method)) {
+    sessionId = Array.from(connectedTargets.values())[0].sessionId;
+  }
+  
   // Handle some commands locally
   switch (method) {
     case 'Browser.getVersion':
@@ -257,13 +289,10 @@ async function routeCDPCommand({ method, params, sessionId }) {
       };
     
     case 'Target.attachToTarget':
-      const targetId = params?.targetId;
-      for (const target of connectedTargets.values()) {
-        if (target.targetId === targetId) {
-          return { sessionId: target.sessionId };
-        }
-      }
-      throw new Error(`Target ${targetId} not found`);
+      // Forward to extension - it handles the actual attachment
+      // The extension will send back Target.attachedToTarget event
+      console.log(`[relay] Forwarding Target.attachToTarget to extension for target: ${params?.targetId}`);
+      break;
     
     case 'Target.getTargetInfo':
       if (params?.targetId) {
@@ -279,6 +308,13 @@ async function routeCDPCommand({ method, params, sessionId }) {
       }
       const first = Array.from(connectedTargets.values())[0];
       return { targetInfo: first?.targetInfo };
+    
+    case 'Target.createTarget':
+    case 'Target.closeTarget':
+    case 'Target.activateTarget':
+      // These MUST go to extension - they control browser windows/tabs
+      console.log(`[relay] Forwarding ${method} to extension:`, JSON.stringify(params).slice(0, 100));
+      break;
   }
   
   // Forward to extension