cli-browser 1.0.0

package/src/renderer.js

@@ -0,0 +1,259 @@
+import * as cheerio from 'cheerio';
+import { theme } from './themes.js';
+
+class Renderer {
+  constructor() {
+    this.links = [];
+    this.images = [];
+  }
+
+  render(html, url = '') {
+    this.links = [];
+    this.images = [];
+    
+    const $ = cheerio.load(html);
+
+    // Remove unwanted elements
+    $('script, style, noscript, iframe, svg, nav, footer, header, .ad, .ads, .advertisement, .sidebar, .menu, .nav, .cookie, .popup, .modal, .banner').remove();
+
+    const title = $('title').text().trim() || 'Untitled Page';
+    const body = $('body');
+    
+    let output = '';
+    output += this._processElement($, body, 0);
+    
+    // Deduplicate links
+    const uniqueLinks = [];
+    const seen = new Set();
+    for (const link of this.links) {
+      const key = link.url;
+      if (!seen.has(key) && link.url && !link.url.startsWith('#') && !link.url.startsWith('javascript:')) {
+        seen.add(key);
+        // Resolve relative URLs
+        if (link.url.startsWith('/') && url) {
+          try {
+            const base = new URL(url);
+            link.url = `${base.protocol}//${base.host}${link.url}`;
+          } catch {}
+        }
+        uniqueLinks.push(link);
+      }
+    }
+    this.links = uniqueLinks;
+
+    return {
+      title,
+      content: this._cleanOutput(output),
+      links: this.links,
+      images: this.images,
+    };
+  }
+
+  renderReader(html, url = '') {
+    const $ = cheerio.load(html);
+
+    // Remove navigation, ads, sidebars, etc
+    $('script, style, noscript, iframe, svg, nav, footer, header, aside, .ad, .ads, .advertisement, .sidebar, .menu, .nav, .cookie, .popup, .modal, .banner, .share, .social, .related, .comments, .comment, form, button, input, select, textarea').remove();
+
+    const title = $('title').text().trim() ||
+                  $('h1').first().text().trim() ||
+                  'Untitled Page';
+
+    // Try to find main content
+    let mainContent = $('article, [role="main"], main, .post-content, .article-content, .entry-content, .content, #content, #main').first();
+    if (!mainContent.length) {
+      mainContent = $('body');
+    }
+
+    this.links = [];
+    this.images = [];
+
+    let output = this._processElement($, mainContent, 0);
+
+    // Resolve relative URLs
+    const uniqueLinks = [];
+    const seen = new Set();
+    for (const link of this.links) {
+      if (!seen.has(link.url) && link.url && !link.url.startsWith('#') && !link.url.startsWith('javascript:')) {
+        seen.add(link.url);
+        if (link.url.startsWith('/') && url) {
+          try {
+            const base = new URL(url);
+            link.url = `${base.protocol}//${base.host}${link.url}`;
+          } catch {}
+        }
+        uniqueLinks.push(link);
+      }
+    }
+    this.links = uniqueLinks;
+
+    return {
+      title,
+      content: this._cleanOutput(output),
+      links: this.links,
+      images: this.images,
+    };
+  }
+
+  getPageInfo(html) {
+    const $ = cheerio.load(html);
+    return {
+      title: $('title').text().trim(),
+      description: $('meta[name="description"]').attr('content') || $('meta[property="og:description"]').attr('content') || '',
+      keywords: $('meta[name="keywords"]').attr('content') || '',
+      language: $('html').attr('lang') || '',
+      author: $('meta[name="author"]').attr('content') || '',
+      ogTitle: $('meta[property="og:title"]').attr('content') || '',
+      ogImage: $('meta[property="og:image"]').attr('content') || '',
+      ogType: $('meta[property="og:type"]').attr('content') || '',
+      canonical: $('link[rel="canonical"]').attr('href') || '',
+      favicon: $('link[rel="icon"]').attr('href') || $('link[rel="shortcut icon"]').attr('href') || '',
+      charset: $('meta[charset]').attr('charset') || '',
+      viewport: $('meta[name="viewport"]').attr('content') || '',
+      generator: $('meta[name="generator"]').attr('content') || '',
+    };
+  }
+
+  _processElement($, el, depth) {
+    let output = '';
+
+    $(el).contents().each((_, node) => {
+      if (node.type === 'text') {
+        const text = $(node).text();
+        if (text.trim()) {
+          output += text.replace(/\s+/g, ' ');
+        }
+      } else if (node.type === 'tag') {
+        const tagName = node.tagName?.toLowerCase();
+        const $node = $(node);
+
+        switch (tagName) {
+          case 'h1':
+            output += '\n\n' + theme.title('  ══ ' + $node.text().trim() + ' ══') + '\n\n';
+            break;
+          case 'h2':
+            output += '\n\n' + theme.title('  ── ' + $node.text().trim() + ' ──') + '\n';
+            break;
+          case 'h3':
+            output += '\n\n' + theme.accent('  ▸ ' + $node.text().trim()) + '\n';
+            break;
+          case 'h4':
+          case 'h5':
+          case 'h6':
+            output += '\n' + theme.accent('    ' + $node.text().trim()) + '\n';
+            break;
+          case 'p':
+            output += '\n  ' + this._processElement($, $node, depth).trim() + '\n';
+            break;
+          case 'br':
+            output += '\n';
+            break;
+          case 'hr':
+            output += '\n' + theme.muted('  ' + '─'.repeat(60)) + '\n';
+            break;
+          case 'a': {
+            const href = $node.attr('href') || '';
+            const text = $node.text().trim();
+            if (text && href) {
+              const linkIdx = this.links.length + 1;
+              this.links.push({ text, url: href });
+              output += theme.link(text) + theme.muted(` [${linkIdx}]`);
+            } else if (text) {
+              output += text;
+            }
+            break;
+          }
+          case 'img': {
+            const src = $node.attr('src') || '';
+            const alt = $node.attr('alt') || 'image';
+            if (src) {
+              this.images.push({ src, alt });
+              output += theme.muted(`[IMG: ${alt}]`);
+            }
+            break;
+          }
+          case 'strong':
+          case 'b':
+            output += theme.highlight($node.text().trim());
+            break;
+          case 'em':
+          case 'i':
+            output += theme.info($node.text().trim());
+            break;
+          case 'code':
+            output += theme.warning('`' + $node.text().trim() + '`');
+            break;
+          case 'pre': {
+            const code = $node.text().trim();
+            output += '\n' + theme.muted('  ┌─ code ────────────────────') + '\n';
+            code.split('\n').forEach(line => {
+              output += theme.muted('  │ ') + theme.secondary(line) + '\n';
+            });
+            output += theme.muted('  └─────────────────────────────') + '\n';
+            break;
+          }
+          case 'ul':
+            $node.children('li').each((_, li) => {
+              output += '\n  ' + theme.accent('  • ') + this._processElement($, $(li), depth + 1).trim();
+            });
+            output += '\n';
+            break;
+          case 'ol':
+            $node.children('li').each((i, li) => {
+              output += '\n  ' + theme.accent(`  ${i + 1}. `) + this._processElement($, $(li), depth + 1).trim();
+            });
+            output += '\n';
+            break;
+          case 'li':
+            output += this._processElement($, $node, depth + 1);
+            break;
+          case 'blockquote':
+            output += '\n' + theme.muted('  │ ') + theme.info(this._processElement($, $node, depth + 1).trim()) + '\n';
+            break;
+          case 'table': {
+            output += '\n';
+            $node.find('tr').each((_, tr) => {
+              const cells = [];
+              $(tr).find('th, td').each((__, cell) => {
+                cells.push($(cell).text().trim());
+              });
+              output += '  ' + theme.muted('│') + cells.map(c => ` ${c} `).join(theme.muted('│')) + theme.muted('│') + '\n';
+            });
+            output += '\n';
+            break;
+          }
+          case 'div':
+          case 'section':
+          case 'article':
+          case 'main':
+          case 'span':
+          case 'figure':
+          case 'figcaption':
+            output += this._processElement($, $node, depth);
+            break;
+          default:
+            output += this._processElement($, $node, depth);
+        }
+      }
+    });
+
+    return output;
+  }
+
+  _cleanOutput(text) {
+    return text
+      .replace(/\n{4,}/g, '\n\n\n')
+      .replace(/[ \t]+$/gm, '')
+      .trim();
+  }
+
+  getLinks() {
+    return this.links;
+  }
+
+  getImages() {
+    return this.images;
+  }
+}
+
+export default new Renderer();

