@gavin-hu/my-pi-agent 0.19.0 → 0.21.0

package/extensions/file-browse/files/list.ts

@@ -0,0 +1,261 @@
+/**
+ * Directory listings and single-file reads: what a folder holds, capped and sorted, and
+ * what one file's bytes are.
+ *
+ * The filesystem reads are injected (`DirectoryFs`) so a test can count them: the property
+ * worth holding is that a directory is read once per entry, not once per row drawn.
+ */
+
+import { join } from "node:path";
+import { lstat, readdir, readFile, stat } from "node:fs/promises";
+import type { Stats } from "node:fs";
+import { mapConcurrent } from "../../../lib/pool.ts";
+import { HttpError } from "./paths.ts";
+import {
+	classifyByName,
+	contentTypeFor,
+	type EntryKind,
+	isImageName,
+	isMarkdownName,
+	isProbablyText,
+} from "./classify.ts";
+
+export interface DirEntry {
+	name: string;
+	/** Root-relative posix path. */
+	rel: string;
+	isDir: boolean;
+	isSymlink: boolean;
+	broken: boolean;
+	size: number;
+	mtimeMs: number;
+	kind: EntryKind;
+	isImage: boolean;
+}
+
+export interface Listing {
+	entries: DirEntry[];
+	total: number;
+	truncated: boolean;
+}
+
+export interface FileMeta {
+	size: number;
+	mtimeMs: number;
+	mime: string;
+}
+
+export type FileView =
+	| (FileMeta & { kind: "text"; lines: string[]; truncated: boolean; totalLines: number })
+	| (FileMeta & { kind: "markdown"; lines: string[]; truncated: boolean; totalLines: number })
+	| (FileMeta & { kind: "image" })
+	| (FileMeta & { kind: "binary" })
+	| (FileMeta & { kind: "tooLarge" });
+
+/** Whether the name has an image extension. */
+export function toAbs(root: string, rel: string): string {
+	return rel ? join(root, ...rel.split("/")) : root;
+}
+
+/** The `Dirent` fields a listing reads; a test's fake need not be a real `Dirent`. */
+export interface DirectoryEntryInfo {
+	name: string;
+	isDirectory(): boolean;
+	isSymbolicLink(): boolean;
+}
+
+/** The `Stats` fields a listing reads. */
+export interface DirectoryStats {
+	size: number;
+	mtimeMs: number;
+	isDirectory(): boolean;
+}
+
+/**
+ * The three filesystem reads a listing makes.
+ *
+ * Injected so a test can observe them: the interesting property — a directory is
+ * read once per entry, not once per entry *and* once per row drawn — is a count,
+ * not a value, and a wall-clock assertion would be flaky on a loaded machine.
+ */
+export interface DirectoryFs {
+	readdir(path: string): Promise<DirectoryEntryInfo[]>;
+	lstat(path: string): Promise<DirectoryStats>;
+	stat(path: string): Promise<DirectoryStats>;
+}
+
+/** Production reads; a symlink's size and kind come from the target. */
+const NODE_DIRECTORY_FS: DirectoryFs = {
+	readdir: (path) => readdir(path, { withFileTypes: true }),
+	lstat: (path) => lstat(path),
+	stat: (path) => stat(path),
+};
+
+/** Reads in flight per listing: enough to hide latency, bounded against a burst. */
+const LISTING_CONCURRENCY = 32;
+
+/** A row while it is still missing its metadata. */
+interface Row {
+	name: string;
+	rel: string;
+	isDir: boolean;
+	isSymlink: boolean;
+	broken: boolean;
+	size: number;
+	mtimeMs: number;
+}
+
+/**
+ * Resolve one symlink: the link's own stat, then the target's.
+ *
+ * A symlink's directory-ness is the target's, so this cannot wait until after
+ * the sort; it is also the only entry whose classification needs a read.
+ */
+async function resolveSymlink(fs: DirectoryFs, absDir: string, row: Row): Promise<void> {
+	const abs = join(absDir, row.name);
+	try {
+		const info = await fs.lstat(abs);
+		row.size = info.size;
+		row.mtimeMs = info.mtimeMs;
+	} catch {
+		// Vanished between readdir and lstat: the target read decides below.
+	}
+	try {
+		const target = await fs.stat(abs);
+		row.isDir = target.isDirectory();
+		row.size = target.size;
+		row.mtimeMs = target.mtimeMs;
+	} catch {
+		row.broken = true;
+	}
+}
+
+/**
+ * List a directory, sorted (directories first, then case-insensitive name).
+ *
+ * A listing is latency per entry, not work per entry, so it is read in three
+ * passes instead of one entry at a time:
+ *
+ * 1. `readdir`, whose dirents already say whether each name is a directory;
+ * 2. the symlinks only, resolved through the pool, because their kind is the
+ *    target's and the sort needs it;
+ * 3. the kept rows only, `stat`ed through the pool — so a directory of three
+ *    thousand names pays for the two thousand it draws, not for every name, and
+ *    pays them concurrently instead of in turn.
+ *
+ * `total` is still the directory's full entry count and `truncated` its `> limit`
+ * flip, so the page can say how many were dropped. Ties keep `readdir` order:
+ * `sort` is stable and the rows arrive unsorted.
+ */
+export async function listDirectory(
+	root: string,
+	relDir: string,
+	limit: number,
+	fs: DirectoryFs = NODE_DIRECTORY_FS,
+): Promise<Listing> {
+	const absDir = toAbs(root, relDir);
+	let dirents: DirectoryEntryInfo[];
+	try {
+		dirents = await fs.readdir(absDir);
+	} catch {
+		throw new HttpError(404, "That folder could not be read.");
+	}
+
+	const links: Row[] = [];
+	const rows: Row[] = dirents.map((dirent) => {
+		const row: Row = {
+			name: dirent.name,
+			rel: relDir ? `${relDir}/${dirent.name}` : dirent.name,
+			isDir: dirent.isDirectory(),
+			isSymlink: dirent.isSymbolicLink(),
+			broken: false,
+			size: 0,
+			mtimeMs: 0,
+		};
+		if (row.isSymlink) links.push(row);
+		return row;
+	});
+
+	await mapConcurrent(links, LISTING_CONCURRENCY, (row) => resolveSymlink(fs, absDir, row));
+
+	// Directories first, then case-insensitive name. The sort runs before the cap,
+	// so the rows that survive it are the rows that would have been drawn.
+	rows.sort((a, b) => {
+		if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+		return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
+	});
+
+	const total = rows.length;
+	const truncated = total > limit;
+	const kept = truncated ? rows.slice(0, limit) : rows;
+
+	await mapConcurrent(
+		kept.filter((row) => !row.isSymlink),
+		LISTING_CONCURRENCY,
+		async (row) => {
+			try {
+				const info = await fs.stat(join(absDir, row.name));
+				row.size = info.size;
+				row.mtimeMs = info.mtimeMs;
+			} catch {
+				// Directory entry vanished between readdir and stat.
+			}
+		},
+	);
+
+	const entries: DirEntry[] = kept.map((row) => {
+		const kind: EntryKind = row.isDir ? "directory" : classifyByName(row.name);
+		return {
+			name: row.name,
+			rel: row.rel,
+			isDir: row.isDir,
+			isSymlink: row.isSymlink,
+			broken: row.broken,
+			size: row.size,
+			mtimeMs: row.mtimeMs,
+			kind,
+			isImage: !row.isDir && kind === "image",
+		};
+	});
+
+	return { entries, total, truncated };
+}
+
+/** Read a file into a renderable view, honouring the size and line caps. */
+export async function readFileView(
+	root: string,
+	rel: string,
+	maxFileBytes: number,
+	maxTextLines: number,
+	markdownEnabled = true,
+): Promise<FileView> {
+	const abs = toAbs(root, rel);
+	let info: Stats;
+	try {
+		info = await stat(abs);
+	} catch {
+		throw new HttpError(404, "That file could not be read.");
+	}
+	if (info.isDirectory()) throw new HttpError(404, "That path is a folder.");
+
+	const meta: FileMeta = { size: info.size, mtimeMs: info.mtimeMs, mime: contentTypeFor(rel) };
+	if (isImageName(rel)) return { kind: "image", ...meta };
+	if (info.size > maxFileBytes) return { kind: "tooLarge", ...meta };
+
+	let buffer: Buffer;
+	try {
+		buffer = await readFile(abs);
+	} catch {
+		throw new HttpError(404, "That file could not be read.");
+	}
+	if (!isProbablyText(buffer)) return { kind: "binary", ...meta };
+
+	const allLines = buffer.toString("utf-8").split(/\r\n|\r|\n/);
+	const truncated = allLines.length > maxTextLines;
+	const lines = truncated ? allLines.slice(0, maxTextLines) : allLines;
+	const kind = markdownEnabled && isMarkdownName(rel) ? "markdown" : "text";
+	if (kind === "markdown") {
+		return { kind: "markdown", ...meta, lines, truncated, totalLines: allLines.length };
+	}
+	return { kind: "text", ...meta, lines, truncated, totalLines: allLines.length };
+}

