@zigai/pi-mode 0.1.3 → 0.1.4

package/README.md

@@ -5,7 +5,7 @@ This Pi extension adds prompt modes for model and thinking-level switching.
 ## Install
 
 ```sh
-pi install git:github.com/zigai/pi-tweaks
+pi install npm:@zigai/pi-mode
 ```
 
 ## Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigai/pi-mode",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Pi package that adds prompt modes for model and thinking-level switching.",
   "keywords": [
     "mode",

package/src/mode-state.ts

@@ -161,6 +161,22 @@ function normalizeThinkingLevel(level: ThinkingLevel | undefined): ThinkingLevel
     return undefined;
 }
 
+function getLoadErrorCode(error: unknown): string | undefined {
+    if (!(error instanceof Error)) return undefined;
+    const code = (error as NodeJS.ErrnoException).code;
+    if (typeof code === "string") return code;
+    return undefined;
+}
+
+function errorMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    return String(error);
+}
+
+function throwLoadError(filePath: string, error: unknown): never {
+    throw new Error(`Failed to load ${filePath}: ${errorMessage(error)}`);
+}
+
 function sanitizeModeSpec(spec: ModeSpecJson | undefined): ModeSpec {
     if (spec === undefined) return {};
 
@@ -225,6 +241,7 @@ async function loadModesFile(
     filePath: string,
     ctx: ExtensionContext,
     pi: ExtensionAPI,
+    options?: { throwOnInvalid?: boolean },
 ): Promise<ModesFile> {
     try {
         const raw = await fs.readFile(filePath, "utf8");
@@ -244,7 +261,9 @@ async function loadModesFile(
         };
         ensureDefaultModeEntries(file, ctx, pi);
         return file;
-    } catch {
+    } catch (error: unknown) {
+        if (getLoadErrorCode(error) === "ENOENT") return createDefaultModes(ctx, pi);
+        if (options?.throwOnInvalid === true) throwLoadError(filePath, error);
         return createDefaultModes(ctx, pi);
     }
 }
@@ -404,16 +423,23 @@ async function persistRuntime(pi: ExtensionAPI, ctx: ExtensionContext): Promise<
     const patch = computeModesPatch(runtime.baseline, runtime.data, false);
     if (patch === null) return;
 
-    await withFileLock(runtime.filePath, async () => {
-        const latest = await loadModesFile(runtime.filePath, ctx, pi);
-        applyModesPatch(latest, patch);
-        ensureDefaultModeEntries(latest, ctx, pi);
-        await saveModesFile(runtime.filePath, latest);
-
-        runtime.data = latest;
-        runtime.baseline = cloneModesFile(latest);
-        runtime.fileMtimeMs = await getMtimeMs(runtime.filePath);
-    });
+    try {
+        await withFileLock(runtime.filePath, async () => {
+            const latest = await loadModesFile(runtime.filePath, ctx, pi, { throwOnInvalid: true });
+            applyModesPatch(latest, patch);
+            ensureDefaultModeEntries(latest, ctx, pi);
+            await saveModesFile(runtime.filePath, latest);
+
+            runtime.data = latest;
+            runtime.baseline = cloneModesFile(latest);
+            runtime.fileMtimeMs = await getMtimeMs(runtime.filePath);
+        });
+    } catch (error: unknown) {
+        if (ctx.hasUI) {
+            ctx.ui.notify(`Mode settings were not saved: ${errorMessage(error)}`, "error");
+        }
+        throw error;
+    }
 }
 
 function getCurrentSelectionSpec(pi: ExtensionAPI): ModeSpec {
@@ -810,7 +836,12 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
 
         if (choice === MODE_UI_SHOW_NAME_ON || choice === MODE_UI_SHOW_NAME_OFF) {
             const next = !shouldShowModeName();
-            setShowModeName(next);
+            try {
+                setShowModeName(next);
+            } catch (error: unknown) {
+                ctx.ui.notify(`Mode name display was not saved: ${errorMessage(error)}`, "error");
+                continue;
+            }
             requestEditorRender?.();
             let displayState = "disabled";
             if (next) {

package/src/settings.ts

@@ -1,14 +1,131 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+    closeSync,
+    existsSync,
+    mkdirSync,
+    openSync,
+    readFileSync,
+    renameSync,
+    statSync,
+    unlinkSync,
+    writeFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
 
 export const SHOW_MODE_NAME_SETTINGS_KEY = "modeShowName";
 
+const SETTINGS_LOCK_TIMEOUT_MS = 5_000;
+const STALE_SETTINGS_LOCK_MS = 30_000;
+
 let cachedShowModeName: boolean | undefined;
 let cachedSettingsMtimeMs: number | null | undefined;
 
 function getSettingsPath(): string {
-    return join(homedir(), ".pi", "agent", "settings.json");
+    return join(getAgentDir(), "settings.json");
+}
+
+function getErrorCode(error: unknown): string | undefined {
+    if (!(error instanceof Error)) return undefined;
+    const code = (error as NodeJS.ErrnoException).code;
+    if (typeof code === "string") return code;
+    return undefined;
+}
+
+function throwError(error: unknown): never {
+    if (error instanceof Error) throw error;
+    throw new Error(String(error));
+}
+
+function sleepSync(ms: number): void {
+    const buffer = new SharedArrayBuffer(4);
+    Atomics.wait(new Int32Array(buffer), 0, 0, ms);
+}
+
+function withSettingsLock<T>(settingsPath: string, fn: () => T): T {
+    const lockPath = `${settingsPath}.lock`;
+    mkdirSync(dirname(lockPath), { recursive: true });
+
+    const start = Date.now();
+    while (true) {
+        try {
+            const fd = openSync(lockPath, "wx");
+            try {
+                writeFileSync(
+                    fd,
+                    `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`,
+                    "utf8",
+                );
+            } catch {
+                // Ignore best-effort lock metadata.
+            }
+
+            try {
+                return fn();
+            } finally {
+                try {
+                    closeSync(fd);
+                } catch {
+                    // Ignore cleanup failures.
+                }
+                try {
+                    unlinkSync(lockPath);
+                } catch {
+                    // Ignore cleanup failures.
+                }
+            }
+        } catch (error: unknown) {
+            if (getErrorCode(error) !== "EEXIST") throwError(error);
+
+            try {
+                const stat = statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > STALE_SETTINGS_LOCK_MS) {
+                    unlinkSync(lockPath);
+                    continue;
+                }
+            } catch {
+                // Ignore stale-lock checks.
+            }
+
+            if (Date.now() - start > SETTINGS_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out waiting for lock: ${lockPath}`);
+            }
+            sleepSync(40 + Math.random() * 80);
+        }
+    }
+}
+
+function atomicWriteUtf8Sync(filePath: string, content: string): void {
+    mkdirSync(dirname(filePath), { recursive: true });
+
+    const tempPath = join(
+        dirname(filePath),
+        `.${filePath.split(/[\\/]/).pop() ?? "settings.json"}.tmp.${process.pid}.${Math.random()
+            .toString(16)
+            .slice(2)}`,
+    );
+
+    writeFileSync(tempPath, content, "utf8");
+
+    try {
+        renameSync(tempPath, filePath);
+    } catch (error: unknown) {
+        const code = getErrorCode(error);
+        if (code === "EEXIST" || code === "EPERM") {
+            try {
+                unlinkSync(filePath);
+            } catch {
+                // Ignore missing target before retrying the rename.
+            }
+            renameSync(tempPath, filePath);
+            return;
+        }
+        try {
+            unlinkSync(tempPath);
+        } catch {
+            // Ignore cleanup failures.
+        }
+        throwError(error);
+    }
 }
 
 function getSettingsMtimeMs(): number | null {
@@ -20,20 +137,35 @@ function getSettingsMtimeMs(): number | null {
     }
 }
 
-function readSettingsObject(): Record<string, unknown> {
+function readSettingsObject(options?: { throwOnInvalid?: boolean }): Record<string, unknown> {
+    const settingsPath = getSettingsPath();
     try {
-        const raw = readFileSync(getSettingsPath(), "utf8");
+        const raw = readFileSync(settingsPath, "utf8");
         const parsed = JSON.parse(raw) as unknown;
         if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
             return { ...parsed };
         }
-    } catch {
-        // Ignore malformed or missing settings files and fall back to defaults.
+        if (options?.throwOnInvalid === true) {
+            throw new Error(`${settingsPath} must contain a JSON object.`);
+        }
+    } catch (error: unknown) {
+        if (getErrorCode(error) === "ENOENT") return {};
+        if (options?.throwOnInvalid === true) throwError(error);
+        // Ignore malformed settings files while reading and fall back to defaults.
     }
 
     return {};
 }
 
+function updateSettingsObject(update: (settings: Record<string, unknown>) => void): void {
+    const settingsPath = getSettingsPath();
+    withSettingsLock(settingsPath, () => {
+        const settings = readSettingsObject({ throwOnInvalid: true });
+        update(settings);
+        atomicWriteUtf8Sync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    });
+}
+
 export function shouldShowModeName(): boolean {
     const mtimeMs = getSettingsMtimeMs();
     if (cachedShowModeName !== undefined && cachedSettingsMtimeMs === mtimeMs) {
@@ -47,12 +179,9 @@ export function shouldShowModeName(): boolean {
 }
 
 export function setShowModeName(show: boolean): void {
-    const settingsPath = getSettingsPath();
-    const settings = readSettingsObject();
-    settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
-
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+    updateSettingsObject((settings) => {
+        settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
+    });
 
     cachedSettingsMtimeMs = getSettingsMtimeMs();
     cachedShowModeName = show;

package/src/storage.ts

@@ -1,17 +1,9 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 
-export function expandUserPath(value: string): string {
-    if (value === "~") return os.homedir();
-    if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
-    return value;
-}
-
 export function getGlobalAgentDir(): string {
-    const env = process.env.PI_CODING_AGENT_DIR;
-    if (env !== undefined && env.length > 0) return expandUserPath(env);
-    return path.join(os.homedir(), ".pi", "agent");
+    return getAgentDir();
 }
 
 export function getGlobalModesPath(): string {