workon 3.2.2 → 3.2.3

package/dist/cli.js

@@ -11,18 +11,99 @@ var __export = (target, all) => {
 
 // src/lib/config.ts
 import Conf from "conf";
-var TRANSIENT_PROPS, Config;
+import { openSync, closeSync, unlinkSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var TRANSIENT_PROPS, FileLock, Config;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     TRANSIENT_PROPS = ["pkg", "work"];
-    Config = class {
+    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((resolve2) => setTimeout(resolve2, _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 {
+        }
+      }
+    };
+    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];
@@ -37,10 +118,9 @@ var init_config = __esm({
           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) {
@@ -58,6 +138,9 @@ var init_config = __esm({
           this._store.delete(key);
         }
       }
+      /**
+       * Get all projects. Returns a fresh copy from the store.
+       */
       getProjects() {
         return this.get("projects") ?? {};
       }
@@ -65,15 +148,50 @@ var init_config = __esm({
         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");
@@ -280,7 +398,7 @@ var init_environment = __esm({
       }
       static ensureConfigured() {
         if (!this.configured) {
-          this.config = new Config();
+          this.config = Config.getInstance();
           this.log = {
             debug: () => {
             },
@@ -632,10 +750,10 @@ var init_claude = __esm({
       }
       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 {
@@ -1469,8 +1587,7 @@ async function initProject(defaultName, fromUser, ctx) {
     ide,
     events
   };
-  projects[name] = projectConfig;
-  config.set("projects", projects);
+  await config.setProjectSafe(name, projectConfig);
   log.info("Your project has been initialized.");
   log.info(`Use 'workon ${name}' to start working!`);
 }
@@ -1491,8 +1608,7 @@ async function initBranch(defaultName, ctx) {
     branch
   });
   const branchConfig = mergedConfig;
-  projects[branchName] = branchConfig;
-  config.set("projects", projects);
+  await config.setProjectSafe(branchName, branchConfig);
   log.info("Your branch configuration has been initialized.");
   log.info(`Use 'workon ${branchName}' to start working!`);
 }
@@ -1690,7 +1806,7 @@ async function createProjectManage(ctx) {
     default: true
   });
   if (confirmed) {
-    config.setProject(name, projectConfig);
+    await config.setProjectSafe(name, projectConfig);
     log.info(`Project '${name}' created successfully!`);
   }
 }
@@ -1768,7 +1884,7 @@ async function editProjectManage(ctx) {
     default: true
   });
   if (confirmed) {
-    config.setProject(name, updatedConfig);
+    await config.setProjectSafe(name, updatedConfig);
     log.info(`Project '${name}' updated successfully!`);
   }
 }
@@ -1794,7 +1910,7 @@ async function deleteProjectManage(ctx) {
     });
     if (deleteAll) {
       for (const branch of branches) {
-        config.deleteProject(branch);
+        await config.deleteProjectSafe(branch);
       }
     }
   }
@@ -1803,7 +1919,7 @@ async function deleteProjectManage(ctx) {
     default: false
   });
   if (confirmed) {
-    config.deleteProject(name);
+    await config.deleteProjectSafe(name);
     log.info(`Project '${name}' deleted.`);
   }
 }
@@ -1883,7 +1999,7 @@ async function editBranchManage(projectName, ctx) {
     default: true
   });
   if (confirmed) {
-    config.setProject(branchName, updatedConfig);
+    await config.setProjectSafe(branchName, updatedConfig);
     log.info(`Branch configuration '${branchName}' updated successfully!`);
   }
 }
@@ -1908,7 +2024,7 @@ async function deleteBranchManage(projectName, ctx) {
     default: false
   });
   if (confirmed) {
-    config.deleteProject(branchName);
+    await config.deleteProjectSafe(branchName);
     log.info(`Branch configuration '${branchName}' deleted.`);
   }
 }