package/src/search.js

@@ -0,0 +1,113 @@
+import axios from 'axios';
+import config from './config.js';
+import { theme } from './themes.js';
+
+class SearchEngine {
+  constructor() {
+    this.baseUrl = config.get('searxng');
+    this.lastResults = [];
+  }
+
+  async search(query, options = {}) {
+    const {
+      engine = null,
+      type = 'general',
+      time = null,
+      page = 1,
+      language = 'en',
+    } = options;
+
+    const params = {
+      q: query,
+      format: 'json',
+      categories: type,
+      pageno: page,
+      language,
+    };
+
+    if (engine) {
+      params.engines = engine;
+    }
+
+    if (time) {
+      const timeMap = {
+        day: 'day',
+        week: 'week',
+        month: 'month',
+        year: 'year',
+      };
+      params.time_range = timeMap[time] || time;
+    }
+
+    const proxy = config.get('proxy');
+    const axiosConfig = {
+      params,
+      headers: {
+        'User-Agent': config.get('userAgent'),
+        Accept: 'application/json',
+      },
+      timeout: 15000,
+    };
+
+    if (proxy) {
+      axiosConfig.proxy = {
+        host: proxy.split(':')[0],
+        port: parseInt(proxy.split(':')[1]),
+      };
+    }
+
+    const response = await axios.get(`${this.baseUrl}/search`, axiosConfig);
+    const data = response.data;
+
+    this.lastResults = (data.results || []).map((r, i) => ({
+      index: i + 1,
+      title: r.title || 'Untitled',
+      url: r.url || '',
+      content: r.content || '',
+      engine: r.engine || '',
+      category: r.category || type,
+      publishedDate: r.publishedDate || null,
+      thumbnail: r.thumbnail || null,
+      img_src: r.img_src || null,
+    }));
+
+    return {
+      results: this.lastResults,
+      query: data.query || query,
+      number_of_results: data.number_of_results || this.lastResults.length,
+      suggestions: data.suggestions || [],
+      infoboxes: data.infoboxes || [],
+    };
+  }
+
+  async multiSearch(query, options = {}) {
+    const categories = ['general', 'images', 'videos', 'news'];
+    const results = {};
+
+    const promises = categories.map(async (cat) => {
+      try {
+        const res = await this.search(query, { ...options, type: cat });
+        results[cat] = res.results.slice(0, 5);
+      } catch {
+        results[cat] = [];
+      }
+    });
+
+    await Promise.all(promises);
+    return results;
+  }
+
+  async imageSearch(query, options = {}) {
+    return this.search(query, { ...options, type: 'images' });
+  }
+
+  getLastResults() {
+    return this.lastResults;
+  }
+
+  getResultByIndex(idx) {
+    return this.lastResults[idx - 1] || null;
+  }
+}
+
+export default new SearchEngine();

