@a-t-h-i/bot-lobby 0.6.30 → 0.6.32

package/README.md

@@ -57,6 +57,11 @@ A task that is paused, or that no running session drives, shows **Resume** (`R`)
 It carries the task on without moving your window: a paused task is unpaused where it runs, and a
 stopped one carries on in a background session, which restarts its own session when its file is found.
 
+The **Tasks** screen has **List** and **Board** subtabs. Board groups saved plans and new tasks
+in **Backlog**, active work in **In progress**, and finished work in **Completed**. Abandoned
+work stays labeled in Backlog until archived. Cards open the existing task details and actions;
+archiving removes a card immediately, while the List view can still show the archive.
+
 | Agent | Does |
 | --- | --- |
 | Oracle | Your Pi session: questions, plan, delegation and approvals |
@@ -65,6 +70,16 @@ stopped one carries on in a background session, which restarts its own session w
 | QA | The final quality gate, at the depth the change's risk calls for |
 | RESEARCH | External facts, with sources |
 
+## Projects
+
+Click the project name (or press `P`) to switch between running projects or choose **Open folder…**.
+The folder browser lists directories on the machine running bot-lobby, not the browser's machine;
+you can browse, go to a parent, or enter an absolute path. An existing project is reused; otherwise
+a dedicated Pi session starts for the folder's detected project root. It loads this copy of bot-lobby
+without other extensions and does not automatically trust project-local resources. Switching projects
+reloads the page and discards unsent drafts. Projects opened this way stop when their hosting lobby
+stops; opening a folder does not start a task or merge work.
+
 ## Knowledge
 
 Each agent keeps what it learns about your project in `.pi/bot-lobby/<Agent>/knowledge/`:
