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

package/src/lobby/blocks.ts

@@ -0,0 +1,57 @@
+/**
+ * Plain Markdown helpers the lobby shares: model text with escaped line
+ * breaks made real, and a reply split into blocks that can be rendered one by
+ * one (the page renders them, not the terminal).
+ */
+
+/**
+ * Line breaks a model wrote out as `\n` (text escaped twice on its way here,
+ * so a whole plan arrives as one line): made real when the text has no real
+ * line break at all, outside inline code, where `\n` is usually meant.
+ */
+export function unescapeBreaks(text: string): string {
+  if (text.includes("\n") || !text.includes("\\n")) return text;
+  return text
+    .split(/(`[^`\n]*`)/)
+    .map((part, index) => (index % 2 === 1 ? part : part.replace(/(?:\\r)?\\n/g, "\n")))
+    .join("");
+}
+
+/** A fenced code block's opening or closing line. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+/** A list item's first line: after a blank line it continues the list above, so blocks never split there. */
+const LIST_ITEM = /^(?:[-*+]|\d{1,9}[.)])(?:\s|$)/;
+
+/**
+ * Markdown split into blocks that render, one by one, into the same output as
+ * the whole (each block's lines, a blank line between blocks, blocks that
+ * render to nothing left out). A split falls on a blank line outside code
+ * fences that is followed by an unindented line that does not start a list
+ * item — the only places where one block can never run into the next. A
+ * streaming reply can then keep its finished blocks rendered and render only
+ * the one still being written.
+ */
+export function markdownBlocks(text: string): string[] {
+  const lines = text.split("\n");
+  const blocks: string[] = [];
+  let fence: string | undefined;
+  let start = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]!;
+    const marker = FENCE.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = undefined;
+      continue;
+    }
+    if (fence || line.trim() || index === 0) continue;
+    const next = lines[index + 1];
+    if (next === undefined || !/^\S/.test(next) || LIST_ITEM.test(next)) continue;
+    const block = lines.slice(start, index).join("\n");
+    if (block.trim()) blocks.push(block);
+    start = index + 1;
+  }
+  const last = lines.slice(start).join("\n");
+  if (last.trim()) blocks.push(last);
+  return blocks;
+}

package/src/lobby/feed.ts

@@ -7,7 +7,7 @@
  */
 import type { AgentRun } from "../schemas/findings.ts";
 import { agentName } from "../pi/run-summary.ts";
-import { markdownBlocks } from "./markdown.ts";
+import { markdownBlocks } from "./blocks.ts";
 
 export type ActivityKind = "info" | "success" | "warning" | "error";
 

package/src/lobby/host.ts

@@ -0,0 +1,178 @@
+/**
+ * What the lobby's backend offers: the service interface the web server
+ * drives, and the shapes of the sessions it lists. Pure types (the
+ * implementation is `service.ts`).
+ */
+import type { Task } from "../schemas/task.ts";
+import type { AgentRun } from "../schemas/findings.ts";
+import type { PlannedTask } from "../state/backlog.ts";
+import type { PlanComment } from "../state/comments.ts";
+import type { MetricRecord } from "../state/metrics.ts";
+import type { BotLobbyConfig, LobbyAgentKind, PanelMember } from "../schemas/configuration.ts";
+import type { ChatEntry, LobbyFeed } from "./feed.ts";
+import type { BackgroundSession } from "./sessions.ts";
+import type { QuickFixQueue } from "./quickfix.ts";
+import type { PlannerSeed, PlanningSession } from "./planner.ts";
+import type { IssuesState } from "./issues.ts";
+import type { PullsState } from "./pulls.ts";
+import type { PullReviews } from "./pr-review.ts";
+import type { KnowledgeBook } from "./knowledge.ts";
+import type { ExcalidrawBook, ExcalidrawSession } from "../excalidraw/sessions.ts";
+import type { WorkspaceInfo } from "../execution/workspace.ts";
+
+export { TAB_IDS, TAB_LABELS, visibleTabs } from "./prompts.ts";
+export type { TabId } from "./prompts.ts";
+
+/** What a checked Excalidraw session reported. */
+export interface SessionCheck {
+  ok: boolean;
+  text: string;
+}
+
+/**
+ * Which session the Lobby tab shows and talks to: this window, one it started
+ * in the background, one running in another terminal, or a task whose
+ * session is not running at all.
+ */
+export type SessionView =
+  | { kind: "here" }
+  | { kind: "background"; key: string }
+  | { kind: "other"; sessionId: string }
+  | { kind: "idle"; taskId: string };
+
+export type SessionWhere = "this window" | "background" | "other terminal" | "not running";
+
+/** One row of the session browser. */
+export interface SessionEntry {
+  view: SessionView;
+  name: string;
+  where: SessionWhere;
+  task?: Task;
+  /** What it is doing: working, idle, starting, ended, or its task's state. */
+  status: string;
+  auto: boolean;
+  /** Questions it waits on you for. */
+  waiting: number;
+  /** The pi session it is (absent for a task no session ever owned). */
+  sessionId?: string;
+  /** The process running it, for sessions in other terminals. */
+  pid?: number;
+}
+
+/** A session running in this project, as its heartbeat tells (see state/presence.ts). */
+export interface LiveSession {
+  sessionId: string;
+  pid: number;
+  name?: string;
+  taskId?: string;
+  mode: string;
+}
+
+/** What `switchTo` needs: the session to run in this window, and the background process to stop first. */
+export interface SwitchTarget {
+  name: string;
+  sessionId?: string;
+  background?: BackgroundSession;
+  /** A task no session owns: this window claims it instead. */
+  claimTaskId?: string;
+}
+
+/** One model Pi offers, for the settings page's picker: `provider/id`, its label and thinking levels. */
+export interface ModelChoice {
+  id: string;
+  label: string;
+  thinkingLevels: string[];
+}
+
+/** Everything the web server needs from pi and bot-lobby. */
+export interface LobbyService {
+  sessionId(): string | undefined;
+  /** This session's active task and its runs, as the lobby reads them. */
+  zen(): { task?: Task; runs: readonly AgentRun[] };
+  feed: LobbyFeed;
+  masterBusy(): boolean;
+  tasks(): Task[];
+  plans(): PlannedTask[];
+  comments(taskId: string): PlanComment[];
+  metrics(): MetricRecord[];
+  /** Classifier calls (kind `classifier`), kept out of the agent tables. */
+  classifierMetrics?(): MetricRecord[];
+  /** Send text to the oracle, or start a task when none is active; returns a notice. */
+  toOracle(text: string): string | undefined;
+  comment(taskId: string, text: string): string;
+  startPlanned(plan: PlannedTask): string;
+  discardPlan(id: string): void;
+  abortMaster(): void;
+  quickfix: QuickFixQueue;
+  planner(): PlanningSession | undefined;
+  /** Start a planning session (replacing any other) with these seats on the panel. */
+  newPlanner(seed?: PlannerSeed, seats?: readonly PanelMember[]): PlanningSession;
+  /** The oracle puts the panel's open questions to the user, one questionnaire at a time; returns a notice. */
+  answerPanel(): Promise<string>;
+  /** Save the plan as a pending task, offering to split a long one into several first; returns a notice. */
+  savePlan(): Promise<string>;
+  /** The seats a new session starts with, from settings. */
+  defaultPanel(): readonly PanelMember[];
+  /** Planning rounds before the oracle finalizes alone (`lobby.maxPlanningRounds`); 0 = unlimited. */
+  planningRounds?(): number;
+  /** `model · thinking` a panel seat runs on. */
+  seatLabel(member: PanelMember): string;
+  issues: IssuesState;
+  /** The Git tab's pull requests, read through `gh`. */
+  pulls: PullsState;
+  /** Reviews of pull requests by an agent, and Jev's reads of them. */
+  reviews: PullReviews;
+  /** Every agent's knowledge files: read, edited, commented on. */
+  knowledge: KnowledgeBook;
+  /** The shared Excalidraw sessions (five at most) and which agents each is assigned to. */
+  excalidraw: ExcalidrawBook;
+  /** Join a session's room for a moment and report what is there. */
+  checkExcalidraw(session: ExcalidrawSession): Promise<SessionCheck>;
+  /** The effective config, never a secret; the web settings page reads it. */
+  config?(): BotLobbyConfig;
+  /** Save a whole config, the way the settings menu does; the web settings page writes it. */
+  saveConfig?(config: BotLobbyConfig): void;
+  /** Reload cached config (keys, panes) after a settings change. */
+  configChanged?(): void;
+  /** The models Pi offers, for the settings page's picker. */
+  models?(): ModelChoice[];
+  /** The model this window's session runs on (`provider/id`), when it has one. */
+  sessionModel?(): string | undefined;
+  /** The Issues tab is switched on (`lobby.issues`). */
+  issuesEnabled(): boolean;
+  /** This window's pi session name, when it has one. */
+  sessionName(): string | undefined;
+  /** Background sessions this window started, oldest first. */
+  sessions(): readonly BackgroundSession[];
+  /** Start a task in a new background session, named after the task; the session, or why not. */
+  startSession(start: { request?: string; plan?: PlannedTask; auto?: boolean }): BackgroundSession | string;
+  /** Auto mode for any task, whichever session drives it. */
+  isAuto(taskId: string): boolean;
+  setAuto(taskId: string, on: boolean): void;
+  /** Leave a message for a task's oracle, delivered by whichever session drives it (now or once one resumes it); returns a notice. */
+  sendToTask(taskId: string, text: string): string;
+  /** Leave a message for a session running in another terminal; it delivers it within seconds. Returns a notice. */
+  sendToSession(sessionId: string, text: string): string;
+  /** Sessions running in this project, other than this window's, from their heartbeats. */
+  liveSessions(): readonly LiveSession[];
+  /** Run another session in this window (stopping its background process first); resolves to a notice. */
+  switchTo(target: SwitchTarget): Promise<string>;
+  /** Archived tasks, most recently archived first. */
+  archivedTasks(): Task[];
+  /** Archive, restore or delete a task; each returns a notice. */
+  archiveTask(taskId: string): string;
+  restoreTask(taskId: string): string;
+  deleteTask(taskId: string, where: "list" | "archive"): string;
+  /** Another session's conversation, read from its saved session file (its newest messages). */
+  sessionChat(sessionId: string): ChatEntry[];
+  /** Whether another session has messages earlier than `sessionChat` returns. */
+  hasOlderChat(sessionId: string): boolean;
+  /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
+  chatHistory(sessionId?: string): readonly ChatEntry[];
+  profileLabel(kind: LobbyAgentKind): string;
+  /** The repository (or folder) and branch the title shows; the folder's name alone until git has answered. */
+  workspace?(): WorkspaceInfo;
+  /** Ask for the workspace to be read again (the branch may have changed); it arrives through `workspace()`. */
+  refreshWorkspace?(): void;
+}
+

package/src/lobby/keys.ts

@@ -1,27 +1,17 @@
 /**
- * The lobby's shortcuts in one table: every action has a default key, a line
- * for the help overlay, and can be rebound under `lobby.keys` in the config
- * (`{ "toggleThinking": "alt+t" }`). They work in typing and browsing mode
- * alike, so each default is a key that never types a character.
+ * The web lobby's shortcuts in one table: every action has a default key, a
+ * line for the help overlay, and can be rebound under `lobby.keys` in the
+ * config (`{ "search": "alt+f" }`). Chords are written `alt+k`,
+ * `ctrl+f`, `shift+tab`; the page matches them on the physical key.
  */
-import { Key, matchesKey, type KeyId } from "@earendil-works/pi-tui";
 
 export const LOBBY_ACTIONS = {
-  hide: { key: "alt+l", help: "hide the lobby (back to pi)" },
-  help: { key: "alt+h", help: "show or hide these keys" },
-  settings: { key: "alt+s", help: "bot-lobby settings: each agent's model and thinking, the lobby" },
-  search: { key: "ctrl+f", help: "search the current tab" },
-  savePlan: { key: "ctrl+s", help: "save the plan being made in the Plan tab to the pending tasks" },
-  sessions: { key: "alt+o", help: "browse sessions: view one, message it, or switch this window to it" },
-  newSession: { key: "alt+n", help: "start a task in a new session, named after it" },
-  toggleAuto: { key: "alt+g", help: "auto mode: the oracle drives the task to completion without asking" },
-  nextTab: { key: "tab", help: "next tab" },
-  prevTab: { key: "shift+tab", help: "previous tab" },
-  toggleConversation: { key: "alt+c", help: "show or hide the conversation" },
-  toggleActivity: { key: "alt+a", help: "show or hide the activity log" },
-  toggleThinking: { key: "alt+k", help: "show or hide thinking" },
-  scrollUp: { key: "pageUp", help: "scroll up a page" },
-  scrollDown: { key: "pageDown", help: "scroll down a page" },
+  help: { key: "alt+h", help: "show or hide this list" },
+  settings: { key: "alt+s", help: "settings: each agent's model and effort" },
+  savePlan: { key: "ctrl+s", help: "save the plan from the Plan tab" },
+  sessions: { key: "alt+o", help: "browse and message your sessions" },
+  nextTab: { key: "alt+]", help: "next tab" },
+  prevTab: { key: "alt+[", help: "previous tab" },
 } as const;
 
 export type LobbyAction = keyof typeof LOBBY_ACTIONS;
@@ -37,27 +27,6 @@ export function keyMap(overrides: Readonly<Record<string, string>> = {}): KeyMap
   return map;
 }
 
-/** Alt+digit jumps to the tab at `index`; the same key the TUI matches. */
-export function tabJumpKey(index: number): KeyId {
-  return Key.alt(String(index + 1) as "1");
-}
-
-/** `keyMap` with the web-only tab cycling defaults; user overrides win. */
-export function webKeyMap(overrides: Readonly<Record<string, string>> = {}): KeyMap {
-  const map = keyMap(overrides);
-  if (!overrides.nextTab?.trim()) map.nextTab = "alt+]";
-  if (!overrides.prevTab?.trim()) map.prevTab = "alt+[";
-  return map;
-}
-
-/** The action `data` triggers under `map`, if any. */
-export function actionFor(data: string, map: KeyMap): LobbyAction | undefined {
-  for (const action of Object.keys(map) as LobbyAction[]) {
-    if (matchesKey(data, map[action] as KeyId)) return action;
-  }
-  return undefined;
-}
-
 /** `alt+k` reads `Alt+K` in hints and help. */
 export function keyLabel(key: string): string {
   return key

package/src/lobby/prompt-hub.ts

@@ -1,15 +1,15 @@
 /**
- * Bot-lobby's questions answerable from several surfaces, with the first
- * answer winning. A surface registers (`terminal` today; the web page later);
- * `open` shows the prompt on every surface, `answer` settles it once, and a
- * cancelled caller's `signal` withdraws every surface. The terminal drives
- * its prompts through `run`, which wraps today's code unchanged.
+ * Bot-lobby's questions, answered in the web page. `open` puts a prompt in
+ * the page's queue, `answer` settles it once (a late answer is refused), and
+ * `ask` is what the agents' code awaits: it opens a prompt and resolves with
+ * the answer, or with how it was put away. A cancelled caller's `signal`
+ * withdraws the prompt.
  */
 import { lobbyTopics } from "./topics.ts";
 
 export type PromptKind = "questionnaire" | "choose" | "confirm" | "text" | "sessionDialog";
 
-/** A pending question in the shape the later web API lists. */
+/** A pending question in the shape the web API lists. */
 export interface WebPrompt {
   id: string;
   kind: PromptKind;
@@ -18,13 +18,6 @@ export interface WebPrompt {
   payload: unknown;
 }
 
-/** One surface a prompt shows on; `withdraw` takes it back off screen. */
-export interface PromptSurface {
-  name: string;
-  show(prompt: WebPrompt): void;
-  withdraw(id: string): void;
-}
-
 interface Pending {
   prompt: WebPrompt;
 }
@@ -42,30 +35,13 @@ function nextId(seq: number): string {
   return `p${seq}-${Date.now().toString(36)}`;
 }
 
-function showOn(surfaces: Iterable<PromptSurface>, prompt: WebPrompt): void {
-  for (const surface of surfaces) surface.show(prompt);
-}
-
-function withdrawFrom(surfaces: Iterable<PromptSurface>, id: string): void {
-  for (const surface of surfaces) surface.withdraw(id);
-}
-
-/** Questions from several surfaces; the first answer wins. */
+/** The questions waiting for the page; the first answer wins. */
 export class PromptHub {
   private seq = 0;
   private readonly pendingMap = new Map<string, Pending>();
-  private readonly surfaces = new Map<string, PromptSurface>();
+  private readonly waiters = new Map<string, (outcome: Outcome) => void>();
   private readonly outcomes: Outcome[] = [];
 
-  /** Put a surface on show duty; returns its unregister function. */
-  registerSurface(surface: PromptSurface): () => void {
-    this.surfaces.set(surface.name, surface);
-    for (const entry of this.pendingMap.values()) surface.show(entry.prompt);
-    return () => {
-      this.surfaces.delete(surface.name);
-    };
-  }
-
   /** The questions still waiting for an answer, oldest first. */
   pending(): WebPrompt[] {
     return [...this.pendingMap.values()].map((entry) => entry.prompt);
@@ -76,14 +52,13 @@ export class PromptHub {
     this.seq += 1;
     const prompt: WebPrompt = { id: nextId(this.seq), kind, createdAt: Date.now(), from, payload };
     this.pendingMap.set(prompt.id, { prompt });
-    showOn(this.surfaces.values(), prompt);
     lobbyTopics.bump("prompts");
     return prompt;
   }
 
   /**
    * Settle `id` with `value`. True when this call won; false when the prompt
-   * is already settled or unknown (the later web API answers 409 then).
+   * is already settled or unknown (the web API answers 409 then).
    */
   answer(id: string, value: unknown): boolean {
     if (!this.pendingMap.has(id)) return false;
@@ -105,57 +80,35 @@ export class PromptHub {
 
   private settle(id: string, value: unknown, how: Outcome["how"]): void {
     this.pendingMap.delete(id);
-    withdrawFrom(this.surfaces.values(), id);
-    this.outcomes.push({ id, value, how });
+    const outcome: Outcome = { id, value, how };
+    this.outcomes.push(outcome);
     if (this.outcomes.length > MAX_OUTCOMES) this.outcomes.splice(0, this.outcomes.length - MAX_OUTCOMES);
+    const waiter = this.waiters.get(id);
+    this.waiters.delete(id);
+    waiter?.(outcome);
     lobbyTopics.bump("prompts");
   }
 
   /**
-   * Run today's terminal code for a prompt: it shows on every surface, the
-   * terminal's `show` answers it, and a cancelled `signal` withdraws them
-   * all. With only the terminal registered this is exactly today's behaviour.
+   * Open a prompt and wait for its outcome: the page's answer, or `dismissed`
+   * / `cancelled` when it is put away or `signal` aborts first.
    */
-  async run<T>(kind: PromptKind, from: string, payload: unknown, show: (prompt: WebPrompt) => Promise<T>, options?: { signal?: AbortSignal }): Promise<T> {
-    const prompt = this.open(kind, from, payload);
+  ask(kind: PromptKind, from: string, payload: unknown, options?: { signal?: AbortSignal }): Promise<{ how: Outcome["how"]; value: unknown }> {
     const signal = options?.signal;
-    if (signal?.aborted) return this.cancelled(prompt.id, show, prompt);
-    const onAbort = () => this.dismiss(prompt.id);
-    signal?.addEventListener("abort", onAbort, { once: true });
-    try {
-      const value = await show(prompt);
-      return this.claim(prompt.id, value);
-    } finally {
-      signal?.removeEventListener("abort", onAbort);
-    }
-  }
-
-  /** The caller was already cancelled: withdraw every surface, keep today's result. */
-  private async cancelled<T>(id: string, show: (prompt: WebPrompt) => Promise<T>, prompt: WebPrompt): Promise<T> {
-    this.pendingMap.delete(id);
-    withdrawFrom(this.surfaces.values(), id);
-    lobbyTopics.bump("prompts");
-    return this.remember(id, await show(prompt));
-  }
-
-  /** Claim the win for `value`, unless another surface answered first. */
-  private claim<T>(id: string, value: T): T {
-    if (!this.pendingMap.has(id)) return this.remembered(id, value);
-    this.settle(id, value, "answered");
-    return value;
-  }
-
-  private remember<T>(id: string, value: T): T {
-    if (!this.outcome(id)) this.outcomes.push({ id, value, how: "cancelled" });
-    lobbyTopics.bump("prompts");
-    return value;
-  }
-
-  private remembered<T>(id: string, fallback: T): T {
-    const outcome = this.outcome(id);
-    return (outcome?.value ?? fallback) as T;
+    if (signal?.aborted) return Promise.resolve({ how: "cancelled", value: undefined });
+    const prompt = this.open(kind, from, payload);
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        if (this.pendingMap.has(prompt.id)) this.settle(prompt.id, undefined, "cancelled");
+      };
+      this.waiters.set(prompt.id, (outcome) => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve({ how: outcome.how, value: outcome.value });
+      });
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
   }
 }
 
-/** The process-wide hub; the terminal surface registers at lobby start. */
+/** The process-wide hub. */
 export const promptHub = new PromptHub();

package/src/lobby/prompts.ts

@@ -1,11 +1,10 @@
 /**
- * Strings the terminal lobby and the web lobby share: tab metadata and the
- * short status lines shown while a question is answered elsewhere. Pure on
- * purpose (no `node:*`, no `@earendil-works/pi-tui`): the web page imports
- * this file directly.
+ * Strings the server and the page share: tab metadata and the short line
+ * shown when a question was answered elsewhere. Pure on purpose (no
+ * `node:*`): the web page imports this file directly.
  */
 
-export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "issues", "metrics", "git", "knowledge", "excalidraw"] as const;
+export const TAB_IDS = ["lobby", "tasks", "plan", "quickfix", "issues", "excalidraw", "git", "knowledge", "metrics"] as const;
 export type TabId = (typeof TAB_IDS)[number];
 
 export const TAB_LABELS: Record<TabId, string> = {
@@ -25,11 +24,8 @@ export function visibleTabs(issues: boolean): TabId[] {
   return TAB_IDS.filter((tab) => issues || tab !== "issues");
 }
 
-/** A question answered in the terminal while the web lobby watched it. */
-export const ANSWERED_IN_TERMINAL = "already answered in the terminal";
+/** A question answered in another window of the page (or put away) before this one's answer arrived. */
+export const ANSWERED_ELSEWHERE = "already answered in another window";
 
-/** Pi itself is asking in the terminal; the web lobby waits. */
-export const PI_ASKING_IN_TERMINAL = "pi is asking in the terminal";
-
-/** The window is too narrow to show the lobby. */
-export const NARROW_WINDOW = "the window is too narrow to show the lobby";
+/** Opens the list of files a message carries (see src/webui/uploads.ts); the page shows them as thumbnails and chips. */
+export const ATTACHMENTS_MARK = "Attached files:";