glidercli 0.2.0 → 0.3.0

package/lib/bspawn.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * bspawn.js - Spawn multiple browser tabs in parallel via Glider
+ * 
+ * Usage:
+ *   bspawn <url1> <url2> ...           # Spawn tabs for each URL
+ *   bspawn -f urls.txt                 # Read URLs from file (one per line)
+ *   bspawn --json '["url1","url2"]'    # URLs as JSON array
+ *   cat urls.txt | bspawn -            # Read from stdin
+ * 
+ * Options:
+ *   --wait <ms>     Wait time after spawning (default: 3000)
+ *   --status        Show status after spawning
+ *   --quiet         Suppress output
+ * 
+ * Examples:
+ *   bspawn https://example.com https://google.com
+ *   bspawn -f /tmp/orr-urls.txt --wait 5000
+ *   echo "https://example.com" | bspawn -
+ */
+
+const WebSocket = require('ws');
+const fs = require('fs');
+
+const RELAY_URL = process.env.RELAY_URL || 'ws://127.0.0.1:19988/cdp';
+const DEFAULT_WAIT = 3000;
+
+async function spawnTabs(urls, options = {}) {
+  const { wait = DEFAULT_WAIT, quiet = false } = options;
+  
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(RELAY_URL);
+    let id = 0;
+    const results = [];
+    
+    ws.on('open', () => {
+      if (!quiet) console.error(`[bspawn] Spawning ${urls.length} tabs...`);
+      urls.forEach(url => {
+        ws.send(JSON.stringify({ 
+          id: ++id, 
+          method: 'Target.createTarget', 
+          params: { url } 
+        }));
+      });
+    });
+    
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data.toString());
+      if (msg.result?.targetId) {
+        results.push({ id: msg.id, targetId: msg.result.targetId });
+        if (!quiet) console.error(`[bspawn] Tab ${results.length}/${urls.length} created`);
+      }
+      if (msg.method === 'Target.attachedToTarget') {
+        if (!quiet) console.error(`[bspawn] Attached: ${msg.params?.targetInfo?.url?.substring(0, 60)}...`);
+      }
+      if (results.length === urls.length) {
+        setTimeout(() => {
+          ws.close();
+          resolve(results);
+        }, wait);
+      }
+    });
+    
+    ws.on('error', (err) => reject(new Error(`WebSocket error: ${err.message}`)));
+    
+    // Timeout after 30s
+    setTimeout(() => {
+      ws.close();
+      if (results.length > 0) resolve(results);
+      else reject(new Error('Timeout waiting for tabs to spawn'));
+    }, 30000);
+  });
+}
+
+async function getStatus() {
+  const http = require('http');
+  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 main() {
+  const args = process.argv.slice(2);
+  let urls = [];
+  let wait = DEFAULT_WAIT;
+  let showStatus = false;
+  let quiet = false;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--wait' || arg === '-w') {
+      wait = parseInt(args[++i], 10);
+    } else if (arg === '--status' || arg === '-s') {
+      showStatus = true;
+    } else if (arg === '--quiet' || arg === '-q') {
+      quiet = true;
+    } else if (arg === '-f' || arg === '--file') {
+      const file = args[++i];
+      urls = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean);
+    } else if (arg === '--json' || arg === '-j') {
+      urls = JSON.parse(args[++i]);
+    } else if (arg === '-') {
+      // Read from stdin
+      urls = fs.readFileSync(0, 'utf8').trim().split('\n').filter(Boolean);
+    } else if (arg === '--help' || arg === '-h') {
+      console.log(`
+bspawn - Spawn multiple browser tabs in parallel via Glider
+
+Usage:
+  bspawn <url1> <url2> ...           # Spawn tabs for each URL
+  bspawn -f urls.txt                 # Read URLs from file
+  bspawn --json '["url1","url2"]'    # URLs as JSON array
+  cat urls.txt | bspawn -            # Read from stdin
+
+Options:
+  -w, --wait <ms>   Wait time after spawning (default: 3000)
+  -s, --status      Show status after spawning
+  -q, --quiet       Suppress output
+  -h, --help        Show this help
+`);
+      process.exit(0);
+    } else if (arg.startsWith('http')) {
+      urls.push(arg);
+    }
+  }
+  
+  if (urls.length === 0) {
+    console.error('Error: No URLs provided');
+    process.exit(1);
+  }
+  
+  try {
+    const results = await spawnTabs(urls, { wait, quiet });
+    
+    if (showStatus) {
+      const targets = await getStatus();
+      console.log(JSON.stringify(targets.map(t => ({
+        sessionId: t.sessionId,
+        url: t.targetInfo?.url
+      })), null, 2));
+    } else if (!quiet) {
+      console.log(JSON.stringify(results, null, 2));
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/bwindow.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+/**
+ * bwindow.js - Multi-window/tab management for Glider
+ * 
+ * Commands:
+ *   glider window new [url]              Create new browser window
+ *   glider window close <targetId>       Close specific tab/window
+ *   glider window closeall               Close all tabs created by Glider
+ *   glider window list                   List all windows/tabs
+ *   glider window focus <targetId>       Bring tab to foreground
+ * 
+ * The key insight: tabs created with newWindow:true CAN be closed via Target.closeTarget
+ * Tabs created in the main window CANNOT be closed (Chrome security)
+ */
+
+const WebSocket = require('ws');
+
+const RELAY_URL = process.env.RELAY_URL || 'ws://127.0.0.1:19988/cdp';
+
+class WindowManager {
+  constructor() {
+    this.ws = null;
+    this.messageId = 0;
+    this.pending = new Map();
+    this.targets = new Map(); // targetId -> { sessionId, url, windowId, createdByGlider }
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(RELAY_URL);
+      this.ws.on('open', resolve);
+      this.ws.on('error', reject);
+      this.ws.on('message', (data) => this._handleMessage(JSON.parse(data.toString())));
+    });
+  }
+
+  _handleMessage(msg) {
+    if (msg.id !== undefined) {
+      const pending = this.pending.get(msg.id);
+      if (pending) {
+        this.pending.delete(msg.id);
+        msg.error ? pending.reject(new Error(JSON.stringify(msg.error))) : pending.resolve(msg.result);
+      }
+      return;
+    }
+
+    // Track targets
+    if (msg.method === 'Target.targetCreated') {
+      const info = msg.params.targetInfo;
+      if (info.type === 'page') {
+        this.targets.set(info.targetId, { 
+          targetId: info.targetId, 
+          url: info.url,
+          type: info.type
+        });
+      }
+    }
+
+    if (msg.method === 'Target.attachedToTarget') {
+      const { sessionId, targetInfo } = msg.params;
+      if (this.targets.has(targetInfo.targetId)) {
+        this.targets.get(targetInfo.targetId).sessionId = sessionId;
+      }
+    }
+
+    if (msg.method === 'Target.targetDestroyed') {
+      this.targets.delete(msg.params.targetId);
+    }
+  }
+
+  async send(method, params = {}) {
+    const id = ++this.messageId;
+    const msg = { id, method, params };
+    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: (r) => { clearTimeout(timer); resolve(r); },
+        reject: (e) => { clearTimeout(timer); reject(e); }
+      });
+    });
+  }
+
+  async init() {
+    // Enable target discovery
+    await this.send('Target.setDiscoverTargets', { discover: true });
+    await new Promise(r => setTimeout(r, 300));
+    
+    // Get existing targets
+    try {
+      const { targetInfos } = await this.send('Target.getTargets');
+      for (const info of targetInfos) {
+        if (info.type === 'page') {
+          this.targets.set(info.targetId, { 
+            targetId: info.targetId, 
+            url: info.url,
+            type: info.type
+          });
+        }
+      }
+    } catch (e) {
+      // Target.getTargets may not be supported by relay
+    }
+  }
+
+  /**
+   * Create a new browser window (not just a tab)
+   * Tabs in this window CAN be closed via Target.closeTarget
+   */
+  async createWindow(url = 'about:blank') {
+    const { targetId } = await this.send('Target.createTarget', { 
+      url,
+      newWindow: true  // CRITICAL: creates separate window
+    });
+    
+    // Wait for target to be ready
+    await new Promise(r => setTimeout(r, 500));
+    
+    // Attach to get sessionId
+    try {
+      const { sessionId } = await this.send('Target.attachToTarget', { 
+        targetId, 
+        flatten: true 
+      });
+      
+      this.targets.set(targetId, {
+        targetId,
+        sessionId,
+        url,
+        createdByGlider: true,
+        isWindow: true
+      });
+      
+      return { targetId, sessionId };
+    } catch (e) {
+      // May already be attached
+      return { targetId };
+    }
+  }
+
+  /**
+   * Create a tab in the current window (will go to focused window)
+   */
+  async createTab(url = 'about:blank') {
+    const { targetId } = await this.send('Target.createTarget', { url });
+    await new Promise(r => setTimeout(r, 500));
+    
+    try {
+      const { sessionId } = await this.send('Target.attachToTarget', { 
+        targetId, 
+        flatten: true 
+      });
+      
+      this.targets.set(targetId, {
+        targetId,
+        sessionId,
+        url,
+        createdByGlider: true,
+        isWindow: false
+      });
+      
+      return { targetId, sessionId };
+    } catch (e) {
+      return { targetId };
+    }
+  }
+
+  /**
+   * Close a specific tab/window
+   * Only works for tabs created with newWindow:true or via Target.createTarget
+   */
+  async closeTarget(targetId) {
+    try {
+      await this.send('Target.closeTarget', { targetId });
+      this.targets.delete(targetId);
+      return { success: true, targetId };
+    } catch (e) {
+      // Fallback: try window.close() via Runtime.evaluate
+      const target = this.targets.get(targetId);
+      if (target?.sessionId) {
+        try {
+          await this.send('Runtime.evaluate', {
+            expression: 'window.close()',
+            returnByValue: true
+          }, target.sessionId);
+          this.targets.delete(targetId);
+          return { success: true, targetId, method: 'window.close' };
+        } catch (e2) {
+          return { success: false, targetId, error: e2.message };
+        }
+      }
+      return { success: false, targetId, error: e.message };
+    }
+  }
+
+  /**
+   * Close all tabs created by Glider
+   */
+  async closeAll() {
+    const results = [];
+    for (const [targetId, info] of this.targets) {
+      if (info.createdByGlider) {
+        const result = await this.closeTarget(targetId);
+        results.push(result);
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Bring a tab to the foreground
+   */
+  async focusTarget(targetId) {
+    try {
+      await this.send('Target.activateTarget', { targetId });
+      return { success: true, targetId };
+    } catch (e) {
+      return { success: false, targetId, error: e.message };
+    }
+  }
+
+  /**
+   * List all targets
+   */
+  list() {
+    return Array.from(this.targets.values());
+  }
+
+  close() {
+    if (this.ws) this.ws.close();
+  }
+}
+
+// CLI
+async function main() {
+  const args = process.argv.slice(2);
+  const cmd = args[0];
+
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    console.log(`
+bwindow - Multi-window/tab management for Glider
+
+Commands:
+  new [url]              Create new browser window (closeable)
+  tab [url]              Create new tab in current window
+  close <targetId>       Close specific tab/window
+  closeall               Close all Glider-created tabs
+  list                   List all windows/tabs
+  focus <targetId>       Bring tab to foreground
+
+Examples:
+  bwindow new https://google.com
+  bwindow close ABC123DEF456
+  bwindow list
+`);
+    process.exit(0);
+  }
+
+  const wm = new WindowManager();
+
+  try {
+    await wm.connect();
+    await wm.init();
+
+    switch (cmd) {
+      case 'new':
+      case 'window': {
+        const url = args[1] || 'about:blank';
+        const result = await wm.createWindow(url);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'tab': {
+        const url = args[1] || 'about:blank';
+        const result = await wm.createTab(url);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'close': {
+        const targetId = args[1];
+        if (!targetId) {
+          console.error('Error: targetId required');
+          process.exit(1);
+        }
+        const result = await wm.closeTarget(targetId);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'closeall': {
+        const results = await wm.closeAll();
+        console.log(JSON.stringify(results, null, 2));
+        break;
+      }
+
+      case 'list': {
+        const targets = wm.list();
+        console.log(JSON.stringify(targets, null, 2));
+        break;
+      }
+
+      case 'focus': {
+        const targetId = args[1];
+        if (!targetId) {
+          console.error('Error: targetId required');
+          process.exit(1);
+        }
+        const result = await wm.focusTarget(targetId);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      default:
+        console.error(`Unknown command: ${cmd}`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    wm.close();
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { WindowManager };