@@ -81,10 +96,10 @@ moved to Redis"). A note travels with its entry into every agent's prompt.
 
 ![The Knowledge tab: each agent's files, and one open with notes on its entries](.github/screenshots/knowledge.png)
 
-Ask project questions from **Knowledge** using the **Ask** target below. The oracle checks saved
-knowledge first, searches the codebase for missing information, and records verified findings in
-the relevant agent's knowledge. Answers appear in the tab's **Ask** view; **Files** returns to the
-knowledge tree. Questions do not create tasks.
+Ask project questions directly from the **Knowledge** composer. The oracle checks saved knowledge
+first, searches the codebase for missing information, and records verified findings in the relevant
+agent's knowledge. Answers appear in the side pane; the **Chat / Docs** toggle inside the composer
+switches back to the selected document. Questions do not create tasks.
 
 ## Keys
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.30",
+  "version": "0.6.32",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/src/lobby/runtime.ts

@@ -286,9 +286,10 @@ function nudgeWhenIdle(state: Runtime, message: string): void {
  * Whether this pi process serves the web page: an interactive session. A
  * one-shot run has nobody to answer, and the background sessions the lobby
  * starts (RPC) are shown by the page of the window that started them.
+ * Explicitly opened project folders get their own managed RPC web server.
  */
 export function servesPage(ctx: ExtensionContext): boolean {
-  return ctx.mode === "tui";
+  return ctx.mode === "tui" || (ctx.mode === "rpc" && process.env.BOT_LOBBY_WEB_PROJECT === "1");
 }
 
 interface MasterTurn {

package/src/lobby/sessions.ts

@@ -294,10 +294,12 @@ export function sessionArgs(name: string, model?: string, argv: readonly string[
 const POSIX = process.platform !== "win32";
 
 /** The real launcher: the same pi build as this session, in its own process group, without subagent markers. */
-export const launchPi: SessionLauncher = (args, cwd) => {
+export const launchPi = (args: string[], cwd: string, overrides: NodeJS.ProcessEnv = {}): SessionProcess => {
   const invocation = resolvePiInvocation(args);
   const env: NodeJS.ProcessEnv = { ...process.env, PI_SKIP_VERSION_CHECK: "1" };
   delete env.BOT_LOBBY_SUBAGENT;
+  delete env.BOT_LOBBY_WEB_PROJECT;
+  Object.assign(env, overrides);
   const proc: ChildProcess = spawn(invocation.command, invocation.args, { cwd, env, shell: false, detached: POSIX, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
   return proc as unknown as SessionProcess;
 };

package/src/webui/command.ts

@@ -55,7 +55,7 @@ function resolveService(deps?: WebCommandDeps): LobbyService | undefined {
 }
 
 function openLink(url: string, deps?: WebCommandDeps): void {
-  if (!loadConfig().lobby.web.openBrowser) return;
+  if (process.env.BOT_LOBBY_WEB_PROJECT === "1" || !loadConfig().lobby.web.openBrowser) return;
   try {
     (deps?.open ?? openBrowser)(url);
   } catch {

package/src/webui/dev/fake-service.ts

@@ -512,12 +512,14 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
       const index = tasks.findIndex((task) => (task as { id: string }).id === taskId);
       if (index < 0) return `no task ${taskId}`;
       archived.unshift(tasks.splice(index, 1)[0]!);
+      lobbyTopics.bump("tasks");
       return `archived ${taskId} — v shows archived tasks, a restores one`;
     },
     restoreTask: (taskId: string) => {
       const index = archived.findIndex((task) => (task as { id: string }).id === taskId);
       if (index < 0) return `no archived task ${taskId}`;
       tasks.unshift(archived.splice(index, 1)[0]!);
+      lobbyTopics.bump("tasks");
       return `restored ${taskId} to the task list`;
     },
     deleteTask: (taskId: string, where: "list" | "archive") => {
@@ -525,6 +527,7 @@ export function createFixtureService(name: string, feed = new LobbyFeed()): Lobb
       const index = list.findIndex((task) => (task as { id: string }).id === taskId);
       if (index < 0) return `no task ${taskId}`;
       list.splice(index, 1);
+      lobbyTopics.bump("tasks");
       return `deleted ${taskId} for good`;
     },
     isAuto: (taskId: string) => auto.has(taskId),

package/src/webui/project-folders.ts

@@ -0,0 +1,53 @@
+import { constants } from "node:fs";
+import { access, opendir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { HttpError } from "./api/index.ts";
+import type { FolderListing } from "./protocol.ts";
+
+export function folderPath(body: unknown): string {
+  if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).some((key) => key !== "path")) {
+    throw new HttpError(400, "bad_request", "send only a folder path");
+  }
+  const path = (body as { path?: unknown }).path;
+  if (typeof path !== "string" || path.length > 4096 || path.includes("\0") || !isAbsolute(path)) {
+    throw new HttpError(400, "bad_request", "choose an absolute folder path on the bot-lobby machine");
+  }
+  return path;
+}
+
+function folderError(error: unknown): never {
+  if (error instanceof HttpError) throw error;
+  const code = (error as NodeJS.ErrnoException).code;
+  if (code === "ENOENT") throw new HttpError(404, "not_found", "That folder does not exist.");
+  if (code === "ENOTDIR") throw new HttpError(400, "bad_request", "That path is not a folder.");
+  throw new HttpError(403, "forbidden", "That folder cannot be read. Check its permissions or choose another folder.");
+}
+
+export async function readableFolder(path: string): Promise<string> {
+  try {
+    const root = await realpath(path);
+    if (!(await stat(root)).isDirectory()) throw new HttpError(400, "bad_request", "That path is not a folder.");
+    await access(root, constants.R_OK | constants.X_OK);
+    return root;
+  } catch (error) { return folderError(error); }
+}
+
+async function directoryLink(path: string): Promise<boolean> {
+  try { return (await stat(path)).isDirectory(); } catch { return false; }
+}
+
+export async function browseFolders(path: string): Promise<FolderListing> {
+  const root = await readableFolder(path);
+  const folders: FolderListing["folders"] = [];
+  let seen = 0;
+  try {
+    for await (const entry of await opendir(root)) {
+      if (++seen > 2000) break;
+      if (entry.isDirectory() || (entry.isSymbolicLink() && await directoryLink(join(root, entry.name)))) {
+        folders.push({ name: entry.name, path: join(root, entry.name) });
+      }
+    }
+  } catch (error) { return folderError(error); }
+  folders.sort((a, b) => a.name.localeCompare(b.name));
+  return { path: root, parent: dirname(root) === root ? undefined : dirname(root), folders, truncated: seen > 2000 };
+}

package/src/webui/project-open.ts

@@ -0,0 +1,73 @@
+import { basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { setTimeout as delay } from "node:timers/promises";
+import { BackgroundSession, launchPi, sessionArgs } from "../lobby/sessions.ts";
+import { detectProjectRoot } from "../state/project.ts";
+import { HttpError } from "./api/index.ts";
+import { listProjects, type ProjectRegistry } from "./projects.ts";
+import { readableFolder } from "./project-folders.ts";
+import type { ProjectInfo } from "./protocol.ts";
+
+type ProjectProcess = Pick<BackgroundSession, "alive" | "stop" | "whenExited">;
+type LaunchProject = (root: string) => ProjectProcess;
+
+function launchProject(root: string): ProjectProcess {
+  const name = basename(root) || root;
+  const extension = fileURLToPath(new URL("../index.ts", import.meta.url));
+  const args = [...sessionArgs(name, undefined, []), "--no-approve", "--no-extensions", "--extension", extension];
+  const proc = launchPi(args, root, { BOT_LOBBY_WEB_PROJECT: "1" });
+  return new BackgroundSession(proc, { name, projectRoot: root, message: "/bot-lobby on" });
+}
+
+export class ProjectOpener {
+  private readonly pending = new Map<string, Promise<ProjectInfo>>();
+  private readonly children = new Set<ProjectProcess>();
+  private closed = false;
+
+  private readonly registry: ProjectRegistry;
+  private readonly launch: LaunchProject;
+  private readonly timeoutMs: number;
+
+  constructor(registry: ProjectRegistry, launch: LaunchProject = launchProject, timeoutMs = 30_000) {
+    this.registry = registry;
+    this.launch = launch;
+    this.timeoutMs = timeoutMs;
+  }
+
+  async open(path: string, cookie?: string): Promise<ProjectInfo> {
+    const root = await readableFolder(detectProjectRoot(await readableFolder(path)));
+    if (this.closed) throw new HttpError(503, "failed", "The project host is closing.");
+    const pending = this.pending.get(root);
+    if (pending) return pending;
+    const opening = this.start(root, cookie).finally(() => this.pending.delete(root));
+    this.pending.set(root, opening);
+    return opening;
+  }
+
+  private async start(root: string, cookie?: string): Promise<ProjectInfo> {
+    const existing = (await listProjects(this.registry, cookie)).find((project) => project.cwd === root);
+    if (this.closed) throw new HttpError(503, "failed", "The project host is closing.");
+    if (existing) return existing;
+    if (this.children.size >= 8) throw new HttpError(409, "failed", "Eight project sessions are already open. Close a project session before opening another.");
+    const child = this.launch(root);
+    this.children.add(child);
+    void child.whenExited().then(() => this.children.delete(child));
+    try { return await this.waitForProject(root, child, cookie); }
+    catch (error) { child.stop(); throw error; }
+  }
+
+  private async waitForProject(root: string, child: ProjectProcess, cookie?: string): Promise<ProjectInfo> {
+    const deadline = Date.now() + this.timeoutMs;
+    while (!this.closed && child.alive && Date.now() < deadline) {
+      const project = (await listProjects(this.registry, cookie)).find((entry) => entry.cwd === root);
+      if (project && child.alive && !this.closed) return project;
+      await delay(100);
+    }
+    throw new HttpError(503, "failed", "The project did not start. Check that Pi and bot-lobby load successfully, then try again.");
+  }
+
+  close(): void {
+    this.closed = true;
+    for (const child of this.children) child.stop();
+  }
+}

package/src/webui/protocol.ts

@@ -17,6 +17,7 @@ import type { MemberState, PanelNote, PanelQuestion, PlannerMessage } from "../l
 import type { QuickFixJob } from "../lobby/quickfix.ts";
 
 export interface ProjectInfo { id: string; name: string; cwd: string; port: number }
+export interface FolderListing { path: string; parent?: string; folders: Array<{ name: string; path: string }>; truncated: boolean }
 
 export type { WebPrompt };
 export type { LobbyTopic };
@@ -634,6 +635,8 @@ export interface Api {
   "quickfix.runAnyway": { request: { id: string }; result: { notice: string } };
   "quickfix.movedToTask": { request: { id: string }; result: { notice: string; key?: string } };
   "metrics.get": { request: { groupBy: "model" | "model-kind"; query?: string }; result: MetricsData };
+  "projects.browse": { request: { path?: string }; result: FolderListing };
+  "projects.open": { request: { path: string }; result: { project: ProjectInfo } };
   "knowledge.files": { request: Record<string, never>; result: { files: KnowledgeFileInfo[]; models?: Partial<Record<KnowledgeAgentName, string>> } };
   "knowledge.ask": { request: { text: string; attachments?: string[] }; result: { notice: string } };
   "knowledge.open": { request: { agent: KnowledgeAgentName; file: string }; result: { view: KnowledgeViewData } };

package/src/webui/server.ts

@@ -10,6 +10,8 @@ import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { canonicalRoot } from "../state/previews.ts";
 import { ProjectRegistry, registryDirectory, projectInfo, listProjects, browserSession } from "./projects.ts";
 import { gateway } from "./gateway.ts";
+import { browseFolders, folderPath } from "./project-folders.ts";
+import { ProjectOpener } from "./project-open.ts";
 import { lobbyFeed } from "../lobby/feed.ts";
 import type { LobbyService } from "../lobby/host.ts";
 import {
@@ -166,6 +168,7 @@ interface RouteState {
   root: string;
   projectRoot: string;
   registry?: ProjectRegistry;
+  opener?: ProjectOpener;
 }
 
 async function login(req: IncomingMessage, res: ServerResponse, state: RouteState): Promise<void> {
@@ -191,6 +194,15 @@ function openStream(req: IncomingMessage, res: ServerResponse, url: URL, state:
   req.on("close", () => state.hub.remove(res));
 }
 
+async function projectFolderRequest(req: IncomingMessage, res: ServerResponse, url: URL, state: RouteState): Promise<void> {
+  const body = await readJson(req, false);
+  const empty = body && typeof body === "object" && !Array.isArray(body) && Object.keys(body).length === 0;
+  const path = folderPath(url.pathname.endsWith(".browse") && empty ? { path: state.projectRoot } : body);
+  const result = url.pathname.endsWith(".browse") ? await browseFolders(path)
+    : { project: await state.opener!.open(path, browserSession(req.headers.cookie)) };
+  sendJson(res, 200, { ok: true, result });
+}
+
 async function routeApi(req: IncomingMessage, res: ServerResponse, url: URL, state: RouteState): Promise<void> {
   if (req.method !== "POST") {
     sendError(res, "unsupported", "only POST", 405);
@@ -214,6 +226,7 @@ async function routeApi(req: IncomingMessage, res: ServerResponse, url: URL, sta
     sendJson(res, 200, { ok: true, result });
     return;
   }
+  if (url.pathname === "/api/projects.browse" || url.pathname === "/api/projects.open") return projectFolderRequest(req, res, url, state);
   const name = callName(url);
   if (name === undefined) {
     sendError(res, "not_found", `no call ${url.pathname.slice("/api/".length)}`, 404);
@@ -354,6 +367,7 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
   state.port = bound;
   try { state.registry = new ProjectRegistry(options.registryDir ?? registryDirectory(), state.projectRoot, bound); }
   catch (error) { hub.close(); server.close(); throw error; }
+  state.opener = new ProjectOpener(state.registry);
   hookExit();
   const api: WebServer = {
     link: `http://127.0.0.1:${bound}/#token=${link}`,
@@ -374,6 +388,7 @@ export async function startWebServer(options: WebServerOptions): Promise<WebServ
       return `http://127.0.0.1:${state.port}/#token=${state.link}`;
     },
     close: async () => {
+      state.opener!.close();
       state.registry!.close();
       hub.close();
       await new Promise<void>((resolve) => {