novaprime 1.7.1 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novaprime",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "NovaPrime — an AI coding assistant in your terminal, powered by GLM.",
   "bin": {
     "novaprime": "bin/novaprime.js"
@@ -13,11 +13,19 @@
   "engines": {
     "node": ">=18"
   },
-  "keywords": ["ai", "cli", "coding", "assistant", "glm", "novaprime"],
+  "keywords": [
+    "ai",
+    "cli",
+    "coding",
+    "assistant",
+    "glm",
+    "novaprime"
+  ],
   "license": "MIT",
   "dependencies": {
     "boxen": "^5.1.2",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1"
+    "ora": "^5.4.1",
+    "puppeteer-core": "^25.1.0"
   }
 }

package/src/agent.js

@@ -26,6 +26,10 @@ const SYSTEM_PROMPT =
   `You MAY start the dev server when the project is ready — run it with run_command (e.g. "cd <project> && npm run dev"). ` +
   `Dev/watch servers are automatically run in the BACKGROUND and the tool returns the localhost URL, so they do NOT block. ` +
   `After it starts, give the user the localhost URL to open in their browser, and do NOT start it a second time. ` +
+  `BROWSING: you can browse the web with the \`browse\` tool — use it to open a link the user shares and read it, ` +
+  `and ESPECIALLY to VERIFY your own work: after starting a site/app, browse its localhost URL to check it actually ` +
+  `renders and to see any JavaScript/console errors, then fix the issues you find and browse again to confirm. ` +
+  `Use \`open_url\` to open a page in the user's own browser when they want to see it themselves. ` +
   `Be concise and warm. Current OS: ${os.platform()}. Working directory: ${process.cwd()}.`;
 
 // Fetch read-only account info for the header (name, plan, usage). Never throws.

package/src/tools.js

@@ -62,6 +62,82 @@ function stopBackground() {
   for (const s of bgServers) { try { s.child.kill(); } catch (_) {} }
 }
 
+// Find an installed Chrome/Edge/Chromium on this machine (so puppeteer-core needs no download).
+function findBrowser() {
+  const cands = [];
+  if (process.platform === 'win32') {
+    const pf = process.env['PROGRAMFILES'] || 'C:\\Program Files';
+    const pf86 = process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)';
+    const la = process.env['LOCALAPPDATA'] || '';
+    cands.push(
+      pf86 + '\\Microsoft\\Edge\\Application\\msedge.exe',
+      pf + '\\Microsoft\\Edge\\Application\\msedge.exe',
+      pf + '\\Google\\Chrome\\Application\\chrome.exe',
+      pf86 + '\\Google\\Chrome\\Application\\chrome.exe',
+      la + '\\Google\\Chrome\\Application\\chrome.exe',
+    );
+  } else if (process.platform === 'darwin') {
+    cands.push('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge', '/Applications/Chromium.app/Contents/MacOS/Chromium');
+  } else {
+    cands.push('/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser', '/usr/bin/microsoft-edge', '/snap/bin/chromium');
+  }
+  for (const p of cands) { try { if (p && fs.existsSync(p)) return p; } catch (_) {} }
+  return null;
+}
+
+// Visit a URL. Uses a headless browser (system Chrome/Edge via puppeteer-core) for
+// real JS rendering + console errors — otherwise falls back to a plain HTTP fetch.
+async function browsePage(url, waitMs) {
+  let pup = null, isCore = false;
+  try { pup = require('puppeteer'); } catch (_) { try { pup = require('puppeteer-core'); isCore = true; } catch (_) {} }
+  const exe = isCore ? findBrowser() : null;
+  if (pup && (!isCore || exe)) {
+    let browser;
+    try {
+      const opts = { headless: 'new', args: ['--no-sandbox', '--disable-setuid-sandbox'] };
+      if (exe) opts.executablePath = exe;
+      browser = await pup.launch(opts);
+      const page = await browser.newPage();
+      const errors = [];
+      page.on('console', (m) => { if (m.type() === 'error') errors.push('console.error: ' + m.text()); });
+      page.on('pageerror', (e) => errors.push('pageerror: ' + e.message));
+      const resp = await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+      if (waitMs) await new Promise((r) => setTimeout(r, Math.min(Math.max(0, waitMs), 8000)));
+      const title = await page.title();
+      const text = await page.evaluate(() => (document.body ? document.body.innerText : ''));
+      try { await browser.close(); } catch (_) {}
+      const status = resp ? resp.status() : '?';
+      return {
+        summary: 'rendered (HTTP ' + status + ')' + (errors.length ? ' · ' + errors.length + ' JS error(s)' : ' · no JS errors'),
+        text: 'URL: ' + url + '\nHTTP ' + status + '  ·  title: ' + title + '\n' +
+          (errors.length ? 'JAVASCRIPT ERRORS:\n' + errors.join('\n') + '\n\n' : '(no console errors)\n\n') +
+          'RENDERED PAGE TEXT:\n' + clip(text),
+      };
+    } catch (e) { try { if (browser) await browser.close(); } catch (_) {} /* fall back to fetch */ }
+  }
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 20000);
+    const r = await fetch(url, { signal: ctrl.signal, headers: { 'user-agent': 'NovaPrime-CLI' } });
+    clearTimeout(t);
+    const ct = (r.headers.get('content-type') || '').split(';')[0];
+    const body = await r.text();
+    const tm = body.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const title = tm ? tm[1].trim() : '';
+    const isHtml = /html/i.test(ct);
+    const text = isHtml
+      ? body.replace(/<script[\s\S]*?<\/script>/gi, ' ').replace(/<style[\s\S]*?<\/style>/gi, ' ').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+      : body;
+    return {
+      summary: 'fetched (HTTP ' + r.status + ', ' + ct + ')',
+      text: 'URL: ' + url + '\nHTTP ' + r.status + '  ·  ' + ct + (title ? '  ·  title: ' + title : '') + '\n\n' +
+        (isHtml ? 'NOTE: plain HTTP fetch (JavaScript NOT rendered — a React/Vite app shows little here). For full rendered output + console errors, install puppeteer in the CLI.\n\nVISIBLE TEXT:\n' : 'BODY:\n') + clip(text),
+    };
+  } catch (e) {
+    return { summary: 'failed: ' + e.message, text: 'ERROR browsing ' + url + ': ' + e.message };
+  }
+}
+
 // Permission gate. Returns true if allowed. In auto-accept mode it never asks.
 // Answering "a" (always) flips auto-accept ON for the rest of the session.
 async function allow(label) {
@@ -129,6 +205,27 @@ const definitions = [
       required: ['command'],
     },
   },
