@danypops/papyrus 0.53.0 → 0.53.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.53.0",
+  "version": "0.53.2",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "main": "./src/index.ts",

package/src/constants.ts

@@ -28,7 +28,16 @@ export const GATE_TEST_TIMEOUT_MS = 60_000;
  * this ceiling has had a chance to.
  */
 export const GATE_TIMEOUT_MAX_MS = 300_000;
-export const GATE_OUTPUT_LIMIT = 200;
+/**
+ * How much of a command/test gate's own combined stdout+stderr is kept in the caller-facing
+ * `output` field -- taken from the END of the buffer (see ops.ts's callers), not the start.
+ * Real, confirmed bug this exists for (papyrus task d0eb81b7): at the previous value (200,
+ * head-sliced), a failing gate's `output` carried only the first line or two of banner/setup
+ * noise -- exactly the LEAST useful part of a real test run, whose actual pass/fail summary is
+ * always its last lines. GATE_OPERATION_LIMITS' own maxResponseBytes (262_144, handlers/tasks.ts)
+ * comfortably holds many gates at this size.
+ */
+export const GATE_OUTPUT_LIMIT = 8_000;
 export const GATE_MAX_BUFFER_BYTES = 1_048_576;
 export const GATE_FILE_MAX_BYTES = 1_048_576;
 

package/src/daemon/daemon.ts

@@ -42,6 +42,10 @@ const TASK_READ_ONLY_OPERATIONS = new Set([
 	"tasks.show",
 ]);
 
+/** Matches @danypops/vehicle-server's own STREAMING_IDLE_TIMEOUT_S (daemon.ts) -- see this file's
+ * own fetch handler for why Papyrus needs the identical fix applied directly, not inherited. */
+const VEHICLE_INVOKE_IDLE_TIMEOUT_S = 3_600;
+
 /** Start the supervised, long-running Papyrus service. */
 export async function serveMain(): Promise<void> {
 	const stateDir = daemonStateDir();
@@ -81,7 +85,19 @@ export async function serveMain(): Promise<void> {
 		hostname: DAEMON_HOST,
 		port: 0,
 		fetch: (request, bunServer) => {
-			if (new URL(request.url).pathname === "/push") return pushChannel.upgrade(request, bunServer) ?? undefined;
+			const pathname = new URL(request.url).pathname;
+			if (pathname === "/push") return pushChannel.upgrade(request, bunServer) ?? undefined;
+			// Bun.serve's own idleTimeout defaults to 10s and applies per-connection regardless of
+			// how long a given request is expected to take -- @danypops/vehicle-server's own daemon.ts
+			// (startBunListener) already fixed this for every Vehicle-backed daemon that goes through
+			// its shared startDaemon() substrate; Papyrus's own daemon.ts predates that substrate and
+			// has this separate, hand-rolled Bun.serve() call, so it needs the identical fix applied
+			// directly here. Real live incident (papyrus task d0eb81b7): tasks.run_gates/tasks.complete
+			// can legitimately take tens of seconds to actually run a caller's own gate command,
+			// sending zero response bytes the whole time -- just as exposed to Bun's 10s default as
+			// the streaming case, and neither gate.timeoutMs nor VehicleLimits.maxTimeoutMs ever gets a
+			// chance to apply if the raw TCP connection is already dead first.
+			if (pathname === "/vehicle/invoke") bunServer.timeout(request, VEHICLE_INVOKE_IDLE_TIMEOUT_S);
 			return app.fetch(request);
 		},
 		// A no-op fallback when pushChannel never calls server.upgrade() is safe: Bun only

package/src/ops.ts

@@ -628,17 +628,26 @@ function processGateCommand(gate: Gate): { command: string; timeout: number } {
  * previously "test" was a second, separately-maintained execSync path that never checked
  * gate.expect at all.
  */
+/**
+ * Keeps the LAST GATE_OUTPUT_LIMIT characters, not the first -- a real command's own meaningful
+ * pass/fail summary is its last lines, not its first (setup/banner noise). See GATE_OUTPUT_LIMIT's
+ * own doc comment (constants.ts) for the real incident this fixes.
+ */
+function gateOutputTail(text: string): string {
+	return text.length > GATE_OUTPUT_LIMIT ? text.slice(-GATE_OUTPUT_LIMIT) : text;
+}
+
 function runProcessGateSync(gate: Gate, cwd?: string): GateResult {
 	const { spawnSync } = require_("node:child_process");
 	const { command, timeout } = processGateCommand(gate);
 	const result = spawnSync(command, { shell: true, encoding: "utf-8", timeout, ...(cwd ? { cwd } : {}) });
-	if (result.error) return { gate, passed: false, output: result.error.message.slice(0, GATE_OUTPUT_LIMIT) };
+	if (result.error) return { gate, passed: false, output: gateOutputTail(result.error.message) };
 	const combined = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
 	const passed = result.status === 0 && (gate.expect ? combined.includes(gate.expect) : true);
 	return {
 		gate,
 		passed,
-		output: combined.slice(0, GATE_OUTPUT_LIMIT) || (result.status === 0 ? "ok" : `command exited with code ${result.status}`),
+		output: gateOutputTail(combined) || (result.status === 0 ? "ok" : `command exited with code ${result.status}`),
 	};
 }
 
@@ -695,13 +704,13 @@ function executeGateCommand(
 			resolve(result);
 		};
 
-		child.on("error", (error) => finish({ passed: false, output: error.message.slice(0, GATE_OUTPUT_LIMIT), matchable: error.message }));
+		child.on("error", (error) => finish({ passed: false, output: gateOutputTail(error.message), matchable: error.message }));
 		child.on("close", (code) => {
 			// `matchable` carries the full (GATE_MAX_BUFFER_BYTES-bounded) buffer so the caller's
-			// gate.expect substring check sees the whole run, not just the first GATE_OUTPUT_LIMIT
-			// characters -- a real bun test run's pass/fail summary is its last line, not its first.
+			// gate.expect substring check sees the whole run, regardless of GATE_OUTPUT_LIMIT --
+			// `output` (below) is only ever the display copy.
 			const full = buffered.trim();
-			const output = full.slice(0, GATE_OUTPUT_LIMIT);
+			const output = gateOutputTail(full);
 			finish({ passed: code === 0, output: output || (code === 0 ? "ok" : `command exited with code ${code}`), matchable: full });
 		});