package/extensions/file-browse/files/tree.ts

@@ -0,0 +1,101 @@
+/**
+ * The sidebar tree: the current path's ancestors expanded, siblings collapsed.
+ *
+ * Its rows are the same `DirEntry` a listing produces, so the tree and the listing cannot
+ * disagree about what one name is.
+ */
+
+import { basename } from "node:path";
+import type { EntryKind } from "./classify.ts";
+import { type Listing, listDirectory } from "./list.ts";
+
+export interface TreeNode {
+	name: string;
+	rel: string;
+	isDir: boolean;
+	isImage: boolean;
+	/** True for a symlink whose target cannot be resolved. */
+	broken: boolean;
+	kind: EntryKind;
+	children: TreeNode[];
+}
+
+/**
+ * Build the sidebar tree: the current path's ancestors are expanded so the
+ * active item is always visible, and siblings are shown collapsed.
+ */
+export async function buildTree(root: string, currentRel: string, limit: number): Promise<TreeNode> {
+	return buildNode(root, "", currentRel, basename(root) || root, limit);
+}
+
+/** A directory page's two views of one directory. */
+export interface DirectoryView {
+	/** The current directory's own rows, for the page's listing. */
+	listing: Listing;
+	/** The sidebar tree, with the current path expanded. */
+	tree: TreeNode;
+}
+
+/**
+ * One walk for a directory page: the listing it draws, and the tree that shows
+ * where it sits.
+ *
+ * `listDirectory` is what decides whether the directory can be read at all, so it
+ * runs first and its 404 is the page's error. The walk then reuses that listing
+ * for the same directory instead of reading it a second time; the ancestors are
+ * still read once each, which is what the tree needs.
+ */
+export async function directoryView(root: string, currentRel: string, limit: number): Promise<DirectoryView> {
+	const listing = await listDirectory(root, currentRel, limit);
+	const tree = await buildNode(root, "", currentRel, basename(root) || root, limit, { rel: currentRel, listing });
+	return { listing, tree };
+}
+
+async function buildNode(
+	root: string,
+	relDir: string,
+	currentRel: string,
+	label: string,
+	limit: number,
+	/** A listing the caller already read for this directory, so it is not re-read. */
+	known?: { rel: string; listing: Listing },
+): Promise<TreeNode> {
+	const node: TreeNode = {
+		name: label,
+		rel: relDir,
+		isDir: true,
+		isImage: false,
+		broken: false,
+		kind: "directory",
+		children: [],
+	};
+	let listing: Listing;
+	if (known && known.rel === relDir) {
+		listing = known.listing;
+	} else {
+		try {
+			listing = await listDirectory(root, relDir, limit);
+		} catch {
+			return node;
+		}
+	}
+	for (const entry of listing.entries) {
+		const child: TreeNode = {
+			name: entry.name,
+			rel: entry.rel,
+			isDir: entry.isDir,
+			isImage: entry.isImage,
+			broken: entry.broken,
+			kind: entry.kind,
+			children: [],
+		};
+		if (entry.isDir) {
+			const onPath = currentRel === entry.rel || currentRel.startsWith(`${entry.rel}/`);
+			if (onPath) {
+				child.children = (await buildNode(root, entry.rel, currentRel, entry.name, limit, known)).children;
+			}
+		}
+		node.children.push(child);
+	}
+	return node;
+}

