@heyhuynhgiabuu/pi-pretty 0.6.25 → 0.6.27

package/src/config.ts

@@ -77,6 +77,7 @@ export interface WorkingIndicatorConfig {
 	mid?: string;
 	high?: string;
 	bold?: boolean;
+	/** @deprecated Retained for config compatibility; the working row no longer renders this hint. */
 	hint?: boolean;
 	/** Tint the indicator with a stable per-session accent color. */
 	sessionAccent?: boolean;
@@ -86,6 +87,18 @@ export interface ThinkingIndicatorConfig {
 	enabled?: boolean;
 }
 
+export interface FffConfig {
+	/** Allow FFF to index the user's home directory when Pi starts there. */
+	enableHomeScanning?: boolean;
+	/** Allow FFF to index the filesystem root when Pi starts there. */
+	enableRootScanning?: boolean;
+}
+
+export interface FffScanSettings {
+	enableHomeScanning: boolean;
+	enableRootScanning: boolean;
+}
+
 export interface PrettyConfig {
 	background?: {
 		tool?: string;
@@ -100,6 +113,7 @@ export interface PrettyConfig {
 	cacheLimit?: number;
 	workingIndicator?: WorkingIndicatorConfig;
 	thinkingIndicator?: ThinkingIndicatorConfig;
+	fff?: FffConfig;
 }
 
 /** Normalize a comma-separated env value or JSON array into tool names. */
@@ -148,6 +162,14 @@ export function loadConfig(agentDir = getConfigDir()): PrettyConfig {
 		if (maxHlChars) config.maxHlChars = maxHlChars;
 		if (maxPreviewLines) config.maxPreviewLines = maxPreviewLines;
 		if (cacheLimit) config.cacheLimit = cacheLimit;
+		const fff = parsed.fff;
+		if (fff && typeof fff === "object") {
+			const fffConfig: FffConfig = {};
+			const src = fff as Record<string, unknown>;
+			if (typeof src.enableHomeScanning === "boolean") fffConfig.enableHomeScanning = src.enableHomeScanning;
+			if (typeof src.enableRootScanning === "boolean") fffConfig.enableRootScanning = src.enableRootScanning;
+			if (Object.keys(fffConfig).length > 0) config.fff = fffConfig;
+		}
 		const workingIndicator = parsed.workingIndicator;
 		if (workingIndicator && typeof workingIndicator === "object") {
 			const wi: WorkingIndicatorConfig = {};
@@ -185,6 +207,35 @@ export function getConfigDir(): string | undefined {
 	return process.env.PRETTY_CONFIG_DIR ?? getDefaultAgentDir();
 }
 
+function parseBooleanOverride(value: unknown): boolean | undefined {
+	if (typeof value === "boolean") return value;
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "1" || normalized === "true" || normalized === "on") return true;
+	if (normalized === "0" || normalized === "false" || normalized === "off") return false;
+	return undefined;
+}
+
+export function resolveFffScanSettings(
+	config: Pick<PrettyConfig, "fff">,
+	flags: {
+		enableHomeScanning?: boolean | string;
+		enableRootScanning?: boolean | string;
+	} = {},
+	env: NodeJS.ProcessEnv = process.env,
+): FffScanSettings {
+	const resolve = (
+		flagValue: boolean | string | undefined,
+		envName: string,
+		configValue: boolean | undefined,
+	): boolean => parseBooleanOverride(flagValue) ?? parseBooleanOverride(env[envName]) ?? configValue ?? false;
+
+	return {
+		enableHomeScanning: resolve(flags.enableHomeScanning, "PRETTY_FFF_HOME_SCAN", config.fff?.enableHomeScanning),
+		enableRootScanning: resolve(flags.enableRootScanning, "PRETTY_FFF_ROOT_SCAN", config.fff?.enableRootScanning),
+	};
+}
+
 /**
  * Merge env tool sets with config-file tool lists: a non-empty env set wins
  * over the config file (12-factor precedence); otherwise config applies.

package/src/fff.ts

@@ -6,11 +6,44 @@
  * Graceful fallback: if FFF is not installed or fails, tools degrade to SDK.
  */
 
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, parse, resolve } from "node:path";
 
 import type { FileFinder as FffFileFinder, GrepCursor } from "@ff-labs/fff-node";
 
+export interface FffInitOptions {
+	enableHomeDirScanning: boolean;
+	enableFsRootScanning: boolean;
+}
+
+export type FffInitFailureKind = "restricted-base-path" | "native";
+export type FffRestrictedScanScope = "home" | "root";
+
+export class FffInitError extends Error {
+	readonly kind: FffInitFailureKind;
+	readonly restrictedScope: FffRestrictedScanScope | undefined;
+
+	constructor(kind: FffInitFailureKind, message: string, restrictedScope?: FffRestrictedScanScope) {
+		super(message);
+		this.name = "FffInitError";
+		this.kind = kind;
+		this.restrictedScope = restrictedScope;
+	}
+}
+
+export function isFffRestrictedBasePathError(error: unknown, options: FffInitOptions): boolean {
+	if (!(error instanceof FffInitError) || error.kind !== "restricted-base-path") return false;
+	if (error.restrictedScope === "home") return !options.enableHomeDirScanning;
+	if (error.restrictedScope === "root") return !options.enableFsRootScanning;
+	return false;
+}
+
+const DEFAULT_FFF_INIT_OPTIONS: FffInitOptions = {
+	enableHomeDirScanning: false,
+	enableFsRootScanning: false,
+};
+
 // ---------------------------------------------------------------------------
 // Cursor store — pagination cursors for grep
 // ---------------------------------------------------------------------------
@@ -53,6 +86,12 @@ type SharedFffState = {
 	service: FffService;
 };
 
+type FinderConfig = {
+	basePath: string;
+	enableHomeDirScanning: boolean;
+	enableFsRootScanning: boolean;
+};
+
 type GlobalWithFffService = typeof globalThis & {
 	[SHARED_FFF_SERVICE_KEY]?: SharedFffState;
 };
@@ -83,7 +122,9 @@ export class FffService {
 
 	private fffModule: typeof import("@ff-labs/fff-node") | null = null;
 	private dbDir: string | null = null;
+	private finderConfig: FinderConfig | null = null;
 	private finderPromise: Promise<void> | null = null;
+	private finderPromiseConfig: FinderConfig | null = null;
 
 	constructor(fffModule?: typeof import("@ff-labs/fff-node"), agentDir?: string) {
 		this.configure(fffModule, agentDir);
@@ -130,47 +171,97 @@ export class FffService {
 		}
 	}
 
-	async ensureFinder(cwd: string): Promise<void> {
-		if (this.finder && !this.finder.isDestroyed) return;
-		if (this.finderPromise) return this.finderPromise;
+	async ensureFinder(cwd: string, options: FffInitOptions = DEFAULT_FFF_INIT_OPTIONS): Promise<void> {
+		const requestedConfig = finderConfig(cwd, options);
 
-		const promise = this._createFinder(cwd);
-		this.finderPromise = promise;
-		try {
-			await promise;
-		} finally {
-			if (this.finderPromise === promise) this.finderPromise = null;
+		for (;;) {
+			if (this.finder && !this.finder.isDestroyed && sameFinderConfig(this.finderConfig, requestedConfig)) return;
+
+			const pending = this.finderPromise;
+			if (pending) {
+				const pendingConfig = this.finderPromiseConfig;
+				try {
+					await pending;
+				} catch (error) {
+					// A concurrent request for the same scope must observe the same
+					// failure. A different scope can retry after the pending attempt.
+					if (sameFinderConfig(pendingConfig, requestedConfig)) throw error;
+				}
+				continue;
+			}
+
+			const promise = this._createFinder(cwd, options, requestedConfig);
+			this.finderPromise = promise;
+			this.finderPromiseConfig = requestedConfig;
+			try {
+				await promise;
+				return;
+			} finally {
+				if (this.finderPromise === promise) {
+					this.finderPromise = null;
+					this.finderPromiseConfig = null;
+				}
+			}
 		}
 	}
 
-	private async _createFinder(cwd: string): Promise<void> {
+	private async _createFinder(cwd: string, options: FffInitOptions, config: FinderConfig): Promise<void> {
 		if (!this.fffModule) return;
 
-		if (this.finder && !this.finder.isDestroyed) {
-			this.finder.destroy();
-			this.finder = null;
+		const result = this.createFinder(cwd, this.dbDir, options);
+		if (!result.ok) {
+			const kind = isRestrictedBasePathMessage(result.error) ? "restricted-base-path" : "native";
+			throw new FffInitError(
+				kind,
+				result.error,
+				kind === "restricted-base-path" ? restrictedScanScope(cwd) : undefined,
+			);
 		}
 
-		const result = this.createFinder(cwd, this.dbDir);
-		if (!result.ok) {
-			throw new Error(`FFF init failed: ${result.error}`);
+		const candidate = result.value;
+		let scan: Awaited<ReturnType<typeof candidate.waitForScan>>;
+		try {
+			scan = await candidate.waitForScan(15_000);
+		} catch (error) {
+			if (!candidate.isDestroyed) {
+				try {
+					candidate.destroy();
+				} catch {
+					// Preserve the scan failure; the candidate is no longer selected.
+				}
+			}
+			throw error;
 		}
 
-		this.finder = result.value;
-		const scan = await this.finder.waitForScan(15_000);
+		const previous = this.finder;
+		this.finder = candidate;
 		this.partialIndex = scan.ok && !scan.value;
+		this.finderConfig = config;
+		if (previous && previous !== candidate && !previous.isDestroyed) {
+			try {
+				previous.destroy();
+			} catch {
+				// Keep the replacement active; native cleanup is best effort.
+			}
+		}
 	}
 
 	private createFinder(
 		cwd: string,
 		dbDir: string | null,
+		options: FffInitOptions,
 	): ReturnType<typeof import("@ff-labs/fff-node").FileFinder.create> {
 		if (!this.fffModule) throw new Error("FFF module is not loaded");
-		const result = this.fffModule.FileFinder.create({
+		const commonOptions = {
 			basePath: cwd,
+			aiMode: true,
+			enableHomeDirScanning: options.enableHomeDirScanning,
+			enableFsRootScanning: options.enableFsRootScanning,
+		};
+		const result = this.fffModule.FileFinder.create({
+			...commonOptions,
 			frecencyDbPath: dbDir ? join(dbDir, "frecency.mdb") : "",
 			historyDbPath: dbDir ? join(dbDir, "history.mdb") : "",
-			aiMode: true,
 		});
 		if (result.ok || !isAlreadyOpenError(result.error) || !dbDir) return result;
 
@@ -181,20 +272,23 @@ export class FffService {
 			return result;
 		}
 		return this.fffModule.FileFinder.create({
-			basePath: cwd,
+			...commonOptions,
 			frecencyDbPath: join(isolatedDir, "frecency.mdb"),
 			historyDbPath: join(isolatedDir, "history.mdb"),
-			aiMode: true,
 		});
 	}
 
 	destroy(): void {
-		if (this.finder && !this.finder.isDestroyed) {
-			this.finder.destroy();
-			this.finder = null;
-		}
-		this.partialIndex = false;
+		this.disposeFinder();
 		this.finderPromise = null;
+		this.finderPromiseConfig = null;
+	}
+
+	private disposeFinder(): void {
+		if (this.finder && !this.finder.isDestroyed) this.finder.destroy();
+		this.finder = null;
+		this.finderConfig = null;
+		this.partialIndex = false;
 	}
 
 	getFinder(): import("@ff-labs/fff-node").FileFinder | null {
@@ -206,6 +300,41 @@ export class FffService {
 	}
 }
 
+function finderConfig(cwd: string, options: FffInitOptions): FinderConfig {
+	return {
+		basePath: canonicalPath(cwd),
+		enableHomeDirScanning: options.enableHomeDirScanning,
+		enableFsRootScanning: options.enableFsRootScanning,
+	};
+}
+
+function sameFinderConfig(left: FinderConfig | null, right: FinderConfig): boolean {
+	return (
+		left?.basePath === right.basePath &&
+		left.enableHomeDirScanning === right.enableHomeDirScanning &&
+		left.enableFsRootScanning === right.enableFsRootScanning
+	);
+}
+
 function isAlreadyOpenError(error: string): boolean {
 	return /environment already open/i.test(error);
 }
+
+function isRestrictedBasePathMessage(error: string): boolean {
+	return /certain FFF features in a file system root or home directories/i.test(error);
+}
+
+function restrictedScanScope(cwd: string): FffRestrictedScanScope | undefined {
+	const basePath = canonicalPath(cwd);
+	if (basePath === parse(basePath).root) return "root";
+	if (basePath === canonicalPath(homedir())) return "home";
+	return undefined;
+}
+
+function canonicalPath(path: string): string {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve(path);
+	}
+}