50c 2.5.2 → 2.6.0

package/lib/packs/beacon.js

@@ -47,19 +47,19 @@ async function learningStats() {
 }
 
 async function roadmapAdd(idea, priority = 'medium', tags = []) {
-  return apiRequest('POST', '/tools/roadmap', { action: 'add', idea, priority, tags });
+  return apiRequest('POST', '/tools/roadmap_add', { idea, priority, tags });
 }
 
 async function roadmapList(filter = null) {
-  return apiRequest('POST', '/tools/roadmap', { action: 'list', filter });
+  return apiRequest('POST', '/tools/roadmap_list', { filter });
 }
 
 async function roadmapUpdate(id, updates) {
-  return apiRequest('POST', '/tools/roadmap', { action: 'update', id, ...updates });
+  return apiRequest('POST', '/tools/roadmap_update', { id, ...updates });
 }
 
 async function roadmapDelete(id) {
-  return apiRequest('POST', '/tools/roadmap', { action: 'delete', id });
+  return apiRequest('POST', '/tools/roadmap_delete', { id });
 }
 
 // Tool definitions - STARTER tier ($29/mo)

package/lib/packs/librarian.js

@@ -96,6 +96,210 @@ async function folderPlan(fileList, instruction) {
   });
 }
 
+// ═══════════════════════════════════════════════════════════════
+//                    BROWSER UTILITIES (LOCAL)
+// ═══════════════════════════════════════════════════════════════
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+function getChromeDataPath(profile = 'Default') {
+  const platform = process.platform;
+  const home = process.env.HOME || process.env.USERPROFILE;
+  
+  if (platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA, 'Google', 'Chrome', 'User Data', profile);
+  } else if (platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Google', 'Chrome', profile);
+  } else {
+    return path.join(home, '.config', 'google-chrome', profile);
+  }
+}
+
+function parseBookmarksFile(profile = 'Default') {
+  const bookmarksPath = path.join(getChromeDataPath(profile), 'Bookmarks');
+  if (!fs.existsSync(bookmarksPath)) {
+    throw new Error(`Chrome bookmarks not found at ${bookmarksPath}`);
+  }
+  
+  const data = JSON.parse(fs.readFileSync(bookmarksPath, 'utf8'));
+  const urls = [];
+  
+  function extractUrls(node, folder = '') {
+    if (node.url) {
+      urls.push({ url: node.url, title: node.name, folder });
+    }
+    if (node.children) {
+      const newFolder = node.name || folder;
+      node.children.forEach(child => extractUrls(child, newFolder));
+    }
+  }
+  
+  Object.values(data.roots).forEach(root => extractUrls(root));
+  return urls;
+}
+
+function checkUrl(url, timeout = 10000) {
+  return new Promise((resolve) => {
+    const protocol = url.startsWith('https') ? https : http;
+    const req = protocol.get(url, { 
+      timeout,
+      headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0' }
+    }, (res) => {
+      resolve({ url, status: res.statusCode, ok: res.statusCode >= 200 && res.statusCode < 400 });
+    });
+    req.on('error', (e) => resolve({ url, status: 0, ok: false, error: e.message }));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ url, status: 0, ok: false, error: 'timeout' });
+    });
+  });
+}
+
+async function chromeBookmarksCheck(limit = 100, timeout = 10, profile = 'Default') {
+  const bookmarks = parseBookmarksFile(profile);
+  const toCheck = bookmarks.filter(b => 
+    b.url.startsWith('http') && !b.url.includes('localhost') && !b.url.includes('127.0.0.1')
+  ).slice(0, limit);
+  
+  const results = { ok: [], dead: [], errors: [], skipped: bookmarks.length - toCheck.length };
+  
+  // Check in batches of 10
+  for (let i = 0; i < toCheck.length; i += 10) {
+    const batch = toCheck.slice(i, i + 10);
+    const checks = await Promise.all(batch.map(b => checkUrl(b.url, timeout * 1000)));
+    
+    checks.forEach((result, idx) => {
+      const bookmark = batch[idx];
+      if (result.ok) {
+        results.ok.push({ ...bookmark, status: result.status });
+      } else if (result.status === 404) {
+        results.dead.push({ ...bookmark, status: 404 });
+      } else {
+        results.errors.push({ ...bookmark, status: result.status, error: result.error });
+      }
+    });
+  }
+  
+  return {
+    total: bookmarks.length,
+    checked: toCheck.length,
+    ok: results.ok.length,
+    dead: results.dead,
+    errors: results.errors.filter(e => e.status !== 403), // 403 = login required, not dead
+    login_required: results.errors.filter(e => e.status === 403),
+    skipped: results.skipped
+  };
+}
+
+function getExtensionsInfo(profile = 'Default') {
+  const extPath = path.join(getChromeDataPath(profile), 'Extensions');
+  if (!fs.existsSync(extPath)) {
+    return { error: 'Extensions folder not found' };
+  }
+  
+  const extensions = [];
+  const extDirs = fs.readdirSync(extPath);
+  
+  extDirs.forEach(extId => {
+    const extDir = path.join(extPath, extId);
+    if (fs.statSync(extDir).isDirectory()) {
+      const versions = fs.readdirSync(extDir).filter(v => !v.startsWith('.'));
+      if (versions.length > 0) {
+        const latestVersion = versions.sort().pop();
+        const manifestPath = path.join(extDir, latestVersion, 'manifest.json');
+        
+        if (fs.existsSync(manifestPath)) {
+          try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            extensions.push({
+              id: extId,
+              name: manifest.name || 'Unknown',
+              version: manifest.version,
+              description: manifest.description?.substring(0, 100),
+              permissions: manifest.permissions || [],
+              hostPermissions: manifest.host_permissions || manifest.optional_host_permissions || []
+            });
+          } catch (e) {
+            extensions.push({ id: extId, name: 'Unknown', error: 'Invalid manifest' });
+          }
+        }
+      }
+    }
+  });
+  
+  // Flag risky extensions
+  const risky = extensions.filter(ext => {
+    const perms = [...(ext.permissions || []), ...(ext.hostPermissions || [])];
+    return perms.some(p => 
+      p.includes('<all_urls>') || 
+      p.includes('*://*/*') || 
+      p === 'webRequest' || 
+      p === 'webRequestBlocking'
+    );
+  });
+  
+  return {
+    total: extensions.length,
+    extensions,
+    risky,
+    recommendations: risky.length > 0 ? 
+      `Found ${risky.length} extensions with broad permissions. Review: ${risky.map(e => e.name).join(', ')}` : 
+      'No obviously risky extensions found'
+  };
+}
+
+async function passwordsCheck(exportFile, checkBreaches = false) {
+  if (!fs.existsSync(exportFile)) {
+    return { error: `File not found: ${exportFile}` };
+  }
+  
+  const csv = fs.readFileSync(exportFile, 'utf8');
+  const lines = csv.split('\n').slice(1); // Skip header
+  
+  const passwords = lines.filter(l => l.trim()).map(line => {
+    const parts = line.split(',');
+    return {
+      name: parts[0],
+      url: parts[1],
+      username: parts[2],
+      password: parts[3]
+    };
+  });
+  
+  // Check for weak passwords
+  const weak = passwords.filter(p => {
+    const pwd = p.password || '';
+    return pwd.length < 8 || 
+           pwd === pwd.toLowerCase() || 
+           /^[0-9]+$/.test(pwd) ||
+           ['password', '123456', 'qwerty'].includes(pwd.toLowerCase());
+  });
+  
+  // Check for reused passwords
+  const pwdCounts = {};
+  passwords.forEach(p => {
+    const pwd = p.password;
+    pwdCounts[pwd] = (pwdCounts[pwd] || 0) + 1;
+  });
+  const reused = Object.entries(pwdCounts).filter(([_, count]) => count > 1);
+  
+  return {
+    total: passwords.length,
+    weak: weak.map(p => ({ name: p.name, url: p.url, reason: 'Weak password pattern' })),
+    reused: reused.map(([pwd, count]) => ({ 
+      count, 
+      sites: passwords.filter(p => p.password === pwd).map(p => p.name).slice(0, 3)
+    })),
+    recommendations: [
+      weak.length > 0 ? `${weak.length} weak passwords need updating` : null,
+      reused.length > 0 ? `${reused.length} passwords are reused across sites` : null
+    ].filter(Boolean)
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════
 //                    TOOL DEFINITIONS
 // ═══════════════════════════════════════════════════════════════
@@ -439,6 +643,76 @@ const LIBRARIAN_TOOLS = [
     },
     cost: 0.08,
     tier: 'pro'
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  //                    BROWSER MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  {
+    name: 'chrome_bookmarks_check',
+    description: 'Check Chrome bookmarks for dead links (404, timeouts). Local scan. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', default: 100, description: 'Max URLs to check' },
+        timeout: { type: 'number', default: 10, description: 'Timeout per URL (seconds)' },
+        profile: { type: 'string', default: 'Default', description: 'Chrome profile name' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'chrome_bookmarks_report',
+    description: 'Full bookmark health report with categorization. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_recommendations: { type: 'boolean', default: true },
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'chrome_extensions_audit',
+    description: 'Audit installed Chrome extensions for security/bloat. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'browser_passwords_check',
+    description: 'Check for weak/reused passwords (via Puppeteer). $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        export_file: { type: 'string', description: 'Path to exported passwords CSV' },
+        check_breaches: { type: 'boolean', default: false, description: 'Check haveibeenpwned (requires API key)' }
+      },
+      required: ['export_file']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'browser_history_analyze',
+    description: 'Analyze browsing patterns for productivity insights. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        days: { type: 'number', default: 30, description: 'Days of history to analyze' },
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0.08,
+    tier: 'pro'
   }
 ];
 