package/src/sessions.js

@@ -0,0 +1,37 @@
+import config from './config.js';
+
+class SessionManager {
+  getSessions() {
+    return config.get('sessions') || {};
+  }
+
+  saveSession(domain, cookies) {
+    const sessions = this.getSessions();
+    sessions[domain] = {
+      cookies,
+      savedAt: new Date().toISOString(),
+    };
+    config.set('sessions', sessions);
+  }
+
+  getSession(domain) {
+    const sessions = this.getSessions();
+    return sessions[domain] || null;
+  }
+
+  removeSession(domain) {
+    const sessions = this.getSessions();
+    delete sessions[domain];
+    config.set('sessions', sessions);
+  }
+
+  clearAll() {
+    config.set('sessions', {});
+  }
+
+  listDomains() {
+    return Object.keys(this.getSessions());
+  }
+}
+
+export default new SessionManager();

package/src/stats.js

@@ -0,0 +1,66 @@
+import config from './config.js';
+
+class StatsManager {
+  constructor() {
+    this.sessionStart = Date.now();
+  }
+
+  incrementSearch() {
+    const stats = config.get('stats');
+    stats.searchCount = (stats.searchCount || 0) + 1;
+    config.set('stats', stats);
+  }
+
+  incrementPageVisit() {
+    const stats = config.get('stats');
+    stats.pagesVisited = (stats.pagesVisited || 0) + 1;
+    config.set('stats', stats);
+  }
+
+  getStats() {
+    const stats = config.get('stats');
+    const now = Date.now();
+    const sessionTime = now - this.sessionStart;
+    const totalTime = (stats.totalTime || 0) + sessionTime;
+
+    return {
+      searchCount: stats.searchCount || 0,
+      pagesVisited: stats.pagesVisited || 0,
+      sessionTime: this.formatTime(sessionTime),
+      totalTime: this.formatTime(totalTime),
+      bookmarkCount: (config.get('bookmarks') || []).length,
+      historyCount: (config.get('history') || []).length,
+    };
+  }
+
+  formatTime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+
+  saveTotalTime() {
+    const stats = config.get('stats');
+    stats.totalTime = (stats.totalTime || 0) + (Date.now() - this.sessionStart);
+    config.set('stats', stats);
+  }
+
+  reset() {
+    config.set('stats', {
+      searchCount: 0,
+      pagesVisited: 0,
+      startTime: Date.now(),
+      totalTime: 0,
+    });
+  }
+}
+
+export default new StatsManager();

