glidercli 0.1.5 → 0.3.0

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

package/lib/cdp-direct.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+/**
+ * cdp-direct.js - Direct Chrome DevTools Protocol connection
+ * No relay, no extension, no bullshit. Just straight to Chrome.
+ * 
+ * Chrome must be running with --remote-debugging-port=9222
+ */
+
+const WebSocket = require('ws');
+const http = require('http');
+
+const DEBUG_PORT = process.env.GLIDER_DEBUG_PORT || 9222;
+const DEBUG_HOST = '127.0.0.1';
+
+class DirectCDP {
+  constructor() {
+    this.ws = null;
+    this.messageId = 0;
+    this.pending = new Map();
+    this.targetId = null;
+    this.sessionId = null;
+  }
+
+  // Get list of debuggable targets from Chrome
+  async getTargets() {
+    return new Promise((resolve, reject) => {
+      http.get(`http://${DEBUG_HOST}:${DEBUG_PORT}/json/list`, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error('Failed to parse targets'));
+          }
+        });
+      }).on('error', reject);
+    });
+  }
+
+  // Get Chrome version info
+  async getVersion() {
+    return new Promise((resolve, reject) => {
+      http.get(`http://${DEBUG_HOST}:${DEBUG_PORT}/json/version`, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error('Failed to parse version'));
+          }
+        });
+      }).on('error', reject);
+    });
+  }
+
+  // Connect to a specific target (tab)
+  async connect(targetOrUrl) {
+    let wsUrl;
+    
+    if (typeof targetOrUrl === 'string' && targetOrUrl.startsWith('ws://')) {
+      wsUrl = targetOrUrl;
+    } else {
+      // Find target by URL pattern or use first page
+      const targets = await this.getTargets();
+      let target;
+      
+      if (typeof targetOrUrl === 'string') {
+        target = targets.find(t => t.url?.includes(targetOrUrl) && t.type === 'page');
+      }
+      if (!target) {
+        target = targets.find(t => t.type === 'page' && !t.url?.startsWith('chrome://') && !t.url?.startsWith('devtools://'));
+      }
+      if (!target) {
+        target = targets.find(t => t.type === 'page');
+      }
+      if (!target) {
+        throw new Error('No debuggable page found');
+      }
+      
+      wsUrl = target.webSocketDebuggerUrl;
+      this.targetId = target.id;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(wsUrl);
+      
+      this.ws.on('open', async () => {
+        // Enable required domains
+        await this.send('Runtime.enable');
+        await this.send('Page.enable');
+        resolve();
+      });
+      
+      this.ws.on('error', reject);
+      
+      this.ws.on('message', (data) => {
+        const msg = JSON.parse(data.toString());
+        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);
+            }
+          }
+        }
+      });
+      
+      this.ws.on('close', () => {
+        this.ws = null;
+      });
+    });
+  }
+
+  // Send CDP command
+  async send(method, params = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected');
+    }
+    
+    const id = ++this.messageId;
+    this.ws.send(JSON.stringify({ id, method, params }));
+    
+    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); }
+      });
+    });
+  }
+
+  // High-level helpers
+  async evaluate(expression) {
+    const result = await this.send('Runtime.evaluate', {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.text || 'Evaluation failed');
+    }
+    return result.result?.value;
+  }
+
+  async navigate(url) {
+    return this.send('Page.navigate', { url });
+  }
+
+  async screenshot(format = 'png') {
+    return this.send('Page.captureScreenshot', { format });
+  }
+
+  async getTitle() {
+    return this.evaluate('document.title');
+  }
+
+  async getUrl() {
+    return this.evaluate('window.location.href');
+  }
+
+  async getText() {
+    return this.evaluate('document.body.innerText');
+  }
+
+  async getHtml(selector) {
+    if (selector) {
+      return this.evaluate(`document.querySelector('${selector}')?.outerHTML`);
+    }
+    return this.evaluate('document.documentElement.outerHTML');
+  }
+
+  async click(selector) {
+    return this.evaluate(`
+      (() => {
+        const el = document.querySelector('${selector}');
+        if (!el) throw new Error('Element not found: ${selector}');
+        el.click();
+        return true;
+      })()
+    `);
+  }
+
+  async type(selector, text) {
+    return this.evaluate(`
+      (() => {
+        const el = document.querySelector('${selector}');
+        if (!el) throw new Error('Element not found: ${selector}');
+        el.focus();
+        el.value = '${text.replace(/'/g, "\\'")}';
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        return true;
+      })()
+    `);
+  }
+
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+
+// Check if Chrome debugging is available
+async function checkChrome() {
+  try {
+    const cdp = new DirectCDP();
+    const version = await cdp.getVersion();
+    return { ok: true, version };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// Export for use as module
+module.exports = { DirectCDP, checkChrome, DEBUG_PORT, DEBUG_HOST };
+
+// CLI mode
+if (require.main === module) {
+  const cmd = process.argv[2];
+  const arg = process.argv.slice(3).join(' ');
+  
+  (async () => {
+    const cdp = new DirectCDP();
+    
+    try {
+      if (cmd === 'check' || cmd === 'status') {
+        const check = await checkChrome();
+        if (check.ok) {
+          console.log('Chrome debugging available');
+          console.log('Browser:', check.version.Browser);
+          const targets = await cdp.getTargets();
+          console.log('Tabs:', targets.filter(t => t.type === 'page').length);
+        } else {
+          console.error('Chrome debugging not available:', check.error);
+          console.error('Run: glider chrome-start');
+          process.exit(1);
+        }
+        return;
+      }
+      
+      if (cmd === 'targets' || cmd === 'tabs') {
+        const targets = await cdp.getTargets();
+        targets.filter(t => t.type === 'page').forEach((t, i) => {
+          console.log(`[${i + 1}] ${t.title}`);
+          console.log(`    ${t.url}`);
+        });
+        return;
+      }
+      
+      // Commands that need connection
+      await cdp.connect();
+      
+      switch (cmd) {
+        case 'eval':
+          const result = await cdp.evaluate(arg || 'document.title');
+          console.log(JSON.stringify(result, null, 2));
+          break;
+        case 'title':
+          console.log(await cdp.getTitle());
+          break;
+        case 'url':
+          console.log(await cdp.getUrl());
+          break;
+        case 'text':
+          console.log(await cdp.getText());
+          break;
+        case 'html':
+          console.log(await cdp.getHtml(arg));
+          break;
+        case 'goto':
+          await cdp.navigate(arg);
+          console.log('Navigated to:', arg);
+          break;
+        case 'click':
+          await cdp.click(arg);
+          console.log('Clicked:', arg);
+          break;
+        case 'screenshot':
+          const ss = await cdp.screenshot();
+          const path = arg || `/tmp/screenshot-${Date.now()}.png`;
+          require('fs').writeFileSync(path, Buffer.from(ss.data, 'base64'));
+          console.log('Screenshot saved:', path);
+          break;
+        default:
+          console.log('Usage: cdp-direct <command> [args]');
+          console.log('Commands: check, targets, eval, title, url, text, html, goto, click, screenshot');
+      }
+    } catch (e) {
+      console.error('Error:', e.message);
+      process.exit(1);
+    } finally {
+      cdp.close();
+    }
+  })();
+}

package/lib/glider-daemon.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Glider daemon - respawns relay forever, fuck launchd throttling
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+BSERVE="$SCRIPT_DIR/bserve.js"
+LOG_DIR="$HOME/.glider"
+PID_FILE="$LOG_DIR/daemon.pid"
+
+mkdir -p "$LOG_DIR"
+
+# Kill any existing
+if [ -f "$PID_FILE" ]; then
+  kill $(cat "$PID_FILE") 2>/dev/null
+  rm "$PID_FILE"
+fi
+
+echo $$ > "$PID_FILE"
+
+cleanup() {
+  rm -f "$PID_FILE"
+  exit 0
+}
+trap cleanup SIGTERM SIGINT
+
+while true; do
+  echo "[$(date)] Starting relay..." >> "$LOG_DIR/daemon.log"
+  node "$BSERVE" >> "$LOG_DIR/daemon.log" 2>&1
+  EXIT_CODE=$?
+  echo "[$(date)] Relay exited with code $EXIT_CODE, restarting in 2s..." >> "$LOG_DIR/daemon.log"
+  sleep 2
+done

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glidercli",
-  "version": "0.1.5",
+  "version": "0.3.0",
   "description": "Browser automation CLI with autonomous loop execution. Control Chrome via CDP, run YAML task files, execute in Ralph Wiggum loops.",
   "main": "index.js",
   "bin": {
@@ -33,5 +33,11 @@
   "dependencies": {
     "ws": "^8.18.0",
     "yaml": "^2.7.0"
-  }
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "index.js",
+    "README.md"
+  ]
 }

package/.git-personal-enforced

@@ -1,4 +0,0 @@
-# This repository enforces personal git config only
-# DO NOT use git-amazon or any other corporate git configs
-ENFORCED_DATE=2026-01-10
-REQUIRED_CONFIG=personal