cli-browser 1.0.0

package/src/browser.js

@@ -0,0 +1,1277 @@
+import axios from 'axios';
+import config from './config.js';
+import search from './search.js';
+import renderer from './renderer.js';
+import tabs from './tabs.js';
+import history from './history.js';
+import bookmarks from './bookmarks.js';
+import developer from './developer.js';
+import downloads from './download.js';
+import network from './network.js';
+import stats from './stats.js';
+import bangs from './bangs.js';
+import plugins from './plugins.js';
+import sessions from './sessions.js';
+import { theme, THEMES } from './themes.js';
+import * as ui from './ui.js';
+import ora from 'ora';
+
+class Browser {
+  constructor() {
+    this.lastSearchResults = [];
+    this.currentPage = null;
+    this.running = true;
+  }
+
+  async fetchPage(url) {
+    const spinner = ora({
+      text: theme.muted('Loading...'),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const res = await axios.get(url, {
+        headers: { 'User-Agent': config.get('userAgent') },
+        timeout: 15000,
+        maxRedirects: 5,
+        validateStatus: (status) => status < 500,
+      });
+
+      spinner.stop();
+      stats.incrementPageVisit();
+      history.add({ type: 'page', title: '', url });
+
+      return {
+        html: res.data,
+        headers: res.headers,
+        status: res.status,
+        url: res.request?.res?.responseUrl || url,
+      };
+    } catch (err) {
+      spinner.stop();
+      throw err;
+    }
+  }
+
+  async handleCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed) return;
+
+    // Parse command
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const rawArgs = trimmed.slice(cmd.length).trim();
+
+    try {
+      // Bang commands
+      if (bangs.isBang(cmd)) {
+        return await this.handleBang(trimmed);
+      }
+
+      switch (cmd) {
+        // === SEARCH ===
+        case 'search':
+        case 's':
+          return await this.handleSearch(rawArgs, args);
+        
+        case 'image':
+          return await this.handleImageSearch(rawArgs);
+
+        // === NAVIGATION ===
+        case 'open':
+        case 'o':
+        case 'goto':
+          return await this.handleOpen(rawArgs);
+
+        case 'link':
+        case 'l':
+          return await this.handleLink(parseInt(args[0]));
+
+        case 'back':
+        case 'b':
+          return this.handleBack();
+
+        case 'forward':
+        case 'f':
+          return this.handleForward();
+
+        case 'home':
+          return this.handleHome();
+
+        case 'refresh':
+        case 'reload':
+          return await this.handleRefresh();
+
+        // === READER ===
+        case 'reader':
+        case 'read':
+          return this.handleReader();
+
+        case 'info':
+          return this.handleInfo();
+
+        // === TABS ===
+        case 'tab':
+          return this.handleTab(args);
+
+        case 'tabs':
+          return this.handleTabsList();
+
+        // === HISTORY ===
+        case 'history':
+        case 'hist':
+          return this.handleHistory(args);
+
+        // === BOOKMARKS ===
+        case 'bookmark':
+        case 'bm':
+          return this.handleBookmark(args);
+
+        // === DEVELOPER ===
+        case 'inspect':
+          return this.handleInspect();
+
+        case 'headers':
+          return await this.handleHeaders();
+
+        case 'cookies':
+          return this.handleCookies();
+
+        case 'scan':
+          return await this.handleScan(rawArgs);
+
+        case 'robots':
+          return await this.handleRobots();
+
+        case 'sitemap':
+          return await this.handleSitemap();
+
+        // === DOWNLOADS ===
+        case 'download':
+        case 'dl':
+          return await this.handleDownload(rawArgs);
+
+        case 'downloads':
+          return this.handleDownloadsList();
+
+        // === NETWORK ===
+        case 'proxy':
+          return this.handleProxy(args);
+
+        case 'ua':
+          return this.handleUserAgent(args[0]);
+
+        // === THEME ===
+        case 'theme':
+          return this.handleTheme(args[0]);
+
+        case 'color':
+          return this.handleColor(args);
+
+        case 'style':
+          return this.handleStyle(args[0]);
+
+        // === SESSIONS ===
+        case 'login':
+          return this.handleLogin(args[0]);
+
+        case 'session':
+          return this.handleSession(args);
+
+        // === AI ===
+        case 'summary':
+          return this.handleSummary();
+
+        case 'ask':
+          return this.handleAsk(rawArgs);
+
+        case 'translate':
+          return this.handleTranslate(rawArgs);
+
+        // === STATS ===
+        case 'stats':
+          return this.handleStats();
+
+        // === PLUGINS ===
+        case 'plugin':
+          return this.handlePlugin(args);
+
+        // === MISC ===
+        case 'help':
+        case 'h':
+        case '?':
+          return this.handleHelp(args[0]);
+
+        case 'clear':
+        case 'cls':
+          console.clear();
+          return;
+
+        case 'exit':
+        case 'quit':
+        case 'q':
+          return this.handleExit();
+
+        case 'version':
+        case 'ver':
+          return ui.info('CLI Browser v1.0.0');
+
+        default:
+          // If it looks like a URL
+          if (trimmed.startsWith('http://') || trimmed.startsWith('https://') || trimmed.includes('.') && !trimmed.includes(' ')) {
+            return await this.handleOpen(trimmed);
+          }
+          // Otherwise treat as search
+          if (trimmed.length > 0) {
+            return await this.handleSearch(trimmed, parts);
+          }
+      }
+    } catch (err) {
+      ui.error(err.message || 'An error occurred');
+    }
+  }
+
+  // ==================
+  // SEARCH
+  // ==================
+  async handleSearch(rawArgs, args) {
+    let query = rawArgs;
+    let engine = null;
+    let type = 'general';
+    let time = null;
+    let multi = false;
+
+    // Parse flags
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--engine' && args[i + 1]) {
+        engine = args[i + 1];
+        query = query.replace(`--engine ${engine}`, '').trim();
+        i++;
+      } else if (args[i] === '--type' && args[i + 1]) {
+        type = args[i + 1];
+        query = query.replace(`--type ${type}`, '').trim();
+        i++;
+      } else if (args[i] === '--time' && args[i + 1]) {
+        time = args[i + 1];
+        query = query.replace(`--time ${time}`, '').trim();
+        i++;
+      } else if (args[i] === '--multi') {
+        multi = true;
+        query = query.replace('--multi', '').trim();
+      }
+    }
+
+    if (!query) {
+      return ui.error('Usage: search <query> [--engine google] [--type image] [--time day]');
+    }
+
+    if (multi) {
+      return await this.handleMultiSearch(query);
+    }
+
+    const spinner = ora({
+      text: theme.muted(`Searching "${query}"...`),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const data = await search.search(query, { engine, type, time });
+      spinner.stop();
+
+      stats.incrementSearch();
+      history.add({ type: 'search', query, title: `Search: ${query}` });
+
+      if (data.results.length === 0) {
+        return ui.warn('No results found');
+      }
+
+      ui.header(`Search Results: "${query}"`);
+      if (data.number_of_results) {
+        ui.info(`${data.number_of_results.toLocaleString()} results found`);
+      }
+      console.log();
+
+      data.results.slice(0, config.get('pageSize')).forEach((r, i) => {
+        ui.searchResult(i + 1, r);
+      });
+
+      if (data.suggestions?.length) {
+        console.log();
+        ui.subheader('Suggestions:');
+        data.suggestions.forEach(s => {
+          console.log('  ' + theme.muted('→ ') + theme.info(s));
+        });
+      }
+
+      if (data.infoboxes?.length) {
+        console.log();
+        const ib = data.infoboxes[0];
+        ui.subheader(ib.infobox || 'Info');
+        if (ib.content) {
+          console.log('  ' + theme.muted(ib.content.slice(0, 200)));
+        }
+      }
+
+      this.lastSearchResults = data.results;
+      console.log();
+      ui.info('Type "open <number>" to visit a result');
+
+    } catch (err) {
+      spinner.stop();
+      ui.error(`Search failed: ${err.message}`);
+    }
+  }
+
+  async handleMultiSearch(query) {
+    const spinner = ora({
+      text: theme.muted(`Multi-searching "${query}"...`),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const results = await search.multiSearch(query);
+      spinner.stop();
+
+      stats.incrementSearch();
+      ui.header(`Multi-Search: "${query}"`);
+
+      for (const [category, items] of Object.entries(results)) {
+        if (items.length > 0) {
+          ui.subheader(`${category.charAt(0).toUpperCase() + category.slice(1)}`);
+          items.forEach((r, i) => {
+            ui.searchResult(i + 1, r);
+          });
+        }
+      }
+    } catch (err) {
+      spinner.stop();
+      ui.error(`Multi-search failed: ${err.message}`);
+    }
+  }
+
+  async handleImageSearch(query) {
+    if (!query) return ui.error('Usage: image <query>');
+
+    const spinner = ora({
+      text: theme.muted(`Searching images "${query}"...`),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const data = await search.imageSearch(query);
+      spinner.stop();
+
+      stats.incrementSearch();
+      ui.header(`Image Results: "${query}"`);
+
+      data.results.slice(0, 10).forEach((r, i) => {
+        const num = theme.accent(`  [${i + 1}] `);
+        console.log(num + theme.title(r.title || 'Image'));
+        if (r.img_src) console.log('       ' + theme.url(r.img_src));
+        if (r.url) console.log('       ' + theme.muted('from: ' + r.url));
+        console.log();
+      });
+
+      this.lastSearchResults = data.results;
+      ui.info('Type "open <number>" to view source page');
+    } catch (err) {
+      spinner.stop();
+      ui.error(`Image search failed: ${err.message}`);
+    }
+  }
+
+  // ==================
+  // OPEN / NAVIGATION
+  // ==================
+  async handleOpen(target) {
+    let url = target;
+
+    // If it's a number, get from search results
+    const num = parseInt(target);
+    if (!isNaN(num) && num > 0) {
+      const result = search.getResultByIndex(num);
+      if (!result) {
+        return ui.error(`No result #${num}. Run a search first.`);
+      }
+      url = result.url;
+    }
+
+    // Add protocol if missing
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      url = 'https://' + url;
+    }
+
+    try {
+      const page = await this.fetchPage(url);
+      const rendered = renderer.render(page.html, page.url);
+
+      tabs.setCurrentPage(page.url, rendered.title, page.html, rendered.content, rendered.links);
+      this.currentPage = page;
+
+      ui.statusBar(tabs.getAllTabs(), tabs.getActiveIndex(), page.url);
+      ui.pageView(rendered.title, rendered.content, rendered.links.slice(0, 30));
+    } catch (err) {
+      ui.error(`Failed to load: ${err.message}`);
+    }
+  }
+
+  async handleLink(idx) {
+    if (!idx || isNaN(idx)) {
+      return ui.error('Usage: link <number>');
+    }
+
+    const tab = tabs.getCurrentTab();
+    const link = tab.links[idx - 1];
+    if (!link) {
+      return ui.error(`Link #${idx} not found`);
+    }
+
+    await this.handleOpen(link.url);
+  }
+
+  handleBack() {
+    try {
+      const tab = tabs.goBack();
+      if (tab.content) {
+        ui.statusBar(tabs.getAllTabs(), tabs.getActiveIndex(), tab.url);
+        ui.pageView(tab.title, tab.content, tab.links?.slice(0, 30));
+      }
+    } catch (err) {
+      ui.error(err.message);
+    }
+  }
+
+  handleForward() {
+    try {
+      const tab = tabs.goForward();
+      if (tab.content) {
+        ui.statusBar(tabs.getAllTabs(), tabs.getActiveIndex(), tab.url);
+        ui.pageView(tab.title, tab.content, tab.links?.slice(0, 30));
+      }
+    } catch (err) {
+      ui.error(err.message);
+    }
+  }
+
+  handleHome() {
+    console.clear();
+    ui.banner();
+    ui.info('Welcome home! Type "search <query>" or "help" for commands.');
+  }
+
+  async handleRefresh() {
+    const tab = tabs.getCurrentTab();
+    if (tab.url) {
+      await this.handleOpen(tab.url);
+    } else {
+      ui.warn('No page to refresh');
+    }
+  }
+
+  // ==================
+  // READER / INFO
+  // ==================
+  handleReader() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.html) {
+      return ui.warn('No page loaded. Open a page first.');
+    }
+
+    const rendered = renderer.renderReader(tab.html, tab.url);
+    ui.header(`Reader Mode: ${rendered.title}`);
+    console.log(rendered.content);
+  }
+
+  handleInfo() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.html) {
+      return ui.warn('No page loaded. Open a page first.');
+    }
+
+    const info = renderer.getPageInfo(tab.html);
+    ui.header('Page Information');
+    Object.entries(info).forEach(([key, value]) => {
+      if (value) {
+        ui.keyValue(key, typeof value === 'string' ? value.slice(0, 80) : String(value));
+      }
+    });
+  }
+
+  // ==================
+  // TABS
+  // ==================
+  handleTab(args) {
+    const action = args[0];
+    const param = args[1];
+
+    switch (action) {
+      case 'new':
+        tabs.newTab(param || 'New Tab');
+        ui.success('New tab created');
+        this.handleTabsList();
+        break;
+      case 'close':
+        try {
+          const idx = param ? parseInt(param) - 1 : undefined;
+          tabs.closeTab(idx);
+          ui.success('Tab closed');
+          this.handleTabsList();
+        } catch (err) {
+          ui.error(err.message);
+        }
+        break;
+      case 'switch':
+        if (!param) return ui.error('Usage: tab switch <number>');
+        try {
+          const tab = tabs.switchTab(parseInt(param) - 1);
+          ui.success(`Switched to tab ${param}`);
+          if (tab.content) {
+            ui.statusBar(tabs.getAllTabs(), tabs.getActiveIndex(), tab.url);
+            ui.pageView(tab.title, tab.content, tab.links?.slice(0, 30));
+          }
+        } catch (err) {
+          ui.error(err.message);
+        }
+        break;
+      default:
+        ui.error('Usage: tab <new|close|switch> [number]');
+    }
+  }
+
+  handleTabsList() {
+    const allTabs = tabs.getAllTabs();
+    ui.header('Tabs');
+    allTabs.forEach(tab => {
+      const marker = tab.active ? theme.accent(' ● ') : theme.muted(' ○ ');
+      const title = tab.active ? theme.title(tab.title) : theme.secondary(tab.title);
+      const url = tab.url ? theme.url(` - ${tab.url}`) : '';
+      console.log(`  ${marker} ${theme.accent(`[${tab.index}]`)} ${title}${url}`);
+    });
+  }
+
+  // ==================
+  // HISTORY
+  // ==================
+  handleHistory(args) {
+    const action = args[0];
+
+    if (action === 'clear') {
+      history.clear();
+      return ui.success('History cleared');
+    }
+
+    if (action === 'open' && args[1]) {
+      const entry = history.getByIndex(parseInt(args[1]));
+      if (entry) {
+        if (entry.url) {
+          return this.handleOpen(entry.url);
+        }
+        if (entry.query) {
+          return this.handleSearch(entry.query, entry.query.split(/\s+/));
+        }
+      }
+      return ui.error('History entry not found');
+    }
+
+    const items = history.getRecent(20);
+    if (items.length === 0) {
+      return ui.info('No history yet');
+    }
+
+    ui.header('History');
+    items.forEach((item, i) => {
+      const time = new Date(item.timestamp).toLocaleTimeString();
+      const icon = item.type === 'search' ? '🔍' : '📄';
+      console.log(
+        theme.accent(`  [${i + 1}] `) +
+        theme.muted(`${time} `) +
+        `${icon} ` +
+        theme.secondary(item.title || item.query || item.url)
+      );
+    });
+    console.log();
+    ui.info('Type "history open <number>" to revisit');
+  }
+
+  // ==================
+  // BOOKMARKS
+  // ==================
+  handleBookmark(args) {
+    const action = args[0];
+
+    switch (action) {
+      case 'add': {
+        const tab = tabs.getCurrentTab();
+        if (!tab.url) {
+          return ui.warn('No page loaded to bookmark');
+        }
+        try {
+          bookmarks.add(tab.title, tab.url);
+          ui.success(`Bookmarked: ${tab.title}`);
+        } catch (err) {
+          ui.warn(err.message);
+        }
+        break;
+      }
+      case 'list':
+      case undefined: {
+        const all = bookmarks.getAll();
+        if (all.length === 0) {
+          return ui.info('No bookmarks');
+        }
+        ui.header('Bookmarks');
+        all.forEach((bm, i) => {
+          console.log(
+            theme.accent(`  [${i + 1}] `) +
+            theme.title(bm.title) + '\n' +
+            '       ' + theme.url(bm.url)
+          );
+        });
+        console.log();
+        ui.info('Type "bookmark open <number>" to visit');
+        break;
+      }
+      case 'open': {
+        const bm = bookmarks.getByIndex(parseInt(args[1]));
+        if (bm) {
+          return this.handleOpen(bm.url);
+        }
+        ui.error('Bookmark not found');
+        break;
+      }
+      case 'remove':
+      case 'rm':
+      case 'delete': {
+        try {
+          const removed = bookmarks.remove(parseInt(args[1]));
+          ui.success(`Removed: ${removed.title}`);
+        } catch (err) {
+          ui.error(err.message);
+        }
+        break;
+      }
+      default:
+        ui.error('Usage: bookmark <add|list|open|remove> [number]');
+    }
+  }
+
+  // ==================
+  // DEVELOPER
+  // ==================
+  handleInspect() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.html) {
+      return ui.warn('No page loaded');
+    }
+
+    const data = developer.inspect(tab.html, tab.url);
+    ui.header('Site Inspection');
+
+    ui.subheader('Frameworks');
+    data.framework.forEach(f => console.log('  ' + theme.accent('  → ') + theme.secondary(f)));
+
+    if (data.technologies.length) {
+      ui.subheader('Technologies');
+      data.technologies.forEach(t => console.log('  ' + theme.accent('  → ') + theme.secondary(t)));
+    }
+
+    if (data.scripts.length) {
+      ui.subheader('Scripts');
+      data.scripts.slice(0, 10).forEach(s => console.log('  ' + theme.muted('  → ') + theme.url(s)));
+    }
+
+    if (Object.keys(data.metaTags).length) {
+      ui.subheader('Meta Tags');
+      Object.entries(data.metaTags).slice(0, 15).forEach(([k, v]) => {
+        ui.keyValue(k, v.slice(0, 60));
+      });
+    }
+  }
+
+  async handleHeaders() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.url) return ui.warn('No page loaded');
+
+    try {
+      const data = await developer.getHeaders(tab.url);
+      ui.header(`HTTP Headers (${data.status} ${data.statusText})`);
+      Object.entries(data.headers).forEach(([k, v]) => {
+        ui.keyValue(k, String(v).slice(0, 80));
+      });
+    } catch (err) {
+      ui.error(err.message);
+    }
+  }
+
+  handleCookies() {
+    const tab = tabs.getCurrentTab();
+    if (!this.currentPage) return ui.warn('No page loaded');
+
+    const cookies = developer.getCookies(tab.html, this.currentPage.headers);
+    ui.header('Cookies');
+    if (cookies.length === 0) {
+      return ui.info('No cookies found');
+    }
+    cookies.forEach(c => {
+      ui.keyValue(c.name, c.value?.slice(0, 60) || '');
+    });
+  }
+
+  async handleScan(target) {
+    if (!target) {
+      const tab = tabs.getCurrentTab();
+      if (!tab.url) return ui.error('Usage: scan <url>');
+      target = tab.url;
+    }
+
+    if (!target.startsWith('http')) target = 'https://' + target;
+
+    const spinner = ora({
+      text: theme.muted(`Scanning ${target}...`),
+      spinner: 'dots',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const data = await developer.scan(target);
+      spinner.stop();
+
+      ui.header(`Scan: ${target}`);
+
+      if (data.security) {
+        ui.subheader('Security');
+        ui.keyValue('HTTPS', data.security.https ? '✓ Yes' : '✗ No');
+        ui.keyValue('HSTS', data.security.hsts ? '✓ Enabled' : '✗ Not set');
+        ui.keyValue('CSP', data.security.csp ? '✓ Enabled' : '✗ Not set');
+        ui.keyValue('X-Frame-Options', data.security.xframe);
+        ui.keyValue('X-Content-Type', data.security.xcontent);
+        ui.keyValue('Server', data.security.server);
+        ui.keyValue('Powered By', data.security.poweredBy);
+      }
+
+      if (data.frameworks?.length) {
+        ui.subheader('Frameworks');
+        data.frameworks.forEach(f => console.log('  ' + theme.accent('  → ') + f));
+      }
+
+      if (data.technologies?.length) {
+        ui.subheader('Technologies');
+        data.technologies.forEach(t => console.log('  ' + theme.accent('  → ') + t));
+      }
+
+      if (data.links?.length) {
+        ui.subheader(`Links (${data.links.length})`);
+        data.links.slice(0, 15).forEach(l => {
+          console.log('  ' + theme.muted('  → ') + theme.url(l));
+        });
+      }
+    } catch (err) {
+      spinner.stop();
+      ui.error(err.message);
+    }
+  }
+
+  async handleRobots() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.url) return ui.error('Open a page first');
+
+    const spinner = ora({ text: theme.muted('Fetching robots.txt...'), spinner: 'dots', color: 'cyan' }).start();
+    try {
+      const content = await developer.getRobots(tab.url);
+      spinner.stop();
+      ui.header('robots.txt');
+      console.log(theme.secondary(content));
+    } catch (err) {
+      spinner.stop();
+      ui.error(err.message);
+    }
+  }
+
+  async handleSitemap() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.url) return ui.error('Open a page first');
+
+    const spinner = ora({ text: theme.muted('Fetching sitemap.xml...'), spinner: 'dots', color: 'cyan' }).start();
+    try {
+      const data = await developer.getSitemap(tab.url);
+      spinner.stop();
+      ui.header('Sitemap');
+      if (Array.isArray(data)) {
+        data.slice(0, 30).forEach((url, i) => {
+          console.log(theme.accent(`  [${i + 1}] `) + theme.url(url));
+        });
+        if (data.length > 30) {
+          ui.muted(`  ... and ${data.length - 30} more`);
+        }
+      } else {
+        console.log(theme.secondary(data));
+      }
+    } catch (err) {
+      spinner.stop();
+      ui.error(err.message);
+    }
+  }
+
+  // ==================
+  // DOWNLOADS
+  // ==================
+  async handleDownload(url) {
+    if (!url) return ui.error('Usage: download <url>');
+    if (!url.startsWith('http')) url = 'https://' + url;
+
+    const spinner = ora({ text: theme.muted('Downloading...'), spinner: 'dots', color: 'cyan' }).start();
+    try {
+      const entry = await downloads.download(url);
+      spinner.stop();
+      ui.success(`Downloaded: ${entry.filename} (${downloads.formatSize(entry.downloaded)})`);
+      ui.info(`Saved to: ${entry.filepath}`);
+    } catch (err) {
+      spinner.stop();
+      ui.error(`Download failed: ${err.message}`);
+    }
+  }
+
+  handleDownloadsList() {
+    const dls = downloads.getDownloads();
+    if (dls.length === 0) return ui.info('No downloads');
+
+    ui.header('Downloads');
+    dls.forEach(dl => {
+      const status = dl.status === 'complete' ? theme.success('✓') :
+                     dl.status === 'failed' ? theme.error('✗') :
+                     theme.warning('↓');
+      console.log(
+        `  ${status} ${theme.accent(`[${dl.id}]`)} ${theme.secondary(dl.filename)} ` +
+        theme.muted(`(${downloads.formatSize(dl.downloaded)})`)
+      );
+    });
+  }
+
+  // ==================
+  // NETWORK
+  // ==================
+  handleProxy(args) {
+    if (args[0] === 'set' && args[1]) {
+      network.setProxy(args[1]);
+      ui.success(`Proxy set to ${args[1]}`);
+    } else if (args[0] === 'clear') {
+      network.clearProxy();
+      ui.success('Proxy cleared');
+    } else {
+      const proxy = network.getProxy();
+      if (proxy) {
+        ui.info(`Current proxy: ${proxy}`);
+      } else {
+        ui.info('No proxy set');
+      }
+    }
+  }
+
+  handleUserAgent(preset) {
+    if (!preset) {
+      return ui.info(`Current UA: ${network.getUserAgent()}`);
+    }
+    const ua = network.setUserAgent(preset);
+    ui.success(`User-Agent set to: ${ua.slice(0, 60)}...`);
+  }
+
+  // ==================
+  // THEME
+  // ==================
+  handleTheme(name) {
+    if (!name) {
+      ui.header('Themes');
+      theme.listThemes().forEach(t => {
+        const active = t === theme.currentTheme ? theme.accent(' ● ') : '   ';
+        console.log(`  ${active}${theme.secondary(t)}`);
+      });
+      return;
+    }
+
+    if (theme.setTheme(name)) {
+      ui.success(`Theme set to "${name}"`);
+    } else {
+      ui.error(`Unknown theme. Available: ${theme.listThemes().join(', ')}`);
+    }
+  }
+
+  handleColor(args) {
+    if (args.length < 2) {
+      return ui.error('Usage: color <element> <color>');
+    }
+    const colors = config.get('colors');
+    colors[args[0]] = args[1];
+    config.set('colors', colors);
+    ui.success(`${args[0]} color set to ${args[1]}`);
+  }
+
+  handleStyle(styleName) {
+    if (!styleName) {
+      return ui.info(`Current style: ${config.get('style')}`);
+    }
+    config.set('style', styleName);
+    ui.success(`Style set to "${styleName}"`);
+  }
+
+  // ==================
+  // SESSIONS
+  // ==================
+  handleLogin(domain) {
+    if (!domain) {
+      const tab = tabs.getCurrentTab();
+      if (!tab.url) return ui.error('Usage: login <domain>');
+      domain = new URL(tab.url).hostname;
+    }
+    if (this.currentPage?.headers) {
+      const cookies = developer.getCookies('', this.currentPage.headers);
+      sessions.saveSession(domain, cookies);
+      ui.success(`Session saved for ${domain}`);
+    } else {
+      ui.warn('No cookies to save');
+    }
+  }
+
+  handleSession(args) {
+    const action = args[0];
+
+    switch (action) {
+      case 'list': {
+        const domains = sessions.listDomains();
+        if (domains.length === 0) return ui.info('No saved sessions');
+        ui.header('Sessions');
+        domains.forEach((d, i) => {
+          console.log(theme.accent(`  [${i + 1}] `) + theme.secondary(d));
+        });
+        break;
+      }
+      case 'clear':
+        sessions.clearAll();
+        ui.success('All sessions cleared');
+        break;
+      default:
+        ui.error('Usage: session <list|clear>');
+    }
+  }
+
+  // ==================
+  // AI
+  // ==================
+  handleSummary() {
+    const tab = tabs.getCurrentTab();
+    if (!tab.content) return ui.warn('No page loaded');
+
+    // Extract key content for summary
+    const text = tab.content
+      .replace(/\x1B\[[0-9;]*m/g, '') // strip ANSI
+      .replace(/\s+/g, ' ')
+      .trim();
+
+    const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+    const summary = sentences.slice(0, 8).join(' ').trim();
+
+    ui.header(`Summary: ${tab.title}`);
+    if (summary) {
+      console.log('\n  ' + theme.secondary(summary.slice(0, 500)));
+    } else {
+      ui.warn('Could not generate summary from this page');
+    }
+    console.log();
+  }
+
+  handleAsk(question) {
+    if (!question) return ui.error('Usage: ask <question>');
+
+    const tab = tabs.getCurrentTab();
+    if (!tab.content) return ui.warn('No page loaded');
+
+    const text = tab.content.replace(/\x1B\[[0-9;]*m/g, '').replace(/\s+/g, ' ');
+
+    // Simple keyword extraction
+    const keywords = question.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+    
+    const relevant = sentences.filter(s => {
+      const lower = s.toLowerCase();
+      return keywords.some(k => lower.includes(k));
+    });
+
+    ui.header('Answer');
+    if (relevant.length > 0) {
+      console.log('\n  ' + theme.secondary(relevant.slice(0, 5).join(' ').trim().slice(0, 500)));
+    } else {
+      console.log('\n  ' + theme.muted('No relevant information found on this page for your question.'));
+    }
+    console.log();
+  }
+
+  handleTranslate(targetLang) {
+    if (!targetLang) return ui.error('Usage: translate <language>');
+    ui.info(`Translation to "${targetLang}" requires an external API.`);
+    ui.info('Connect an AI translation service for this feature.');
+  }
+
+  // ==================
+  // BANG COMMANDS
+  // ==================
+  async handleBang(input) {
+    const { bang, query } = bangs.parse(input);
+    const url = bangs.getUrl(bang, query);
+
+    if (!url) {
+      ui.error(`Unknown bang command: ${bang}`);
+      ui.info('Available bangs:');
+      bangs.listBangs().forEach(b => {
+        console.log(theme.accent(`  ${b.bang.padEnd(10)}`) + theme.muted(b.name));
+      });
+      return;
+    }
+
+    if (!query) {
+      return ui.error(`Usage: ${bang} <query>`);
+    }
+
+    await this.handleOpen(url);
+  }
+
+  // ==================
+  // STATS
+  // ==================
+  handleStats() {
+    const s = stats.getStats();
+    ui.header('Statistics');
+    ui.keyValue('Searches', String(s.searchCount));
+    ui.keyValue('Pages Visited', String(s.pagesVisited));
+    ui.keyValue('Session Time', s.sessionTime);
+    ui.keyValue('Total Time', s.totalTime);
+    ui.keyValue('Bookmarks', String(s.bookmarkCount));
+    ui.keyValue('History Items', String(s.historyCount));
+  }
+
+  // ==================
+  // PLUGINS
+  // ==================
+  handlePlugin(args) {
+    const action = args[0];
+    const name = args[1];
+
+    switch (action) {
+      case 'install': {
+        if (!name) return ui.error('Usage: plugin install <name>');
+        try {
+          const p = plugins.install(name);
+          ui.success(`Installed plugin: ${p.name} v${p.version}`);
+          ui.info(p.description);
+        } catch (err) {
+          ui.error(err.message);
+        }
+        break;
+      }
+      case 'remove':
+      case 'uninstall': {
+        if (!name) return ui.error('Usage: plugin remove <name>');
+        try {
+          plugins.uninstall(name);
+          ui.success(`Removed plugin: ${name}`);
+        } catch (err) {
+          ui.error(err.message);
+        }
+        break;
+      }
+      case 'list':
+      default: {
+        const installed = plugins.listInstalled();
+        if (installed.length === 0) {
+          ui.info('No plugins installed');
+          ui.info('Available: youtube, wikipedia, github, stackoverflow, reddit');
+          return;
+        }
+        ui.header('Plugins');
+        installed.forEach(p => {
+          console.log(theme.accent(`  → `) + theme.secondary(`${p.name}`) + theme.muted(` v${p.version} - ${p.description}`));
+        });
+        break;
+      }
+    }
+  }
+
+  // ==================
+  // HELP
+  // ==================
+  handleHelp(topic) {
+    if (topic) {
+      return this.handleHelpTopic(topic);
+    }
+
+    console.log();
+    ui.helpBox('Search', [
+      ['search <query>', 'Search the web'],
+      ['s <query>', 'Search (shortcut)'],
+      ['search <q> --engine google', 'Use specific search engine'],
+      ['search <q> --type image|video|news', 'Category search'],
+      ['search <q> --time day|week|month|year', 'Time-filtered search'],
+      ['search <q> --multi', 'Multi-category search'],
+      ['image <query>', 'Image search'],
+    ]);
+
+    ui.helpBox('Browse', [
+      ['open <number|url>', 'Open search result or URL'],
+      ['link <number>', 'Follow a link on current page'],
+      ['reader', 'Reader mode (clean view)'],
+      ['info', 'Page information'],
+    ]);
+
+    ui.helpBox('Navigation', [
+      ['back / b', 'Go back'],
+      ['forward / f', 'Go forward'],
+      ['home', 'Go home'],
+      ['refresh', 'Refresh page'],
+    ]);
+
+    ui.helpBox('Tabs', [
+      ['tab new', 'New tab'],
+      ['tab switch <n>', 'Switch to tab'],
+      ['tab close <n>', 'Close tab'],
+      ['tabs', 'List all tabs'],
+    ]);
+
+    ui.helpBox('History & Bookmarks', [
+      ['history', 'View history'],
+      ['history open <n>', 'Revisit from history'],
+      ['history clear', 'Clear history'],
+      ['bookmark add', 'Bookmark current page'],
+      ['bookmark list', 'List bookmarks'],
+      ['bookmark open <n>', 'Open bookmark'],
+      ['bookmark remove <n>', 'Remove bookmark'],
+    ]);
+
+    ui.helpBox('Bang Commands', [
+      ['!yt <query>', 'YouTube'],
+      ['!gh <query>', 'GitHub'],
+      ['!wiki <query>', 'Wikipedia'],
+      ['!npm <query>', 'npm'],
+      ['!so <query>', 'Stack Overflow'],
+      ['!reddit <query>', 'Reddit'],
+    ]);
+
+    ui.helpBox('Developer', [
+      ['inspect', 'Inspect site technologies'],
+      ['headers', 'View HTTP headers'],
+      ['cookies', 'View cookies'],
+      ['scan <url>', 'Security scan'],
+      ['robots', 'View robots.txt'],
+      ['sitemap', 'View sitemap'],
+    ]);
+
+    ui.helpBox('Tools', [
+      ['download <url>', 'Download a file'],
+      ['downloads', 'List downloads'],
+      ['summary', 'Summarize current page'],
+      ['ask <question>', 'Ask about current page'],
+      ['stats', 'View statistics'],
+    ]);
+
+    ui.helpBox('Settings', [
+      ['theme <name>', 'Change theme (dark/hacker/minimal/ocean/sunset)'],
+      ['proxy set <host:port>', 'Set proxy'],
+      ['ua <chrome|firefox|mobile>', 'Change user-agent'],
+      ['plugin install <name>', 'Install plugin'],
+    ]);
+
+    ui.helpBox('General', [
+      ['clear', 'Clear screen'],
+      ['help', 'Show help'],
+      ['help <topic>', 'Topic help (search/browse/tabs/dev)'],
+      ['exit', 'Exit browser'],
+    ]);
+  }
+
+  handleHelpTopic(topic) {
+    switch (topic) {
+      case 'search':
+        ui.helpBox('Search Help', [
+          ['search cats', 'Basic search'],
+          ['s cats', 'Search shortcut'],
+          ['search cats --engine google', 'Use Google'],
+          ['search cats --engine duckduckgo', 'Use DuckDuckGo'],
+          ['search cats --engine bing', 'Use Bing'],
+          ['search cats --type image', 'Image search'],
+          ['search cats --type video', 'Video search'],
+          ['search cats --type news', 'News search'],
+          ['search ai --time day', 'Last 24 hours'],
+          ['search ai --time week', 'Last week'],
+          ['search ai --multi', 'All categories'],
+        ]);
+        break;
+      case 'browse':
+        ui.helpBox('Browse Help', [
+          ['open 1', 'Open search result #1'],
+          ['open https://example.com', 'Open URL'],
+          ['link 3', 'Follow link #3 on page'],
+          ['reader', 'Clean reading mode'],
+          ['info', 'Page metadata'],
+          ['back', 'Go back'],
+          ['forward', 'Go forward'],
+        ]);
+        break;
+      case 'tabs':
+        ui.helpBox('Tabs Help', [
+          ['tab new', 'Create new tab'],
+          ['tab switch 2', 'Switch to tab 2'],
+          ['tab close 2', 'Close tab 2'],
+          ['tabs', 'Show all tabs'],
+        ]);
+        break;
+      case 'dev':
+      case 'developer':
+        ui.helpBox('Developer Help', [
+          ['inspect', 'Detect frameworks & tech'],
+          ['headers', 'HTTP response headers'],
+          ['cookies', 'Page cookies'],
+          ['scan example.com', 'Full site scan'],
+          ['robots', 'Fetch robots.txt'],
+          ['sitemap', 'Fetch sitemap.xml'],
+        ]);
+        break;
+      default:
+        ui.error(`Unknown help topic: ${topic}`);
+        ui.info('Available: search, browse, tabs, dev');
+    }
+  }
+
+  // ==================
+  // EXIT
+  // ==================
+  handleExit() {
+    stats.saveTotalTime();
+    console.log();
+    ui.info('Saving session...');
+    const s = stats.getStats();
+    ui.muted?.call(ui, `  Session: ${s.searchCount} searches, ${s.pagesVisited} pages, ${s.sessionTime}`);
+    console.log();
+    ui.success('Goodbye! Thanks for using CLI Browser.');
+    console.log();
+    this.running = false;
+    process.exit(0);
+  }
+
+  getAutocompletions(partial) {
+    const commands = [
+      'search', 'open', 'link', 'back', 'forward', 'home', 'refresh',
+      'reader', 'info', 'tab', 'tabs', 'history', 'bookmark',
+      'inspect', 'headers', 'cookies', 'scan', 'robots', 'sitemap',
+      'download', 'downloads', 'summary', 'ask', 'translate',
+      'theme', 'proxy', 'ua', 'plugin', 'session', 'stats',
+      'help', 'clear', 'exit', 'image', 'login', 'color', 'style',
+    ];
+
+    if (!partial) return commands;
+    return commands.filter(c => c.startsWith(partial.toLowerCase()));
+  }
+}
+
+export default Browser;