cli-browser 1.0.0

package/src/config.js

@@ -0,0 +1,51 @@
+import Conf from 'conf';
+
+const config = new Conf({
+  projectName: 'cli-browser',
+  defaults: {
+    searxng: 'https://searxng.exe.xyz',
+    theme: 'dark',
+    colors: {
+      links: 'cyan',
+      title: 'green',
+      url: 'gray',
+      highlight: 'yellow',
+      error: 'red',
+      success: 'green',
+      info: 'blue',
+      muted: 'gray',
+      border: 'white',
+    },
+    style: 'default',
+    userAgent: 'CLI-Browser/1.0',
+    proxy: null,
+    downloadDir: './downloads',
+    maxHistory: 500,
+    maxTabs: 20,
+    pageSize: 10,
+    bangCommands: {
+      '!yt': 'https://www.youtube.com/results?search_query=',
+      '!gh': 'https://github.com/search?q=',
+      '!wiki': 'https://en.wikipedia.org/wiki/Special:Search?search=',
+      '!npm': 'https://www.npmjs.com/search?q=',
+      '!so': 'https://stackoverflow.com/search?q=',
+      '!reddit': 'https://www.reddit.com/search/?q=',
+      '!mdn': 'https://developer.mozilla.org/en-US/search?q=',
+      '!twitter': 'https://twitter.com/search?q=',
+      '!amazon': 'https://www.amazon.com/s?k=',
+      '!maps': 'https://www.google.com/maps/search/',
+    },
+    bookmarks: [],
+    history: [],
+    stats: {
+      searchCount: 0,
+      pagesVisited: 0,
+      startTime: Date.now(),
+      totalTime: 0,
+    },
+    plugins: [],
+    sessions: {},
+  },
+});
+
+export default config;

package/src/developer.js

