@danypops/papyrus 0.52.1 → 0.53.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.52.1",
+  "version": "0.53.0",
   "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/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