fix(ai): sniff the accumulated tail, not the raw chunk (PR #35 review)

1. runCommand streams arbitrary stdout slices, so a dev server's address
   routinely arrives split across a boundary — "http://local" + "host:5173/" —
   and neither half matches. The preview would then silently never open, which is
   the worst failure mode for this feature because there is nothing to point at.
   Simulated against the real streaming path:

     per-chunk (old): null
     tail      (new): "http://localhost:5173/"

   The sniffs now read a bounded tail of entry.ring, which was already being
   maintained for read_command_output. 8 KB is far more than any single log line
   needs, and bounding it keeps the rescan cheap for a noisy watcher that never
   prints an address at all.

   Applied to ALL THREE sniffs, not just the preview: port and ready had the same
   latent gap, and fixing only the new one would have left the identical bug in
   place next to it.

2. ctx.openPreview is async and was called bare. Now wrapped so a rejection can
   never escape into a live stream handler — showing a browser tab must not be
   able to disturb a running command's output.

3. The junk-input test asserted only doesNotThrow. For a stdout handler that is
   necessary but not sufficient: a non-null return would still pop a browser tab.
   It now asserts the value is null, over a wider set of junk.

Verified: 23 suites, 0 failures; verify.test.js is 16 cases. The split-chunk case
is pinned with the real sniffer — each half must not match, the join must.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ndemianc

extensions/levelcode-ai/agent.js

@@ -69,6 +69,11 @@ function buildSystem(menu) {
 }
 const TOOLS_TOKENS_EST = Math.round(JSON.stringify(TOOLS).length / 4);
 
+// How much of a background command's accumulated output the sniffers re-read on each chunk. Generous
+// next to any single log line, so a url split across chunk boundaries is still found, yet small enough
+// that a noisy watcher which never prints an address costs nothing to keep scanning.
+const SNIFF_TAIL = 8192;
+
 const FILE_EXCLUDES = '{**/node_modules/**,**/.git/**,**/out/**,**/dist/**,**/.vscode-test/**,**/*.map}';
 
 // ---- ripgrep search (self-contained) ---------------------------------------
@@ -392,15 +397,27 @@ async function runTool(tu, ctx) {
 				if (entry) {
 					entry.ring = (entry.ring + chunk).slice(-100000);   // bounded tail for read_command_output
 					entry.totalBytes += chunk.length;
-					if (!entry.port) { const p = sniffPort(chunk); if (p) { entry.port = p; ctx.post({ type: 'bgTask', id: runId, port: p }); } }
-					if (!entry.ready && looksReady(chunk)) { entry.ready = true; ctx.post({ type: 'bgTask', id: runId, ready: true }); }
+					// Sniff the accumulated TAIL, never the raw chunk: stdout arrives in arbitrary slices, so
+					// a line can straddle a boundary ("http://local" + "host:5173/") and match neither half.
+					// A few KB is far more than any single line needs, and bounding it keeps the rescan cheap
+					// for a chatty server that never prints an address at all. (Applies to all three sniffs —
+					// port and ready had the same latent gap.)
+					const tail = entry.ring.slice(-SNIFF_TAIL);
+					if (!entry.port) { const p = sniffPort(tail); if (p) { entry.port = p; ctx.post({ type: 'bgTask', id: runId, port: p }); } }
+					if (!entry.ready && looksReady(tail)) { entry.ready = true; ctx.post({ type: 'bgTask', id: runId, ready: true }); }
 					// Auto-preview: the moment a background command advertises a LOCAL address, offer to show
 					// it in the built-in browser. Fired at most ONCE per run — if the user closes the tab we
 					// must not reopen it on the next log line, and a restart-on-save server would otherwise
 					// spawn a tab per reload. The host decides whether to honour it (setting + dedupe).
 					if (!entry.previewUrl && typeof ctx.openPreview === 'function') {
-						const url = sniffPreviewUrl(chunk);
-						if (url) { entry.previewUrl = url; dbg('preview.detected', { id: runId, url: url }); ctx.openPreview(url); }
+						const url = sniffPreviewUrl(tail);
+						if (url) {
+							entry.previewUrl = url;
+							dbg('preview.detected', { id: runId, url: url });
+							// Never let a preview reject inside a live stream handler — showing a browser tab
+							// must not be able to disturb a running command's output.
+							Promise.resolve(ctx.openPreview(url)).catch((e) => dbg('preview.rejected', { id: runId, error: String((e && e.message) || e) }));
+						}
 					}
 				}
 			};

extensions/levelcode-ai/test/verify.test.js

@@ -76,13 +76,28 @@ test('PREVIEW: silence when nothing resembles a server', () => {
 	}
 });
 
-test('PREVIEW: garbage input returns null instead of throwing', () => {
-	// This runs inside a stdout handler — a throw here would take down a live command stream.
-	for (const junk of [{}, [], 42, true, Symbol.iterator.toString()]) {
-		assert.doesNotThrow(() => sniffPreviewUrl(/** @type {any} */(junk)));
+test('PREVIEW: garbage input returns null — not merely "does not throw"', () => {
+	// This runs inside a stdout handler, so not throwing is necessary but nowhere near sufficient:
+	// returning a non-null url would still pop a browser tab. Assert the value, not just the absence
+	// of an exception.
+	for (const junk of [{}, [], 42, true, Symbol.iterator.toString(), NaN, () => {}]) {
+		let got;
+		assert.doesNotThrow(() => { got = sniffPreviewUrl(/** @type {any} */(junk)); }, 'threw on ' + String(junk));
+		assert.strictEqual(got, null, 'opened something from junk input: ' + String(junk));
 	}
 });
 
+test('SPLIT: a url straddling two stdout chunks matches only once reassembled', () => {
+	// Why agent.js sniffs the accumulated ring TAIL rather than the raw chunk. runCommand streams
+	// arbitrary slices, so a dev server's address routinely arrives in two pieces — and each piece on
+	// its own is invisible to the sniffer, which would mean the preview silently never opened.
+	const first = '  ➜  Local:   http://local';
+	const second = 'host:5173/\n';
+	assert.strictEqual(sniffPreviewUrl(first), null, 'the leading half must not match on its own');
+	assert.strictEqual(sniffPreviewUrl(second), null, 'the trailing half must not match on its own');
+	assert.strictEqual(sniffPreviewUrl(first + second), 'http://localhost:5173/', 'reassembled, it must');
+});
+
 // ---- 3. the sniffers the preview builds on (previously untested) ------------------------------
 
 test('PORT: the most specific pattern wins, so later logs cannot masquerade as the server', () => {