@a-t-h-i/bot-lobby 0.6.12 → 0.6.13

package/src/webui/api/status.ts

@@ -0,0 +1,55 @@
+/**
+ * `status.get`: everything the page shell needs before it reads a tab —
+ * workspace, session, tabs, shortcuts and open windows. Tab ids and labels
+ * come from the shared strings, shortcuts from the shared key map (with the
+ * web-only tab cycling defaults), so the page matches the terminal exactly.
+ */
+import { loadConfig } from "../../state/project.ts";
+import { LOBBY_ACTIONS, keyLabel, webKeyMap } from "../../lobby/keys.ts";
+import { TAB_LABELS, visibleTabs } from "../../lobby/prompts.ts";
+import type { ApiContext } from "./index.ts";
+import type { KeyInfo, StatusInfo, TabInfo } from "../protocol.ts";
+
+function tabs(issuesEnabled: boolean): TabInfo[] {
+  return visibleTabs(issuesEnabled).map((id, index) => ({ id, label: TAB_LABELS[id], key: `Alt+${index + 1}` }));
+}
+
+function keys(overrides: Readonly<Record<string, string>>): KeyInfo[] {
+  const map = webKeyMap(overrides);
+  return (Object.keys(LOBBY_ACTIONS) as Array<keyof typeof LOBBY_ACTIONS>).map((action) => ({
+    action,
+    key: map[action],
+    label: keyLabel(map[action]),
+    help: LOBBY_ACTIONS[action].help,
+  }));
+}
+
+/** Whether pi itself is asking in the terminal (a later surface reports it; false until one does). */
+function terminalDialog(ctx: ApiContext): boolean {
+  const extra = ctx.service as unknown as { terminalDialog?: () => boolean };
+  try {
+    return extra.terminalDialog?.() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+/** The page shell's first call. */
+export function statusGet(ctx: ApiContext): StatusInfo {
+  const service = ctx.service;
+  const issuesEnabled = service.issuesEnabled();
+  const workspace = service.workspace?.() ?? { name: "bot-lobby" };
+  return {
+    workspace: { name: workspace.name, ...(workspace.branch ? { branch: workspace.branch } : {}) },
+    ...(workspace.branch ? { branch: workspace.branch } : {}),
+    sessionId: service.sessionId() ?? undefined,
+    sessionName: service.sessionName() ?? undefined,
+    busy: service.masterBusy(),
+    terminalDialog: terminalDialog(ctx),
+    port: ctx.port,
+    issuesEnabled,
+    tabs: tabs(issuesEnabled),
+    keys: keys(loadConfig().lobby.keys),
+    windows: [],
+  };
+}

package/src/webui/api/tasks.ts

@@ -0,0 +1,204 @@
+/**
+ * The Tasks tab over HTTP: rows, archived tasks, plan comments, and the row
+ * actions (comment, archive, restore, delete, auto mode, message). Actions
+ * answer with the same notice text the terminal shows.
+ *
+ * The row shape mirrors `taskRows` in `src/lobby/tabs/tasks.ts`, whose pure
+ * data part is rebuilt here instead of imported: that module draws through
+ * `layout.ts` and would load the TUI (`@earendil-works/pi-tui`) into the
+ * server. The one type import above is erased at compile time.
+ */
+import { TERMINAL_STATES, taskRequest, type Task } from "../../schemas/task.ts";
+import type { PlannedTask } from "../../state/backlog.ts";
+import { describeRun, runFromLog } from "../../pi/run-summary.ts";
+import { pendingApprovals } from "../../workflow/approvals.ts";
+import type { TaskRow } from "../../lobby/tabs/tasks.ts";
+import type { TaskDetail } from "../protocol.ts";
+import type { ApiContext } from "./index.ts";
+import { fail } from "./index.ts";
+import { taskSteps } from "./plan-facts.ts";
+import type { TaskSection } from "../../lobby/tabs/tasks.ts";
+
+interface RowContext {
+  names: ReadonlyMap<string, string>;
+  auto: ReadonlySet<string>;
+  live: ReadonlySet<string>;
+}
+
+function checkOf(task: Task): TaskRow["check"] {
+  if (task.state === "completed") return "done";
+  if (task.state === "abandoned") return "dropped";
+  return "open";
+}
+
+function progressOf(task: Task): TaskRow["progress"] {
+  const steps = taskSteps(task);
+  if (steps.length === 0) return undefined;
+  return { done: steps.filter((step) => step.status === "done").length, total: steps.length };
+}
+
+/** How long ago, as `3h` (mirrors the lobby layout's `ago`). */
+function ago(ms: number): string {
+  if (!Number.isFinite(ms) || ms < 5_000) return "now";
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h`;
+  return `${Math.floor(hours / 24)}d`;
+}
+
+function ownerOf(task: Task, sessionId: string | undefined, ctx: RowContext): string {
+  if (!task.ownerSessionId) return "not running";
+  if (task.ownerSessionId === sessionId) return "this session";
+  const name = ctx.names.get(task.ownerSessionId);
+  if (name) return name === task.title ? "background" : `background · ${name}`;
+  return !ctx.live.has(task.ownerSessionId) ? "not running" : `session ${task.ownerSessionId.slice(0, 8)}`;
+}
+
+function rowOf(task: Task, section: TaskSection, ctx: RowContext, sessionId: string | undefined, now: number): TaskRow {
+  const progress = section === "recent" ? undefined : progressOf(task);
+  return {
+    kind: "task",
+    id: task.id,
+    title: task.title,
+    section,
+    status: task.state,
+    ...(task.paused && section !== "recent" ? { paused: true } : {}),
+    check: checkOf(task),
+    ...(progress ? { progress } : {}),
+    ...(section === "others" ? { owner: ownerOf(task, sessionId, ctx) } : {}),
+    ...(section === "recent" ? { age: ago(now - Date.parse(task.updatedAt)) } : {}),
+    ...(section !== "recent" && ctx.auto.has(task.id) ? { auto: true } : {}),
+  };
+}
+
+/** Rows in display order, mirroring the terminal's `taskRows` (without its search narrowing). */
+function buildRows(tasks: readonly Task[], plans: readonly PlannedTask[], sessionId: string | undefined, ctx: RowContext, now: number, archived: readonly Task[]): TaskRow[] {
+  const active = tasks.filter((task) => !TERMINAL_STATES.includes(task.state));
+  return [
+    ...active.filter((task) => sessionId && task.ownerSessionId === sessionId).map((task) => rowOf(task, "mine", ctx, sessionId, now)),
+    ...active.filter((task) => !sessionId || task.ownerSessionId !== sessionId).map((task) => rowOf(task, "others", ctx, sessionId, now)),
+    ...plans.filter((plan) => plan.status === "pending").map((plan): TaskRow => ({
+      kind: "plan",
+      id: plan.id,
+      title: plan.split ? `${plan.title} (${plan.split.part}/${plan.split.of})` : plan.title,
+      section: "pending",
+      status: "pending",
+      check: "open",
+      ...(plan.createdAt ? { age: ago(now - Date.parse(plan.createdAt)) } : {}),
+      ...(plan.issue ? { issue: plan.issue.number } : {}),
+    })),
+    ...tasks.filter((task) => TERMINAL_STATES.includes(task.state)).map((task) => rowOf(task, "recent", ctx, sessionId, now)),
+    ...archived.map((task): TaskRow => ({
+      kind: "archived",
+      id: task.id,
+      title: task.title,
+      section: "archived",
+      status: task.state,
+      check: checkOf(task),
+      age: ago(now - Date.parse(task.archivedAt ?? task.updatedAt)),
+    })),
+  ];
+}
+
+function contextOf(ctx: ApiContext, tasks: readonly Task[]): RowContext {
+  const names = new Map<string, string>();
+  for (const session of ctx.service.sessions()) {
+    if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
+  }
+  const auto = new Set(tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && ctx.service.isAuto(task.id)).map((task) => task.id));
+  return { names, auto, live: new Set(ctx.service.liveSessions().map((session) => session.sessionId)) };
+}
+
+/** Every task, plan and recent row, oldest groups first like the terminal. */
+export function tasksList(ctx: ApiContext): { rows: TaskRow[] } {
+  const tasks = ctx.service.tasks();
+  const rows = buildRows(tasks, ctx.service.plans(), ctx.service.sessionId(), contextOf(ctx, tasks), Date.now(), []);
+  return { rows };
+}
+
+/** Archived tasks as rows, most recently archived first. */
+export function tasksArchived(ctx: ApiContext): { rows: TaskRow[] } {
+  const archived = ctx.service.archivedTasks();
+  const rows = archived.map((task): TaskRow => ({
+    kind: "archived",
+    id: task.id,
+    title: task.title,
+    section: "archived",
+    status: task.state,
+    check: checkOf(task),
+    age: ago(Date.now() - Date.parse(task.archivedAt ?? task.updatedAt)),
+  }));
+  return { rows };
+}
+
+/** One task's plan comments, oldest first. */
+export function tasksComments(body: { taskId: string }, ctx: ApiContext): { comments: unknown[] } {
+  return { comments: ctx.service.comments(body.taskId) };
+}
+
+/** Comment on a task's plan; blank text is a no-op notice like the lobby's. */
+export function tasksComment(body: { taskId: string; text: string }, ctx: ApiContext): { notice?: string } {
+  if (!body.text.trim()) return { notice: "type something first" };
+  return { notice: ctx.service.comment(body.taskId, body.text) };
+}
+
+/** Archive, restore or delete a task; each answers the terminal's notice. */
+export function tasksArchive(body: { taskId: string }, ctx: ApiContext): { notice: string } {
+  return { notice: ctx.service.archiveTask(body.taskId) };
+}
+
+/** Bring an archived task back to the list. */
+export function tasksRestore(body: { taskId: string }, ctx: ApiContext): { notice: string } {
+  return { notice: ctx.service.restoreTask(body.taskId) };
+}
+
+/** Delete a task for good, from the list or the archive. */
+export function tasksDelete(body: { taskId: string; where: "list" | "archive" }, ctx: ApiContext): { notice: string } {
+  return { notice: ctx.service.deleteTask(body.taskId, body.where) };
+}
+
+/** Switch auto mode for a task; unknown or finished tasks are refused. */
+export function tasksAuto(body: { taskId: string; on: boolean }, ctx: ApiContext): { notice: string; on: boolean } {
+  const task = [...ctx.service.tasks(), ...ctx.service.archivedTasks()].find((entry) => entry.id === body.taskId);
+  if (!task) fail(404, "not_found", `no task ${body.taskId}`);
+  if (TERMINAL_STATES.includes((task as Task).state)) fail(400, "bad_request", `${body.taskId} is ${(task as Task).state}; auto mode applies to a task under way`);
+  ctx.service.setAuto(body.taskId, body.on);
+  const id = body.taskId;
+  return { notice: body.on ? `auto mode on — the oracle drives ${id} to completion without asking` : `auto mode off — the oracle asks you again on ${id}`, on: body.on };
+}
+
+/** Leave a message for a task's oracle; blank text is a no-op notice. */
+export function tasksMessage(body: { taskId: string; text: string }, ctx: ApiContext): { notice: string } {
+  if (!body.text.trim()) return { notice: "type something first" };
+  return { notice: ctx.service.sendToTask(body.taskId, body.text) };
+}
+
+/** How many recent runs the detail lists (the terminal's count). */
+const DETAIL_RUNS = 6;
+
+/** The terminal's "Waiting on" approvals: `kind` plus `for <domain>: <detail>`. */
+function waitingOf(task: Task): TaskDetail["waiting"] {
+  return pendingApprovals(task).map((approval) => ({ kind: approval.kind, detail: `for ${approval.domain}: ${approval.detail}` }));
+}
+
+/** One task read whole: request, plan or proposal, step checklist, waits and recent runs. */
+export function tasksGet(body: { taskId: string }, ctx: ApiContext): TaskDetail {
+  const task = [...ctx.service.tasks(), ...ctx.service.archivedTasks()].find((entry) => entry.id === body.taskId);
+  if (!task) fail(404, "not_found", `no task ${body.taskId}`);
+  const found = task as Task;
+  const request = taskRequest(found);
+  const now = Date.now();
+  return {
+    ...(request !== found.title ? { request } : {}),
+    ...(!found.plan && found.proposal ? { proposal: found.proposal } : {}),
+    ...(found.plan ? { plan: found.plan } : {}),
+    steps: taskSteps(found).map((step) => ({ text: step.text, status: step.status === "pending" ? "open" : step.status })),
+    amendments: [...found.amendments],
+    waiting: waitingOf(found),
+    blockers: found.blockers.map((blocker) => ({ reason: blocker.reason, need: blocker.need })),
+    runs: (found.runLog ?? []).slice(-DETAIL_RUNS).map((entry) => describeRun(runFromLog(entry, found.id), now)),
+  };
+}

package/src/webui/auth.ts

@@ -0,0 +1,153 @@
+/**
+ * Who may use the loopback server: whoever holds the link. The link carries
+ * a token in its `#fragment` (never sent to any server); the page trades it
+ * once for an HttpOnly, SameSite=Strict cookie. Pure helpers plus the secret
+ * file; the server wires them to HTTP.
+ */
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { globalConfigDir } from "../state/project.ts";
+
+/** Largest JSON body the server reads; past it the request is refused. */
+export const MAX_BODY_BYTES = 1_000_000;
+/** Session cookie name. */
+export const COOKIE_NAME = "bl_session";
+/** Wrong link tokens per minute before the server locks logins out. */
+export const LOGIN_FAILURES_PER_MINUTE = 10;
+/** The lockout window (and the failure window) in milliseconds. */
+export const LOGIN_WINDOW_MS = 60_000;
+
+function derive(secret: Buffer, purpose: string): string {
+  return createHmac("sha256", secret).update(purpose).digest("base64url");
+}
+
+/** The token the link carries (`#token=…`). */
+export function linkToken(secret: Buffer): string {
+  return derive(secret, "bot-lobby link v1");
+}
+
+/** The cookie value a signed-in browser holds. */
+export function sessionValue(secret: Buffer): string {
+  return derive(secret, "bot-lobby session v1");
+}
+
+/** Constant-time string compare (both sides hashed first, so lengths match). */
+export function safeEqual(a: string, b: string): boolean {
+  return timingSafeEqual(createHash("sha256").update(a).digest(), createHash("sha256").update(b).digest());
+}
+
+/** Path of the secret file: `web.json` under the user-global config dir. */
+export function webSecretPath(): string {
+  return join(globalConfigDir(), "web.json");
+}
+
+/** Leave a file readable only by its owner; fix it when it is wider. */
+function ensurePrivate(path: string): void {
+  try {
+    if ((statSync(path).mode & 0o077) !== 0) chmodSync(path, 0o600);
+  } catch {
+    // A file that cannot be inspected is replaced by the caller.
+  }
+}
+
+function writeSecret(path: string): Buffer {
+  const secret = randomBytes(32);
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, JSON.stringify({ secret: secret.toString("base64") }), { mode: 0o600 });
+  ensurePrivate(path);
+  return secret;
+}
+
+function readSecret(path: string): Buffer | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8")) as { secret?: unknown };
+    if (typeof raw.secret !== "string") return undefined;
+    const secret = Buffer.from(raw.secret, "base64");
+    return secret.length === 32 ? secret : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The loopback secret, created on first use. A corrupt file is replaced
+ * (`replaced` says so, and the caller logs a notice); a file that is wider
+ * than 0600 is narrowed in place.
+ */
+export function loadOrCreateSecret(): { secret: Buffer; created: boolean; replaced: boolean } {
+  const path = webSecretPath();
+  if (!existsSync(path)) return { secret: writeSecret(path), created: true, replaced: false };
+  const secret = readSecret(path);
+  if (!secret) return { secret: writeSecret(path), created: false, replaced: true };
+  ensurePrivate(path);
+  return { secret, created: false, replaced: false };
+}
+
+/** A new secret, signing everyone out (the next step's `web reset`). */
+export function resetSecret(): Buffer {
+  return writeSecret(webSecretPath());
+}
+
+/** The `Set-Cookie` value for a signed-in browser. */
+export function sessionCookie(value: string): string {
+  return `${COOKIE_NAME}=${value}; HttpOnly; SameSite=Strict; Path=/; Max-Age=2592000`;
+}
+
+/** One cookie's value from a `Cookie` header. */
+export function cookieOf(header: string | undefined, name: string): string | undefined {
+  if (!header) return undefined;
+  for (const part of header.split(";")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    if (part.slice(0, index).trim() === name) return part.slice(index + 1).trim();
+  }
+  return undefined;
+}
+
+/** Whether the request carries this server's session cookie. */
+export function isSignedIn(cookieHeader: string | undefined, session: string): boolean {
+  const value = cookieOf(cookieHeader, COOKIE_NAME);
+  return value !== undefined && value.length > 0 && safeEqual(value, session);
+}
+
+/** Hosts a loopback server on `port` answers to (DNS rebinding names anything else). */
+export function allowedHosts(port: number): Set<string> {
+  return new Set([`127.0.0.1:${port}`, `localhost:${port}`, `[::1]:${port}`]);
+}
+
+/** Whether `Host` names this loopback server. */
+export function isHostAllowed(host: string | undefined, port: number): boolean {
+  return host !== undefined && allowedHosts(port).has(host.trim().toLowerCase());
+}
+
+/** Origins this loopback server answers to. */
+function allowedOrigins(port: number): Set<string> {
+  return new Set([...allowedHosts(port)].map((host) => `http://${host}`));
+}
+
+/** A foreign `Origin` or a cross-site `Sec-Fetch-Site` (never another website). */
+export function isCrossSite(origin: string | undefined, site: string | undefined, port: number): boolean {
+  if (origin !== undefined && origin !== "" && !allowedOrigins(port).has(origin)) return true;
+  return site === "cross-site" || site === "same-site";
+}
+
+/** Wrong link tokens in the last minute; past the limit logins lock out for that minute. */
+export class LoginGuard {
+  private failures: number[] = [];
+  private readonly now: () => number;
+  constructor(now: () => number = Date.now) {
+    this.now = now;
+  }
+
+  /** Whether logins are locked out right now. */
+  blocked(at = this.now()): boolean {
+    this.failures = this.failures.filter((seen) => at - seen < LOGIN_WINDOW_MS);
+    return this.failures.length >= LOGIN_FAILURES_PER_MINUTE;
+  }
+
+  /** Record a wrong token. */
+  noteFailure(at = this.now()): void {
+    this.failures = [...this.failures.filter((seen) => at - seen < LOGIN_WINDOW_MS), at];
+  }
+}

package/src/webui/command.ts

@@ -0,0 +1,152 @@
+/**
+ * `/bot-lobby web`: the loopback server from Pi. `web` starts it (once per
+ * process), prints the link and opens the browser; `web link` prints only
+ * the link, `web stop` frees the port, `web reset` mints a new secret and
+ * returns the new link. Errors become a notice, never a throw; the link
+ * itself carries the secret, so notices never name it beyond the link.
+ */
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { loadConfig } from "../state/project.ts";
+import { currentLobbyService } from "../lobby/runtime.ts";
+import type { LobbyService } from "../lobby/service.ts";
+import { isSubagentProcess } from "../pi/quiet.ts";
+import { heartbeat } from "../pi/owner.ts";
+import { currentWebServer, startWebServer } from "./server.ts";
+import { openBrowser } from "./open.ts";
+
+export type WebSubcommand = "start" | "stop" | "link" | "reset";
+
+export interface WebCommandDeps {
+  service?: LobbyService;
+  open?: (url: string) => boolean;
+}
+
+/**
+ * The freshest link: the server's `link` is the one it started with, so a
+ * `reset` after it would leave `link`/`web link` printing the old secret.
+ * The commands below keep the newest link here instead.
+ */
+let latestLink: string | undefined;
+
+/** The link to print: the newest one from this module, else the server's own. */
+export function webLink(): string | undefined {
+  const running = currentWebServer();
+  if (!running) {
+    latestLink = undefined;
+    return undefined;
+  }
+  return latestLink ?? running.link;
+}
+
+/** The subcommand of `web stop|link|reset` (bare `web` starts); undefined when the word is none of those. */
+export function webAction(word: string | undefined): WebSubcommand | undefined {
+  if (!word) return "start";
+  if (word === "stop" || word === "link" || word === "reset") return word;
+  return undefined;
+}
+
+function resolveService(deps?: WebCommandDeps): LobbyService | undefined {
+  return deps?.service ?? currentLobbyService();
+}
+
+function openLink(url: string, deps?: WebCommandDeps): void {
+  if (!loadConfig().lobby.web.openBrowser) return;
+  try {
+    (deps?.open ?? openBrowser)(url);
+  } catch {
+    // A browser that will not open only means the link stays on screen.
+  }
+}
+
+async function startCommand(ctx: ExtensionCommandContext, deps?: WebCommandDeps): Promise<void> {
+  const running = currentWebServer();
+  if (running) {
+    ctx.ui.notify(`bot-lobby web is already running: ${webLink()}`, "info");
+    return;
+  }
+  const service = resolveService(deps);
+  if (!service) {
+    ctx.ui.notify("bot-lobby web needs the lobby service; open the lobby first.", "warning");
+    return;
+  }
+  const server = await startWebServer({ service, port: loadConfig().lobby.web.port });
+  latestLink = server.link;
+  heartbeat();
+  ctx.ui.notify(`bot-lobby web: ${server.link}`, "info");
+  openLink(server.link, deps);
+}
+
+function linkCommand(ctx: ExtensionCommandContext): void {
+  const link = webLink();
+  if (link) ctx.ui.notify(`bot-lobby web: ${link}`, "info");
+  else ctx.ui.notify("bot-lobby web is not running; /bot-lobby web starts it.", "warning");
+}
+
+async function stopCommand(ctx: ExtensionCommandContext): Promise<void> {
+  const running = currentWebServer();
+  if (!running) {
+    ctx.ui.notify("bot-lobby web is not running.", "warning");
+    return;
+  }
+  await running.close();
+  latestLink = undefined;
+  heartbeat();
+  ctx.ui.notify("bot-lobby web stopped.", "info");
+}
+
+function resetCommand(ctx: ExtensionCommandContext): void {
+  const running = currentWebServer();
+  if (!running) {
+    ctx.ui.notify("bot-lobby web is not running; /bot-lobby web starts it.", "warning");
+    return;
+  }
+  const link = running.reset();
+  latestLink = link;
+  heartbeat();
+  ctx.ui.notify(`bot-lobby web: the link changed: ${link}`, "info");
+}
+
+/** Run one `web` subcommand; a failure is a notice, never a throw. */
+export async function webCommand(ctx: ExtensionCommandContext, word: string | undefined, deps?: WebCommandDeps): Promise<void> {
+  const action = webAction(word);
+  if (!action) {
+    ctx.ui.notify("Usage: /bot-lobby web [stop|link|reset]", "warning");
+    return;
+  }
+  try {
+    if (action === "start") await startCommand(ctx, deps);
+    else if (action === "stop") await stopCommand(ctx);
+    else if (action === "reset") resetCommand(ctx);
+    else linkCommand(ctx);
+  } catch (error) {
+    ctx.ui.notify(`bot-lobby web failed — ${(error as Error).message}`, "warning");
+  }
+}
+
+/**
+ * On `session_start`: follow the fresh lobby service, and start the server
+ * when the config asks for it. Silent (no notice, no browser): the status
+ * line shows the link once the server runs.
+ */
+export function webSessionStarted(deps?: WebCommandDeps): void {
+  if (isSubagentProcess()) return;
+  const service = resolveService(deps);
+  const running = currentWebServer();
+  if (running) {
+    if (service) running.rebind(service);
+    return;
+  }
+  if (!service || !loadConfig().lobby.web.enabled) return;
+  startWebServer({ service, port: loadConfig().lobby.web.port })
+    .then((server) => {
+      latestLink = server.link;
+      heartbeat();
+    })
+    .catch(() => {});
+}
+
+/** Wire the web server's lifecycle; called with the other session wiring. */
+export function registerWebServer(pi: ExtensionAPI): void {
+  if (isSubagentProcess()) return;
+  pi.on("session_start", () => webSessionStarted());
+}