@@ -0,0 +1,246 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { theme } from './themes.js';
+import config from './config.js';
+
+class Developer {
+  inspect(html, url) {
+    const $ = cheerio.load(html);
+    const result = {
+      framework: this._detectFramework($),
+      scripts: this._getScripts($, url),
+      apis: this._detectAPIs($),
+      metaTags: this._getMetaTags($),
+      technologies: this._detectTechnologies($, html),
+    };
+    return result;
+  }
+
+  _detectFramework($) {
+    const frameworks = [];
+    
+    if ($('[ng-app], [data-ng-app], [ng-controller]').length || $('script[src*="angular"]').length) {
+      frameworks.push('Angular');
+    }
+    if ($('[data-reactroot], [data-reactid]').length || $('script[src*="react"]').length || $('#__next').length) {
+      frameworks.push('React');
+    }
+    if ($('[data-v-], [v-cloak]').length || $('script[src*="vue"]').length || $('#__nuxt').length) {
+      frameworks.push('Vue.js');
+    }
+    if ($('script[src*="jquery"]').length || $('script[src*="jQuery"]').length) {
+      frameworks.push('jQuery');
+    }
+    if ($('script[src*="bootstrap"]').length || $('link[href*="bootstrap"]').length) {
+      frameworks.push('Bootstrap');
+    }
+    if ($('script[src*="tailwind"]').length || $('link[href*="tailwind"]').length) {
+      frameworks.push('Tailwind CSS');
+    }
+    if ($('meta[name="generator"][content*="WordPress"]').length) {
+      frameworks.push('WordPress');
+    }
+    if ($('meta[name="generator"][content*="Next.js"]').length || $('#__next').length) {
+      frameworks.push('Next.js');
+    }
+    if ($('#__nuxt').length || $('[data-n-head]').length) {
+      frameworks.push('Nuxt.js');
+    }
+    if ($('meta[name="generator"][content*="Gatsby"]').length || $('#___gatsby').length) {
+      frameworks.push('Gatsby');
+    }
+    if ($('script[src*="svelte"]').length) {
+      frameworks.push('Svelte');
+    }
+
+    return frameworks.length ? frameworks : ['Unknown'];
+  }
+
+  _getScripts($, url) {
+    const scripts = [];
+    $('script[src]').each((_, el) => {
+      let src = $(el).attr('src');
+      if (src) {
+        if (src.startsWith('/') && url) {
+          try {
+            const base = new URL(url);
+            src = `${base.protocol}//${base.host}${src}`;
+          } catch {}
+        }
+        scripts.push(src);
+      }
+    });
+    return scripts.slice(0, 20);
+  }
+
+  _detectAPIs($) {
+    const apis = [];
+    $('script').each((_, el) => {
+      const text = $(el).html() || '';
+      const matches = text.match(/(?:fetch|axios|XMLHttpRequest|\.ajax)\s*\(\s*['"`]([^'"`]+)['"`]/g);
+      if (matches) {
+        apis.push(...matches.slice(0, 5));
+      }
+    });
+    return apis.slice(0, 10);
+  }
+
+  _getMetaTags($) {
+    const meta = {};
+    $('meta').each((_, el) => {
+      const name = $(el).attr('name') || $(el).attr('property') || $(el).attr('http-equiv');
+      const content = $(el).attr('content');
+      if (name && content) {
+        meta[name] = content;
+      }
+    });
+    return meta;
+  }
+
+  _detectTechnologies($, html) {
+    const techs = [];
+    
+    if (html.includes('Google Analytics') || html.includes('gtag') || html.includes('UA-')) {
+      techs.push('Google Analytics');
+    }
+    if (html.includes('Google Tag Manager') || html.includes('gtm.js')) {
+      techs.push('Google Tag Manager');
+    }
+    if (html.includes('fb-root') || html.includes('facebook')) {
+      techs.push('Facebook SDK');
+    }
+    if (html.includes('cloudflare')) {
+      techs.push('Cloudflare');
+    }
+    if ($('link[href*="fonts.googleapis"]').length) {
+      techs.push('Google Fonts');
+    }
+    if ($('link[href*="fontawesome"]').length || $('script[src*="fontawesome"]').length) {
+      techs.push('Font Awesome');
+    }
+    
+    return techs;
+  }
+
+  async getHeaders(url) {
+    const response = await axios.head(url, {
+      headers: { 'User-Agent': config.get('userAgent') },
+      timeout: 10000,
+      validateStatus: () => true,
+    });
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+    };
+  }
+
+  getCookies(html, headers) {
+    const cookies = [];
+    if (headers && headers['set-cookie']) {
+      const setCookies = Array.isArray(headers['set-cookie'])
+        ? headers['set-cookie']
+        : [headers['set-cookie']];
+      setCookies.forEach(c => {
+        const parts = c.split(';')[0].split('=');
+        cookies.push({
+          name: parts[0]?.trim(),
+          value: parts.slice(1).join('=')?.trim(),
+          raw: c,
+        });
+      });
+    }
+    return cookies;
+  }
+
+  async scan(url) {
+    const result = {
+      url,
+      headers: null,
+      technologies: [],
+      openPorts: [],
+      links: [],
+      robots: null,
+    };
+
+    try {
+      const headerInfo = await this.getHeaders(url);
+      result.headers = headerInfo;
+
+      // Check security headers
+      const secHeaders = headerInfo.headers;
+      result.security = {
+        https: url.startsWith('https'),
+        hsts: !!secHeaders['strict-transport-security'],
+        csp: !!secHeaders['content-security-policy'],
+        xframe: secHeaders['x-frame-options'] || 'Not set',
+        xcontent: secHeaders['x-content-type-options'] || 'Not set',
+        xss: secHeaders['x-xss-protection'] || 'Not set',
+        server: secHeaders['server'] || 'Hidden',
+        poweredBy: secHeaders['x-powered-by'] || 'Hidden',
+      };
+
+      // Fetch page for tech detection
+      const pageRes = await axios.get(url, {
+        headers: { 'User-Agent': config.get('userAgent') },
+        timeout: 10000,
+      });
+      
+      const $ = cheerio.load(pageRes.data);
+      result.technologies = this._detectTechnologies($, pageRes.data);
+      result.frameworks = this._detectFramework($);
+      
+      // Get all links
+      const links = new Set();
+      $('a[href]').each((_, el) => {
+        const href = $(el).attr('href');
+        if (href && !href.startsWith('#') && !href.startsWith('javascript:')) {
+          links.add(href);
+        }
+      });
+      result.links = [...links].slice(0, 30);
+
+    } catch (err) {
+      result.error = err.message;
+    }
+
+    return result;
+  }
+
+  async getRobots(url) {
+    try {
+      const base = new URL(url);
+      const robotsUrl = `${base.protocol}//${base.host}/robots.txt`;
+      const res = await axios.get(robotsUrl, {
+        headers: { 'User-Agent': config.get('userAgent') },
+        timeout: 10000,
+      });
+      return res.data;
+    } catch {
+      return 'robots.txt not found';
+    }
+  }
+
+  async getSitemap(url) {
+    try {
+      const base = new URL(url);
+      const sitemapUrl = `${base.protocol}//${base.host}/sitemap.xml`;
+      const res = await axios.get(sitemapUrl, {
+        headers: { 'User-Agent': config.get('userAgent') },
+        timeout: 10000,
+      });
+      
+      const $ = cheerio.load(res.data, { xmlMode: true });
+      const urls = [];
+      $('url loc').each((_, el) => {
+        urls.push($(el).text());
+      });
+      
+      return urls.length ? urls : res.data.slice(0, 2000);
+    } catch {
+      return 'sitemap.xml not found';
+    }
+  }
+}
+
+export default new Developer();

package/src/download.js

@@ -0,0 +1,80 @@
+import axios from 'axios';
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { basename, join } from 'path';
+import config from './config.js';
+
+class DownloadManager {
+  constructor() {
+    this.downloads = [];
+    this.downloadDir = config.get('downloadDir');
+  }
+
+  async download(url, filename) {
+    const dir = this.downloadDir;
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    const fname = filename || basename(new URL(url).pathname) || `download_${Date.now()}`;
+    const filepath = join(dir, fname);
+
+    const entry = {
+      id: this.downloads.length + 1,
+      url,
+      filename: fname,
+      filepath,
+      status: 'downloading',
+      startTime: Date.now(),
+      size: 0,
+      downloaded: 0,
+    };
+
+    this.downloads.push(entry);
+
+    try {
+      const response = await axios({
+        method: 'GET',
+        url,
+        responseType: 'stream',
+        headers: { 'User-Agent': config.get('userAgent') },
+        timeout: 60000,
+      });
+
+      entry.size = parseInt(response.headers['content-length'] || 0);
+
+      const writer = createWriteStream(filepath);
+
+      response.data.on('data', (chunk) => {
+        entry.downloaded += chunk.length;
+      });
+
+      await new Promise((resolve, reject) => {
+        response.data.pipe(writer);
+        writer.on('finish', resolve);
+        writer.on('error', reject);
+      });
+
+      entry.status = 'complete';
+      entry.endTime = Date.now();
+      return entry;
+    } catch (err) {
+      entry.status = 'failed';
+      entry.error = err.message;
+      throw err;
+    }
+  }
+
+  getDownloads() {
+    return this.downloads;
+  }
+
+  formatSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  }
+}
+
+export default new DownloadManager();

package/src/history.js

@@ -0,0 +1,58 @@
+import config from './config.js';
+
+class HistoryManager {
+  constructor() {
+    this.sessionHistory = [];
+  }
+
+  add(entry) {
+    const item = {
+      id: Date.now(),
+      timestamp: new Date().toISOString(),
+      type: entry.type || 'page', // 'search' | 'page'
+      title: entry.title || '',
+      url: entry.url || '',
+      query: entry.query || '',
+    };
+
+    this.sessionHistory.push(item);
+
+    // Also persist
+    const saved = config.get('history') || [];
+    saved.push(item);
+    
+    // Trim to max
+    const max = config.get('maxHistory');
+    if (saved.length > max) {
+      saved.splice(0, saved.length - max);
+    }
+    config.set('history', saved);
+
+    return item;
+  }
+
+  getAll() {
+    return config.get('history') || [];
+  }
+
+  getSession() {
+    return this.sessionHistory;
+  }
+
+  getByIndex(idx) {
+    const all = this.getAll();
+    return all[idx - 1] || null;
+  }
+
+  clear() {
+    this.sessionHistory = [];
+    config.set('history', []);
+  }
+
+  getRecent(count = 20) {
+    const all = this.getAll();
+    return all.slice(-count).reverse();
+  }
+}
+
+export default new HistoryManager();

package/src/index.js

@@ -0,0 +1,45 @@
+import { createInterface } from 'readline';
+import Browser from './browser.js';
+import { theme } from './themes.js';
+import * as ui from './ui.js';
+
+export async function startBrowser() {
+  const browser = new Browser();
+
+  // Show banner
+  console.clear();
+  ui.banner();
+  ui.info('Type "help" for commands, or start searching!');
+  ui.info('Type "search <query>" or just type anything to search.');
+  console.log();
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: ui.prompt(),
+    completer: (line) => {
+      const completions = browser.getAutocompletions(line);
+      return [completions, line];
+    },
+    terminal: true,
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (input) {
+      await browser.handleCommand(input);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    browser.handleExit();
+  });
+
+  // Handle SIGINT gracefully
+  process.on('SIGINT', () => {
+    browser.handleExit();
+  });
+}

package/src/network.js

@@ -0,0 +1,56 @@
+import config from './config.js';
+
+class NetworkManager {
+  setProxy(proxy) {
+    config.set('proxy', proxy);
+    return proxy;
+  }
+
+  clearProxy() {
+    config.set('proxy', null);
+  }
+
+  getProxy() {
+    return config.get('proxy');
+  }
+
+  setUserAgent(preset) {
+    const agents = {
+      chrome: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      firefox: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+      safari: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+      mobile: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1',
+      edge: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0',
+      bot: 'CLI-Browser/1.0 (Terminal Internet)',
+      curl: 'curl/8.0',
+      default: 'CLI-Browser/1.0',
+    };
+
+    const ua = agents[preset] || preset;
+    config.set('userAgent', ua);
+    return ua;
+  }
+
+  getUserAgent() {
+    return config.get('userAgent');
+  }
+
+  getAxiosConfig() {
+    const axiosConfig = {
+      headers: {
+        'User-Agent': config.get('userAgent'),
+      },
+      timeout: 15000,
+    };
+
+    const proxy = config.get('proxy');
+    if (proxy) {
+      const [host, port] = proxy.split(':');
+      axiosConfig.proxy = { host, port: parseInt(port) };
+    }
+
+    return axiosConfig;
+  }
+}
+
+export default new NetworkManager();

package/src/plugins.js

@@ -0,0 +1,74 @@
+import config from './config.js';
+
+class PluginManager {
+  constructor() {
+    this.loadedPlugins = new Map();
+  }
+
+  listInstalled() {
+    return config.get('plugins') || [];
+  }
+
+  async install(name) {
+    const plugins = config.get('plugins') || [];
+    if (plugins.find(p => p.name === name)) {
+      throw new Error(`Plugin "${name}" is already installed`);
+    }
+
+    // Built-in plugin definitions
+    const builtIn = {
+      youtube: {
+        name: 'youtube',
+        description: 'Quick YouTube search and video info',
+        bang: '!yt',
+        version: '1.0.0',
+      },
+      wikipedia: {
+        name: 'wikipedia',
+        description: 'Quick Wikipedia article lookup',
+        bang: '!wiki',
+        version: '1.0.0',
+      },
+      github: {
+        name: 'github',
+        description: 'Quick GitHub repository search',
+        bang: '!gh',
+        version: '1.0.0',
+      },
+      stackoverflow: {
+        name: 'stackoverflow',
+        description: 'Quick Stack Overflow search',
+        bang: '!so',
+        version: '1.0.0',
+      },
+      reddit: {
+        name: 'reddit',
+        description: 'Quick Reddit search',
+        bang: '!reddit',
+        version: '1.0.0',
+      },
+    };
+
+    const plugin = builtIn[name];
+    if (!plugin) {
+      throw new Error(`Plugin "${name}" not found. Available: ${Object.keys(builtIn).join(', ')}`);
+    }
+
+    plugins.push(plugin);
+    config.set('plugins', plugins);
+    return plugin;
+  }
+
+  uninstall(name) {
+    const plugins = config.get('plugins') || [];
+    const idx = plugins.findIndex(p => p.name === name);
+    if (idx === -1) {
+      throw new Error(`Plugin "${name}" is not installed`);
+    }
+    const removed = plugins.splice(idx, 1);
+    config.set('plugins', plugins);
+    return removed[0];
+  }
+}
+
+export default new PluginManager();