@byfriends/vis-server 0.3.4

package/dist/server-CqbNDUBH.mjs

@@ -0,0 +1,1044 @@
+import { serve } from "@hono/node-server";
+import { timingSafeEqual } from "node:crypto";
+import { readFile, readdir, rm, stat } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+import { Hono } from "hono";
+import { homedir } from "node:os";
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { spawn } from "node:child_process";
+//#region src/config.ts
+/** Resolve BYF_HOME (env > ~/.byf). */
+function resolveByfHome() {
+	const envHome = process.env["BYF_HOME"];
+	if (envHome !== void 0 && envHome.length > 0) return envHome;
+	return join(homedir(), ".byf");
+}
+/** HTTP port for the vis API server. */
+function resolvePort() {
+	const raw = process.env["PORT"];
+	if (raw !== void 0 && raw.length > 0) {
+		const n = Number.parseInt(raw, 10);
+		if (Number.isFinite(n) && n > 0 && n < 65536) return n;
+	}
+	return 3001;
+}
+/** HTTP host for the vis API server. Defaults to loopback. */
+function resolveHost() {
+	const host = (process.env["VIS_HOST"] ?? process.env["HOST"])?.trim();
+	return host !== void 0 && host.length > 0 ? host : "127.0.0.1";
+}
+function isLoopbackHost(host) {
+	const normalized = host.trim().toLowerCase().replaceAll("[", "").replaceAll("]", "");
+	return normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1" || normalized.startsWith("127.");
+}
+function resolveVisAuthToken(host = resolveHost()) {
+	const token = process.env["VIS_AUTH_TOKEN"]?.trim();
+	if (token !== void 0 && token.length > 0) return token;
+	if (!isLoopbackHost(host)) throw new Error(`VIS_AUTH_TOKEN is required when binding vis-server outside loopback (host=${host})`);
+}
+//#endregion
+//#region src/lib/context-projector.ts
+const ZERO = {
+	inputOther: 0,
+	output: 0,
+	inputCacheRead: 0,
+	inputCacheCreation: 0
+};
+/** Build a conversation timeline + derived state from a sequence of
+*  wire entries. The reconstruction mirrors agent-core's own
+*  `appendLoopEvent` logic, so:
+*
+*  - `context.append_message` records become messages as-is (the
+*    user / tool messages and any explicit assistant injections).
+*  - `step.begin` pushes a fresh assistant message; later
+*    `content.part` and `tool.call` events on the same step **mutate
+*    that same message** to grow its content / toolCalls. `step.end`
+*    just closes the step.
+*  - `tool.result` events emit an independent `role: 'tool'` message,
+*    matching how agent-core surfaces tool exchanges to the model.
+*
+*  Without this loop-event reconstruction the timeline would only
+*  show user prompts — agent-core does not emit a synthetic
+*  `context.append_message` for assistant turns. */
+function projectContext(entries) {
+	let messages = [];
+	const usage = {
+		byScope: {
+			session: { ...ZERO },
+			turn: { ...ZERO }
+		},
+		byModel: {}
+	};
+	const config = {};
+	let permissionMode = null;
+	let openSteps = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const rec = entry.data;
+		switch (rec.type) {
+			case "context.append_message":
+				messages.push({
+					lineNo: entry.lineNo,
+					time: rec.time,
+					source: "append_message",
+					message: rec.message,
+					toolStepUuids: []
+				});
+				break;
+			case "context.append_loop_event": {
+				const ev = rec.event;
+				if (ev.type === "step.begin") {
+					const projected = {
+						lineNo: entry.lineNo,
+						time: rec.time,
+						source: "append_message",
+						message: {
+							role: "assistant",
+							content: [],
+							toolCalls: []
+						},
+						toolStepUuids: [ev.uuid]
+					};
+					messages.push(projected);
+					openSteps.set(ev.uuid, projected);
+				} else if (ev.type === "content.part") {
+					const projected = openSteps.get(ev.stepUuid);
+					if (projected !== void 0) projected.message.content.push(ev.part);
+				} else if (ev.type === "tool.call") {
+					const projected = openSteps.get(ev.stepUuid);
+					if (projected !== void 0) {
+						const args = typeof ev.args === "string" ? ev.args : ev.args === void 0 ? null : JSON.stringify(ev.args);
+						projected.message.toolCalls.push({
+							type: "function",
+							id: ev.toolCallId,
+							name: ev.name,
+							arguments: args
+						});
+					}
+				} else if (ev.type === "step.end") openSteps.delete(ev.uuid);
+				else if (ev.type === "tool.result") {
+					const output = ev.result.output;
+					const toolMsg = {
+						role: "tool",
+						content: typeof output === "string" ? [{
+							type: "text",
+							text: output
+						}] : output,
+						toolCalls: [],
+						toolCallId: ev.toolCallId,
+						...ev.result.isError === true ? { isError: true } : {}
+					};
+					messages.push({
+						lineNo: entry.lineNo,
+						time: rec.time,
+						source: "append_message",
+						message: toolMsg,
+						toolStepUuids: []
+					});
+				}
+				break;
+			}
+			case "context.clear":
+				messages = [];
+				openSteps = /* @__PURE__ */ new Map();
+				break;
+			case "context.apply_compaction":
+				openSteps = /* @__PURE__ */ new Map();
+				messages = [{
+					lineNo: entry.lineNo,
+					time: rec.time,
+					source: "compaction_summary",
+					message: {
+						role: "assistant",
+						content: [{
+							type: "text",
+							text: rec.summary
+						}],
+						toolCalls: [],
+						origin: { kind: "compaction_summary" }
+					},
+					toolStepUuids: []
+				}];
+				break;
+			case "usage.record": {
+				const scope = rec.usageScope ?? "session";
+				addUsage(usage.byScope[scope], rec.usage);
+				usage.byModel[rec.model] ??= { ...ZERO };
+				addUsage(usage.byModel[rec.model], rec.usage);
+				break;
+			}
+			case "config.update": {
+				const typeChecked = rec;
+				if (typeChecked.cwd !== void 0) config.cwd = typeChecked.cwd;
+				if (typeChecked.modelAlias !== void 0) config.modelAlias = typeChecked.modelAlias;
+				if (typeChecked.profileName !== void 0) config.profileName = typeChecked.profileName;
+				if (typeChecked.thinkingLevel !== void 0) config.thinkingLevel = typeChecked.thinkingLevel;
+				if (typeChecked.systemPrompt !== void 0) config.systemPrompt = typeChecked.systemPrompt;
+				break;
+			}
+			case "permission.set_mode":
+				permissionMode = rec.mode;
+				break;
+			default: break;
+		}
+	}
+	return {
+		messages,
+		usage,
+		config,
+		permission: { mode: permissionMode }
+	};
+}
+function addUsage(into, src) {
+	into.inputOther += src.inputOther;
+	into.output += src.output;
+	into.inputCacheRead += src.inputCacheRead;
+	into.inputCacheCreation += src.inputCacheCreation;
+}
+//#endregion
+//#region src/lib/session-store.ts
+const SESSION_ID_RE = /^session_[A-Za-z0-9._-]+$/;
+const AGENT_ID_RE = /^[A-Za-z0-9._-]+$/;
+/** Reject agent ids that could escape the session directory via path
+*  joins. Defence-in-depth: the on-disk source of these ids is
+*  agent-core (which only generates main / agent-N), but a corrupted
+*  or hand-edited `state.json.agents` key could otherwise turn vis
+*  into a local-file-read primitive when exposed beyond loopback. */
+function isSafeAgentId(id) {
+	return AGENT_ID_RE.test(id) && id !== "." && id !== "..";
+}
+async function listSessions(home) {
+	const sessionsDir = join(home, "sessions");
+	const buckets = await readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
+	const index = await readSessionIndex(home);
+	const out = [];
+	for (const bucket of buckets) {
+		if (!bucket.isDirectory()) continue;
+		const bucketDir = join(sessionsDir, bucket.name);
+		const sessionDirs = await readdir(bucketDir, { withFileTypes: true }).catch(() => []);
+		for (const entry of sessionDirs) {
+			if (!entry.isDirectory() || !SESSION_ID_RE.test(entry.name)) continue;
+			const sessionDir = join(bucketDir, entry.name);
+			const workDir = index.get(entry.name)?.workDir ?? "";
+			const summary = await tryReadSummary(sessionDir, entry.name, workDir);
+			if (summary !== null) out.push(summary);
+		}
+	}
+	out.sort((a, b) => b.updatedAt - a.updatedAt);
+	return out;
+}
+async function readSessionDetail(home, sessionId) {
+	const sessionDir = await findSessionDir(home, sessionId);
+	if (sessionDir === null) return null;
+	const workDir = (await readSessionIndex(home)).get(sessionId)?.workDir ?? "";
+	const state = await readState(sessionDir);
+	if (state === null) return {
+		sessionId,
+		sessionDir,
+		workDir,
+		state: null,
+		agents: await discoverAgentsFromDisk(sessionDir)
+	};
+	if (state.custom?.["imported_from_byf_cli"] === true) return null;
+	return {
+		sessionId,
+		sessionDir,
+		workDir,
+		state,
+		agents: await inventoryAgents(sessionDir, state)
+	};
+}
+/** Fallback inventory used when `state.json` is unreadable: walk
+*  `<sessionDir>/agents/*` directly and synthesize minimal AgentInfo
+*  records for the directories that contain a `wire.jsonl`. Parent
+*  links and `type` are unknown without state, so we mark every agent
+*  as `independent` with a null parent — the routes only need
+*  `agentId` + `wireExists` to serve wire/context. */
+async function discoverAgentsFromDisk(sessionDir) {
+	const agentsDir = join(sessionDir, "agents");
+	let entries;
+	try {
+		entries = await readdir(agentsDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const id = entry.name;
+		if (!isSafeAgentId(id)) continue;
+		const wirePath = join(agentsDir, id, "wire.jsonl");
+		const exists = await pathExists(wirePath);
+		let readable = exists;
+		let info = {
+			count: 0,
+			protocolVersion: null
+		};
+		if (exists) try {
+			info = await scanWire(wirePath);
+		} catch {
+			readable = false;
+		}
+		out.push({
+			agentId: id,
+			type: id === "main" ? "main" : "independent",
+			parentAgentId: null,
+			homedir: join(agentsDir, id),
+			wireExists: readable,
+			wireRecordCount: info.count,
+			wireProtocolVersion: info.protocolVersion
+		});
+	}
+	return out.toSorted((a, b) => {
+		if (a.agentId === "main") return -1;
+		if (b.agentId === "main") return 1;
+		return a.agentId.localeCompare(b.agentId);
+	});
+}
+async function tryReadSummary(sessionDir, sessionId, workDir) {
+	const state = await readState(sessionDir);
+	if (state === null) return brokenStateSummary(sessionDir, sessionId, workDir);
+	if (state.custom?.["imported_from_byf_cli"] === true) return null;
+	const mainWirePath = join(sessionDir, "agents", "main", "wire.jsonl");
+	const mainExists = await pathExists(mainWirePath);
+	let mainCount = 0;
+	let protocolVersion = null;
+	let health = "ok";
+	if (!mainExists) health = "missing_main_wire";
+	else try {
+		const info = await scanWire(mainWirePath);
+		mainCount = info.count;
+		protocolVersion = info.protocolVersion;
+	} catch {
+		health = "broken_main_wire";
+	}
+	return {
+		sessionId,
+		sessionDir,
+		workDir,
+		title: state.title ?? null,
+		lastPrompt: state.lastPrompt ?? null,
+		isCustomTitle: state.isCustomTitle ?? false,
+		createdAt: parseTs(state.createdAt),
+		updatedAt: parseTs(state.updatedAt),
+		agentCount: Object.keys(state.agents ?? {}).length,
+		mainAgentExists: mainExists,
+		mainWireRecordCount: mainCount,
+		wireProtocolVersion: protocolVersion,
+		health
+	};
+}
+function brokenStateSummary(sessionDir, sessionId, workDir) {
+	return {
+		sessionId,
+		sessionDir,
+		workDir,
+		title: null,
+		lastPrompt: null,
+		isCustomTitle: false,
+		createdAt: 0,
+		updatedAt: 0,
+		agentCount: 0,
+		mainAgentExists: false,
+		mainWireRecordCount: 0,
+		wireProtocolVersion: null,
+		health: "broken_state"
+	};
+}
+async function readSessionIndex(home) {
+	const out = /* @__PURE__ */ new Map();
+	let raw;
+	try {
+		raw = await readFile(join(home, "session_index.jsonl"), "utf8");
+	} catch {
+		return out;
+	}
+	for (const line of raw.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			if (typeof entry.sessionId === "string" && typeof entry.sessionDir === "string") out.set(entry.sessionId, {
+				sessionDir: entry.sessionDir,
+				workDir: typeof entry.workDir === "string" ? entry.workDir : ""
+			});
+		} catch {}
+	}
+	return out;
+}
+async function inventoryAgents(sessionDir, state) {
+	const result = [];
+	for (const [id, meta] of Object.entries(state.agents ?? {})) {
+		if (!isSafeAgentId(id)) continue;
+		const wirePath = join(sessionDir, "agents", id, "wire.jsonl");
+		const exists = await pathExists(wirePath);
+		let readable = exists;
+		let info = {
+			count: 0,
+			protocolVersion: null
+		};
+		if (exists) try {
+			info = await scanWire(wirePath);
+		} catch {
+			readable = false;
+		}
+		result.push({
+			agentId: id,
+			type: meta.type,
+			parentAgentId: meta.parentAgentId,
+			homedir: meta.homedir,
+			wireExists: readable,
+			wireRecordCount: info.count,
+			wireProtocolVersion: info.protocolVersion
+		});
+	}
+	return result.toSorted((a, b) => {
+		if (a.agentId === "main") return -1;
+		if (b.agentId === "main") return 1;
+		return a.agentId.localeCompare(b.agentId);
+	});
+}
+async function readState(sessionDir) {
+	try {
+		return JSON.parse(await readFile(join(sessionDir, "state.json"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+async function findSessionDir(home, sessionId) {
+	if (!SESSION_ID_RE.test(sessionId)) return null;
+	const sessionsRoot = resolve(join(home, "sessions"));
+	const sessionsRootPrefix = sessionsRoot + sep;
+	try {
+		const indexLines = (await readFile(join(home, "session_index.jsonl"), "utf8")).split(/\r?\n/);
+		for (const line of indexLines) {
+			if (!line.trim()) continue;
+			const entry = JSON.parse(line);
+			if (entry.sessionId !== sessionId || typeof entry.sessionDir !== "string") continue;
+			const candidate = resolve(entry.sessionDir);
+			if (!candidate.startsWith(sessionsRootPrefix)) continue;
+			if (candidate.split(sep).pop() !== sessionId) continue;
+			if (await pathExists(candidate)) return candidate;
+		}
+	} catch {}
+	const buckets = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
+	for (const bucket of buckets) {
+		if (!bucket.isDirectory()) continue;
+		const candidate = join(sessionsRoot, bucket.name, sessionId);
+		if (await pathExists(candidate)) return candidate;
+	}
+	return null;
+}
+async function scanWire(path) {
+	const rl = createInterface({
+		input: createReadStream(path, { encoding: "utf8" }),
+		crlfDelay: Infinity
+	});
+	let count = 0;
+	let protocolVersion = null;
+	for await (const line of rl) {
+		if (line.length === 0) continue;
+		if (protocolVersion === null) {
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				throw new Error(`wire metadata is not valid JSON at line 1`);
+			}
+			if (parsed.type !== "metadata" || typeof parsed.protocol_version !== "string") throw new Error(`wire is missing a metadata header on line 1`);
+			protocolVersion = parsed.protocol_version;
+		}
+		count += 1;
+	}
+	if (protocolVersion === null) throw new Error("wire file is empty");
+	return {
+		count,
+		protocolVersion
+	};
+}
+function parseTs(input) {
+	if (!input) return 0;
+	const n = Date.parse(input);
+	return Number.isFinite(n) ? n : 0;
+}
+async function pathExists(p) {
+	try {
+		await stat(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../../../packages/agent-core/src/agent/records/migration/v1.1.ts
+function isLegacyToolCall(v) {
+	if (!isRecord(v)) return false;
+	return v["type"] === "function" && typeof v["id"] === "string" && isRecord(v["function"]);
+}
+function migrateToolCall(v) {
+	const { function: fn, ...rest } = v;
+	return {
+		...rest,
+		name: fn.name,
+		arguments: fn.arguments
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const MIGRATIONS = [{
+	sourceVersion: "1.0",
+	targetVersion: "1.1",
+	migrateRecord(record) {
+		if (record.type !== "context.append_message") return record;
+		const message = record["message"];
+		let changed = false;
+		const toolCalls = message.toolCalls.map((toolCall) => {
+			if (!isLegacyToolCall(toolCall)) return toolCall;
+			changed = true;
+			return migrateToolCall(toolCall);
+		});
+		if (!changed) return record;
+		return {
+			...record,
+			message: {
+				...message,
+				toolCalls
+			}
+		};
+	}
+}];
+function resolveWireMigrations(readVersion) {
+	if (compareWireVersions(readVersion, "1.1") >= 0) return [];
+	const migrations = [];
+	let version = readVersion;
+	while (compareWireVersions(version, "1.1") < 0) {
+		const migration = findMigration(version);
+		if (migration === void 0) throw new Error(`Missing wire migration for version ${version}`);
+		migrations.push(migration);
+		version = migration.targetVersion;
+	}
+	return migrations;
+}
+function migrateWireRecord(record, migrations) {
+	return migrations.reduce((current, migration) => migration.migrateRecord(current), record);
+}
+function findMigration(sourceVersion) {
+	for (const migration of MIGRATIONS) if (migration.sourceVersion === sourceVersion) return migration;
+}
+function compareWireVersions(a, b) {
+	const partsA = a.split(".");
+	const partsB = b.split(".");
+	const maxLength = Math.max(partsA.length, partsB.length);
+	for (let i = 0; i < maxLength; i++) {
+		const diff = Number(partsA[i] ?? "0") - Number(partsB[i] ?? "0");
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+//#endregion
+//#region src/lib/wire-reader.ts
+/** Best-effort fallback when a wire file declares a protocol_version that
+*  `agent-core` does not know about (e.g. the historic "2.2" alias that
+*  pre-dates the 1.x renumber). We try to apply the chain *starting* from
+*  the oldest known version (1.0) and warn the caller. If even that fails
+*  we just pass records through unchanged. */
+function bestEffortMigrations() {
+	try {
+		return resolveWireMigrations("1.0");
+	} catch {
+		return [];
+	}
+}
+/** Read a single agent's `wire.jsonl`.
+*
+*  Each record is returned as a `WireEntry` containing both the
+*  on-disk parsed form (`raw`) and the migrated current-protocol form
+*  (`data`). For wires that declare a protocol version `agent-core`
+*  does not recognise (historic 2.x labels, or truly future versions),
+*  the reader falls back to a best-effort path: records are run
+*  through the 1.0-onwards migration chain and a warning is added to
+*  `warnings[]` so the UI can surface the caveat. */
+async function readAgentWire(path) {
+	const rl = createInterface({
+		input: createReadStream(path, { encoding: "utf8" }),
+		crlfDelay: Infinity
+	});
+	let lineNo = 0;
+	let metadata = null;
+	let migrations = [];
+	const records = [];
+	const warnings = [];
+	for await (const line of rl) {
+		lineNo += 1;
+		if (line.length === 0) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch (error) {
+			warnings.push(`line ${lineNo}: invalid JSON (${error.message})`);
+			continue;
+		}
+		if (!isObject(parsed) || typeof parsed.type !== "string") {
+			warnings.push(`line ${lineNo}: missing 'type' field`);
+			continue;
+		}
+		if (metadata === null) {
+			if (parsed.type !== "metadata") throw new Error(`Wire file missing metadata header at line ${lineNo}`);
+			const pv = parsed["protocol_version"];
+			const ca = parsed["created_at"];
+			if (typeof pv !== "string" || typeof ca !== "number") throw new TypeError(`Wire metadata malformed at line ${lineNo}`);
+			try {
+				migrations = resolveWireMigrations(pv);
+			} catch (error) {
+				warnings.push(`unrecognised protocol_version "${pv}" — parsing as best-effort (${error.message})`);
+				migrations = bestEffortMigrations();
+			}
+			metadata = {
+				protocolVersion: pv,
+				createdAt: ca
+			};
+			continue;
+		}
+		const raw = parsed;
+		let migrated;
+		try {
+			migrated = migrations.length === 0 ? raw : migrateWireRecord(raw, migrations);
+		} catch (error) {
+			warnings.push(`line ${lineNo}: migration failed (${error.message}); using raw record`);
+			migrated = raw;
+		}
+		records.push({
+			lineNo,
+			data: migrated,
+			raw
+		});
+	}
+	if (metadata === null) throw new Error("Wire file is empty (no metadata)");
+	return {
+		metadata,
+		records,
+		warnings
+	};
+}
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+//#endregion
+//#region src/routes/context.ts
+function contextRoute() {
+	const r = new Hono();
+	r.get("/:id/context", async (c) => {
+		const id = c.req.param("id");
+		const agentId = c.req.query("agent") ?? "main";
+		if (!isSafeAgentId(agentId)) return c.json({
+			error: "invalid agent id",
+			code: "BAD_REQUEST"
+		}, 400);
+		const detail = await readSessionDetail(resolveByfHome(), id);
+		if (!detail) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		const agent = detail.agents.find((a) => a.agentId === agentId);
+		if (!agent || !agent.wireExists) return c.json({
+			error: "agent wire not found",
+			code: "NOT_FOUND"
+		}, 404);
+		try {
+			const proj = projectContext((await readAgentWire(join(detail.sessionDir, "agents", agentId, "wire.jsonl"))).records);
+			return c.json({
+				sessionId: id,
+				agentId,
+				messages: proj.messages,
+				usage: proj.usage,
+				config: proj.config,
+				permission: proj.permission
+			});
+		} catch (error) {
+			const msg = error.message;
+			if (msg.toLowerCase().includes("unsupported protocol")) return c.json({
+				error: msg,
+				code: "UNSUPPORTED_PROTOCOL"
+			}, 400);
+			return c.json({
+				error: msg,
+				code: "READ_ERROR"
+			}, 500);
+		}
+	});
+	return r;
+}
+//#endregion
+//#region src/routes/session-detail.ts
+function sessionDetailRoute() {
+	const r = new Hono();
+	r.get("/:id", async (c) => {
+		const id = c.req.param("id");
+		const detail = await readSessionDetail(resolveByfHome(), id);
+		if (!detail) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		return c.json(detail);
+	});
+	return r;
+}
+//#endregion
+//#region src/lib/reveal.ts
+/** Resolve the platform-specific "reveal in file manager" command for
+*  the given absolute path. Kept pure (no IO) so it can be unit-tested. */
+function revealCommandFor(path, platform = process.platform) {
+	switch (platform) {
+		case "darwin": return {
+			command: "open",
+			args: [path]
+		};
+		case "win32": return {
+			command: "cmd",
+			args: [
+				"/c",
+				"start",
+				"\"\"",
+				path
+			]
+		};
+		default: return {
+			command: "xdg-open",
+			args: [path]
+		};
+	}
+}
+/** Spawn the OS file manager to reveal `path`. Resolves once the launcher
+*  process has started; rejects only if the launcher itself fails to
+*  spawn (missing binary etc.) — not if it later fails to find the path,
+*  since the launcher exits asynchronously after we've detached. */
+async function revealInOs(path) {
+	const { command, args } = revealCommandFor(path);
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore"
+		});
+		child.once("error", (err) => {
+			if (settled) return;
+			settled = true;
+			reject(err);
+		});
+		child.once("spawn", () => {
+			if (settled) return;
+			settled = true;
+			child.unref();
+			resolve();
+		});
+	});
+}
+//#endregion
+//#region src/routes/sessions.ts
+function sessionsRoute() {
+	const r = new Hono();
+	r.get("/", async (c) => {
+		const sessions = await listSessions(resolveByfHome());
+		return c.json({ sessions });
+	});
+	r.delete("/:id", async (c) => {
+		const id = c.req.param("id");
+		const target = (await listSessions(resolveByfHome())).find((s) => s.sessionId === id);
+		if (!target) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		await rm(target.sessionDir, {
+			recursive: true,
+			force: true
+		});
+		return c.json({
+			sessionId: id,
+			deleted: true
+		});
+	});
+	r.post("/:id/reveal", async (c) => {
+		const id = c.req.param("id");
+		const detail = await readSessionDetail(resolveByfHome(), id);
+		if (!detail) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		try {
+			await revealInOs(detail.sessionDir);
+			return c.json({
+				sessionId: id,
+				opened: detail.sessionDir
+			});
+		} catch (error) {
+			return c.json({
+				error: `failed to open: ${error.message}`,
+				code: "READ_ERROR"
+			}, 500);
+		}
+	});
+	return r;
+}
+//#endregion
+//#region src/lib/agent-tree.ts
+/**
+* Build a parent/child tree from the flat agent inventory found on
+* `state.json.agents`. Roots are agents with no `parentAgentId`, plus any
+* agent whose `parentAgentId` does not resolve in the inventory (orphans).
+* The returned roots are sorted so that the `main` agent always appears
+* first; remaining roots fall back to a stable lexicographic order.
+*/
+function buildAgentTree(agents) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const a of agents) byId.set(a.agentId, {
+		...a,
+		children: []
+	});
+	const roots = [];
+	for (const node of byId.values()) if (node.parentAgentId !== null && byId.has(node.parentAgentId)) byId.get(node.parentAgentId).children.push(node);
+	else roots.push(node);
+	return roots.toSorted(sortAgents);
+}
+function sortAgents(a, b) {
+	if (a.agentId === "main") return -1;
+	if (b.agentId === "main") return 1;
+	return a.agentId.localeCompare(b.agentId);
+}
+//#endregion
+//#region src/routes/subagents.ts
+function subagentsRoute() {
+	const r = new Hono();
+	r.get("/:id/agents", async (c) => {
+		const id = c.req.param("id");
+		const detail = await readSessionDetail(resolveByfHome(), id);
+		if (!detail) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		return c.json({
+			sessionId: id,
+			tree: buildAgentTree(detail.agents)
+		});
+	});
+	return r;
+}
+//#endregion
+//#region src/routes/wire.ts
+function wireRoute() {
+	const r = new Hono();
+	r.get("/:id/wire", async (c) => {
+		const id = c.req.param("id");
+		const agentId = c.req.query("agent") ?? "main";
+		if (!isSafeAgentId(agentId)) return c.json({
+			error: "invalid agent id",
+			code: "BAD_REQUEST"
+		}, 400);
+		const detail = await readSessionDetail(resolveByfHome(), id);
+		if (!detail) return c.json({
+			error: "session not found",
+			code: "NOT_FOUND"
+		}, 404);
+		const agent = detail.agents.find((a) => a.agentId === agentId);
+		if (!agent) return c.json({
+			error: `agent "${agentId}" not found`,
+			code: "NOT_FOUND"
+		}, 404);
+		if (!agent.wireExists) return c.json({
+			error: "wire missing",
+			code: "NOT_FOUND"
+		}, 404);
+		try {
+			const result = await readAgentWire(join(detail.sessionDir, "agents", agentId, "wire.jsonl"));
+			return c.json({
+				sessionId: id,
+				agentId,
+				protocolVersion: result.metadata.protocolVersion,
+				metadata: result.metadata,
+				records: result.records,
+				warnings: result.warnings
+			});
+		} catch (error) {
+			const msg = error.message;
+			if (msg.toLowerCase().includes("unsupported protocol")) return c.json({
+				error: msg,
+				code: "UNSUPPORTED_PROTOCOL"
+			}, 400);
+			return c.json({
+				error: msg,
+				code: "READ_ERROR"
+			}, 500);
+		}
+	});
+	return r;
+}
+//#endregion
+//#region src/app.ts
+/** Resolve the SPA bundle directory next to the compiled server.mjs, if it
+* exists. Returns `null` in dev mode where the web bundle lives elsewhere. */
+async function resolvePublicDir() {
+	try {
+		const here = import.meta.dirname;
+		const candidate = resolve(here, "public");
+		if ((await stat(candidate)).isDirectory()) return candidate;
+	} catch {}
+	return null;
+}
+const STATIC_EXT_MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".map": "application/json; charset=utf-8"
+};
+function mimeFor(path) {
+	const i = path.lastIndexOf(".");
+	if (i < 0) return "application/octet-stream";
+	return STATIC_EXT_MIME[path.slice(i).toLowerCase()] ?? "application/octet-stream";
+}
+function bearerToken(value) {
+	if (value === void 0) return null;
+	return /^Bearer\s+(.+)$/i.exec(value)?.[1]?.trim() ?? null;
+}
+function tokenMatches(actual, expected) {
+	const actualBytes = Buffer.from(actual);
+	const expectedBytes = Buffer.from(expected);
+	return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
+}
+/** Build a Hono app mounting /api/* routes, plus SPA static fallback. */
+async function createApp(options = {}) {
+	const app = new Hono();
+	const api = new Hono();
+	const authToken = options.authToken;
+	if (authToken !== void 0 && authToken.length > 0) api.use("*", async (c, next) => {
+		const token = bearerToken(c.req.header("authorization"));
+		if (token !== null && tokenMatches(token, authToken)) {
+			await next();
+			return;
+		}
+		c.header("www-authenticate", "Bearer realm=\"byf-vis\"");
+		return c.json({
+			error: "unauthorized",
+			code: "UNAUTHORIZED"
+		}, 401);
+	});
+	api.route("/sessions", sessionsRoute());
+	api.route("/sessions", sessionDetailRoute());
+	api.route("/sessions", wireRoute());
+	api.route("/sessions", subagentsRoute());
+	api.route("/sessions", contextRoute());
+	app.route("/api", api);
+	const publicDir = options.publicDir ?? await resolvePublicDir();
+	if (publicDir !== null) app.get("*", async (c) => {
+		const url = new URL(c.req.url);
+		let pathname = decodeURIComponent(url.pathname);
+		if (pathname.startsWith("/api")) return c.json({
+			error: `api route not found: ${pathname}`,
+			code: "NOT_FOUND"
+		}, 404);
+		if (pathname === "/" || pathname === "") pathname = "/index.html";
+		const resolved = resolve(publicDir, `.${pathname}`);
+		if (!resolved.startsWith(publicDir)) return c.text("forbidden", 403);
+		try {
+			if ((await stat(resolved)).isFile()) {
+				const buf = await readFile(resolved);
+				const body = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+				return new Response(body, { headers: { "content-type": mimeFor(resolved) } });
+			}
+		} catch {}
+		try {
+			const indexHtml = await readFile(join(publicDir, "index.html"));
+			const body = new Uint8Array(indexHtml.buffer, indexHtml.byteOffset, indexHtml.byteLength);
+			return new Response(body, { headers: { "content-type": "text/html; charset=utf-8" } });
+		} catch {
+			return c.text("not found", 404);
+		}
+	});
+	return app;
+}
+//#endregion
+//#region src/startup-banner.ts
+function formatStartupBanner(options) {
+	const authStatus = options.authToken === void 0 ? "auth=disabled" : "auth=required";
+	return `[vis-server] listening on http://${hostForUrl$1(options.host)}:${String(options.port)} (${authStatus}, BYF_HOME=${options.byfCodeHome})\n`;
+}
+function hostForUrl$1(host) {
+	if (host.includes(":") && !host.startsWith("[")) return `[${host}]`;
+	return host;
+}
+//#endregion
+//#region src/server.ts
+function hostForUrl(host) {
+	if (host.includes(":") && !host.startsWith("[")) return `[${host}]`;
+	return host;
+}
+/**
+* Start the vis HTTP server programmatically. Resolves once the server is
+* listening. Used by the CLI `byf vis` subcommand (in-process) and by the
+* standalone `index.ts` entry.
+*/
+async function startVisServer(options = {}) {
+	const host = options.host ?? resolveHost();
+	const port = options.port ?? resolvePort();
+	const app = await createApp({
+		authToken: options.authToken ?? resolveVisAuthToken(host),
+		publicDir: options.publicDir
+	});
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const server = serve({
+			fetch: app.fetch,
+			hostname: host,
+			port
+		}, () => {
+			if (settled) return;
+			settled = true;
+			const address = server.address();
+			const actualPort = typeof address === "object" && address !== null ? address.port : port;
+			resolve({
+				host,
+				port: actualPort,
+				url: `http://${hostForUrl(host)}:${actualPort}`,
+				close: () => {
+					server.closeAllConnections();
+					server.close();
+				}
+			});
+		});
+		server.on("error", (error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		});
+	});
+}
+/**
+* Resolve the BYF_HOME the server reads session records from. Exposed for the
+* standalone entry's startup banner. CLI consumers rely on the same env var.
+*/
+function resolveVisByfHome() {
+	return resolveByfHome();
+}
+/**
+* Format the startup banner text. Exposed so the CLI can reuse the exact same
+* wording without depending on startup-banner internals.
+*/
+function formatVisStartupBanner(input) {
+	return formatStartupBanner({
+		authToken: input.authToken,
+		host: input.host,
+		byfCodeHome: resolveByfHome(),
+		port: input.port
+	});
+}
+//#endregion
+export { resolvePort as a, resolveHost as i, resolveVisByfHome as n, resolveVisAuthToken as o, startVisServer as r, formatVisStartupBanner as t };