glidercli 0.1.5 → 0.3.0

package/bin/glider.js

@@ -31,11 +31,16 @@ const YAML = require('yaml');
 
 // Config
 const PORT = process.env.GLIDER_PORT || 19988;
+const DEBUG_PORT = process.env.GLIDER_DEBUG_PORT || 9222;
 const SERVER_URL = `http://127.0.0.1:${PORT}`;
-const SCRIPTS_DIR = process.env.SCRIPTS || path.join(os.homedir(), 'scripts');
+const DEBUG_URL = `http://127.0.0.1:${DEBUG_PORT}`;
+const LIB_DIR = path.join(__dirname, '..', 'lib');
 const STATE_FILE = '/tmp/glider-state.json';
 const LOG_FILE = '/tmp/glider.log';
 
+// Direct CDP module
+const { DirectCDP, checkChrome } = require(path.join(LIB_DIR, 'cdp-direct.js'));
+
 // Domain extensions - load from ~/.cursor/glider/domains.json or ~/.glider/domains.json
 const DOMAIN_CONFIG_PATHS = [
   path.join(os.homedir(), '.cursor', 'glider', 'domains.json'),
@@ -51,7 +56,7 @@ for (const cfgPath of DOMAIN_CONFIG_PATHS) {
   }
 }
 
-// Colors
+// Colors - matching the deep blue gradient logo
 const RED = '\x1b[31m';
 const GREEN = '\x1b[32m';
 const YELLOW = '\x1b[33m';
@@ -63,25 +68,30 @@ const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
 const NC = '\x1b[0m';
 
-// Gradient colors for rainbow effect
-const G1 = '\x1b[38;5;51m';   // cyan
-const G2 = '\x1b[38;5;45m';   // teal
-const G3 = '\x1b[38;5;39m';   // blue
-const G4 = '\x1b[38;5;33m';   // deeper blue
-const G5 = '\x1b[38;5;27m';   // indigo
-const G6 = '\x1b[38;5;21m';   // purple
+// Deep blue gradient (matching logo)
+const B1 = '\x1b[38;5;17m';   // darkest navy
+const B2 = '\x1b[38;5;18m';   // dark navy
+const B3 = '\x1b[38;5;19m';   // navy
+const B4 = '\x1b[38;5;20m';   // blue
+const B5 = '\x1b[38;5;27m';   // bright blue
+const B6 = '\x1b[38;5;33m';   // sky blue
+const BW = '\x1b[38;5;255m';  // white (for glider icon)
 
