workon 3.2.2 → 3.2.3

package/dist/index.d.cts

@@ -135,17 +135,51 @@ interface OpenOptions extends GlobalOptions {
     dryRun?: boolean;
 }
 
+/**
+ * Config class with singleton pattern and file locking to prevent
+ * race conditions that could clear the config.
+ */
 declare class Config {
+    private static _instance;
     private _transient;
     private _store;
+    private _lock;
     constructor();
+    /**
+     * Get the singleton instance (creates one if needed)
+     */
+    static getInstance(): Config;
+    /**
+     * Reset the singleton instance (for testing purposes)
+     */
+    static resetInstance(): void;
     get<T = unknown>(key: string, defaultValue?: T): T | undefined;
-    set(key: string, value?: unknown): void;
+    set(key: string, value: unknown): void;
     has(key: string): boolean;
     delete(key: string): void;
+    /**
+     * Get all projects. Returns a fresh copy from the store.
+     */
     getProjects(): Record<string, ProjectConfig>;
     getProject(name: string): ProjectConfig | undefined;
+    /**
+     * Set a project with file locking to prevent race conditions.
+     * This ensures atomic read-modify-write operations.
+     */
+    setProjectSafe(name: string, config: ProjectConfig): Promise<void>;
+    /**
+     * Synchronous version of setProject for backwards compatibility.
+     * Note: This is less safe than setProjectSafe() in concurrent scenarios.
+     * Consider migrating to setProjectSafe() for critical operations.
+     */
     setProject(name: string, config: ProjectConfig): void;
+    /**
+     * Delete a project with file locking to prevent race conditions.
+     */
+    deleteProjectSafe(name: string): Promise<void>;
+    /**
+     * Synchronous version of deleteProject for backwards compatibility.
+     */
     deleteProject(name: string): void;
     getDefaults(): ProjectDefaults | undefined;
     setDefaults(defaults: ProjectDefaults): void;

package/dist/index.d.ts

@@ -135,17 +135,51 @@ interface OpenOptions extends GlobalOptions {
     dryRun?: boolean;
 }
 
+/**
+ * Config class with singleton pattern and file locking to prevent
+ * race conditions that could clear the config.
+ */
 declare class Config {
+    private static _instance;
     private _transient;
     private _store;
+    private _lock;
     constructor();
+    /**
+     * Get the singleton instance (creates one if needed)
+     */
+    static getInstance(): Config;
+    /**
+     * Reset the singleton instance (for testing purposes)
+     */
+    static resetInstance(): void;
     get<T = unknown>(key: string, defaultValue?: T): T | undefined;
-    set(key: string, value?: unknown): void;
+    set(key: string, value: unknown): void;
     has(key: string): boolean;
     delete(key: string): void;
+    /**
+     * Get all projects. Returns a fresh copy from the store.
+     */
     getProjects(): Record<string, ProjectConfig>;
     getProject(name: string): ProjectConfig | undefined;
+    /**
+     * Set a project with file locking to prevent race conditions.
+     * This ensures atomic read-modify-write operations.
+     */
+    setProjectSafe(name: string, config: ProjectConfig): Promise<void>;
+    /**
+     * Synchronous version of setProject for backwards compatibility.
+     * Note: This is less safe than setProjectSafe() in concurrent scenarios.
+     * Consider migrating to setProjectSafe() for critical operations.
+     */
     setProject(name: string, config: ProjectConfig): void;
+    /**
+     * Delete a project with file locking to prevent race conditions.
+     */
+    deleteProjectSafe(name: string): Promise<void>;
+    /**
+     * Synchronous version of deleteProject for backwards compatibility.
+     */
     deleteProject(name: string): void;
     getDefaults(): ProjectDefaults | undefined;
     setDefaults(defaults: ProjectDefaults): void;

package/dist/index.js

@@ -1,13 +1,94 @@
 // src/lib/config.ts
 import Conf from "conf";
+import { openSync, closeSync, unlinkSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
 var TRANSIENT_PROPS = ["pkg", "work"];
-var Config = class {
+var FileLock = class _FileLock {
+  lockPath;
+  fd = null;
+  static LOCK_TIMEOUT_MS = 5e3;
+  static RETRY_INTERVAL_MS = 50;
+  constructor(configPath) {
+    this.lockPath = `${configPath}.lock`;
+  }
+  async acquire() {
+    const startTime = Date.now();
+    const lockDir = dirname(this.lockPath);
+    if (!existsSync(lockDir)) {
+      mkdirSync(lockDir, { recursive: true });
+    }
+    while (Date.now() - startTime < _FileLock.LOCK_TIMEOUT_MS) {
+      try {
+        this.fd = openSync(this.lockPath, "wx");
+        return;
+      } catch (error) {
+        if (error.code === "EEXIST") {
+          try {
+            const stat = await import("fs").then((fs) => fs.promises.stat(this.lockPath));
+            const age = Date.now() - stat.mtimeMs;
+            if (age > _FileLock.LOCK_TIMEOUT_MS) {
+              try {
+                unlinkSync(this.lockPath);
+              } catch {
+              }
+            }
+          } catch {
+          }
+          await new Promise((resolve) => setTimeout(resolve, _FileLock.RETRY_INTERVAL_MS));
+        } else {
+          throw error;
+        }
+      }
+    }
+    throw new Error("Failed to acquire config lock: timeout");
+  }
+  release() {
+    if (this.fd !== null) {
+      try {
+        closeSync(this.fd);
+      } catch {
+      }
+      this.fd = null;
+    }
+    try {
+      unlinkSync(this.lockPath);
+    } catch {
+    }
+  }
+};
+var Config = class _Config {
+  static _instance = null;
   _transient = {};
+  // Using definite assignment assertion since singleton pattern may return existing instance
   _store;
+  _lock;
   constructor() {
+    if (_Config._instance && process.env.NODE_ENV !== "test") {
+      return _Config._instance;
+    }
     this._store = new Conf({
-      projectName: "workon"
+      projectName: "workon",
+      ...process.env.WORKON_CONFIG_DIR && { cwd: process.env.WORKON_CONFIG_DIR }
     });
+    this._lock = new FileLock(this._store.path);
+    if (process.env.NODE_ENV !== "test") {
+      _Config._instance = this;
+    }
+  }
+  /**
+   * Get the singleton instance (creates one if needed)
+   */
+  static getInstance() {
+    if (!_Config._instance) {
+      _Config._instance = new _Config();
+    }
+    return _Config._instance;
+  }
+  /**
+   * Reset the singleton instance (for testing purposes)
+   */
+  static resetInstance() {
+    _Config._instance = null;
   }
   get(key, defaultValue) {
     const rootKey = key.split(".")[0];
@@ -22,10 +103,9 @@ var Config = class {
       this._transient[key] = value;
     } else {
       if (value === void 0) {
-        this._store.set(key, value);
-      } else {
-        this._store.set(key, value);
+        throw new Error(`Cannot set '${key}' to undefined. Use delete() to remove keys.`);
       }
+      this._store.set(key, value);
     }
   }
   has(key) {
@@ -43,6 +123,9 @@ var Config = class {
       this._store.delete(key);
     }
   }
+  /**
+   * Get all projects. Returns a fresh copy from the store.
+   */
   getProjects() {
     return this.get("projects") ?? {};
   }
@@ -50,15 +133,50 @@ var Config = class {
     const projects = this.getProjects();
     return projects[name];
   }
+  /**
+   * Set a project with file locking to prevent race conditions.
+   * This ensures atomic read-modify-write operations.
+   */
+  async setProjectSafe(name, config) {
+    await this._lock.acquire();
+    try {
+      const freshProjects = this._store.get("projects") ?? {};
+      freshProjects[name] = config;
+      this._store.set("projects", freshProjects);
+    } finally {
+      this._lock.release();
+    }
+  }
+  /**
+   * Synchronous version of setProject for backwards compatibility.
+   * Note: This is less safe than setProjectSafe() in concurrent scenarios.
+   * Consider migrating to setProjectSafe() for critical operations.
+   */
   setProject(name, config) {
-    const projects = this.getProjects();
-    projects[name] = config;
-    this.set("projects", projects);
+    const freshProjects = this._store.get("projects") ?? {};
+    freshProjects[name] = config;
+    this._store.set("projects", freshProjects);
   }
+  /**
+   * Delete a project with file locking to prevent race conditions.
+   */
+  async deleteProjectSafe(name) {
+    await this._lock.acquire();
+    try {
+      const freshProjects = this._store.get("projects") ?? {};
+      delete freshProjects[name];
+      this._store.set("projects", freshProjects);
+    } finally {
+      this._lock.release();
+    }
+  }
+  /**
+   * Synchronous version of deleteProject for backwards compatibility.
+   */
   deleteProject(name) {
-    const projects = this.getProjects();
-    delete projects[name];
-    this.set("projects", projects);
+    const freshProjects = this._store.get("projects") ?? {};
+    delete freshProjects[name];
+    this._store.set("projects", freshProjects);
   }
   getDefaults() {
     return this.get("project_defaults");
@@ -441,7 +559,7 @@ var EnvironmentRecognizer = class {
   }
   static ensureConfigured() {
     if (!this.configured) {
-      this.config = new Config();
+      this.config = Config.getInstance();
       this.log = {
         debug: () => {
         },
@@ -769,10 +887,10 @@ var ClaudeEvent = class _ClaudeEvent {
   }
   static getClaudeCommand(config) {
     if (typeof config === "boolean" || config === void 0) {
-      return "claude";
+      return "claude --dangerously-skip-permissions";
     }
     const flags = config.flags || [];
-    return flags.length > 0 ? `claude ${flags.join(" ")}` : "claude";
+    return flags.length > 0 ? `claude --dangerously-skip-permissions ${flags.join(" ")}` : "claude --dangerously-skip-permissions";
   }
   static get processing() {
     return {