workon 3.2.1 → 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: () => {
             },
@@ -345,18 +463,22 @@ var init_cwd = __esm({
             const { project, isShellMode, shellCommands } = context;
             const projectPath = project.path.path;
             if (isShellMode) {
-              shellCommands.push(`cd "${projectPath}"`);
+              shellCommands.push(`pushd "${projectPath}" > /dev/null`);
             } else {
               const shell = process.env.SHELL || "/bin/bash";
-              spawn(shell, [], {
+              const child = spawn(shell, ["-i"], {
                 cwd: projectPath,
                 stdio: "inherit"
               });
+              await new Promise((resolve2, reject) => {
+                child.on("close", () => resolve2());
+                child.on("error", (err) => reject(err));
+              });
             }
           },
           generateShellCommand(context) {
             const projectPath = context.project.path.path;
-            return [`cd "${projectPath}"`];
+            return [`pushd "${projectPath}" > /dev/null`];
           }
         };
       }
@@ -421,7 +543,7 @@ var init_ide = __esm({
             const projectPath = project.path.path;
             const ide = project.ide || "code";
             if (isShellMode) {
-              shellCommands.push(`${ide} "${projectPath}" &`);
+              shellCommands.push(`set +m; ${ide} "${projectPath}" &>/dev/null &`);
             } else {
               spawn2(ide, [projectPath], {
                 detached: true,
@@ -432,7 +554,7 @@ var init_ide = __esm({
           generateShellCommand(context) {
             const projectPath = context.project.path.path;
             const ide = context.project.ide || "code";
-            return [`${ide} "${projectPath}" &`];
+            return [`set +m; ${ide} "${projectPath}" &>/dev/null &`];
           }
         };
       }
@@ -628,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 {
@@ -1094,12 +1216,213 @@ var init_registry = __esm({
   }
 });
 
+// src/lib/sanitize.ts
+function sanitizeForShell(input6) {
+  if (!input6) return "";
+  return input6.replace(/[^a-zA-Z0-9_\-.]/g, "_");
+}
+function escapeForSingleQuotes(input6) {
+  if (!input6) return "";
+  return input6.replace(/'/g, "'\\''");
+}
+var init_sanitize = __esm({
+  "src/lib/sanitize.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/tmux.ts
+import { exec as execCallback, spawn as spawn7 } from "child_process";
+import { promisify } from "util";
+var exec, TmuxManager;
+var init_tmux = __esm({
+  "src/lib/tmux.ts"() {
+    "use strict";
+    init_sanitize();
+    exec = promisify(execCallback);
+    TmuxManager = class {
+      sessionPrefix = "workon-";
+      async isTmuxAvailable() {
+        try {
+          await exec("which tmux");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async sessionExists(sessionName) {
+        try {
+          await exec(`tmux has-session -t '${escapeForSingleQuotes(sessionName)}'`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      getSessionName(projectName) {
+        return `${this.sessionPrefix}${sanitizeForShell(projectName)}`;
+      }
+      async killSession(sessionName) {
+        try {
+          await exec(`tmux kill-session -t '${escapeForSingleQuotes(sessionName)}'`);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      async createSplitSession(projectName, projectPath, claudeArgs = []) {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        if (await this.sessionExists(sessionName)) {
+          await this.killSession(sessionName);
+        }
+        const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+        const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+        await exec(
+          `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
+        );
+        await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
+        await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+        return sessionName;
+      }
+      async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        if (await this.sessionExists(sessionName)) {
+          await this.killSession(sessionName);
+        }
+        const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+        const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+        const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+        await exec(
+          `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
+        );
+        await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
+        await exec(
+          `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`
+        );
+        await exec(`tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`);
+        await exec(`tmux resize-pane -t '${escapedSession}:0.2' -y 10`);
+        await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+        return sessionName;
+      }
+      async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+        if (await this.sessionExists(sessionName)) {
+          await this.killSession(sessionName);
+        }
+        await exec(`tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`);
+        await exec(
+          `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`
+        );
+        await exec(`tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`);
+        await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
+        return sessionName;
+      }
+      async attachToSession(sessionName) {
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        if (process.env.TMUX) {
+          await exec(`tmux switch-client -t '${escapedSession}'`);
+        } else {
+          const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || !!process.env.ITERM_SESSION_ID;
+          const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+          if (useiTermIntegration) {
+            spawn7("tmux", ["-CC", "attach-session", "-t", sessionName], {
+              stdio: "inherit",
+              detached: true
+            });
+          } else {
+            spawn7("tmux", ["attach-session", "-t", sessionName], {
+              stdio: "inherit",
+              detached: true
+            });
+          }
+        }
+      }
+      buildShellCommands(projectName, projectPath, claudeArgs = []) {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+        const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+        return [
+          `# Create tmux split session for ${sanitizeForShell(projectName)}`,
+          `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+          `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
+          `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
+          `tmux select-pane -t '${escapedSession}:0.0'`,
+          this.getAttachCommand(sessionName)
+        ];
+      }
+      buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
+        const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
+        const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+        return [
+          `# Create tmux three-pane session for ${sanitizeForShell(projectName)}`,
+          `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+          `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
+          `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
+          `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`,
+          `tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`,
+          `tmux resize-pane -t '${escapedSession}:0.2' -y 10`,
+          `tmux select-pane -t '${escapedSession}:0.0'`,
+          this.getAttachCommand(sessionName)
+        ];
+      }
+      buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
+        const sessionName = this.getSessionName(projectName);
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        const escapedPath = escapeForSingleQuotes(projectPath);
+        const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
+        return [
+          `# Create tmux two-pane session with npm for ${sanitizeForShell(projectName)}`,
+          `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
+          `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`,
+          `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`,
+          `tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`,
+          `tmux select-pane -t '${escapedSession}:0.0'`,
+          this.getAttachCommand(sessionName)
+        ];
+      }
+      getAttachCommand(sessionName) {
+        const escapedSession = escapeForSingleQuotes(sessionName);
+        if (process.env.TMUX) {
+          return `tmux switch-client -t '${escapedSession}'`;
+        }
+        const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || process.env.ITERM_SESSION_ID;
+        const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
+        if (useiTermIntegration) {
+          return `tmux -CC attach-session -t '${escapedSession}'`;
+        }
+        return `tmux attach-session -t '${escapedSession}'`;
+      }
+      async listWorkonSessions() {
+        try {
+          const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
+          return stdout.trim().split("\n").filter((session) => session.startsWith(this.sessionPrefix)).map((session) => session.replace(this.sessionPrefix, ""));
+        } catch {
+          return [];
+        }
+      }
+    };
+  }
+});
+
 // src/types/constants.ts
 var IDE_CHOICES;
 var init_constants = __esm({
   "src/types/constants.ts"() {
     "use strict";
     IDE_CHOICES = [
+      { name: "Cursor", value: "cursor" },
       { name: "Visual Studio Code", value: "vscode" },
       { name: "Visual Studio Code (code)", value: "code" },
       { name: "IntelliJ IDEA", value: "idea" },
@@ -1264,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!`);
 }
@@ -1286,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!`);
 }
@@ -1485,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!`);
   }
 }
@@ -1563,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!`);
   }
 }
@@ -1589,7 +1910,7 @@ async function deleteProjectManage(ctx) {
     });
     if (deleteAll) {
       for (const branch of branches) {
-        config.deleteProject(branch);
+        await config.deleteProjectSafe(branch);
       }
     }
   }
@@ -1598,7 +1919,7 @@ async function deleteProjectManage(ctx) {
     default: false
   });
   if (confirmed) {
-    config.deleteProject(name);
+    await config.deleteProjectSafe(name);
     log.info(`Project '${name}' deleted.`);
   }
 }
@@ -1678,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!`);
   }
 }
@@ -1703,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.`);
   }
 }
@@ -1732,215 +2053,21 @@ var init_interactive = __esm({
   }
 });
 
-// src/commands/index.ts
-init_config();
-init_environment();
-init_registry();
-import { Command as Command8 } from "commander";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import loog from "loog";
-import omelette from "omelette";
-import File7 from "phylo";
-
 // src/commands/open.ts
-init_environment();
+var open_exports = {};
+__export(open_exports, {
+  createOpenCommand: () => createOpenCommand,
+  runOpen: () => runOpen
+});
 import { Command } from "commander";
 import File4 from "phylo";
-
-// src/lib/tmux.ts
-import { exec as execCallback, spawn as spawn7 } from "child_process";
-import { promisify } from "util";
-
-// src/lib/sanitize.ts
-function sanitizeForShell(input6) {
-  if (!input6) return "";
-  return input6.replace(/[^a-zA-Z0-9_\-.]/g, "_");
-}
-function escapeForSingleQuotes(input6) {
-  if (!input6) return "";
-  return input6.replace(/'/g, "'\\''");
-}
-
-// src/lib/tmux.ts
-var exec = promisify(execCallback);
-var TmuxManager = class {
-  sessionPrefix = "workon-";
-  async isTmuxAvailable() {
-    try {
-      await exec("which tmux");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async sessionExists(sessionName) {
-    try {
-      await exec(`tmux has-session -t '${escapeForSingleQuotes(sessionName)}'`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  getSessionName(projectName) {
-    return `${this.sessionPrefix}${sanitizeForShell(projectName)}`;
-  }
-  async killSession(sessionName) {
-    try {
-      await exec(`tmux kill-session -t '${escapeForSingleQuotes(sessionName)}'`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async createSplitSession(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
-    await exec(
-      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
-    );
-    await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
-    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
-    return sessionName;
-  }
-  async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
-    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
-    await exec(
-      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`
-    );
-    await exec(`tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`);
-    await exec(
-      `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`
-    );
-    await exec(`tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`);
-    await exec(`tmux resize-pane -t '${escapedSession}:0.2' -y 10`);
-    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
-    return sessionName;
-  }
-  async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    await exec(`tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`);
-    await exec(
-      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`
-    );
-    await exec(`tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`);
-    await exec(`tmux select-pane -t '${escapedSession}:0.0'`);
-    return sessionName;
-  }
-  async attachToSession(sessionName) {
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    if (process.env.TMUX) {
-      await exec(`tmux switch-client -t '${escapedSession}'`);
-    } else {
-      const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || !!process.env.ITERM_SESSION_ID;
-      const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
-      if (useiTermIntegration) {
-        spawn7("tmux", ["-CC", "attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      } else {
-        spawn7("tmux", ["attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      }
-    }
-  }
-  buildShellCommands(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
-    return [
-      `# Create tmux split session for ${sanitizeForShell(projectName)}`,
-      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
-      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
-      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
-      `tmux select-pane -t '${escapedSession}:0.0'`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    const escapedClaudeCmd = escapeForSingleQuotes(claudeCommand);
-    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
-    return [
-      `# Create tmux three-pane session for ${sanitizeForShell(projectName)}`,
-      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
-      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}' '${escapedClaudeCmd}'`,
-      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}'`,
-      `tmux split-window -v -t '${escapedSession}:0.1' -c '${escapedPath}' '${escapedNpmCmd}'`,
-      `tmux set-option -t '${escapedSession}:0.2' remain-on-exit on`,
-      `tmux resize-pane -t '${escapedSession}:0.2' -y 10`,
-      `tmux select-pane -t '${escapedSession}:0.0'`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    const escapedPath = escapeForSingleQuotes(projectPath);
-    const escapedNpmCmd = escapeForSingleQuotes(npmCommand);
-    return [
-      `# Create tmux two-pane session with npm for ${sanitizeForShell(projectName)}`,
-      `tmux has-session -t '${escapedSession}' 2>/dev/null && tmux kill-session -t '${escapedSession}'`,
-      `tmux new-session -d -s '${escapedSession}' -c '${escapedPath}'`,
-      `tmux split-window -h -t '${escapedSession}' -c '${escapedPath}' '${escapedNpmCmd}'`,
-      `tmux set-option -t '${escapedSession}:0.1' remain-on-exit on`,
-      `tmux select-pane -t '${escapedSession}:0.0'`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  getAttachCommand(sessionName) {
-    const escapedSession = escapeForSingleQuotes(sessionName);
-    if (process.env.TMUX) {
-      return `tmux switch-client -t '${escapedSession}'`;
-    }
-    const isITerm = process.env.TERM_PROGRAM === "iTerm.app" || process.env.LC_TERMINAL === "iTerm2" || process.env.ITERM_SESSION_ID;
-    const useiTermIntegration = isITerm && !process.env.TMUX_CC_NOT_SUPPORTED;
-    if (useiTermIntegration) {
-      return `tmux -CC attach-session -t '${escapedSession}'`;
-    }
-    return `tmux attach-session -t '${escapedSession}'`;
-  }
-  async listWorkonSessions() {
-    try {
-      const { stdout } = await exec('tmux list-sessions -F "#{session_name}"');
-      return stdout.trim().split("\n").filter((session) => session.startsWith(this.sessionPrefix)).map((session) => session.replace(this.sessionPrefix, ""));
-    } catch {
-      return [];
-    }
+async function runOpen(projectArg, options, ctx) {
+  const { log } = ctx;
+  if (options.debug) {
+    log.setLogLevel("debug");
   }
-};
-
-// src/commands/open.ts
-init_registry();
+  await processProject(projectArg, options, ctx);
+}
 function createOpenCommand(ctx) {
   const { config, log } = ctx;
   const command = new Command("open").description("Open a project by passing its project id").argument("[project]", "The id of the project to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("-n, --dry-run", "Show what would happen without executing").option("--shell", "Output shell commands instead of spawning processes").action(async (projectArg, options) => {
@@ -1985,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) {
@@ -2055,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;
@@ -2069,12 +2197,25 @@ async function handleTmuxLayout(project, layout, options, shellCommands, events,
   let tmuxHandled = false;
   if (isShellMode) {
     if (await tmux.isTmuxAvailable()) {
+      const remainingEvents = events.filter((e) => !layout.handledEvents.includes(e));
+      for (const event of remainingEvents) {
+        const eventHandler = EventRegistry.getEventByName(event);
+        if (eventHandler) {
+          const cmds = eventHandler.processing.generateShellCommand({
+            project,
+            isShellMode: true,
+            shellCommands: []
+          });
+          shellCommands.push(...cmds);
+        }
+      }
       const commands = buildLayoutShellCommands(tmux, project, layout);
       shellCommands.push(...commands);
       tmuxHandled = true;
     } else {
       log.debug("Tmux not available, falling back to normal mode");
-      buildFallbackCommands(shellCommands, project, layout);
+      const remainingEvents = events.filter((e) => !layout.handledEvents.includes(e));
+      buildFallbackCommandsWithEvents(shellCommands, project, layout, remainingEvents, ctx);
       tmuxHandled = true;
     }
   } else if (!dryRun) {
@@ -2098,7 +2239,7 @@ async function handleTmuxLayout(project, layout, options, shellCommands, events,
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
   }
-  if (!dryRun) {
+  if (!dryRun && !isShellMode) {
     for (const event of events.filter((e) => !layout.handledEvents.includes(e))) {
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
@@ -2119,14 +2260,19 @@ function buildLayoutShellCommands(tmux, project, layout) {
       return tmux.buildTwoPaneNpmShellCommands(project.name, project.path.path, layout.npmCommand);
   }
 }
-function buildFallbackCommands(shellCommands, project, layout) {
-  shellCommands.push(`cd "${project.path.path}"`);
-  if (layout.type === "split-claude" || layout.type === "three-pane") {
-    const claudeCommand = layout.claudeArgs.length > 0 ? `claude ${layout.claudeArgs.join(" ")}` : "claude";
-    shellCommands.push(claudeCommand);
-  }
-  if (layout.npmCommand) {
-    shellCommands.push(layout.npmCommand);
+function buildFallbackCommandsWithEvents(shellCommands, project, layout, remainingEvents, _ctx) {
+  shellCommands.push(`echo "\u26A0 tmux not available - install with: brew install tmux" >&2`);
+  shellCommands.push(`pushd "${project.path.path}" > /dev/null`);
+  for (const event of remainingEvents) {
+    const eventHandler = EventRegistry.getEventByName(event);
+    if (eventHandler) {
+      const cmds = eventHandler.processing.generateShellCommand({
+        project,
+        isShellMode: true,
+        shellCommands: []
+      });
+      shellCommands.push(...cmds);
+    }
   }
 }
 async function createTmuxSession(tmux, project, layout) {
@@ -2227,6 +2373,27 @@ Available commands for '${projectName}':`);
   console.log(`  workon ${projectName}:cwd --shell       # Output shell commands
 `);
 }
+var init_open = __esm({
+  "src/commands/open.ts"() {
+    "use strict";
+    init_environment();
+    init_tmux();
+    init_registry();
+  }
+});
+
+// src/commands/index.ts
+init_config();
+init_environment();
+init_registry();
+init_open();
+import { Command as Command8 } from "commander";
+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";
+import File7 from "phylo";
 
 // src/commands/config/index.ts
 import { Command as Command5 } from "commander";
@@ -2449,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 {
@@ -2539,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.");
@@ -2562,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.");
@@ -2588,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";
@@ -2610,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);
   }
@@ -2644,7 +2811,7 @@ async function addProject(pathArg, options, ctx) {
       return;
     }
   }
-  const ide = options.ide || discovery.detectedIde || "vscode";
+  const ide = options.ide || discovery.detectedIde || "code";
   log.debug(`IDE: ${ide}`);
   let relativePath = targetPath;
   if (defaults?.base) {
@@ -2672,7 +2839,10 @@ async function addProject(pathArg, options, ctx) {
       projectConfig.events.npm = scripts.dev ? "dev" : "start";
     }
   }
-  config.setProject(projectName, projectConfig);
+  if (discovery.hasClaude) {
+    projectConfig.events.claude = true;
+  }
+  await config.setProjectSafe(projectName, projectConfig);
   log.info(`Added project '${projectName}'`);
   log.info(`  Path: ${relativePath}`);
   log.info(`  IDE: ${ide}`);
@@ -2686,11 +2856,12 @@ function discoverProject(targetPath, log) {
     name: dirName,
     isNode: false,
     isBun: false,
+    hasClaude: false,
     detectedIde: null,
     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 {
@@ -2706,25 +2877,34 @@ 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(vscodeDir)) {
-    discovery.detectedIde = "vscode";
+  if (existsSync2(cursorDir)) {
+    discovery.detectedIde = "cursor";
+    log.debug("Detected Cursor (.cursor directory found)");
+  } 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 (existsSync2(claudeMdPath)) {
+    discovery.hasClaude = true;
+    log.debug("Detected Claude Code project (CLAUDE.md found)");
+  }
   return discovery;
 }
 
 // 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"),
@@ -2732,7 +2912,7 @@ function findPackageJson() {
     join(process.cwd(), "package.json")
   ];
   for (const p of paths) {
-    if (existsSync2(p)) {
+    if (existsSync3(p)) {
       return p;
     }
   }
@@ -2750,7 +2930,7 @@ function createCli() {
   config.set("pkg", packageJson);
   EnvironmentRecognizer.configure(config, log);
   const completion = setupCompletion(config);
-  program2.name("workon").description("Work on something great!").version(packageJson.version).argument("[project]", "Project name to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", async (thisCommand) => {
+  program2.name("workon").description("Work on something great!").version(packageJson.version).enablePositionalOptions().argument("[project]", "Project name to open (supports project:command syntax)").option("-d, --debug", "Enable debug logging").option("--completion", "Setup shell tab completion").option("--shell", "Output shell commands for evaluation").option("--init", "Generate shell integration function").hook("preAction", async (thisCommand) => {
     const opts = thisCommand.opts();
     if (opts.debug) {
       log.setLogLevel("debug");
@@ -2772,10 +2952,8 @@ function createCli() {
         return;
       }
       if (project) {
-        const args = ["open", project];
-        if (options.shell) args.push("--shell");
-        if (options.debug) args.push("--debug");
-        await program2.parseAsync(["node", "workon", ...args]);
+        const { runOpen: runOpen2 } = await Promise.resolve().then(() => (init_open(), open_exports));
+        await runOpen2(project, { debug: options.debug, shell: options.shell }, { config, log });
         return;
       }
       const environment = await EnvironmentRecognizer.recognize(File7.cwd());
@@ -2874,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