package/extensions/file-browse/index.ts

@@ -14,9 +14,8 @@ import { realpathSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled, resolveEffectiveCwd } from "../../lib/env.ts";
-import { GLYPHS, STATUS_KEYS } from "../../lib/tui/glyphs.ts";
-import { paint } from "../../lib/tui/tokens.ts";
-import { loadConfig, randomPort } from "./config/config.ts";
+import { requestMount } from "../../lib/http/index.ts";
+import { loadConfig } from "./config/config.ts";
 import { createGitDiff, createGitStatus } from "./git/git.ts";
 import { openInBrowser } from "../../lib/browser.ts";
 import { HttpError, resolveRequestPath } from "./files/paths.ts";
@@ -27,8 +26,6 @@ export interface FileBrowserDeps {
 	createServer?: typeof createFileServer;
 	/** Override the browser opener (tests). */
 	open?: typeof openInBrowser;
-	/** Override session-port selection (tests). */
-	pickPort?: () => number;
 }
 
 interface RunningServer {
@@ -40,40 +37,25 @@ interface RunningServer {
 export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}): void {
 	if (!isExtensionEnabled("file-browse")) return;
 	let running: RunningServer | undefined;
-	/** Random port fixed for the session after the first successful start. */
-	let sessionPort: number | undefined;
+	/** The session this page serves as; the mount lands on its one server. */
+	let sessionId = "";
 
-	/** Publish the browse chip, or clear it with `undefined`; best-effort UI. */
-	const setBrowseStatus = (ctx: ExtensionContext, port: number | undefined): void => {
-		try {
-			const value =
-				port === undefined
-					? undefined
-					: `${paint(ctx.ui.theme, "ok", GLYPHS.browse)} ${paint(ctx.ui.theme, "accent", String(port))}`;
-			ctx.ui.setStatus(STATUS_KEYS.browse, value);
-		} catch {
-			// A UI without a theme or setStatus must not break the command.
-		}
-	};
-
-	const stop = async (ctx?: ExtensionContext): Promise<boolean> => {
+	const stop = async (): Promise<boolean> => {
 		const current = running;
 		if (!current) return false;
 		running = undefined;
 		await current.server.close();
-		if (ctx) setBrowseStatus(ctx, undefined);
 		return true;
 	};
 
 	/**
-	 * Close the server once the page that was its only reader has gone: nothing is
-	 * left to serve, and the chip would otherwise advertise a port that answers no
-	 * one. `/browse` starts it again on the same session port.
+	 * Give the prefix back once the page that was its only reader has gone: nothing is
+	 * left to serve. `/browse` starts it again on the session's port.
 	 */
 	const stopWhenPageLeft = async (): Promise<void> => {
 		const current = running;
 		if (!current) return;
-		if (await stop(current.ctx)) current.ctx.ui.notify("browse: stopped — the last page was closed", "info");
+		if (await stop()) current.ctx.ui.notify("browse: stopped — the last page was closed", "info");
 	};
 
 	const start = async (args: string, ctx: ExtensionContext): Promise<void> => {
@@ -86,15 +68,12 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 			return;
 		}
 		if (target === "stop") {
-			ctx.ui.notify((await stop(ctx)) ? "browse: stopped" : "browse: not running", "info");
+			ctx.ui.notify((await stop()) ? "browse: stopped" : "browse: not running", "info");
 			return;
 		}
 
 		const cwd = resolveEffectiveCwd(ctx.cwd);
 		const config = loadConfig(cwd);
-		// A pinned config port wins; otherwise one random port is fixed for the session.
-		const unpinned = config.port <= 0;
-		const port = unpinned ? (sessionPort ?? (deps.pickPort ?? randomPort)()) : config.port;
 		let root = cwd;
 		if (target) {
 			try {
@@ -117,17 +96,19 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 		} catch {
 			// Keep the unresolved root; the server factory reports a real failure.
 		}
-		if (running && running.server.root === realRoot && running.server.port === port) {
+		if (running && running.server.root === realRoot) {
 			ctx.ui.notify(`browse: ${running.server.url} (already running)`, "info");
 			return;
 		}
 
-		await stop(ctx);
+		await stop();
 		const create = deps.createServer ?? createFileServer;
 		try {
-			const server = await create({
+			const outcome = await create({
 				root,
-				config: { ...config, port },
+				config,
+				mount: (spec) => requestMount(pi, spec),
+				session: sessionId,
 				git: createGitStatus(pi, root),
 				diff: createGitDiff(pi, root, {
 					context: config.diffContext,
@@ -137,21 +118,16 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 				}),
 				onIdle: () => void stopWhenPageLeft(),
 			});
-			if (unpinned) sessionPort = port;
+			if (outcome.kind === "refused") {
+				ctx.ui.notify(`browse: ${outcome.reason}`, "error");
+				return;
+			}
+			const server = outcome.server;
 			running = { server, ctx };
-			setBrowseStatus(ctx, server.port);
 			ctx.ui.notify(`browse: ${server.root} at ${server.url}`, "info");
 			if (config.autoOpen) (deps.open ?? openInBrowser)(server.url);
 		} catch (error) {
-			const code = (error as NodeJS.ErrnoException | undefined)?.code;
-			if (code === "EADDRINUSE") {
-				ctx.ui.notify(
-					`browse: port ${port} is in use; run /browse again to try another or set "port" in the bytefly.json file-browse section`,
-					"error",
-				);
-			} else {
-				ctx.ui.notify(`browse: ${error instanceof Error ? error.message : String(error)}`, "error");
-			}
+			ctx.ui.notify(`browse: ${error instanceof Error ? error.message : String(error)}`, "error");
 		}
 	};
 
@@ -168,8 +144,11 @@ export default function fileBrowser(pi: ExtensionAPI, deps: FileBrowserDeps = {}
 		},
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
-		await stop(ctx);
-		sessionPort = undefined;
+	pi.on("session_start", async (_event, ctx) => {
+		sessionId = ctx.sessionManager.getSessionId();
+	});
+
+	pi.on("session_shutdown", async () => {
+		await stop();
 	});
 }

package/extensions/file-browse/live/live.ts

@@ -174,7 +174,7 @@ export interface LiveChannel {
  * attached, so an idle server does no status work at all; the last page leaving
  * parks it and the next page starts it again. What happens to a server nobody is
  * reading — the idle grace and the close it leads to — is the server's policy, so
- * the caller hands it to `lib/http`'s `serveLoopback` instead of configuring it
+ * the caller hands it to its own mount instead of configuring it
  * here.
  */
 export function createLiveChannel(options: LiveChannelOptions): LiveChannel {

package/extensions/file-browse/transport/router.ts

@@ -15,7 +15,6 @@ import {
 	isLocalHostHeader,
 	jsonError,
 	jsonResponse,
-	pageHeaders,
 	parseRequestUrl,
 	scriptHeaders,
 	type ServeResponse,
@@ -47,13 +46,16 @@ import {
 	renderErrorPage,
 	renderFileDiffPage,
 	renderFilePage,
+	hrefFor,
 } from "../view/html.ts";
 import type { ChangeSummary } from "../view/html.ts";
-import { encodePath, HttpError, relativePath, resolveDecodedPath, resolveRequestPath } from "../files/paths.ts";
+import { HttpError, relativePath, resolveDecodedPath, resolveRequestPath } from "../files/paths.ts";
 import { listingRevision } from "../live/rev.ts";
 
 export interface ServeContext {
 	root: string;
+	/** The prefix this page answers under, e.g. `/files`; `""` for the origin's root. */
+	base: string;
 	config: ServeConfig;
 	/** Read-only git context for the page header; omitted when unavailable. */
 	git?: GitStatusProvider;
@@ -153,6 +155,7 @@ async function errorPage(
 		// Keep the minimal tree.
 	}
 	const body = renderErrorPage({
+		base: ctx.base,
 		rootLabel: ctx.root,
 		status,
 		message,
@@ -188,6 +191,7 @@ async function directoryResponse(ctx: ServeContext, rel: string): Promise<ServeR
 	return htmlResponse(
 		200,
 		renderDirectoryPage({
+			base: ctx.base,
 			rootLabel: ctx.root,
 			rel,
 			listing,
@@ -212,6 +216,7 @@ async function fileResponse(ctx: ServeContext, rel: string, raw: boolean): Promi
 	return htmlResponse(
 		200,
 		renderFilePage({
+			base: ctx.base,
 			rootLabel: ctx.root,
 			rel,
 			file,
@@ -236,6 +241,7 @@ async function diffOverview(ctx: ServeContext, mode: DiffMode): Promise<ServeRes
 	return htmlResponse(
 		200,
 		renderDiffPage({
+			base: ctx.base,
 			rootLabel: ctx.root,
 			mode,
 			files: list?.files ?? [],
@@ -268,6 +274,7 @@ async function diffFile(ctx: ServeContext, rawRel: string, mode: DiffMode): Prom
 	return htmlResponse(
 		200,
 		renderFileDiffPage({
+			base: ctx.base,
 			rootLabel: ctx.root,
 			rel,
 			mode,
@@ -304,12 +311,12 @@ async function raw(ctx: ServeContext, rawRel: string): Promise<ServeResponse> {
 	};
 }
 
-function treeApiEntry(entry: DirEntry): Record<string, unknown> {
+function treeApiEntry(entry: DirEntry, base: string): Record<string, unknown> {
 	const spec = entry.isDir ? FOLDER_ICON : languageOf(entry.name);
 	return {
 		name: entry.name,
 		path: entry.rel,
-		href: entry.isDir ? `/browse/${encodePath(entry.rel)}` : `/view/${encodePath(entry.rel)}`,
+		href: hrefFor(entry, base),
 		isDir: entry.isDir,
 		broken: entry.broken,
 		iconHref: iconHref(spec.icon),
@@ -324,7 +331,7 @@ async function treeApi(ctx: ServeContext, decodedPath: string): Promise<ServeRes
 	const info = await stat(abs).catch(() => undefined);
 	if (info && !info.isDirectory()) throw new HttpError(400, "That path is not a folder.");
 	const listing = await listDirectory(ctx.root, rel, ctx.config.maxDirEntries);
-	return jsonResponse(200, { path: rel, entries: listing.entries.map(treeApiEntry) });
+	return jsonResponse(200, { path: rel, entries: listing.entries.map((entry) => treeApiEntry(entry, ctx.base)) });
 }
 
 /** The revision of one folder's listing: what a page's reload control compares against. */
@@ -379,7 +386,6 @@ export async function handleRequest(
 	try {
 		if (pathname === "/app.js") return { status: 200, headers: scriptHeaders(), body: CLIENT_JS };
 		if (pathname === THEME_JS_PATH) return { status: 200, headers: scriptHeaders(), body: THEME_JS };
-		if (pathname === "/favicon.ico") return { status: 204, headers: pageHeaders(), body: "" };
 		if (pathname === "/api/tree") return await treeApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/dir-rev") return await dirRevApi(ctx, search.get("path") ?? "");
 		if (pathname === "/api/files") return await filesApi(ctx, search.get("q") ?? "");