package/src/tabs.js

@@ -0,0 +1,147 @@
+import config from './config.js';
+
+class TabManager {
+  constructor() {
+    this.tabs = [this._createTab('New Tab')];
+    this.activeTab = 0;
+  }
+
+  _createTab(title = 'New Tab') {
+    return {
+      id: Date.now(),
+      title,
+      url: null,
+      html: null,
+      content: null,
+      links: [],
+      history: [],
+      historyIndex: -1,
+    };
+  }
+
+  newTab(title) {
+    if (this.tabs.length >= config.get('maxTabs')) {
+      throw new Error(`Maximum tabs (${config.get('maxTabs')}) reached`);
+    }
+    const tab = this._createTab(title);
+    this.tabs.push(tab);
+    this.activeTab = this.tabs.length - 1;
+    return this.activeTab;
+  }
+
+  closeTab(index) {
+    if (index === undefined) index = this.activeTab;
+    if (this.tabs.length <= 1) {
+      throw new Error('Cannot close the last tab');
+    }
+    if (index < 0 || index >= this.tabs.length) {
+      throw new Error('Invalid tab index');
+    }
+    this.tabs.splice(index, 1);
+    if (this.activeTab >= this.tabs.length) {
+      this.activeTab = this.tabs.length - 1;
+    }
+    return this.activeTab;
+  }
+
+  switchTab(index) {
+    if (index < 0 || index >= this.tabs.length) {
+      throw new Error(`Tab ${index + 1} does not exist`);
+    }
+    this.activeTab = index;
+    return this.getCurrentTab();
+  }
+
+  getCurrentTab() {
+    return this.tabs[this.activeTab];
+  }
+
+  setCurrentPage(url, title, html, content, links) {
+    const tab = this.getCurrentTab();
+    
+    // Add to tab history
+    if (tab.url) {
+      tab.history = tab.history.slice(0, tab.historyIndex + 1);
+      tab.history.push({
+        url: tab.url,
+        title: tab.title,
+        html: tab.html,
+        content: tab.content,
+        links: tab.links,
+      });
+      tab.historyIndex = tab.history.length - 1;
+    }
+
+    tab.url = url;
+    tab.title = title || 'Untitled';
+    tab.html = html;
+    tab.content = content;
+    tab.links = links || [];
+  }
+
+  goBack() {
+    const tab = this.getCurrentTab();
+    if (tab.historyIndex < 0) {
+      throw new Error('No previous page');
+    }
+
+    const prev = tab.history[tab.historyIndex];
+    tab.historyIndex--;
+
+    // Save current to forward
+    const currentPage = {
+      url: tab.url,
+      title: tab.title,
+      html: tab.html,
+      content: tab.content,
+      links: tab.links,
+    };
+
+    tab.url = prev.url;
+    tab.title = prev.title;
+    tab.html = prev.html;
+    tab.content = prev.content;
+    tab.links = prev.links;
+
+    // Store current page for forward
+    if (tab.historyIndex + 2 < tab.history.length) {
+      tab.history[tab.historyIndex + 2] = currentPage;
+    } else {
+      tab.history.push(currentPage);
+    }
+
+    return tab;
+  }
+
+  goForward() {
+    const tab = this.getCurrentTab();
+    if (tab.historyIndex + 2 >= tab.history.length) {
+      throw new Error('No next page');
+    }
+    tab.historyIndex += 2;
+
+    const next = tab.history[tab.historyIndex];
+    tab.url = next.url;
+    tab.title = next.title;
+    tab.html = next.html;
+    tab.content = next.content;
+    tab.links = next.links;
+
+    return tab;
+  }
+
+  getAllTabs() {
+    return this.tabs.map((tab, i) => ({
+      index: i + 1,
+      title: tab.title,
+      url: tab.url,
+      active: i === this.activeTab,
+    }));
+  }
+
+  getActiveIndex() {
+    return this.activeTab;
+  }
+}
+
+export default new TabManager();