novaprime 1.5.1 → 1.6.1

package/bin/novaprime.js

@@ -5,6 +5,7 @@ const ui = require('../src/ui');
 const { c } = ui;
 const { ask, close, boxInput } = require('../src/prompt');
 const { runTurn, fetchMe } = require('../src/agent');
+const tools = require('../src/tools');
 const pkg = require('../package.json');
 
 // Validate the key against the server before saving — a wrong key never logs in.
@@ -82,7 +83,8 @@ async function repl() {
   let me = await fetchMe(config.getServer(), cfg.key);
   console.clear(); // hide login/clutter — start clean with the header at the top
   ui.banner(meToBanner(cfg, me));
-  process.on('SIGINT', () => { console.log(c.muted('\n  bye')); process.exit(0); });
+  process.on('exit', () => { try { tools.stopBackground(); } catch (_) {} }); // stop bg dev servers on quit
+  process.on('SIGINT', () => { try { tools.stopBackground(); } catch (_) {} console.log(c.muted('\n  bye')); process.exit(0); });
 
   ui.hint('  Tip: press ' + c.indigo('Shift+Tab') + c.dim(' for auto-accept (no permission prompts), or answer ') + c.indigo('a') + c.dim(' at any prompt.'));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "novaprime",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "NovaPrime — an AI coding assistant in your terminal, powered by GLM.",
   "bin": {
     "novaprime": "bin/novaprime.js"

package/src/agent.js

@@ -17,9 +17,9 @@ const SYSTEM_PROMPT =
   `Use clear markdown: short paragraphs, bullet lists, and fenced code blocks with a language tag. ` +
   `When asked to create or change files, call the tool RIGHT AWAY with at most a one-line intro — ` +
   `do NOT write long explanations or feature lists before creating the file. Keep any summary to 1-2 short lines after. ` +
-  `NEVER start dev servers or long-running/blocking processes (e.g. "npm run dev", "npm start", "vite", "next dev", ` +
-  `"nodemon", watchers) — they block the session forever. After creating the files, finish, then tell the user the ` +
-  `commands to run it themselves (e.g. cd into the folder and run "npm run dev", then open the localhost URL). ` +
+  `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. ` +
   `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/prompt.js

@@ -3,8 +3,8 @@ const readline = require('readline');
 const { c } = require('./ui');
 const mode = require('./mode');
 
-// Use Node's readline for single-line prompts (login key, y/N) — it handles
-// editing and history. The multi-line chat box uses a paste-aware reader below.
+// Use Node's readline for single-line prompts (login key, y/N). The multi-line
+// chat box below is a custom raw-mode reader (paste-aware + Shift+Tab + full box).
 let rl = null;
 function getRl() {
   if (!rl) {
@@ -28,16 +28,13 @@ function confirm(message) {
 function close() { if (rl) { rl.close(); rl = null; } }
 
 // ---- bracketed-paste-aware chat input ----------------------------------
-// Terminals that support bracketed paste wrap pasted text in these markers.
-// We capture everything between them (newlines included) WITHOUT submitting,
-// so pasting a big multi-line prompt no longer auto-sends on the first line.
 const PASTE_START = '\x1b[200~';
 const PASTE_END = '\x1b[201~';
 
 function normalize(t) { return t.replace(/\r\n?/g, '\n'); }
+function visLen(s) { return String(s).replace(/\x1b\[[0-9;]*m/g, '').length; } // visible width, minus ANSI
 
-// length of the longest suffix of s that is a prefix of marker (handles a
-// marker that got split across two stdin chunks)
+// longest suffix of s that is a prefix of marker (marker split across chunks)
 function partialTail(s, marker) {
   const max = Math.min(s.length, marker.length - 1);
   for (let n = max; n > 0; n--) {
@@ -46,37 +43,30 @@ function partialTail(s, marker) {
   return 0;
 }
 
-// Handle a run of plain (non-paste) bytes: typing, Enter, backspace, Ctrl+C/D,
-// and swallow escape sequences (arrow keys, etc.) so they don't corrupt input.
+// Plain (non-paste) bytes: typing, Enter, backspace, Ctrl+C/D, Shift+Tab, skip arrows.
+// Only mutates state; the caller redraws the whole box afterward.
 function handlePlain(state, s, sink) {
   for (let i = 0; i < s.length && !state.finished; i++) {
     const ch = s[i];
-    if (ch === '\x03') { sink.cancel(); return; }                         // Ctrl+C
+    if (ch === '\x03') { sink.cancel(); return; }                          // Ctrl+C
     if (ch === '\x04') { if (!state.buf) { sink.cancel(); return; } continue; } // Ctrl+D on empty
-    if (ch === '\r' || ch === '\n') { sink.submit(state.buf); return; }   // Enter -> send
-    if (ch === '\x7f' || ch === '\b') {                                   // backspace
-      if (state.buf.length) {
-        const last = state.buf[state.buf.length - 1];
-        state.buf = state.buf.slice(0, -1);
-        if (last !== '\n') sink.out('\b \b');
-      }
-      continue;
-    }
+    if (ch === '\r' || ch === '\n') { sink.submit(state.buf); return; }    // Enter -> send
+    if (ch === '\x7f' || ch === '\b') { state.buf = state.buf.slice(0, -1); continue; } // backspace
     if (ch === '\x1b') {
       if (s.slice(i, i + 3) === '\x1b[Z') { if (sink.toggleMode) sink.toggleMode(); i += 2; continue; } // Shift+Tab
-      if (s[i + 1] === '[' || s[i + 1] === 'O') {                         // skip other CSI/SS3 escapes (arrows, fn keys)
+      if (s[i + 1] === '[' || s[i + 1] === 'O') {                          // skip arrows / fn keys
         i += 2;
         while (i < s.length && !/[A-Za-z~]/.test(s[i])) i++;
       }
       continue;
     }
-    if (ch === '\t') { state.buf += '  '; sink.out('  '); continue; }     // tab -> 2 spaces
-    if (ch >= ' ') { state.buf += ch; sink.out(ch); }                     // printable
+    if (ch === '\t') { state.buf += '  '; continue; }                      // tab -> 2 spaces
+    if (ch >= ' ') { state.buf += ch; }                                    // printable
   }
 }
 
 // Pure state machine — testable. state = { buf, pasting, pending, finished }.
-// sink = { out(str), submit(value), cancel() }.
+// sink = { submit(value), cancel(), toggleMode() }.
 function processChunk(state, chunk, sink) {
   let s = state.pending + chunk;
   state.pending = '';
@@ -85,13 +75,11 @@ function processChunk(state, chunk, sink) {
       const end = s.indexOf(PASTE_END);
       if (end === -1) {
         const hold = partialTail(s, PASTE_END);
-        const seg = normalize(s.slice(0, s.length - hold));
-        if (seg) { state.buf += seg; sink.out(seg); }
+        state.buf += normalize(s.slice(0, s.length - hold));
         state.pending = s.slice(s.length - hold);
         return;
       }
-      const seg = normalize(s.slice(0, end));
-      if (seg) { state.buf += seg; sink.out(seg); }
+      state.buf += normalize(s.slice(0, end));
       state.pasting = false;
       s = s.slice(end + PASTE_END.length);
       continue;
@@ -99,8 +87,7 @@ function processChunk(state, chunk, sink) {
     const start = s.indexOf(PASTE_START);
     if (start === -1) {
       const hold = partialTail(s, PASTE_START);
-      const plain = s.slice(0, s.length - hold);
-      handlePlain(state, plain, sink);
+      handlePlain(state, s.slice(0, s.length - hold), sink);
       if (!state.finished) state.pending = s.slice(s.length - hold);
       return;
     }
@@ -111,52 +98,70 @@ function processChunk(state, chunk, sink) {
   }
 }
 
-function ttyRaw() { return process.stdin.isTTY && typeof process.stdin.setRawMode === 'function'; }
+function ttyRaw() { return process.stdout.isTTY && process.stdin.isTTY && typeof process.stdin.setRawMode === 'function'; }
 
-// Chat input box. Top border above; readline-free raw reader captures multi-line
-// pastes; bottom border drawn after submit so the message shows as a complete box.
+// Chat input box: a COMPLETE bordered box (top + input lines + bottom) that
+// redraws on every change so the bottom stroke is always visible, multi-line
+// pastes grow the box, and auto-accept status shows inside.
 function boxInput(top, bottom, prompt) {
-  // Fallback for piped / non-TTY input (e.g. `echo ... | novaprime`): plain readline.
-  if (!ttyRaw()) {
+  if (!ttyRaw()) { // piped / non-TTY: fall back to readline
     return new Promise((resolve) => {
       process.stdout.write(top + '\n');
       const r = getRl();
       r.question(prompt, (answer) => { process.stdout.write(bottom + '\n'); resolve(answer); });
     });
   }
-  if (rl) { rl.close(); rl = null; } // release stdin from readline
+  if (rl) { rl.close(); rl = null; }
 
   return new Promise((resolve) => {
     const stdin = process.stdin;
     const state = { buf: '', pasting: false, pending: '', finished: false };
+    const contPrefix = c.dim('│ ');
+    let firstRender = true;
+    let prevUp = 0; // lines from the input line up to the first dynamic line (for clearing)
+
+    function render() {
+      const statusLines = mode.isAuto()
+        ? [c.green('  ⚡ auto-accept ON') + c.dim('  ·  Shift+Tab to turn off')]
+        : [];
+      const inputLines = state.buf.split('\n');
+      const dyn = statusLines
+        .concat(inputLines.map((ln, i) => (i === 0 ? prompt : contPrefix) + ln))
+        .concat([bottom]);
 
-    const onData = (chunk) => processChunk(state, chunk, sink);
-    const cleanup = () => {
+      let out = '';
+      if (!firstRender) { if (prevUp > 0) out += '\x1b[' + prevUp + 'A'; out += '\r\x1b[0J'; }
+      out += dyn.join('\n');
+      out += '\x1b[1A\r'; // from end of bottom up to the last input line, col 0
+      const prefVis = inputLines.length === 1 ? visLen(prompt) : visLen(contPrefix);
+      const col = prefVis + inputLines[inputLines.length - 1].length;
+      if (col > 0) out += '\x1b[' + col + 'C';
+      process.stdout.write(out);
+      prevUp = statusLines.length + (inputLines.length - 1);
+      firstRender = false;
+    }
+
+    function cleanup() {
       try { process.stdout.write('\x1b[?2004l'); } catch (_) {}
       try { stdin.setRawMode(false); } catch (_) {}
       stdin.pause();
       stdin.removeListener('data', onData);
-    };
-    const sink = {
-      out: (str) => process.stdout.write(str),
-      submit: (val) => { state.finished = true; cleanup(); process.stdout.write('\n' + bottom + '\n'); resolve(val); },
-      cancel: () => { state.finished = true; cleanup(); process.stdout.write('\n' + bottom + '\n'); resolve(null); },
-      toggleMode: () => {
-        const on = mode.toggle();
-        process.stdout.write('\r\x1b[2K'); // clear current input line
-        process.stdout.write((on
-          ? c.green('  ⚡ auto-accept: ON') + c.dim('  — running everything without asking (Shift+Tab to undo)')
-          : c.dim('  ⚡ auto-accept: OFF — will ask before changes')) + '\n');
-        process.stdout.write(prompt + state.buf); // redraw input line with whatever was typed
-      },
-    };
+    }
+    function finish(val) {
+      state.finished = true;
+      process.stdout.write('\x1b[1B\r\n'); // move below the bottom border
+      cleanup();
+      resolve(val);
+    }
+    const sink = { submit: (v) => finish(v), cancel: () => finish(null), toggleMode: () => mode.toggle() };
+    const onData = (chunk) => { processChunk(state, chunk, sink); if (!state.finished) render(); };
 
     process.stdout.write(top + '\n');
-    process.stdout.write(prompt);
+    render();
     stdin.setRawMode(true);
     stdin.resume();
     stdin.setEncoding('utf8');
-    process.stdout.write('\x1b[?2004h'); // enable bracketed paste
+    process.stdout.write('\x1b[?2004h'); // bracketed paste on
     stdin.on('data', onData);
   });
 }

package/src/tools.js

@@ -1,13 +1,67 @@
 'use strict';
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const { spawnSync, spawn } = require('child_process');
 const { ask } = require('./prompt');
 const { c, tool } = require('./ui');
 const mode = require('./mode');
 
 const MAX_OUTPUT = 20000; // cap tool output sent back to the model
 
+// dev/watch servers: long-running, so we run them DETACHED in the background and
+// hand back the localhost URL instead of blocking the session.
+const DEV_SERVER_RE = /\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|watch)\b|\bvite\b(?!\s+build)|\bnext\s+dev\b|\bnodemon\b|webpack-dev-server|webpack\s+serve|\bnpx\s+serve\b|\bhttp-server\b|\blive-server\b|php\s+-S|python\s+-m\s+http\.server|flask\s+run|rails\s+s(erver)?\b|\bng\s+serve\b/i;
+const URL_RE = /https?:\/\/(?:localhost|127\.0\.0\.1)(?::\d+)?\/?\S*/i;
+const bgServers = []; // { pid, cmd, child } — kept so they can be stopped on exit
+
+// Start a long-running command (dev server) in the background. We DON'T await it —
+// we stream its output to a log, grab the localhost URL, and return right away so the
+// session never blocks. It keeps running as a child of the CLI for the whole session.
+async function runBackground(cmd) {
+  const logPath = path.join(os.tmpdir(), 'novaprime-dev-' + Date.now() + '.log');
+  let log = '';
+  let child;
+  try {
+    child = spawn(cmd, { shell: true, windowsHide: true });
+  } catch (err) {
+    return 'ERROR starting dev server: ' + err.message;
+  }
+  bgServers.push({ pid: child.pid, cmd, child });
+  const onData = (d) => { const s = d.toString(); log += s; if (log.length > MAX_OUTPUT) log = log.slice(-MAX_OUTPUT); try { fs.appendFileSync(logPath, s); } catch (_) {} };
+  if (child.stdout) child.stdout.on('data', onData);
+  if (child.stderr) child.stderr.on('data', onData);
+  let earlyExit = null;
+  child.on('error', (e) => { log += '\n[spawn error] ' + e.message; });
+  child.on('exit', (code) => { earlyExit = code; });
+
+  const url = await new Promise((resolve) => {
+    const start = Date.now();
+    const t = setInterval(() => {
+      const m = log.match(URL_RE);
+      if (m) { clearInterval(t); resolve(m[0]); }
+      else if (earlyExit !== null) { clearInterval(t); resolve(null); }   // it crashed on startup
+      else if (Date.now() - start >= 10000) { clearInterval(t); resolve(null); }
+    }, 250);
+  });
+
+  if (earlyExit !== null && !url) {
+    console.log(c.amber('  ! dev server exited (code ' + earlyExit + ')'));
+    return 'The dev command "' + cmd + '" exited immediately (code ' + earlyExit + ') instead of staying up. It likely failed. Read the log and fix the problem, then start it again.\n\nOutput:\n' + clip(log);
+  }
+  console.log(c.green('  ✓ dev server running in background') + c.dim('  (pid ' + child.pid + ')'));
+  if (url) console.log(c.green('  → ') + c.white(url) + c.dim('  — open this in your browser'));
+  else console.log(c.dim('  · still starting… log: ' + logPath));
+  return 'OK: started "' + cmd + '" in the BACKGROUND (pid ' + child.pid + '), so the session is NOT blocked and the server keeps running. ' +
+    (url ? 'It is serving at ' + url + ' — tell the user to open that URL in their browser. ' : 'It is still booting; tell the user to watch for the localhost URL. ') +
+    'Do NOT start it again.\n\nStartup log:\n' + clip(log);
+}
+
+// Stop any background dev servers (called when the CLI exits).
+function stopBackground() {
+  for (const s of bgServers) { try { s.child.kill(); } catch (_) {} }
+}
+
 // 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) {
@@ -125,18 +179,13 @@ async function execute(name, input) {
       }
       case 'run_command': {
         const cmd = String(input.command || '');
-        // Refuse blocking dev servers / watchers — they never exit and freeze the session.
-        if (/\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|watch)\b|\bvite\b(?!\s+build)|\bnext\s+dev\b|\bnodemon\b|webpack-dev-server|webpack\s+serve|\bnpx\s+serve\b|\bhttp-server\b|\blive-server\b|php\s+-S|python\s+-m\s+http\.server|flask\s+run|rails\s+s(erver)?\b|\bng\s+serve\b/i.test(cmd)) {
-          console.log('');
-          console.log(c.amber('  ! ') + c.amber('skipped dev server: ') + c.white(cmd));
-          console.log(c.dim('    (long-running — start it yourself in another terminal when ready)'));
-          return 'SKIPPED: "' + cmd + '" is a long-running dev/watch server and was NOT run (it would block the session forever). Do NOT start dev servers. Finish the work, then tell the user how to run it themselves in a separate terminal, e.g. `cd <project>` then `npm run dev`, and to open the localhost URL it prints.';
-        }
+        const isDevServer = DEV_SERVER_RE.test(cmd);
         console.log('');
         console.log(c.red('  ╭─ permission · run command ') + c.dim('───────────────────'));
-        console.log(c.red('  │ ') + c.bold(input.command));
+        console.log(c.red('  │ ') + c.bold(cmd) + (isDevServer ? c.dim('   (runs in background)') : ''));
         if (!(await allow(c.red('  ╰─ run this command?')))) { console.log(c.dim('  · skipped')); return 'DENIED: user did not allow running the command.'; }
-        const r = spawnSync(input.command, { shell: true, encoding: 'utf8', timeout: 1000 * 120 });
+        if (isDevServer) return await runBackground(cmd); // long-running: detach so it doesn't block
+        const r = spawnSync(cmd, { shell: true, encoding: 'utf8', timeout: 1000 * 120 });
         const out = (r.stdout || '') + (r.stderr || '');
         return clip(`exit_code=${r.status}\n${out}`.trim());
       }
@@ -148,4 +197,4 @@ async function execute(name, input) {
   }
 }
 
-module.exports = { definitions, execute };
+module.exports = { definitions, execute, runBackground, stopBackground };