@byfriends/vis-server 0.3.6 → 0.4.0

package/dist/server-enpsx6np.mjs

@@ -0,0 +1,1010 @@
+// src/app.ts
+import { timingSafeEqual } from "node:crypto";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { join as join5, resolve as resolve2 } from "node:path";
+import { Hono as Hono6 } from "hono";
+
+// src/routes/context.ts
+import { join as join3 } from "node:path";
+import { Hono } from "hono";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function resolveByfHome() {
+  const envHome = process.env["BYF_HOME"];
+  if (envHome !== undefined && envHome.length > 0) {
+    return envHome;
+  }
+  return join(homedir(), ".byf");
+}
+function resolvePort() {
+  const raw = process.env["PORT"];
+  if (raw !== undefined && raw.length > 0) {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n > 0 && n < 65536) {
+      return n;
+    }
+  }
+  return 3001;
+}
+function resolveHost() {
+  const raw = process.env["VIS_HOST"] ?? process.env["HOST"];
+  const host = raw?.trim();
+  return host !== undefined && 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 raw = process.env["VIS_AUTH_TOKEN"];
+  const token = raw?.trim();
+  if (token !== undefined && token.length > 0)
+    return token;
+  if (!isLoopbackHost(host)) {
+    throw new Error(`VIS_AUTH_TOKEN is required when binding vis-server outside loopback (host=${host})`);
+  }
+  return;
+}
+
+// src/lib/context-projector.ts
+var ZERO = { inputOther: 0, output: 0, inputCacheRead: 0, inputCacheCreation: 0 };
+function projectContext(entries) {
+  let messages = [];
+  const usage = {
+    byScope: { session: { ...ZERO }, turn: { ...ZERO } },
+    byModel: {}
+  };
+  const config = {};
+  let permissionMode = null;
+  let openSteps = 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 message = {
+            role: "assistant",
+            content: [],
+            toolCalls: []
+          };
+          const projected = {
+            lineNo: entry.lineNo,
+            time: rec.time,
+            source: "append_message",
+            message,
+            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 !== undefined) {
+            projected.message.content.push(ev.part);
+          }
+        } else if (ev.type === "tool.call") {
+          const projected = openSteps.get(ev.stepUuid);
+          if (projected !== undefined) {
+            const args = typeof ev.args === "string" ? ev.args : ev.args === undefined ? 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 content = typeof output === "string" ? [{ type: "text", text: output }] : output;
+          const toolMsg = {
+            role: "tool",
+            content,
+            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 = new Map;
+        break;
+      case "context.apply_compaction":
+        openSteps = 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 === "turn" ? "turn" : "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 !== undefined)
+          config.cwd = typeChecked.cwd;
+        if (typeChecked.modelAlias !== undefined)
+          config.modelAlias = typeChecked.modelAlias;
+        if (typeChecked.profileName !== undefined)
+          config.profileName = typeChecked.profileName;
+        if (typeChecked.thinkingLevel !== undefined)
+          config.thinkingLevel = typeChecked.thinkingLevel;
+        if (typeChecked.systemPrompt !== undefined)
+          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;
+}
+
+// src/lib/session-store.ts
+import { createReadStream } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join as join2, resolve, sep } from "node:path";
+import { createInterface } from "node:readline";
+var SESSION_ID_RE = /^session_[A-Za-z0-9._-]+$/;
+var AGENT_ID_RE = /^[A-Za-z0-9._-]+$/;
+function isSafeAgentId(id) {
+  return AGENT_ID_RE.test(id) && id !== "." && id !== "..";
+}
+async function listSessions(home) {
+  const sessionsDir = join2(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 = join2(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 = join2(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 index = await readSessionIndex(home);
+  const workDir = index.get(sessionId)?.workDir ?? "";
+  const state = await readState(sessionDir);
+  if (state === null) {
+    const agents2 = await discoverAgentsFromDisk(sessionDir);
+    return { sessionId, sessionDir, workDir, state: null, agents: agents2 };
+  }
+  if (state.custom?.["imported_from_byf_cli"] === true)
+    return null;
+  const agents = await inventoryAgents(sessionDir, state);
+  return { sessionId, sessionDir, workDir, state, agents };
+}
+async function discoverAgentsFromDisk(sessionDir) {
+  const agentsDir = join2(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 = join2(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: join2(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 = join2(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 = new Map;
+  let raw;
+  try {
+    raw = await readFile(join2(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 = join2(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(join2(sessionDir, "state.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function findSessionDir(home, sessionId) {
+  if (!SESSION_ID_RE.test(sessionId))
+    return null;
+  const sessionsRoot = resolve(join2(home, "sessions"));
+  const sessionsRootPrefix = sessionsRoot + sep;
+  try {
+    const indexLines = (await readFile(join2(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 = join2(sessionsRoot, bucket.name, sessionId);
+    if (await pathExists(candidate))
+      return candidate;
+  }
+  return null;
+}
+async function scanWire(path) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  const rl = createInterface({ input: stream, 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;
+  }
+}
+
+// src/lib/wire-reader.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { createInterface as createInterface2 } from "node:readline";
+
+// ../../../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);
+}
+var migrateV1_0ToV1_1 = {
+  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
+      }
+    };
+  }
+};
+
+// ../../../packages/agent-core/src/agent/records/migration/index.ts
+var AGENT_WIRE_PROTOCOL_VERSION = "1.1";
+var MIGRATIONS = [migrateV1_0ToV1_1];
+function isNewerWireVersion(readVersion) {
+  return compareWireVersions(readVersion, AGENT_WIRE_PROTOCOL_VERSION) > 0;
+}
+function resolveWireMigrations(readVersion) {
+  if (compareWireVersions(readVersion, AGENT_WIRE_PROTOCOL_VERSION) >= 0) {
+    return [];
+  }
+  const migrations = [];
+  let version = readVersion;
+  while (compareWireVersions(version, AGENT_WIRE_PROTOCOL_VERSION) < 0) {
+    const migration = findMigration(version);
+    if (migration === undefined) {
+      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;
+}
+
+// src/lib/wire-reader.ts
+function bestEffortMigrations() {
+  try {
+    return resolveWireMigrations("1.0");
+  } catch {
+    return [];
+  }
+}
+async function readAgentWire(path) {
+  const stream = createReadStream2(path, { encoding: "utf8" });
+  const rl = createInterface2({ input: stream, 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}`);
+      }
+      if (isNewerWireVersion(pv)) {
+        warnings.push(`unrecognised protocol_version "${pv}" — parsing as best-effort (newer than supported)`);
+        migrations = bestEffortMigrations();
+      } else {
+        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);
+}
+
+// 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 wire = await readAgentWire(join3(detail.sessionDir, "agents", agentId, "wire.jsonl"));
+      const proj = projectContext(wire.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;
+}
+
+// src/routes/session-detail.ts
+import { Hono as Hono2 } from "hono";
+function sessionDetailRoute() {
+  const r = new Hono2;
+  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;
+}
+
+// src/routes/sessions.ts
+import { rm } from "node:fs/promises";
+import { Hono as Hono3 } from "hono";
+
+// src/lib/reveal.ts
+import { spawn } from "node:child_process";
+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] };
+  }
+}
+async function revealInOs(path) {
+  const { command, args } = revealCommandFor(path);
+  return new Promise((resolve2, 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();
+      resolve2();
+    });
+  });
+}
+
+// src/routes/sessions.ts
+function sessionsRoute() {
+  const r = new Hono3;
+  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 all = await listSessions(resolveByfHome());
+    const target = all.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;
+}
+
+// src/routes/subagents.ts
+import { Hono as Hono4 } from "hono";
+
+// src/lib/agent-tree.ts
+function buildAgentTree(agents) {
+  const byId = 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);
+}
+
+// src/routes/subagents.ts
+function subagentsRoute() {
+  const r = new Hono4;
+  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;
+}
+
+// src/routes/wire.ts
+import { join as join4 } from "node:path";
+import { Hono as Hono5 } from "hono";
+function wireRoute() {
+  const r = new Hono5;
+  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(join4(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;
+}
+
+// src/app.ts
+async function resolvePublicDir() {
+  try {
+    const here = import.meta.dirname;
+    const candidate = resolve2(here, "public");
+    const s = await stat2(candidate);
+    if (s.isDirectory())
+      return candidate;
+  } catch {}
+  return null;
+}
+var 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";
+  const ext = path.slice(i).toLowerCase();
+  return STATIC_EXT_MIME[ext] ?? "application/octet-stream";
+}
+function bearerToken(value) {
+  if (value === undefined)
+    return null;
+  const match = /^Bearer\s+(.+)$/i.exec(value);
+  return match?.[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);
+}
+async function createApp(options = {}) {
+  const app = new Hono6;
+  const api = new Hono6;
+  const authToken = options.authToken;
+  if (authToken !== undefined && 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 = resolve2(publicDir, `.${pathname}`);
+      if (!resolved.startsWith(publicDir)) {
+        return c.text("forbidden", 403);
+      }
+      try {
+        const s = await stat2(resolved);
+        if (s.isFile()) {
+          const buf = await readFile2(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 readFile2(join5(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;
+}
+
+// src/startup-banner.ts
+function formatStartupBanner(options) {
+  const authStatus = options.authToken === undefined ? "auth=disabled" : "auth=required";
+  return `[vis-server] listening on http://${hostForUrl(options.host)}:${String(options.port)} ` + `(${authStatus}, BYF_HOME=${options.byfCodeHome})
+`;
+}
+function hostForUrl(host) {
+  if (host.includes(":") && !host.startsWith("["))
+    return `[${host}]`;
+  return host;
+}
+
+// src/server.ts
+function hostForUrl2(host) {
+  if (host.includes(":") && !host.startsWith("["))
+    return `[${host}]`;
+  return host;
+}
+async function startVisServer(options = {}) {
+  const host = options.host ?? resolveHost();
+  const port = options.port ?? resolvePort();
+  const authToken = options.authToken ?? resolveVisAuthToken(host);
+  const app = await createApp({ authToken, publicDir: options.publicDir });
+  const server = Bun.serve({
+    hostname: host,
+    port,
+    fetch: app.fetch
+  });
+  const actualPort = server.port ?? port;
+  return {
+    host,
+    port: actualPort,
+    url: `http://${hostForUrl2(host)}:${actualPort}`,
+    close: () => {
+      server.stop(true);
+    }
+  };
+}
+function resolveVisByfHome() {
+  return resolveByfHome();
+}
+function formatVisStartupBanner(input) {
+  return formatStartupBanner({
+    authToken: input.authToken,
+    host: input.host,
+    byfCodeHome: resolveByfHome(),
+    port: input.port
+  });
+}
+
+export { resolvePort, resolveHost, resolveVisAuthToken, startVisServer, resolveVisByfHome, formatVisStartupBanner };
+
+//# debugId=8EBCC0393347A59C64756E2164756E21
+//# sourceMappingURL=server-enpsx6np.mjs.map