@@ -471,6 +745,26 @@ async function handleTool(name, args) {
         return await folderDedup(args.files, args);
       case 'folder_plan':
         return await folderPlan(args.files, args.instruction);
+      
+      // Browser tools (local execution)
+      case 'chrome_bookmarks_check':
+        return await chromeBookmarksCheck(args.limit || 100, args.timeout || 10, args.profile || 'Default');
+      case 'chrome_bookmarks_report':
+        const checkResult = await chromeBookmarksCheck(500, 8, args.profile || 'Default');
+        return apiRequest('POST', '/tools/librarian/bookmarks_report', { 
+          check_result: checkResult, 
+          include_recommendations: args.include_recommendations !== false 
+        });
+      case 'chrome_extensions_audit':
+        return getExtensionsInfo(args.profile || 'Default');
+      case 'browser_passwords_check':
+        return await passwordsCheck(args.export_file, args.check_breaches);
+      case 'browser_history_analyze':
+        return apiRequest('POST', '/tools/librarian/history_analyze', { 
+          days: args.days || 30, 
+          profile: args.profile || 'Default' 
+        });
+      
       default:
         return { error: `Unknown librarian tool: ${name}` };
     }
@@ -492,5 +786,9 @@ module.exports = {
   folderAnalyze,
   folderOrganize,
   folderDedup,
-  folderPlan
+  folderPlan,
+  // Browser tools
+  chromeBookmarksCheck,
+  getExtensionsInfo,
+  passwordsCheck
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "50c",
-  "version": "2.5.2",
-  "description": "AI toolkit with Dewey index. One install, 100+ tools.",
+  "version": "2.6.0",
+  "description": "AI toolkit with browser tools. One install, 100+ tools.",
   "main": "lib/index.js",
   "bin": {
     "50c": "./bin/50c.js"