thepopebot 1.2.77 → 1.2.78-beta.1

package/lib/ai/headless-stream.js

@@ -1,4 +1,4 @@
-import { Transform } from 'stream';
+import { PassThrough } from 'stream';
 import split2 from 'split2';
 import { DockerFrameParser } from '../tools/docker.js';
 
@@ -47,23 +47,35 @@ export async function* parseHeadlessStream(dockerLogStream, codingAgent = 'claud
   };
   const mapper = mapperMap[codingAgent] || mapClaudeCodeLine;
 
-  // Layer 1: Docker frame decoder using shared DockerFrameParser
+  // Layer 1: Docker frame decoder. Stdout frames feed the line splitter;
+  // stderr frames are buffered and yielded as `{type:'stderr'}` chunks so the
+  // caller can surface them on silent failures (agent crashed before producing
+  // JSON).
+  const stdoutPipe = new PassThrough();
+  const stderrChunks = [];
   const parser = new DockerFrameParser();
-  const frameDecoder = new Transform({
-    transform(chunk, encoding, callback) {
+  let frameError = null;
+  dockerLogStream.on('data', (chunk) => {
+    try {
       for (const frame of parser.push(chunk)) {
         if (frame.stream === 'stdout') {
-          this.push(Buffer.from(frame.text, 'utf8'));
+          stdoutPipe.write(Buffer.from(frame.text, 'utf8'));
+        } else if (frame.stream === 'stderr' && frame.text) {
+          stderrChunks.push(frame.text);
         }
       }
-      callback();
+    } catch (err) {
+      frameError = err;
+      stdoutPipe.destroy(err);
     }
   });
+  dockerLogStream.on('end', () => stdoutPipe.end());
+  dockerLogStream.on('error', (err) => stdoutPipe.destroy(err));
 
-  // Layer 2: split2 for reliable line splitting
-  const lines = dockerLogStream.pipe(frameDecoder).pipe(split2());
+  // Layer 2: split2 for reliable line splitting (stdout only)
+  const lines = stdoutPipe.pipe(split2());
 
-  // Layer 3: map each complete line to chat events
+  // Layer 3: map each complete line to chat events; flush stderr at end
   for await (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -71,4 +83,8 @@ export async function* parseHeadlessStream(dockerLogStream, codingAgent = 'claud
       yield event;
     }
   }
+  if (frameError) throw frameError;
+  if (stderrChunks.length) {
+    yield { type: 'stderr', text: stderrChunks.join('') };
+  }
 }

package/lib/ai/index.js

@@ -350,6 +350,9 @@ async function* streamViaContainer({ threadId, message, options, codingAgent, wo
   const pendingToolCalls = new Map();
   let started = false;
   let wrapperClosed = false;
+  let producedAny = false;
+  let stderrTail = '';
+  const STDERR_TAIL_MAX = 4096;
 
   const closeWrapper = (result) => {
     if (wrapperClosed) return null;
@@ -384,6 +387,15 @@ async function* streamViaContainer({ threadId, message, options, codingAgent, wo
     const logStream = await tailContainerLogs(containerName);
 
     for await (const chunk of parseHeadlessStream(logStream, codingAgent)) {
+      // Buffer stderr server-side; never yield to the caller. Surfaced only
+      // when the agent died silently (producedAny stays false at stream end).
+      if (chunk.type === 'stderr') {
+        stderrTail = (stderrTail + chunk.text).slice(-STDERR_TAIL_MAX);
+        continue;
+      }
+      if (chunk.type === 'text' || chunk.type === 'tool-call' || chunk.type === 'tool-result') {
+        producedAny = true;
+      }
       if (chunk.type === 'text') {
         pendingText += chunk.text;
       } else if (chunk.type === 'tool-call') {
@@ -413,11 +425,20 @@ async function* streamViaContainer({ threadId, message, options, codingAgent, wo
     const exitCode = await waitForContainer(containerName);
     await removeContainer(containerName);
 
-    const closeResult = exitCode === 0 ? 'Completed' : `Exited with code ${exitCode}`;
+    const stderrTrimmed = stderrTail.trim();
+    const silentFailure = !producedAny && stderrTrimmed;
+
+    const closeResult = silentFailure
+      ? `Error: ${stderrTrimmed}`
+      : exitCode === 0 ? 'Completed' : `Exited with code ${exitCode}`;
     const closeChunk = closeWrapper(closeResult);
     if (closeChunk) yield closeChunk;
 
-    if (exitCode !== 0) {
+    if (silentFailure) {
+      const msg = `Coding agent produced no output. Stderr:\n${stderrTrimmed}`;
+      yield { type: 'error', message: msg };
+      try { saveMessage(threadId, options.userId,'assistant', JSON.stringify({ type: 'error', message: msg })); } catch {}
+    } else if (exitCode !== 0) {
       const msg = `Coding agent exited with code ${exitCode}`;
       yield { type: 'error', message: msg };
       try { saveMessage(threadId, options.userId,'assistant', JSON.stringify({ type: 'error', message: msg })); } catch {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thepopebot",
-  "version": "1.2.77",
+  "version": "1.2.78-beta.1",
   "type": "module",
   "description": "Create autonomous AI agents with a two-layer architecture: Next.js Event Handler + Docker Agent.",
   "bin": {
@@ -112,7 +112,7 @@
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "next": ">=15.5.12",
+    "next": "^15.5.12",
     "next-auth": "^5.0.0-beta.30",
     "next-themes": ">=0.4.0",
     "react": ">=19.0.0",

package/setup/setup.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { execSync } from 'child_process';
+import http from 'http';
 import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
@@ -438,19 +439,31 @@ async function main() {
   // Probe /login (not /api/ping) to confirm Next.js can actually render
   // the page, not just answer API routes. /login serves SetupForm on a
   // fresh install; LoginForm once a user exists. Either way it's HTML.
-  async function isLoginPageReady(timeoutMs = 2000) {
-    try {
-      const res = await fetch('http://localhost:80/login', {
-        method: 'GET',
-        signal: AbortSignal.timeout(timeoutMs),
-        redirect: 'manual',
-      });
-      if (!res.ok) return false;
-      const ct = res.headers.get('content-type') || '';
-      return ct.includes('text/html');
-    } catch {
-      return false;
-    }
+  // Traefik routes by Host(`${APP_HOSTNAME}`), so a bare localhost:80
+  // request hits Traefik's default 404 — set the Host header to match.
+  // node:http is used (not fetch) because undici silently strips Host.
+  const appHostname = collected.APP_HOSTNAME;
+  function isLoginPageReady(timeoutMs = 2000) {
+    return new Promise((resolve) => {
+      const req = http.request(
+        {
+          host: '127.0.0.1',
+          port: 80,
+          method: 'GET',
+          path: '/login',
+          headers: { Host: appHostname },
+          timeout: timeoutMs,
+        },
+        (res) => {
+          const ok = res.statusCode === 200 && (res.headers['content-type'] || '').includes('text/html');
+          res.resume();
+          resolve(ok);
+        }
+      );
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+      req.end();
+    });
   }
 
   let serverUp = await isLoginPageReady(3000);