@@ -1996,9 +2112,9 @@ async function processProject(projectParam, options, ctx) {
     const projectEnv = ProjectEnvironment.load(projectCfg, config.getDefaults());
     await switchTo(projectEnv, requestedCommands, options, ctx);
   } else {
-    log.debug(`Project '${projectName}' not found, starting interactive mode`);
-    const { runInteractive: runInteractive2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-    await runInteractive2({ config, log, environment, suggestedName: projectName });
+    log.error(`Project '${projectName}' not found.`);
+    log.info(`Run 'workon' without arguments to see available projects or create a new one.`);
+    process.exit(1);
   }
 }
 function validateRequestedCommands(requestedCommands, projectConfig, projectName) {
@@ -2066,7 +2182,8 @@ function resolveCommandDependencies(requestedCommands, project) {
 }
 function getClaudeArgs(project) {
   const claudeConfig = project.events.claude;
-  return typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  const userFlags = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  return ["--dangerously-skip-permissions", ...userFlags];
 }
 async function getNpmCommand(project) {
   const npmConfig = project.events.npm;
@@ -2271,8 +2388,8 @@ init_environment();
 init_registry();
 init_open();
 import { Command as Command8 } from "commander";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join, dirname } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import loog from "loog";
 import omelette from "omelette";
@@ -2499,7 +2616,7 @@ async function createProject(ctx) {
     default: true
   });
   if (confirmed) {
-    config.setProject(name, projectConfig);
+    await config.setProjectSafe(name, projectConfig);
     log.info(`Project '${name}' created successfully!`);
     log.info(`Use 'workon ${name}' to start working!`);
   } else {
@@ -2589,7 +2706,7 @@ async function editProject(ctx) {
     default: true
   });
   if (confirmed) {
-    config.setProject(name, updatedConfig);
+    await config.setProjectSafe(name, updatedConfig);
     log.info(`Project '${name}' updated successfully!`);
   } else {
     log.info("Edit cancelled.");
@@ -2612,7 +2729,7 @@ async function deleteProject(ctx) {
     default: false
   });
   if (confirmed) {
-    config.deleteProject(name);
+    await config.deleteProjectSafe(name);
     log.info(`Project '${name}' deleted.`);
   } else {
     log.info("Delete cancelled.");
@@ -2638,7 +2755,7 @@ async function listProjects(ctx) {
 
 // src/commands/add.ts
 import { Command as Command7 } from "commander";
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { basename, resolve } from "path";
 import File6 from "phylo";
 import { confirm as confirm5 } from "@inquirer/prompts";
@@ -2660,7 +2777,7 @@ async function addProject(pathArg, options, ctx) {
   const projects = config.getProjects();
   const targetPath = resolve(pathArg);
   log.debug(`Resolved path: ${targetPath}`);
-  if (!existsSync(targetPath)) {
+  if (!existsSync2(targetPath)) {
     log.error(`Path does not exist: ${targetPath}`);
     process.exit(1);
   }
@@ -2725,7 +2842,7 @@ async function addProject(pathArg, options, ctx) {
   if (discovery.hasClaude) {
     projectConfig.events.claude = true;
   }
-  config.setProject(projectName, projectConfig);
+  await config.setProjectSafe(projectName, projectConfig);
   log.info(`Added project '${projectName}'`);
   log.info(`  Path: ${relativePath}`);
   log.info(`  IDE: ${ide}`);
@@ -2744,7 +2861,7 @@ function discoverProject(targetPath, log) {
     packageJson: null
   };
   const packageJsonPath = resolve(targetPath, "package.json");
-  if (existsSync(packageJsonPath)) {
+  if (existsSync2(packageJsonPath)) {
     discovery.isNode = true;
     log.debug("Detected Node project (package.json found)");
     try {
@@ -2760,25 +2877,25 @@ function discoverProject(targetPath, log) {
     }
   }
   const bunLockPath = resolve(targetPath, "bun.lockb");
-  if (existsSync(bunLockPath)) {
+  if (existsSync2(bunLockPath)) {
     discovery.isBun = true;
     log.debug("Detected Bun project (bun.lockb found)");
   }
   const vscodeDir = resolve(targetPath, ".vscode");
   const cursorDir = resolve(targetPath, ".cursor");
   const ideaDir = resolve(targetPath, ".idea");
-  if (existsSync(cursorDir)) {
+  if (existsSync2(cursorDir)) {
     discovery.detectedIde = "cursor";
     log.debug("Detected Cursor (.cursor directory found)");
-  } else if (existsSync(vscodeDir)) {
+  } else if (existsSync2(vscodeDir)) {
     discovery.detectedIde = "code";
     log.debug("Detected VS Code (.vscode directory found)");
-  } else if (existsSync(ideaDir)) {
+  } else if (existsSync2(ideaDir)) {
     discovery.detectedIde = "idea";
     log.debug("Detected IntelliJ IDEA (.idea directory found)");
   }
   const claudeMdPath = resolve(targetPath, "CLAUDE.md");
-  if (existsSync(claudeMdPath)) {
+  if (existsSync2(claudeMdPath)) {
     discovery.hasClaude = true;
     log.debug("Detected Claude Code project (CLAUDE.md found)");
   }
@@ -2787,7 +2904,7 @@ function discoverProject(targetPath, log) {
 
 // src/commands/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
+var __dirname = dirname2(__filename);
 function findPackageJson() {
   const paths = [
     join(__dirname, "../package.json"),
@@ -2795,7 +2912,7 @@ function findPackageJson() {
     join(process.cwd(), "package.json")
   ];
   for (const p of paths) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       return p;
     }
   }
@@ -2935,6 +3052,15 @@ workon() {
 }
 
 // src/cli.ts
+if (process.stdout.isTTY) {
+  process.stdout.write("");
+}
 var program = createCli();
-program.parse();
+program.parseAsync().catch((error) => {
+  if (error?.name === "ExitPromptError" || error?.message?.includes("SIGINT")) {
+    process.exit(130);
+  }
+  console.error(error);
+  process.exit(1);
+});
 //# sourceMappingURL=cli.js.map