-// Banner - simple ASCII, works everywhere
+// Banner - hang glider ASCII art matching logo
 const BANNER = `
-${CYAN}  ------------------------------------------------------->${NC}
-${CYAN}       _____ ${BLUE}__    ${MAGENTA}__ ${CYAN}____  ${BLUE}_____ ${MAGENTA}____  ${NC}
-${CYAN}      / ____|${BLUE}| |   ${MAGENTA}| |${CYAN}|  _ \\${BLUE}| ____|${MAGENTA}|  _ \\ ${NC}
-${CYAN}     | |  __ ${BLUE}| |   ${MAGENTA}| |${CYAN}| | | ${BLUE}|  _| ${MAGENTA}| |_) |${NC}
-${CYAN}     | | |_ |${BLUE}| |   ${MAGENTA}| |${CYAN}| | | ${BLUE}| |___${MAGENTA}|  _ < ${NC}
-${CYAN}     | |__| |${BLUE}| |___${MAGENTA}| |${CYAN}| |_| ${BLUE}| ____|${MAGENTA}| | \\ \\${NC}
-${CYAN}      \\_____|${BLUE}|_____|${MAGENTA}__|${CYAN}|____/${BLUE}|_____|${MAGENTA}|_|  \\_\\${NC}
-${CYAN}  ------------------------------------------------------->${NC}
-${DIM}       Browser Automation CLI ${WHITE}v${require('../package.json').version}${NC}  ${DIM}|${NC}  ${CYAN}github.com/vdutts7/glidercli${NC}
+${B1}    ╔══════════════════════════════════════════════════════════╗${NC}
+${B2}    ║${NC}                                                          ${B2}║${NC}
+${B3}    ║${NC}  ${BW}        ___________________________________${NC}             ${B3}║${NC}
+${B4}    ║${NC}  ${BW}       ╲                                   ╲${NC}            ${B4}║${NC}
+${B5}    ║${NC}  ${BW}        ╲___________________________________╲${NC}           ${B5}║${NC}
+${B5}    ║${NC}  ${BW}         ╲                                 ╱${NC}            ${B5}║${NC}
+${B6}    ║${NC}  ${BW}          ╲_______________________________╱${NC}             ${B6}║${NC}
+${B6}    ║${NC}                                                          ${B6}║${NC}
+${B5}    ║${NC}     ${BW}${BOLD}G L I D E R${NC}                                        ${B5}║${NC}
+${B4}    ║${NC}     ${DIM}Browser Automation CLI${NC}  ${B5}v${require('../package.json').version}${NC}                    ${B4}║${NC}
+${B3}    ║${NC}     ${DIM}github.com/vdutts7/glidercli${NC}                          ${B3}║${NC}
+${B2}    ║${NC}                                                          ${B2}║${NC}
+${B1}    ╚══════════════════════════════════════════════════════════╝${NC}
 `;
 
 function showBanner() {
@@ -91,12 +101,26 @@ function showBanner() {
 const log = {
   ok: (msg) => console.error(`${GREEN}✓${NC} ${msg}`),
   fail: (msg) => console.error(`${RED}✗${NC} ${msg}`),
-  info: (msg) => console.error(`${BLUE}→${NC} ${msg}`),
-  warn: (msg) => console.error(`${YELLOW}!${NC} ${msg}`),
-  step: (msg) => console.error(`${CYAN}[STEP]${NC} ${msg}`),
+  info: (msg) => console.error(`${B5}→${NC} ${msg}`),
+  warn: (msg) => console.error(`${YELLOW}⚠${NC} ${msg}`),
+  step: (msg) => console.error(`${B6}▸${NC} ${msg}`),
   result: (msg) => console.log(msg),
+  box: (title) => {
+    const line = '─'.repeat(50);
+    console.log(`${B3}┌${line}┐${NC}`);
+    console.log(`${B4}│${NC} ${BW}${BOLD}${title.padEnd(48)}${NC} ${B4}│${NC}`);
+    console.log(`${B5}└${line}┘${NC}`);
+  },
 };
 
+// macOS notification helper
+function notify(title, message, sound = false) {
+  try {
+    const soundFlag = sound ? 'sound name "Ping"' : '';
+    execSync(`osascript -e 'display notification "${message}" with title "${title}" ${soundFlag}'`, { stdio: 'ignore' });
+  } catch {}
+}
+
 // HTTP helpers
 function httpGet(urlPath) {
   return new Promise((resolve, reject) => {
@@ -179,31 +203,32 @@ async function getTargets() {
 // Commands
 async function cmdStatus() {
   showBanner();
-  console.log('═══════════════════════════════════════');
-  console.log('  STATUS');
-  console.log('═══════════════════════════════════════');
+  log.box('STATUS');
   
   const serverOk = await checkServer();
-  console.log(serverOk ? `${GREEN}✓${NC} Server running on port ${PORT}` : `${RED}✗${NC} Server not running`);
+  console.log(serverOk ? `  ${GREEN}✓${NC} Server running on port ${PORT}` : `  ${RED}✗${NC} Server not running`);
   
   if (serverOk) {
     const extOk = await checkExtension();
-    console.log(extOk ? `${GREEN}✓${NC} Extension connected` : `${RED}✗${NC} Extension not connected`);
+    console.log(extOk ? `  ${GREEN}✓${NC} Extension connected` : `  ${RED}✗${NC} Extension not connected`);
     
     if (extOk) {
       const targets = await getTargets();
       if (targets.length > 0) {
-        console.log(`${GREEN}✓${NC} ${targets.length} tab(s) connected:`);
+        console.log(`  ${GREEN}✓${NC} ${targets.length} tab(s) connected:`);
         targets.forEach(t => {
           const url = t.targetInfo?.url || 'unknown';
-          console.log(`      ${CYAN}${url}${NC}`);
+          console.log(`      ${B5}${url}${NC}`);
         });
       } else {
-        console.log(`${YELLOW}!${NC} No tabs connected`);
+        console.log(`  ${YELLOW}⚠${NC} No tabs connected`);
+        console.log(`      ${DIM}Run: glider connect${NC}`);
       }
     }
+  } else {
+    console.log(`      ${DIM}Run: glider install${NC}`);
   }
-  console.log('═══════════════════════════════════════');
+  console.log();
 }
 
 async function cmdStart() {
@@ -213,7 +238,7 @@ async function cmdStart() {
   }
   
   log.info('Starting glider server...');
-  const bserve = path.join(SCRIPTS_DIR, 'bserve');
+  const bserve = path.join(LIB_DIR, 'bserve.js');
   
   if (!fs.existsSync(bserve)) {
     log.fail(`bserve not found at ${bserve}`);
@@ -401,6 +426,621 @@ async function cmdText() {
   }
 }
 
+// ═══════════════════════════════════════════════════════════════════
+// NEW COMMANDS: restart, test, tabs, domains, open, html, title, url
+// ═══════════════════════════════════════════════════════════════════
+
+async function cmdRestart() {
+  await cmdStop();
+  await new Promise(r => setTimeout(r, 500));
+  await cmdStart();
+}
+
+// Daemon management - runs forever, respawns on crash
+async function cmdInstallDaemon() {
+  const home = os.homedir();
+  const daemonScript = path.join(LIB_DIR, 'glider-daemon.sh');
+  const logDir = path.join(home, '.glider');
+  const pidFile = path.join(logDir, 'daemon.pid');
+  
+  // Create log directory
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  
+  // Kill existing daemon
+  if (fs.existsSync(pidFile)) {
+    try {
+      const pid = fs.readFileSync(pidFile, 'utf8').trim();
+      execSync(`kill ${pid} 2>/dev/null || true`, { stdio: 'ignore' });
+    } catch {}
+  }
+  
+  // Start daemon in background, detached from terminal
+  const child = spawn('nohup', [daemonScript], {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore'],
+    cwd: home
+  });
+  child.unref();
+  
+  await new Promise(r => setTimeout(r, 1000));
+  
+  if (fs.existsSync(pidFile)) {
+    log.ok('Daemon started');
+    log.info('Relay will auto-restart on crash');
+    log.info(`Logs: ${logDir}/daemon.log`);
+    log.info(`PID: ${fs.readFileSync(pidFile, 'utf8').trim()}`);
+  } else {
+    log.fail('Daemon failed to start');
+  }
+}
+
+async function cmdUninstallDaemon() {
+  const home = os.homedir();
+  const pidFile = path.join(home, '.glider', 'daemon.pid');
+  
+  if (!fs.existsSync(pidFile)) {
+    log.info('Daemon not running');
+    return;
+  }
+  
+  try {
+    const pid = fs.readFileSync(pidFile, 'utf8').trim();
+    execSync(`kill ${pid}`, { stdio: 'ignore' });
+    fs.unlinkSync(pidFile);
+    log.ok('Daemon stopped');
+  } catch (e) {
+    log.fail(`Failed to stop: ${e.message}`);
+  }
+}
+
+async function cmdConnect() {
+  // Bulletproof connect: relay + Chrome + trigger attach via HTTP
+  log.info('Connecting...');
+  
+  // 1. Ensure relay is running
+  if (!await checkServer()) {
+    await cmdStart();
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  
+  // 2. Ensure Chrome is running
+  try {
+    execSync('pgrep -x "Google Chrome"', { stdio: 'ignore' });
+  } catch {
+    log.info('Starting Chrome...');
+    execSync('open -a "Google Chrome"');
+    await new Promise(r => setTimeout(r, 3000));
+  }
+  
+  // 3. Wait for extension to connect to relay
+  for (let i = 0; i < 10; i++) {
+    if (await checkExtension()) break;
+    await new Promise(r => setTimeout(r, 500));
+  }
+  
+  if (!await checkExtension()) {
+    log.fail('Extension not connected to relay');
+    log.info('Make sure Glider extension is installed in Chrome');
+    process.exit(1);
+  }
+  log.ok('Extension connected');
+  
+  // Wait for extension to fully initialize
+  await new Promise(r => setTimeout(r, 500));
+  
+  // 4. Check if already have targets
+  if (await checkTab()) {
+    log.ok('Already connected to tab(s)');
+    const targets = await getTargets();
+    targets.slice(0, 3).forEach(t => {
+      console.log(`  ${CYAN}${t.targetInfo?.url || 'unknown'}${NC}`);
+    });
+    return;
+  }
+  
+  // 5. Ensure we have a real tab (not chrome://)
+  try {
+    const tabUrl = execSync(`osascript -e 'tell application "Google Chrome" to return URL of active tab of front window'`).toString().trim();
+    if (tabUrl.startsWith('chrome://') || tabUrl.startsWith('chrome-extension://')) {
+      log.info('Creating new tab...');
+      execSync(`osascript -e 'tell application "Google Chrome" to make new tab at front window with properties {URL:"https://google.com"}'`);
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  } catch {
+    // No window, create one
+    log.info('Creating new window...');
+    execSync(`osascript -e 'tell application "Google Chrome" to make new window with properties {URL:"https://google.com"}'`);
+    await new Promise(r => setTimeout(r, 2000));
+  }
+  
+  // 6. Trigger attach via HTTP endpoint (no pixel clicking needed!)
+  log.info('Attaching to tab...');
+  try {
+    const result = await fetch(`${SERVER_URL}/attach`, { method: 'POST' });
+    const data = await result.json();
+    
+    if (data.attached > 0) {
+      log.ok('Connected!');
+      const targets = await getTargets();
+      targets.slice(0, 3).forEach(t => {
+        console.log(`  ${CYAN}${t.targetInfo?.url || 'unknown'}${NC}`);
+      });
+      return;
+    }
+  } catch (e) {
+    log.warn(`Attach failed: ${e.message}`);
+  }
+  
+  // 7. Fallback: create fresh tab and retry
+  log.info('Creating fresh tab...');
+  execSync(`osascript -e 'tell application "Google Chrome" to make new tab at front window with properties {URL:"https://google.com"}'`);
+  await new Promise(r => setTimeout(r, 2000));
+  
+  try {
+    const result = await fetch(`${SERVER_URL}/attach`, { method: 'POST' });
+    const data = await result.json();
+    
+    if (data.attached > 0) {
+      log.ok('Connected!');
+      const targets = await getTargets();
+      targets.slice(0, 3).forEach(t => {
+        console.log(`  ${CYAN}${t.targetInfo?.url || 'unknown'}${NC}`);
+      });
+      return;
+    }
+  } catch {}
+  
+  // 8. Need manual click - open Chrome and show instructions
+  log.warn('Click the Glider extension icon in Chrome');
+  console.log(`  ${B5}(on any real webpage, not chrome:// pages)${NC}`);
+  execSync(`osascript -e 'tell application "Google Chrome" to activate'`);
+  
+  // Send macOS notification so user sees it even if not looking at terminal
+  notify('Glider', 'Click the extension icon in Chrome to connect', true);
+  
+  // Wait for user to click
+  log.info('Waiting for connection...');
+  for (let i = 0; i < 30; i++) {
+    await new Promise(r => setTimeout(r, 1000));
+    if (await checkTab()) {
+      log.ok('Connected!');
+      notify('Glider', 'Connected to browser');
+      const targets = await getTargets();
+      targets.slice(0, 3).forEach(t => {
+        console.log(`  ${B5}${t.targetInfo?.url || 'unknown'}${NC}`);
+      });
+      return;
+    }
+  }
+  
+  log.fail('Timed out waiting for connection');
+  notify('Glider', 'Connection timed out - click extension icon', true);
+  log.info('Make sure you clicked the extension icon on a real webpage');
+}
+
+async function cmdTest() {
+  showBanner();
+  log.box('DIAGNOSTICS');
+  
+  // Test 1: Server
+  const serverOk = await checkServer();
+  console.log(serverOk ? `  ${GREEN}✓${NC} ${B5}[1/4]${NC} Server` : `  ${RED}✗${NC} ${B5}[1/4]${NC} Server`);
+  if (!serverOk) {
+    log.info('Starting server...');
+    await cmdStart();
+  }
+  
+  // Test 2: Extension
+  const extOk = await checkExtension();
+  console.log(extOk ? `  ${GREEN}✓${NC} ${B5}[2/4]${NC} Extension` : `  ${RED}✗${NC} ${B5}[2/4]${NC} Extension`);
+  
+  // Test 3: Tab
+  const tabOk = await checkTab();
+  console.log(tabOk ? `  ${GREEN}✓${NC} ${B5}[3/4]${NC} Tab attached` : `  ${RED}✗${NC} ${B5}[3/4]${NC} No tabs`);
+  
+  // Test 4: CDP command
+  if (tabOk) {
+    try {
+      const result = await httpPost('/cdp', {
+        method: 'Runtime.evaluate',
+        params: { expression: '1+1', returnByValue: true }
+      });
+      const cdpOk = result.result?.value === 2;
+      console.log(cdpOk ? `${GREEN}[4/4]${NC} CDP: OK` : `${RED}[4/4]${NC} CDP: FAIL`);
+    } catch {
+      console.log(`${RED}[4/4]${NC} CDP: FAIL`);
+    }
+  } else {
+    console.log(`${YELLOW}[4/4]${NC} CDP: SKIPPED (no tab)`);
+  }
+  
+  console.log('═══════════════════════════════════════');
+}
+
+async function cmdTabs() {
+  const targets = await getTargets();
+  if (targets.length === 0) {
+    log.warn('No tabs connected');
+    return;
+  }
+  console.log(`${GREEN}${targets.length}${NC} tab(s) connected:\n`);
+  targets.forEach((t, i) => {
+    const url = t.targetInfo?.url || 'unknown';
+    const title = t.targetInfo?.title || '';
+    console.log(`  ${CYAN}[${i + 1}]${NC} ${title}`);
+    console.log(`      ${DIM}${url}${NC}`);
+  });
+}
+
+async function cmdWindow(args) {
+  const { WindowManager } = require(path.join(LIB_DIR, 'bwindow.js'));
+  const wm = new WindowManager();
+  
+  try {
+    await wm.connect();
+    await wm.init();
+    
+    const subcmd = args[0] || 'list';
+    
+    switch (subcmd) {
+      case 'new':
+      case 'create': {
+        const url = args[1] || 'about:blank';
+        log.info(`Creating new window: ${url}`);
+        const result = await wm.createWindow(url);
+        log.ok(`Window created: ${result.targetId}`);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      
+      case 'tab': {
+        const url = args[1] || 'about:blank';
+        log.info(`Creating new tab: ${url}`);
+        const result = await wm.createTab(url);
+        log.ok(`Tab created: ${result.targetId}`);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+      
+      case 'close': {
+        const targetId = args[1];
+        if (!targetId) {
+          log.fail('targetId required');
+          return;
+        }
+        log.info(`Closing: ${targetId}`);
+        const result = await wm.closeTarget(targetId);
+        if (result.success) {
+          log.ok(`Closed: ${targetId}`);
+        } else {
+          log.fail(`Failed to close: ${result.error}`);
+        }
+        break;
+      }
+      
+      case 'closeall': {
+        log.info('Closing all Glider-created tabs...');
+        const results = await wm.closeAll();
+        const success = results.filter(r => r.success).length;
+        log.ok(`Closed ${success}/${results.length} tabs`);
+        break;
+      }
+      
+      case 'focus': {
+        const targetId = args[1];
+        if (!targetId) {
+          log.fail('targetId required');
+          return;
+        }
+        const result = await wm.focusTarget(targetId);
+        if (result.success) {
+          log.ok(`Focused: ${targetId}`);
+        } else {
+          log.fail(`Failed to focus: ${result.error}`);
+        }
+        break;
+      }
+      
+      case 'list':
+      default: {
+        const targets = wm.list();
+        if (targets.length === 0) {
+          log.warn('No windows/tabs tracked');
+        } else {
+          console.log(`${GREEN}${targets.length}${NC} target(s):\n`);
+          targets.forEach((t, i) => {
+            const marker = t.createdByGlider ? `${GREEN}●${NC}` : `${DIM}○${NC}`;
+            console.log(`  ${marker} ${CYAN}${t.targetId.substring(0, 16)}...${NC}`);
+            console.log(`      ${DIM}${t.url || 'unknown'}${NC}`);
+          });
+        }
+        break;
+      }
+    }
+  } catch (err) {
+    log.fail(err.message);
+  } finally {
+    wm.close();
+  }
+}
+
+async function cmdDomains() {
+  const domainKeys = Object.keys(DOMAINS);
+  if (domainKeys.length === 0) {
+    log.warn('No domains configured');
+    log.info('Add domains to ~/.cursor/glider/domains.json or ~/.glider/domains.json');
+    return;
+  }
+  console.log(`${GREEN}${domainKeys.length}${NC} domain(s) configured:\n`);
+  for (const key of domainKeys) {
+    const d = DOMAINS[key];
+    const type = d.script ? 'script' : 'url';
+    const target = d.script || d.url || '';
+    console.log(`  ${CYAN}${key}${NC} ${DIM}(${type})${NC}`);
+    if (d.description) console.log(`      ${d.description}`);
+    console.log(`      ${DIM}${target}${NC}`);
+  }
+}
+
+async function cmdOpen(url) {
+  if (!url) {
+    log.fail('Usage: glider open <url>');
+    process.exit(1);
+  }
+  
+  // Open URL in default browser (not in connected tab)
+  const { exec } = require('child_process');
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  exec(`${cmd} "${url}"`, (err) => {
+    if (err) {
+      log.fail(`Failed to open: ${err.message}`);
+      process.exit(1);
+    }
+    log.ok(`Opened: ${url}`);
+  });
+}
+
+async function cmdHtml(selector) {
+  try {
+    const expression = selector 
+      ? `document.querySelector('${selector.replace(/'/g, "\\'")}')?.outerHTML || 'Element not found'`
+      : 'document.documentElement.outerHTML';
+    
+    const result = await httpPost('/cdp', {
+      method: 'Runtime.evaluate',
+      params: { expression, returnByValue: true }
+    });
+    console.log(result.result?.value || '');
+  } catch (e) {
+    log.fail(`HTML extraction failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function cmdTitle() {
+  try {
+    const result = await httpPost('/cdp', {
+      method: 'Runtime.evaluate',
+      params: { expression: 'document.title', returnByValue: true }
+    });
+    console.log(result.result?.value || '');
+  } catch (e) {
+    log.fail(`Title extraction failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+async function cmdUrl() {
+  try {
+    const result = await httpPost('/cdp', {
+      method: 'Runtime.evaluate',
+      params: { expression: 'window.location.href', returnByValue: true }
+    });
+    console.log(result.result?.value || '');
+  } catch (e) {
+    log.fail(`URL extraction failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// Fetch URL using browser session (authenticated)
+async function cmdFetch(url, opts = []) {
+  if (!url) {
+    log.fail('Usage: glider fetch <url> [--output file]');
+    process.exit(1);
+  }
+  
+  log.info(`Fetching: ${url}`);
+  
+  let outputFile = null;
+  for (let i = 0; i < opts.length; i++) {
+    if (opts[i] === '--output' || opts[i] === '-o') {
+      outputFile = opts[++i];
+    }
+  }
+  
+  try {
+    const result = await httpPost('/cdp', {
+      method: 'Runtime.evaluate',
+      params: {
+        expression: `
+          (async () => {
+            const resp = await fetch(${JSON.stringify(url)});
+            const text = await resp.text();
+            try { return JSON.parse(text); } catch { return text; }
+          })()
+        `,
+        awaitPromise: true,
+        returnByValue: true
+      }
+    });
+    
+    const data = result?.result?.value;
+    const output = typeof data === 'object' ? JSON.stringify(data, null, 2) : data;
+    
+    if (outputFile) {
+      fs.writeFileSync(outputFile, output);
+      log.ok(`Saved to ${outputFile}`);
+    } else {
+      console.log(output);
+    }
+  } catch (e) {
+    log.fail(`Fetch failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// Spawn multiple tabs
+async function cmdSpawn(urls) {
+  if (!urls || urls.length === 0) {
+    log.fail('Usage: glider spawn <url1> <url2> ...');
+    process.exit(1);
+  }
+  
+  // Handle file input
+  if (urls[0] === '-f' && urls[1]) {
+    const content = fs.readFileSync(urls[1], 'utf8');
+    urls = content.split('\n').filter(u => u.trim());
+  }
+  
+  log.info(`Spawning ${urls.length} tab(s)...`);
+  
+  const results = [];
+  for (const url of urls) {
+    try {
+      const result = await httpPost('/cdp', {
+        method: 'Target.createTarget',
+        params: { url }
+      });
+      results.push({ url, targetId: result?.targetId });
+      log.ok(`Spawned: ${url}`);
+    } catch (e) {
+      log.warn(`Failed: ${url} - ${e.message}`);
+    }
+  }
+  
+  console.log(JSON.stringify(results, null, 2));
+}
+
+// Extract from multiple tabs
+async function cmdExtract(opts = []) {
+  let js = 'document.body.innerText';
+  let selector = null;
+  let limit = 10000;
+  let asJson = false;
+  
+  for (let i = 0; i < opts.length; i++) {
+    if (opts[i] === '--js') js = opts[++i];
+    else if (opts[i] === '--selector' || opts[i] === '-s') selector = opts[++i];
+    else if (opts[i] === '--limit' || opts[i] === '-l') limit = parseInt(opts[++i], 10);
+    else if (opts[i] === '--json') asJson = true;
+  }
+  
+  if (selector) {
+    js = `document.querySelector(${JSON.stringify(selector)})?.innerText || ''`;
+  }
+  
+  log.info('Extracting from connected tabs...');
+  
+  try {
+    const targets = await getTargets();
+    if (targets.length === 0) {
+      log.warn('No tabs connected');
+      return;
+    }
+    
+    const results = [];
+    for (const target of targets) {
+      const url = target.targetInfo?.url || 'unknown';
+      try {
+        const result = await httpPost('/cdp', {
+          method: 'Runtime.evaluate',
+          params: {
+            expression: js,
+            returnByValue: true
+          }
+        });
+        const text = String(result?.result?.value || '').slice(0, limit);
+        results.push({ url, text });
+        if (!asJson) {
+          console.log(`\n--- ${url} ---`);
+          console.log(text);
+        }
+      } catch (e) {
+        results.push({ url, error: e.message });
+      }
+    }
+    
+    if (asJson) {
+      console.log(JSON.stringify(results, null, 2));
+    }
+  } catch (e) {
+    log.fail(`Extract failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// Explore site (clicks around, captures network)
+async function cmdExplore(url, opts = []) {
+  if (!url) {
+    log.fail('Usage: glider explore <url> [--depth N] [--output dir] [--har file]');
+    process.exit(1);
+  }
+  
+  let depth = 2;
+  let outputDir = '/tmp/glider-explore';
+  let harFile = null;
+  
+  for (let i = 0; i < opts.length; i++) {
+    if (opts[i] === '--depth' || opts[i] === '-d') depth = parseInt(opts[++i], 10);
+    else if (opts[i] === '--output' || opts[i] === '-o') outputDir = opts[++i];
+    else if (opts[i] === '--har') harFile = opts[++i];
+  }
+  
+  log.info(`Exploring: ${url} (depth: ${depth})`);
+  
+  // Use the bexplore.js library
+  const bexplorePath = path.join(LIB_DIR, 'bexplore.js');
+  if (fs.existsSync(bexplorePath)) {
+    const { spawn } = require('child_process');
+    const spawnArgs = [bexplorePath, url, '--depth', String(depth), '--output', outputDir];
+    if (harFile) spawnArgs.push('--har', harFile);
+    
+    const child = spawn('node', spawnArgs, {
+      stdio: 'inherit'
+    });
+    await new Promise((resolve, reject) => {
+      child.on('close', code => code === 0 ? resolve() : reject(new Error(`Exit code: ${code}`)));
+    });
+  } else {
+    // Fallback: simple exploration
+    await cmdGoto(url);
+    await new Promise(r => setTimeout(r, 2000));
+    
+    // Get all links
+    const result = await httpPost('/cdp', {
+      method: 'Runtime.evaluate',
+      params: {
+        expression: `Array.from(document.querySelectorAll('a[href]')).map(a => a.href).filter(h => h.startsWith('http'))`,
+        returnByValue: true
+      }
+    });
+    
+    const links = result?.result?.value || [];
+    log.ok(`Found ${links.length} links`);
+    
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(path.join(outputDir, 'links.json'), JSON.stringify(links, null, 2));
+    
+    // Screenshot
+    await cmdScreenshot(path.join(outputDir, 'screenshot.png'));
+    
+    log.ok(`Output saved to ${outputDir}`);
+  }
+}
+
 // YAML Task Runner
 async function cmdRun(taskFile) {
   if (!taskFile || !fs.existsSync(taskFile)) {
@@ -658,30 +1298,63 @@ async function cmdLoop(taskFileOrPrompt, options = {}) {
 function showHelp() {
   showBanner();
   console.log(`
-${YELLOW}USAGE:${NC}
+${B5}USAGE${NC}
     glider <command> [args]
 
-${YELLOW}SERVER:${NC}
-    status              Check server, extension, tabs
-    start               Start relay server
-    stop                Stop relay server
+${B5}SETUP${NC}
+    ${BW}install${NC}             Install daemon ${DIM}(runs at login, auto-restarts)${NC}
+    ${BW}uninstall${NC}           Remove daemon
+    ${BW}connect${NC}             Connect to browser ${DIM}(run once per Chrome session)${NC}
+
+${B5}STATUS${NC}
+    ${BW}status${NC}              Check server, extension, tabs
+    ${BW}test${NC}                Run diagnostics
+
+${B5}NAVIGATION${NC}
+    ${BW}goto${NC} <url>          Navigate to URL
+    ${BW}eval${NC} <js>           Execute JavaScript
+    ${BW}click${NC} <selector>    Click element
+    ${BW}type${NC} <sel> <text>   Type into input
+    ${BW}screenshot${NC} [path]   Take screenshot
+
+${B5}PAGE INFO${NC}
+    ${BW}text${NC}                Get page text
+    ${BW}html${NC} [selector]     Get HTML
+    ${BW}title${NC}               Get page title
+    ${BW}url${NC}                 Get current URL
+    ${BW}tabs${NC}                List connected tabs
 
-${YELLOW}NAVIGATION:${NC}
-    goto <url>          Navigate current tab to URL
-    eval <js>           Execute JavaScript, return result
-    click <selector>    Click element
-    type <sel> <text>   Type into input
-    screenshot [path]   Take screenshot
-    text                Get page text content
+${B5}MULTI-WINDOW${NC}
+    ${BW}window new${NC} [url]    Create new browser window ${DIM}(closeable)${NC}
+    ${BW}window tab${NC} [url]    Create tab in current window
+    ${BW}window close${NC} <id>   Close specific tab/window
+    ${BW}window closeall${NC}     Close all Glider-created tabs
+    ${BW}window focus${NC} <id>   Bring tab to foreground
+    ${BW}window list${NC}         List all windows/tabs
 
-${YELLOW}AUTOMATION:${NC}
-    run <task.yaml>     Execute YAML task file
-    loop <task> [opts]  Run in Ralph Wiggum loop until complete
+${B5}MULTI-TAB${NC}
+    ${BW}fetch${NC} <url>         Fetch URL with browser session ${DIM}(auth)${NC}
+    ${BW}spawn${NC} <urls...>     Open multiple tabs
+    ${BW}extract${NC} [opts]      Extract from all tabs
+    ${BW}explore${NC} <url>       Crawl site, capture network
 
-${YELLOW}LOOP OPTIONS:${NC}
-    -n, --max-iterations N   Max iterations (default: 10)
-    -t, --timeout N          Max runtime in seconds (default: 3600)
-    -m, --marker STRING      Completion marker (default: LOOP_COMPLETE)
+${B5}AUTOMATION${NC}
+    ${BW}run${NC} <task.yaml>     Execute YAML task file
+    ${BW}loop${NC} <task> [opts]  Autonomous loop ${DIM}(run until complete)${NC}
+    ${BW}ralph${NC} <task>        ${DIM}Alias for loop${NC}
+
+${B5}LOOP OPTIONS${NC}
+    -n, --max-iterations N   Max iterations ${DIM}(default: 10)${NC}
+    -t, --timeout N          Timeout in seconds ${DIM}(default: 3600)${NC}
+    -m, --marker STRING      Completion marker ${DIM}(default: LOOP_COMPLETE)${NC}
+
+${B5}EXAMPLES${NC}
+    ${DIM}$${NC} glider install              ${DIM}# one-time setup${NC}
+    ${DIM}$${NC} glider connect              ${DIM}# connect to Chrome${NC}
+    ${DIM}$${NC} glider goto "https://x.com" ${DIM}# navigate${NC}
+    ${DIM}$${NC} glider eval "document.title"${DIM}# run JS${NC}
+    ${DIM}$${NC} glider run scrape.yaml      ${DIM}# run task${NC}
+    ${DIM}$${NC} glider loop task.yaml -n 50 ${DIM}# autonomous loop${NC}
 
 ${YELLOW}TASK FILE FORMAT:${NC}
     name: "Task name"
@@ -700,6 +1373,7 @@ ${YELLOW}EXAMPLES:${NC}
     glider start
     glider goto "https://google.com"
     glider eval "document.title"
+    glider html "div.main"
     glider run mytask.yaml
     glider loop mytask.yaml -n 20 -t 600
 
@@ -712,7 +1386,6 @@ ${YELLOW}RALPH WIGGUM PATTERN:${NC}
 
 ${YELLOW}REQUIREMENTS:${NC}
     - Node.js 18+
-    - bserve relay server (~/scripts/bserve)
     - Glider Chrome extension connected
 
 ${YELLOW}DOMAIN EXTENSIONS:${NC}
@@ -721,14 +1394,14 @@ ${YELLOW}DOMAIN EXTENSIONS:${NC}
       "mysite": { "url": "https://mysite.com/dashboard" },
       "mytool": { "script": "~/.cursor/tools/scripts/mytool.sh" }
     }
-    Then: glider mysite  →  navigates to that URL
-          glider mytool  →  runs that script
+    Then: glider mysite  ->  navigates to that URL
+          glider mytool  ->  runs that script
 `);
-  
-  // Show loaded domains if any
+
+  // Show loaded domains if any (from local config)
   const domainKeys = Object.keys(DOMAINS);
   if (domainKeys.length > 0) {
-    console.log(`${YELLOW}LOADED DOMAINS:${NC} (from config)`);
+    console.log(`${YELLOW}LOADED DOMAINS:${NC} (from local config)`);
     for (const key of domainKeys) {
       const d = DOMAINS[key];
       const desc = d.description || d.url || d.script || '';
@@ -757,6 +1430,11 @@ async function main() {
   }
   
   switch (cmd) {
+    case 'help':
+    case '--help':
+    case '-h':
+      showHelp();
+      break;
     case 'status':
       await cmdStatus();
       break;
@@ -766,10 +1444,38 @@ async function main() {
     case 'stop':
       await cmdStop();
       break;
+    case 'restart':
+      await cmdRestart();
+      break;
+    case 'install':
+      await cmdInstallDaemon();
+      break;
+    case 'uninstall':
+      await cmdUninstallDaemon();
+      break;
+    case 'connect':
+      await cmdConnect();
+      break;
+    case 'test':
+      await cmdTest();
+      break;
+    case 'tabs':
+      await cmdTabs();
+      break;
+    case 'window':
+    case 'win':
+      await cmdWindow(args.slice(1));
+      break;
+    case 'domains':
+      await cmdDomains();
+      break;
     case 'goto':
     case 'navigate':
       await cmdGoto(args[1]);
       break;
+    case 'open':
+      await cmdOpen(args[1]);
+      break;
     case 'eval':
     case 'js':
       await cmdEval(args.slice(1).join(' '));
@@ -786,10 +1492,32 @@ async function main() {
     case 'text':
       await cmdText();
       break;
+    case 'html':
+      await cmdHtml(args[1]);
+      break;
+    case 'title':
+      await cmdTitle();
+      break;
+    case 'url':
+      await cmdUrl();
+      break;
     case 'run':
       await cmdRun(args[1]);
       break;
+    case 'fetch':
+      await cmdFetch(args[1], args.slice(2));
+      break;
+    case 'spawn':
+      await cmdSpawn(args.slice(1));
+      break;
+    case 'extract':
+      await cmdExtract(args.slice(1));
+      break;
+    case 'explore':
+      await cmdExplore(args[1], args.slice(2));
+      break;
     case 'loop':
+    case 'ralph':  // alias for loop - Ralph Wiggum pattern
       // Parse loop options
       const loopOpts = {
         maxIterations: 10,