@henryqw/pi-session-recall 2.0.0 → 2.1.1

package/extensions/repository-inventory.ts

@@ -0,0 +1,515 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const MAX_MANIFEST_BYTES = 1024 * 1024;
+export const MAX_PACKAGE_MANIFESTS = 512;
+export const MAX_TOTAL_MANIFEST_BYTES = 16 * 1024 * 1024;
+export const REPOSITORY_UNAVAILABLE_REASON = "not-a-git-repository";
+export const REPOSITORY_INVENTORY_FAILED_REASON = "inventory-failed";
+
+const ROOT_STDOUT_BYTES = 4 * 1024;
+const INDEX_STDOUT_BYTES = 8 * 1024 * 1024;
+const GIT_STDERR_BYTES = 4 * 1024;
+const BATCH_RECORD_BYTES = 128;
+const BATCH_CHECK_STDOUT_BYTES = BATCH_RECORD_BYTES * MAX_PACKAGE_MANIFESTS;
+const CONTENT_BATCH_STDOUT_BYTES = MAX_TOTAL_MANIFEST_BYTES + BATCH_RECORD_BYTES * MAX_PACKAGE_MANIFESTS;
+const BATCH_STDIN_BYTES = (64 + 1) * MAX_PACKAGE_MANIFESTS;
+const INSTRUCTION_NAMES = new Set(["AGENTS.md", "AGENTS.override.md", "CLAUDE.md"]);
+const REGULAR_MODES = new Set(["100644", "100755"]);
+const INDEX_MODES = new Set(["100644", "100755", "120000", "160000"]);
+const PROVENANCE = {
+	packageScripts: "git-index",
+	executableScripts: "git-index",
+	agentInstructions: "git-index",
+	skills: "pi-effective-registry",
+} as const;
+
+export type RepositoryInventoryMode = "required" | "optional";
+
+export interface PackageScript {
+	path: string;
+	name: string;
+	command: string;
+}
+
+export interface RepositorySkill {
+	name: string;
+	description: string;
+	sourcePath: string;
+}
+
+interface RepositoryInventoryCollections {
+	packageScripts: PackageScript[];
+	executableScripts: string[];
+	skills: RepositorySkill[];
+	agentInstructions: string[];
+	worktreeVerified: false;
+}
+
+export type RepositoryInventory = RepositoryInventoryCollections & ({
+	available: true;
+	gitRoot: string;
+	provenance: typeof PROVENANCE;
+	reason?: never;
+} | {
+	available: false;
+	reason: typeof REPOSITORY_UNAVAILABLE_REASON | typeof REPOSITORY_INVENTORY_FAILED_REASON;
+	gitRoot?: never;
+	provenance?: never;
+});
+
+type InventoryPi = Pick<ExtensionAPI, "getCommands">;
+type InventoryContext = Pick<ExtensionContext, "cwd" | "signal">;
+
+interface GitResult {
+	stdout: Buffer;
+	code: number;
+}
+
+interface IndexEntry {
+	mode: string;
+	oid: string;
+	path: string;
+}
+
+function compare(left: string, right: string): number {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function toPosixPath(value: string): string {
+	return value.split(path.sep).join("/");
+}
+
+function isWithin(root: string, target: string, allowRoot = true): boolean {
+	const relative = path.relative(root, target);
+	return (allowRoot && relative === "") ||
+		(relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+function boundedPath(value: string): string {
+	const bounded = value.length <= 240 ? value : `${value.slice(0, 239)}…`;
+	return JSON.stringify(bounded);
+}
+
+function malformedManifest(relativePath: string): Error {
+	return new Error(`Malformed repository manifest: ${boundedPath(relativePath)}`);
+}
+
+function unsupportedManifestMode(relativePath: string): Error {
+	return new Error(`Unsupported repository manifest mode: ${boundedPath(relativePath)}`);
+}
+
+function oversizedManifest(relativePath: string): Error {
+	return new Error(`Oversized repository manifest (1 MiB limit): ${boundedPath(relativePath)}`);
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) throw new Error("Repository inventory cancelled.");
+}
+
+/** Spawn one bounded process and never expose child output through failures. */
+function runGit(
+	cwd: string,
+	args: string[],
+	signal: AbortSignal | undefined,
+	stdoutCap: number,
+	options: { allowNonzero?: boolean; allowStderrOnNonzero?: boolean; stdin?: Buffer } = {},
+): Promise<GitResult> {
+	throwIfAborted(signal);
+	if (options.stdin !== undefined && options.stdin.length > BATCH_STDIN_BYTES) {
+		throw new Error("Repository inventory Git stdin exceeded its limit.");
+	}
+	return new Promise((resolve, reject) => {
+		let child: ReturnType<typeof spawn>;
+		try {
+			child = spawn("git", args, {
+				cwd,
+				env: { ...process.env, GIT_NO_LAZY_FETCH: "1" },
+				shell: false,
+				stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+			});
+		} catch {
+			reject(new Error("Repository inventory could not start Git."));
+			return;
+		}
+
+		const childStdout = child.stdout;
+		const childStderr = child.stderr;
+		const childStdin = child.stdin;
+		if (!childStdout || !childStderr || (options.stdin !== undefined && !childStdin)) {
+			child.kill("SIGKILL");
+			reject(new Error("Repository inventory could not start Git."));
+			return;
+		}
+		const stdout: Buffer[] = [];
+		let stdoutBytes = 0;
+		let stderrBytes = 0;
+		let failure: Error | undefined;
+		let settled = false;
+
+		const fail = (error: Error) => {
+			if (failure) return;
+			failure = error;
+			child.kill("SIGKILL");
+		};
+		const finish = (error?: Error, result?: GitResult) => {
+			if (settled) return;
+			settled = true;
+			signal?.removeEventListener("abort", onAbort);
+			if (error) reject(error);
+			else resolve(result!);
+		};
+		const onAbort = () => fail(new Error("Repository inventory cancelled."));
+
+		childStdout.on("data", (chunk: Buffer) => {
+			stdoutBytes += chunk.length;
+			if (stdoutBytes > stdoutCap) {
+				fail(new Error("Repository inventory Git stdout exceeded its limit."));
+				return;
+			}
+			stdout.push(chunk);
+		});
+		childStderr.on("data", (chunk: Buffer) => {
+			stderrBytes += chunk.length;
+			if (stderrBytes > GIT_STDERR_BYTES) {
+				fail(new Error("Repository inventory Git stderr exceeded its limit."));
+			} else if (!options.allowStderrOnNonzero) {
+				fail(new Error("Repository inventory Git wrote unexpected stderr."));
+			}
+		});
+		childStdin?.once("error", () => fail(new Error("Repository inventory could not write Git input.")));
+		child.once("error", () => finish(new Error("Repository inventory could not start Git.")));
+		child.once("close", (code) => {
+			if (failure) {
+				finish(failure);
+				return;
+			}
+			if (signal?.aborted) {
+				finish(new Error("Repository inventory cancelled."));
+				return;
+			}
+			if (code === null || (code !== 0 && !options.allowNonzero)) {
+				finish(new Error("Repository inventory Git command failed."));
+				return;
+			}
+			if (stderrBytes > 0 && !(code !== 0 && options.allowStderrOnNonzero)) {
+				finish(new Error("Repository inventory Git wrote unexpected stderr."));
+				return;
+			}
+			finish(undefined, { stdout: Buffer.concat(stdout, stdoutBytes), code });
+		});
+		signal?.addEventListener("abort", onAbort, { once: true });
+		if (signal?.aborted) onAbort();
+		if (options.stdin !== undefined && !failure) {
+			try {
+				childStdin!.end(options.stdin);
+			} catch {
+				fail(new Error("Repository inventory could not write Git input."));
+			}
+		}
+	});
+}
+
+function decodeUtf8(value: Buffer, error: () => Error): string {
+	let decoded: string;
+	try {
+		decoded = new TextDecoder("utf-8", { fatal: true }).decode(value);
+	} catch {
+		throw error();
+	}
+	if (decoded.includes("�")) throw error();
+	return decoded;
+}
+
+function decodeAscii(value: Buffer, error: () => Error): string {
+	if (value.some((byte) => byte > 0x7f)) throw error();
+	return value.toString("ascii");
+}
+
+function canonicalDirectory(value: string): string {
+	try {
+		const canonical = fs.realpathSync(value);
+		if (!fs.statSync(canonical).isDirectory()) throw new Error("not a directory");
+		return canonical;
+	} catch {
+		throw new Error("Repository inventory could not resolve the Git root.");
+	}
+}
+
+function gitRootFromOutput(stdout: Buffer): string {
+	const invalid = () => new Error("Repository inventory could not resolve the Git root.");
+	const decoded = decodeUtf8(stdout, invalid);
+	const root = decoded.endsWith("\r\n") ? decoded.slice(0, -2) : decoded.endsWith("\n") ? decoded.slice(0, -1) : decoded;
+	if (!root || root.includes("\r") || root.includes("\n") || (!path.isAbsolute(root) && !path.win32.isAbsolute(root))) {
+		throw invalid();
+	}
+	return canonicalDirectory(root);
+}
+
+async function resolveGitRoot(ctx: InventoryContext): Promise<string | undefined> {
+	const cwd = canonicalDirectory(ctx.cwd);
+	const result = await runGit(cwd, ["rev-parse", "--show-toplevel"], ctx.signal, ROOT_STDOUT_BYTES, {
+		allowNonzero: true,
+		allowStderrOnNonzero: true,
+	});
+	return result.code === 0 ? gitRootFromOutput(result.stdout) : undefined;
+}
+
+function looksLikePackageJson(value: string): boolean {
+	return value === "package.json" || value.endsWith("/package.json");
+}
+
+function normalizeRepositoryPath(value: string): string {
+	const segments = value.split("/");
+	if (
+		!value ||
+		value.includes("�") ||
+		value.includes("\\") ||
+		path.isAbsolute(value) ||
+		path.win32.isAbsolute(value) ||
+		segments.some((segment) => !segment || segment === "." || segment === "..")
+	) {
+		throw new Error("Repository inventory received an invalid repository path.");
+	}
+	return value;
+}
+
+function parseIndex(stdout: Buffer): IndexEntry[] {
+	if (stdout.length === 0) return [];
+	if (stdout.at(-1) !== 0) throw new Error("Repository inventory received an invalid Git index listing.");
+	const entries: IndexEntry[] = [];
+	const paths = new Set<string>();
+	let start = 0;
+	while (start < stdout.length) {
+		const end = stdout.indexOf(0, start);
+		if (end < 0) throw new Error("Repository inventory received an invalid Git index listing.");
+		const record = stdout.subarray(start, end);
+		start = end + 1;
+		const tab = record.indexOf(0x09);
+		if (tab < 0) throw new Error("Repository inventory received an invalid Git index listing.");
+		const invalid = () => new Error("Repository inventory received an invalid Git index listing.");
+		const metadata = decodeAscii(record.subarray(0, tab), invalid);
+		const match = /^([0-7]{6}) ([0-9a-fA-F]{40}|[0-9a-fA-F]{64}) ([0-3])$/.exec(metadata);
+		if (!match) throw invalid();
+		const relativePath = normalizeRepositoryPath(decodeUtf8(record.subarray(tab + 1), invalid));
+		const [, mode, oid, stage] = match;
+		if (stage !== "0") throw new Error("Repository inventory does not accept conflicted Git index entries.");
+		if (paths.has(relativePath)) throw new Error("Repository inventory received duplicate Git index entries.");
+		paths.add(relativePath);
+		if (looksLikePackageJson(relativePath) && !REGULAR_MODES.has(mode)) throw unsupportedManifestMode(relativePath);
+		if (!INDEX_MODES.has(mode)) throw invalid();
+		entries.push({ mode, oid, path: relativePath });
+	}
+	return entries.sort((left, right) => compare(left.path, right.path));
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function scriptsFromManifest(source: string, relativePath: string): PackageScript[] {
+	let manifest: unknown;
+	try {
+		manifest = JSON.parse(source);
+	} catch {
+		throw malformedManifest(relativePath);
+	}
+	if (!isRecord(manifest)) throw malformedManifest(relativePath);
+	const scripts = manifest.scripts;
+	if (scripts === undefined) return [];
+	if (!isRecord(scripts)) throw malformedManifest(relativePath);
+	const result: PackageScript[] = [];
+	for (const [name, command] of Object.entries(scripts)) {
+		if (typeof command !== "string") throw malformedManifest(relativePath);
+		result.push({ path: relativePath, name, command });
+	}
+	return result.sort((left, right) => compare(left.name, right.name));
+}
+
+interface SizedIndexEntry extends IndexEntry {
+	size: number;
+}
+
+function invalidBatchOutput(): Error {
+	return new Error("Repository inventory received invalid Git batch output.");
+}
+
+function missingIndexedObject(relativePath: string): Error {
+	return new Error(`Repository inventory is missing an indexed Git object: ${boundedPath(relativePath)}`);
+}
+
+function decimalSize(value: string): number {
+	if (!/^(0|[1-9][0-9]*)$/.test(value)) throw invalidBatchOutput();
+	const size = BigInt(value);
+	if (size > BigInt(Number.MAX_SAFE_INTEGER)) throw invalidBatchOutput();
+	return Number(size);
+}
+
+function parseBatchCheck(stdout: Buffer, packages: IndexEntry[]): SizedIndexEntry[] {
+	if (stdout.at(-1) !== 0x0a) throw invalidBatchOutput();
+	const records = decodeAscii(stdout, invalidBatchOutput).slice(0, -1).split("\n");
+	if (records.length !== packages.length) throw invalidBatchOutput();
+
+	const sized: SizedIndexEntry[] = [];
+	let totalBytes = 0;
+	for (let index = 0; index < packages.length; index++) {
+		const entry = packages[index]!;
+		const record = records[index]!;
+		if (record === `${entry.oid} missing`) throw missingIndexedObject(entry.path);
+		const match = /^([0-9a-fA-F]{40}|[0-9a-fA-F]{64}) ([a-z]+) (0|[1-9][0-9]*)$/.exec(record);
+		if (!match) throw invalidBatchOutput();
+		const [, oid, type, rawSize] = match;
+		if (oid !== entry.oid) throw new Error("Repository inventory received Git objects out of order.");
+		if (type !== "blob") throw new Error("Repository inventory expected an indexed Git blob.");
+		const size = decimalSize(rawSize);
+		if (size > MAX_MANIFEST_BYTES) throw oversizedManifest(entry.path);
+		if (totalBytes > MAX_TOTAL_MANIFEST_BYTES - size) {
+			throw new Error("Repository inventory exceeds the 16 MiB total manifest limit.");
+		}
+		totalBytes += size;
+		sized.push({ ...entry, size });
+	}
+	return sized;
+}
+
+function parseContentBatch(stdout: Buffer, packages: SizedIndexEntry[]): PackageScript[] {
+	const scripts: PackageScript[] = [];
+	let offset = 0;
+	for (const entry of packages) {
+		const headerEnd = stdout.indexOf(0x0a, offset);
+		if (headerEnd < 0) throw invalidBatchOutput();
+		const header = decodeAscii(stdout.subarray(offset, headerEnd), invalidBatchOutput);
+		if (header === `${entry.oid} missing`) throw missingIndexedObject(entry.path);
+		const match = /^([0-9a-fA-F]{40}|[0-9a-fA-F]{64}) ([a-z]+) (0|[1-9][0-9]*)$/.exec(header);
+		if (!match) throw invalidBatchOutput();
+		const [, oid, type, rawSize] = match;
+		if (oid !== entry.oid) throw new Error("Repository inventory received Git objects out of order.");
+		if (type !== "blob") throw new Error("Repository inventory expected an indexed Git blob.");
+		const size = decimalSize(rawSize);
+		if (size !== entry.size) throw new Error("Repository inventory received an incorrect Git blob size.");
+
+		const contentStart = headerEnd + 1;
+		const contentEnd = contentStart + size;
+		if (contentEnd >= stdout.length || stdout[contentEnd] !== 0x0a) throw invalidBatchOutput();
+		const invalid = () => malformedManifest(entry.path);
+		scripts.push(...scriptsFromManifest(decodeUtf8(stdout.subarray(contentStart, contentEnd), invalid), entry.path));
+		offset = contentEnd + 1;
+	}
+	if (offset !== stdout.length) throw invalidBatchOutput();
+	return scripts;
+}
+
+async function packageScriptsFromIndex(
+	root: string,
+	entries: IndexEntry[],
+	signal: AbortSignal | undefined,
+): Promise<PackageScript[]> {
+	const packages = entries.filter((entry) => looksLikePackageJson(entry.path));
+	if (packages.length > MAX_PACKAGE_MANIFESTS) {
+		throw new Error("Repository inventory exceeds the 512 package manifest limit.");
+	}
+	if (packages.length === 0) return [];
+
+	const stdin = Buffer.from(packages.map((entry) => `${entry.oid}\n`).join(""), "ascii");
+	const checked = await runGit(
+		root,
+		["--no-replace-objects", "cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"],
+		signal,
+		BATCH_CHECK_STDOUT_BYTES,
+		{ stdin },
+	);
+	const sized = parseBatchCheck(checked.stdout, packages);
+	const content = await runGit(
+		root,
+		["--no-replace-objects", "cat-file", "--batch"],
+		signal,
+		CONTENT_BATCH_STDOUT_BYTES,
+		{ stdin },
+	);
+	return parseContentBatch(content.stdout, sized);
+}
+
+function effectiveSkills(pi: InventoryPi, root: string): RepositorySkill[] {
+	let commands: ReturnType<InventoryPi["getCommands"]>;
+	try {
+		commands = pi.getCommands();
+	} catch {
+		throw new Error("Repository inventory could not read effective skills.");
+	}
+	const skills: RepositorySkill[] = [];
+	for (const command of commands) {
+		if (command.source !== "skill" || typeof command.name !== "string" || typeof command.sourceInfo?.path !== "string") continue;
+		let sourcePath: string;
+		try {
+			sourcePath = fs.realpathSync(command.sourceInfo.path);
+		} catch {
+			continue;
+		}
+		if (!isWithin(root, sourcePath, false)) continue;
+		skills.push({
+			name: command.name,
+			description: typeof command.description === "string" ? command.description : "",
+			sourcePath: toPosixPath(path.relative(root, sourcePath)),
+		});
+	}
+	return skills.sort((left, right) =>
+		compare(left.name, right.name) ||
+		compare(left.sourcePath, right.sourcePath) ||
+		compare(left.description, right.description),
+	);
+}
+
+function unavailableInventory(
+	reason: typeof REPOSITORY_UNAVAILABLE_REASON | typeof REPOSITORY_INVENTORY_FAILED_REASON,
+): RepositoryInventory {
+	return {
+		available: false,
+		reason,
+		packageScripts: [],
+		executableScripts: [],
+		skills: [],
+		agentInstructions: [],
+		worktreeVerified: false,
+	};
+}
+
+/** Return bounded discovery hints from the Git index and Pi's effective skill registry. */
+export async function inventoryRepository(
+	pi: InventoryPi,
+	ctx: InventoryContext,
+	mode: RepositoryInventoryMode = "required",
+): Promise<RepositoryInventory> {
+	if (mode !== "required" && mode !== "optional") throw new Error("Invalid repository inventory mode.");
+	throwIfAborted(ctx.signal);
+	const gitRoot = await resolveGitRoot(ctx);
+	throwIfAborted(ctx.signal);
+	if (!gitRoot) {
+		if (mode === "optional") return unavailableInventory(REPOSITORY_UNAVAILABLE_REASON);
+		throw new Error("Repository inventory requires a Git repository.");
+	}
+
+	try {
+		const index = parseIndex((await runGit(gitRoot, ["--no-replace-objects", "ls-files", "--stage", "-z"], ctx.signal, INDEX_STDOUT_BYTES)).stdout);
+		const packageScripts = await packageScriptsFromIndex(gitRoot, index, ctx.signal);
+		const skills = effectiveSkills(pi, gitRoot);
+		throwIfAborted(ctx.signal);
+		return {
+			available: true,
+			gitRoot,
+			packageScripts,
+			executableScripts: index.filter((entry) => entry.mode === "100755").map((entry) => entry.path),
+			skills,
+			agentInstructions: index
+				.filter((entry) => REGULAR_MODES.has(entry.mode) && INSTRUCTION_NAMES.has(path.posix.basename(entry.path)))
+				.map((entry) => entry.path),
+			provenance: PROVENANCE,
+			worktreeVerified: false,
+		};
+	} catch (error) {
+		throwIfAborted(ctx.signal);
+		if (mode === "optional") return unavailableInventory(REPOSITORY_INVENTORY_FAILED_REASON);
+		throw error;
+	}
+}

package/extensions/search-core.ts

@@ -9,7 +9,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { buildFtsQueryPlan, buildLikeQueryPlan, foldCase, nearLike } from "./query.ts";
 import { MAX_SESSION_FILE_BYTES, readTranscriptEntries } from "./transcript.ts";
-import type { SearchHit, SessionRow, SyncResult } from "./types.ts";
+import type { PreparationSessionRow, SearchHit, SessionRow, SyncResult } from "./types.ts";
 export const DEFAULT_SYNC_CAP = 50;
 /** Hard ceiling for the internal/test `opts.cap` work bound of syncSessions. */
 const MAX_SYNC_CAP = DEFAULT_SYNC_CAP * 10;
@@ -692,7 +692,76 @@ export function searchIndex(
 	}
 }
 
-// --- Browse ---
+// --- Preparation / browse ---
+
+export interface PreparationRowOptions {
+	limit: number;
+	/** Canonical repository root. Omit to sample all indexed sessions. */
+	repositoryRoot?: string;
+	currentSessionPath?: string;
+}
+
+/** Select deterministic, repository-scoped pattern-miner candidates from the
+ * existing index. Scope, current-session exclusion, and one-hop lineage
+ * collapse all happen before the sample limit. */
+export function getPreparationRows(
+	dbPath: string,
+	opts: PreparationRowOptions,
+): PreparationSessionRow[] {
+	const clauses: string[] = [];
+	const params: string[] = [];
+	if (opts.repositoryRoot !== undefined) {
+		const prefix = opts.repositoryRoot.endsWith(path.sep)
+			? opts.repositoryRoot
+			: opts.repositoryRoot + path.sep;
+		clauses.push("(s.cwd = ? OR substr(s.cwd, 1, length(?)) = ?)");
+		params.push(opts.repositoryRoot, prefix, prefix);
+	}
+	if (opts.currentSessionPath !== undefined) {
+		clauses.push("s.path <> ?");
+		params.push(opts.currentSessionPath);
+	}
+	const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+	const db = openDb(dbPath);
+	try {
+		const rows = db.prepare(`
+			WITH eligible AS (
+				SELECT s.path, s.cwd, s.name, s.started_at, s.preview,
+					CASE
+						WHEN s.parent_session IS NULL THEN s.path
+						WHEN parent.path <> s.path AND parent.parent_session = s.path
+							THEN min(s.path, parent.path)
+						ELSE s.parent_session
+					END AS lineage_id
+				FROM sessions s
+				LEFT JOIN sessions parent ON parent.path = s.parent_session
+				${where}
+			), ranked AS (
+				SELECT *, ROW_NUMBER() OVER (
+					PARTITION BY lineage_id
+					ORDER BY CASE WHEN path = lineage_id THEN 0 ELSE 1 END,
+						started_at DESC, path
+				) AS rn
+				FROM eligible
+			)
+			SELECT path, cwd, name, started_at, preview, lineage_id
+			FROM ranked
+			WHERE rn = 1
+			ORDER BY started_at DESC, path
+			LIMIT ?
+		`).all(...params, opts.limit) as any[];
+		return rows.map((r) => ({
+			path: r.path,
+			cwd: r.cwd ?? "",
+			name: r.name ?? undefined,
+			startedAt: r.started_at ?? undefined,
+			preview: r.preview ?? undefined,
+			lineageId: r.lineage_id,
+		}));
+	} finally {
+		db.close();
+	}
+}
 
 export function getSessionRows(dbPath: string, limit: number): SessionRow[] {
 	const db = openDb(dbPath);