pi-x-ide 1.3.0 → 1.4.0

package/src/pi/zed.ts

@@ -6,6 +6,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent" with {
   "resolution-mode": "import",
 };
 import type { EditorSelectionSnapshot, SelectionRange } from "../shared/protocol";
+import { resolvePiConfigEnv, isProcessEnvOrPiConfigOverlay } from "../shared/config";
 import { snapshotKey } from "../shared/format";
 import { isPathInsideOrEqual } from "../shared/paths";
 import { setLatestSelection, clearLatestSelection } from "./context";
@@ -18,12 +19,14 @@ export const ZED_POLL_INTERVAL_MS = 1000;
 // ── Terminal detection ──────────────────────────────────────────
 
 export function isZedTerminal(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env.ZED_TERM === "true" || env.TERM_PROGRAM?.toLowerCase() === "zed";
+  const configuredEnv = resolvePiConfigEnv(env);
+  return configuredEnv.ZED_TERM === "true" || configuredEnv.TERM_PROGRAM?.toLowerCase() === "zed";
 }
 
 export function isWsl(env: NodeJS.ProcessEnv = process.env): boolean {
-  if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
-  if (env !== process.env) return false;
+  const configuredEnv = resolvePiConfigEnv(env);
+  if (configuredEnv.WSL_DISTRO_NAME || configuredEnv.WSL_INTEROP) return true;
+  if (!isProcessEnvOrPiConfigOverlay(configuredEnv)) return false;
   try {
     return /microsoft|wsl/i.test(readFileSync("/proc/version", "utf8"));
   } catch {
@@ -32,7 +35,8 @@ export function isWsl(env: NodeJS.ProcessEnv = process.env): boolean {
 }
 
 export function normalizeZedPathForHost(input: string, env: NodeJS.ProcessEnv = process.env): string {
-  if (!input || !isWsl(env)) return input;
+  const configuredEnv = resolvePiConfigEnv(env);
+  if (!input || !isWsl(configuredEnv)) return input;
 
   const driveMatch = input.match(/^([a-zA-Z]):[\\/](.*)$/);
   if (driveMatch) {
@@ -45,7 +49,7 @@ export function normalizeZedPathForHost(input: string, env: NodeJS.ProcessEnv =
   if (uncMatch) {
     const distro = uncMatch[1];
     const rest = uncMatch[2].replaceAll("\\", "/");
-    const currentDistro = env.WSL_DISTRO_NAME;
+    const currentDistro = configuredEnv.WSL_DISTRO_NAME;
     if (!currentDistro || distro.toLowerCase() === currentDistro.toLowerCase()) {
       return `/${rest}`;
     }
@@ -57,9 +61,10 @@ export function normalizeZedPathForHost(input: string, env: NodeJS.ProcessEnv =
 // ── DB path resolution ─────────────────────────────────────────
 
 export function resolveZedDbPath(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string | undefined {
-  const override = env[PI_X_IDE_ZED_DB_ENV]?.trim();
+  const configuredEnv = resolvePiConfigEnv(env);
+  const override = configuredEnv[PI_X_IDE_ZED_DB_ENV]?.trim();
   if (override) {
-    const normalizedOverride = normalizeZedPathForHost(override, env);
+    const normalizedOverride = normalizeZedPathForHost(override, configuredEnv);
     return isFile(normalizedOverride) ? normalizedOverride : undefined;
   }
 
@@ -67,8 +72,8 @@ export function resolveZedDbPath(env: NodeJS.ProcessEnv = process.env, home: str
     resolve(home, ".local", "share", "zed", "db", "0-stable", "db.sqlite"), // Linux
     resolve(home, "Library", "Application Support", "Zed", "db", "0-stable", "db.sqlite"), // macOS
     resolve(home, "AppData", "Local", "Zed", "db", "0-stable", "db.sqlite"), // Windows
-    ...zedDbCandidatesFromWindowsEnv(env),
-    ...zedDbCandidatesFromWslMount(env),
+    ...zedDbCandidatesFromWindowsEnv(configuredEnv),
+    ...zedDbCandidatesFromWslMount(configuredEnv),
   ];
 
   return candidates.find(isFile);
@@ -114,10 +119,11 @@ interface ZedDatabaseHandle {
 }
 
 function openZedDatabase(dbPath: string, env: NodeJS.ProcessEnv = process.env): ZedDatabaseHandle | undefined {
+  const configuredEnv = resolvePiConfigEnv(env);
   // Direct open on live WAL-mode databases can succeed at construction time
   // but fail on the first query on WSL/Windows mounts. Always snapshot
   // under WSL to avoid "disk I/O error" during SQL execution.
-  if (isWsl(env)) return openZedDatabaseSnapshot(dbPath);
+  if (isWsl(configuredEnv)) return openZedDatabaseSnapshot(dbPath);
 
   try {
     return { db: new DatabaseSync(dbPath, { readOnly: true }), cleanup: () => undefined };
@@ -274,7 +280,8 @@ export interface ResolveZedSelectionOptions {
 }
 
 export function resolveZedSelection(options: ResolveZedSelectionOptions): EditorSelectionSnapshot | undefined {
-  const { dbPath, cwd, readFile = (path) => readFileSync(path, "utf8"), env = process.env } = options;
+  const { dbPath, cwd, readFile = (path) => readFileSync(path, "utf8"), env: inputEnv = process.env } = options;
+  const env = resolvePiConfigEnv(inputEnv);
   const dbHandle = openZedDatabase(dbPath, env);
   if (!dbHandle) return undefined;
 
@@ -431,7 +438,7 @@ export function startZedPolling(
     env?: NodeJS.ProcessEnv;
   },
 ): boolean {
-  const env = options?.env ?? process.env;
+  const env = resolvePiConfigEnv(options?.env ?? process.env);
   if (!isZedTerminal(env)) return false;
 
   const dbPath = options?.dbPath ?? resolveZedDbPath(env);

package/src/shared/config-options.ts

@@ -0,0 +1,100 @@
+export type ConfigEnvValueType = "string" | "number" | "boolean";
+
+export interface ConfigEnvOption {
+  readonly type: readonly ConfigEnvValueType[];
+  readonly description: string;
+  readonly default?: string;
+}
+
+export interface ConfigEnvPatternOption extends ConfigEnvOption {
+  readonly pattern: string;
+}
+
+export const CONFIG_ENV_VALUE_TYPES = ["string", "number", "boolean"] as const satisfies readonly ConfigEnvValueType[];
+
+export function isConfigEnvValue(value: unknown): value is string | number | boolean {
+  return CONFIG_ENV_VALUE_TYPES.some((type) => typeof value === type);
+}
+
+export const CONFIG_ENV_OPTIONS = {
+  PI_X_IDE_LOCK_DIR: {
+    type: ["string"],
+    default: "~/.pi/pi-x-ide/lock",
+    description: "Directory containing Pi x IDE lock files. Defaults to ~/.pi/pi-x-ide/lock.",
+  },
+  PI_X_IDE_AUTO_INSTALL: {
+    type: ["string", "number", "boolean"],
+    default: "enabled",
+    description: "Controls VS Code-family extension auto-install. Values 0, false, and off disable it.",
+  },
+  PI_X_IDE_ZED_DB: {
+    type: ["string"],
+    description: "Override path to Zed's SQLite database.",
+  },
+  TERM_PROGRAM: {
+    type: ["string"],
+    description: "Terminal program marker used to detect VS Code, Cursor, Windsurf, or Zed.",
+  },
+  VSCODE_CWD: {
+    type: ["string"],
+    description: "VS Code-family cwd marker and IDE path hint.",
+  },
+  VSCODE_PID: {
+    type: ["string", "number"],
+    description: "VS Code-family process marker.",
+  },
+  VSCODE_IPC_HOOK_CLI: {
+    type: ["string"],
+    description: "VS Code-family IPC marker and IDE path hint.",
+  },
+  VSCODE_GIT_IPC_HANDLE: {
+    type: ["string"],
+    description: "VS Code-family Git IPC marker and IDE path hint.",
+  },
+  ZED_TERM: {
+    type: ["string", "boolean"],
+    description: "Zed terminal marker. Pi x IDE detects Zed when this is true.",
+  },
+  WSL_DISTRO_NAME: {
+    type: ["string"],
+    description: "WSL distribution name used for WSL path normalization and Zed database discovery.",
+  },
+  WSL_INTEROP: {
+    type: ["string"],
+    description: "WSL interop marker used for WSL path normalization and Zed database discovery.",
+  },
+  LOCALAPPDATA: {
+    type: ["string"],
+    description: "Windows local application data directory used to find Zed's database.",
+  },
+  USERPROFILE: {
+    type: ["string"],
+    description: "Windows user profile directory used to find Zed's database when LOCALAPPDATA is unavailable.",
+  },
+  PATH: {
+    type: ["string"],
+    description: "Executable search path used to find code, cursor, and windsurf CLIs.",
+  },
+  Path: {
+    type: ["string"],
+    description: "Windows-style executable search path used to find code, cursor, and windsurf CLIs.",
+  },
+  path: {
+    type: ["string"],
+    description: "Lowercase executable search path used to find code, cursor, and windsurf CLIs.",
+  },
+  PATHEXT: {
+    type: ["string"],
+    description: "Windows executable extensions used when searching for IDE CLIs.",
+  },
+} as const satisfies Record<string, ConfigEnvOption>;
+
+export const CONFIG_ENV_PATTERN_OPTIONS = [
+  {
+    pattern: "^(CURSOR|WINDSURF|CODEIUM).*",
+    type: ["string", "number", "boolean"],
+    description: "IDE-specific marker used to detect Cursor or Windsurf terminals.",
+  },
+] as const satisfies readonly ConfigEnvPatternOption[];
+
+export type ConfigEnvOptionName = keyof typeof CONFIG_ENV_OPTIONS;

package/src/shared/config.ts

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { isConfigEnvValue } from "./config-options";
+
+export const PI_CONFIG_FILE = "config.json";
+
+const processEnvOverlays = new WeakSet<NodeJS.ProcessEnv>();
+
+export function resolvePiConfigPath(home: string = homedir()): string {
+  return resolve(home, ".pi", PI_CONFIG_FILE);
+}
+
+export function readPiConfigEnv(configPath: string = resolvePiConfigPath()): NodeJS.ProcessEnv {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf8")) as unknown;
+  } catch {
+    return {};
+  }
+
+  if (!isRecord(parsed) || !isRecord(parsed.env)) return {};
+
+  return Object.fromEntries(
+    Object.entries(parsed.env)
+      .filter((entry): entry is [string, string | number | boolean] => {
+        const [key, value] = entry;
+        return key.length > 0 && isConfigEnvValue(value);
+      })
+      .map(([key, value]) => [key, String(value)]),
+  );
+}
+
+export function resolvePiConfigEnv(
+  env: NodeJS.ProcessEnv = process.env,
+  options: { configPath?: string } = {},
+): NodeJS.ProcessEnv {
+  if (env !== process.env && !options.configPath) return env;
+
+  const configEnv = readPiConfigEnv(options.configPath);
+  if (Object.keys(configEnv).length === 0) return env;
+
+  const merged = { ...configEnv, ...env };
+  if (env === process.env) processEnvOverlays.add(merged);
+  return merged;
+}
+
+export function isProcessEnvOrPiConfigOverlay(env: NodeJS.ProcessEnv): boolean {
+  return env === process.env || processEnvOverlays.has(env);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/shared/paths.ts

@@ -1,11 +1,12 @@
 import { homedir } from "node:os";
 import { isAbsolute, relative, resolve, sep } from "node:path";
+import { resolvePiConfigEnv } from "./config";
 import { LOCK_DIR_ENV } from "./protocol";
 
 export function resolveLockDir(env: NodeJS.ProcessEnv = process.env): string {
-  return env[LOCK_DIR_ENV] && env[LOCK_DIR_ENV].trim()
-    ? resolve(env[LOCK_DIR_ENV])
-    : resolve(homedir(), ".pi", "pi-x-ide");
+  const configuredEnv = resolvePiConfigEnv(env);
+  const override = configuredEnv[LOCK_DIR_ENV]?.trim();
+  return override ? resolve(override) : resolve(homedir(), ".pi", "pi-x-ide", "lock");
 }
 
 export function normalizePath(input: string): string {