+  {
+    name: 'browse',
+    description: 'Visit a web URL (including http://localhost dev servers) and read it. Returns the HTTP status, page title, the RENDERED visible text, and any JavaScript console/page errors. Use this to open a link the user shares, and especially to VERIFY a website/app you built actually works — check it renders and find runtime errors — then fix the issues you find.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'Full URL, e.g. http://localhost:5173 or https://example.com' },
+        wait_ms: { type: 'number', description: 'Optional extra wait for the page to render (max 8000)' },
+      },
+      required: ['url'],
+    },
+  },
+  {
+    name: 'open_url',
+    description: 'Open a URL in the USER\'s real default browser so they can see it themselves (e.g. show them the dev server or a finished page).',
+    input_schema: {
+      type: 'object',
+      properties: { url: { type: 'string' } },
+      required: ['url'],
+    },
+  },
 ];
 
 function clip(s) {
@@ -189,6 +286,30 @@ async function execute(name, input) {
         const out = (r.stdout || '') + (r.stderr || '');
         return clip(`exit_code=${r.status}\n${out}`.trim());
       }
+      case 'browse': {
+        const url = String(input.url || '').trim();
+        if (!/^https?:\/\//i.test(url)) return 'ERROR: url must start with http:// or https://';
+        const isLocal = /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(:|\/|$)/i.test(url);
+        console.log('');
+        console.log(c.indigo('  ╭─ permission · browse ') + c.dim('────────────────────'));
+        console.log(c.indigo('  │ ') + c.bold(url) + (isLocal ? c.dim('   (localhost)') : ''));
+        if (!isLocal) {
+          if (!(await allow(c.indigo('  ╰─ open this URL?')))) { console.log(c.dim('  · skipped')); return 'DENIED: user did not allow browsing this URL.'; }
+        } else { console.log(c.indigo('  ╰─ ') + c.dim('visiting…')); }
+        const res = await browsePage(url, input.wait_ms);
+        console.log(c.green('  ✓ ') + c.dim(res.summary));
+        return res.text;
+      }
+      case 'open_url': {
+        const url = String(input.url || '').trim();
+        if (!/^https?:\/\//i.test(url)) return 'ERROR: url must start with http:// or https://';
+        console.log(c.green('  ↗ ') + c.body('opening in your browser: ') + c.white(url));
+        try {
+          if (process.platform === 'win32') spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+          else spawn(process.platform === 'darwin' ? 'open' : 'xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+        } catch (e) { return 'ERROR opening browser: ' + e.message; }
+        return 'OK: opened ' + url + ' in the default browser for the user to see.';
+      }
       default:
         return 'ERROR: unknown tool ' + name;
     }