@danypops/papyrus 0.52.1 → 0.53.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.52.1",
+  "version": "0.53.1",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "main": "./src/index.ts",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@danypops/vehicle-client": "^0.6.1",
     "@danypops/vehicle-core": "^0.12.3",
-    "@danypops/vehicle-server": "^0.19.0",
+    "@danypops/vehicle-server": "^0.22.0",
     "@stricli/core": "^1.3.0"
   }
 }

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-state.ts

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { LOOPBACK_HOST, removeDaemonHandle, writeDaemonHandle } from "@danypops/vehicle-server/paths";
+import { LOOPBACK_HOST, removeDaemonHandle, resolveSharedVehicleHandlePath, writeDaemonHandle } from "@danypops/vehicle-server/paths";
 import {
 	DAEMON_DIR_ENV,
 	DAEMON_HANDLE_FILE,
@@ -69,6 +69,38 @@ export function clearVehicleHandle(dir: string): void {
 	removeDaemonHandle(vehicleHandlePath(dir));
 }
 
+/** Where the private auth token lives -- passed as SharedVehicleHandleEntry.tokenPath so a broker-mode discoverer with read access to it can authenticate against Papyrus. */
+export function tokenPath(dir: string): string {
+	return join(dir, DAEMON_TOKEN_FILE);
+}
+
+/** Papyrus's own stable identity name in the shared Vehicle Handle Directory (see @danypops/vehicle-server's resolveSharedVehicleHandlePath) -- must match the ownVehicleName Vehicle Shell broker mode is registered under. */
+export const PAPYRUS_VEHICLE_NAME = "papyrus";
+
+/**
+ * Writes Papyrus's entry into the shared, cross-package Vehicle Handle Directory (independent of
+ * writeVehicleHandle's own private per-package handle file above) -- the seam a broker-mode
+ * tools_list/tools_man discovery scan reads without needing to already know Papyrus's own
+ * daemonStateDir convention in advance. env is injectable for tests; defaults to process.env.
+ */
+export function writeSharedVehicleHandle(
+	port: number,
+	tokenFilePath: string,
+	pid: number = process.pid,
+	env: Record<string, string | undefined> = process.env,
+): void {
+	writeDaemonHandle(resolveSharedVehicleHandlePath(PAPYRUS_VEHICLE_NAME, { env }), {
+		host: LOOPBACK_HOST,
+		port,
+		pid,
+		tokenPath: tokenFilePath,
+	});
+}
+
+export function clearSharedVehicleHandle(env: Record<string, string | undefined> = process.env): void {
+	removeDaemonHandle(resolveSharedVehicleHandlePath(PAPYRUS_VEHICLE_NAME, { env }));
+}
+
 export function readDaemonHandle(dir: string): DaemonHandle | undefined {
 	try {
 		const token = readFileSync(join(dir, DAEMON_TOKEN_FILE), "utf8").trim();

package/src/daemon/daemon.ts

@@ -10,11 +10,14 @@ import { logEvent, vehicleLogger } from "../log/log.ts";
 import { createApp, createPapyrusService } from "../service.ts";
 import {
 	clearDaemonPort,
+	clearSharedVehicleHandle,
 	clearVehicleHandle,
 	daemonStateDir,
 	lifecyclePath,
 	loadOrCreateToken,
+	tokenPath,
 	writeDaemonPort,
+	writeSharedVehicleHandle,
 	writeVehicleHandle,
 } from "./daemon-state.ts";
 
@@ -92,6 +95,11 @@ export async function serveMain(): Promise<void> {
 	}
 	writeDaemonPort(stateDir, server.port);
 	writeVehicleHandle(stateDir, server.port);
+	try {
+		writeSharedVehicleHandle(server.port, tokenPath(stateDir));
+	} catch (error) {
+		logEvent("error", "shared_vehicle_handle_write_failed", { message: error instanceof Error ? error.message : String(error) });
+	}
 	const checkpointTimer = setInterval(() => {
 		try {
 			service.checkpoint();
@@ -137,6 +145,11 @@ export async function serveMain(): Promise<void> {
 		clearInterval(purgeTrashTimer);
 		clearDaemonPort(stateDir);
 		clearVehicleHandle(stateDir);
+		try {
+			clearSharedVehicleHandle();
+		} catch (error) {
+			logEvent("error", "shared_vehicle_handle_remove_failed", { message: error instanceof Error ? error.message : String(error) });
+		}
 		releaseDaemonLock(lockPath);
 		service.close();
 		// .finally() re-throws rather than handling a rejection -- catching it first turns a bare

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 });
 		});