workon 3.2.0 → 3.2.2

package/dist/cli.js

@@ -236,7 +236,8 @@ var init_environment = __esm({
             const git = simpleGit(gitDir.path);
             const branchSummary = await git.branchLocal();
             base.branch = branchSummary.current;
-          } catch {
+          } catch (error) {
+            this.log.debug(`Git branch detection failed: ${error.message}`);
           }
         }
         return this.getProjectEnvironment(base, matching);
@@ -302,7 +303,7 @@ var init_environment = __esm({
 });
 
 // src/events/core/cwd.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 var CwdEvent;
 var init_cwd = __esm({
   "src/events/core/cwd.ts"() {
@@ -344,18 +345,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";
-              spawn2(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`];
           }
         };
       }
@@ -377,7 +382,7 @@ var init_cwd = __esm({
 });
 
 // src/events/core/ide.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var IdeEvent;
 var init_ide = __esm({
   "src/events/core/ide.ts"() {
@@ -420,9 +425,9 @@ 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 {
-              spawn3(ide, [projectPath], {
+              spawn2(ide, [projectPath], {
                 detached: true,
                 stdio: "ignore"
               }).unref();
@@ -431,7 +436,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 &`];
           }
         };
       }
@@ -453,7 +458,7 @@ var init_ide = __esm({
 });
 
 // src/events/core/web.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { platform } from "os";
 var WebEvent;
 var init_web = __esm({
@@ -514,7 +519,7 @@ var init_web = __esm({
             if (isShellMode) {
               shellCommands.push(`${openCmd} "${homepage}" &`);
             } else {
-              spawn4(openCmd, [homepage], {
+              spawn3(openCmd, [homepage], {
                 detached: true,
                 stdio: "ignore"
               }).unref();
@@ -546,7 +551,7 @@ var init_web = __esm({
 });
 
 // src/events/extensions/claude.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { input, confirm } from "@inquirer/prompts";
 var ClaudeEvent;
 var init_claude = __esm({
@@ -642,7 +647,7 @@ var init_claude = __esm({
               shellCommands.push(claudeCommand);
             } else {
               const args = claudeCommand.split(" ").slice(1);
-              spawn5("claude", args, {
+              spawn4("claude", args, {
                 cwd: project.path.path,
                 stdio: "inherit"
               });
@@ -686,7 +691,7 @@ var init_claude = __esm({
 });
 
 // src/events/extensions/docker.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { input as input2 } from "@inquirer/prompts";
 var DockerEvent;
 var init_docker = __esm({
@@ -784,7 +789,7 @@ var init_docker = __esm({
               shellCommands.push(dockerCommand);
             } else {
               const [cmd, ...args] = dockerCommand.split(" ");
-              spawn6(cmd, args, {
+              spawn5(cmd, args, {
                 cwd: project.path.path,
                 stdio: "inherit"
               });
@@ -823,7 +828,7 @@ __export(npm_exports, {
   NpmEvent: () => NpmEvent,
   default: () => npm_default
 });
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { input as input3, confirm as confirm2 } from "@inquirer/prompts";
 var NpmEvent, npm_default;
 var init_npm = __esm({
@@ -924,7 +929,7 @@ var init_npm = __esm({
               shellCommands.push(npmCommand);
             } else {
               const [cmd, ...args] = npmCommand.split(" ");
-              spawn7(cmd, args, {
+              spawn6(cmd, args, {
                 cwd: project.path.path,
                 stdio: "inherit"
               });
@@ -993,23 +998,19 @@ var init_registry = __esm({
        */
       registerEvents() {
         for (const EventClass of ALL_EVENTS) {
-          if (this.isValidEvent(EventClass)) {
-            const metadata = EventClass.metadata;
-            this._events.set(metadata.name, EventClass);
+          if (this.isValidEventClass(EventClass)) {
+            this._events.set(EventClass.metadata.name, EventClass);
           }
         }
       }
       /**
-       * Validate if a class is a proper event
+       * Type guard to check if an object is a valid EventHandlerClass
        */
-      isValidEvent(EventClass) {
-        try {
-          if (typeof EventClass !== "function") return false;
-          const metadata = EventClass.metadata;
-          return metadata !== void 0 && typeof metadata.name === "string" && typeof metadata.displayName === "string" && typeof EventClass.validation === "object" && typeof EventClass.configuration === "object" && typeof EventClass.processing === "object";
-        } catch {
-          return false;
-        }
+      isValidEventClass(obj) {
+        if (typeof obj !== "function" && typeof obj !== "object") return false;
+        if (obj === null) return false;
+        const candidate = obj;
+        return candidate.metadata !== void 0 && typeof candidate.metadata.name === "string" && typeof candidate.metadata.displayName === "string" && candidate.validation !== void 0 && typeof candidate.validation.validateConfig === "function" && candidate.configuration !== void 0 && typeof candidate.configuration.configureInteractive === "function" && candidate.processing !== void 0 && typeof candidate.processing.processEvent === "function";
       }
       /**
        * Get all valid event names from registered events
@@ -1031,12 +1032,11 @@ var init_registry = __esm({
       getEventsForManageUI() {
         this.ensureInitialized();
         const events = [];
-        for (const [name, EventClass] of this._events) {
-          const metadata = EventClass.metadata;
+        for (const [name, eventClass] of this._events) {
           events.push({
-            name: metadata.displayName,
+            name: eventClass.metadata.displayName,
             value: name,
-            description: metadata.description
+            description: eventClass.metadata.description
           });
         }
         return events.sort((a, b) => a.name.localeCompare(b.name));
@@ -1047,13 +1047,13 @@ var init_registry = __esm({
       getTmuxEnabledEvents() {
         this.ensureInitialized();
         const tmuxEvents = [];
-        for (const [name, EventClass] of this._events) {
-          const tmux = EventClass.tmux;
+        for (const [name, eventClass] of this._events) {
+          const tmux = eventClass.tmux;
           if (tmux) {
             tmuxEvents.push({
               name,
-              event: EventClass,
-              priority: tmux.getLayoutPriority ? tmux.getLayoutPriority() : 0
+              event: eventClass,
+              priority: tmux.getLayoutPriority()
             });
           }
         }
@@ -1065,16 +1065,15 @@ var init_registry = __esm({
       getAllEvents() {
         this.ensureInitialized();
         const events = [];
-        for (const [name, EventClass] of this._events) {
-          const typedClass = EventClass;
+        for (const [name, eventClass] of this._events) {
           events.push({
             name,
-            metadata: typedClass.metadata,
-            hasValidation: !!typedClass.validation,
-            hasConfiguration: !!typedClass.configuration,
-            hasProcessing: !!typedClass.processing,
-            hasTmux: !!typedClass.tmux,
-            hasHelp: !!typedClass.help
+            metadata: eventClass.metadata,
+            hasValidation: !!eventClass.validation,
+            hasConfiguration: !!eventClass.configuration,
+            hasProcessing: !!eventClass.processing,
+            hasTmux: !!eventClass.tmux,
+            hasHelp: !!eventClass.help
           });
         }
         return events;
@@ -1099,6 +1098,224 @@ 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" },
+      { name: "Atom", value: "atom" },
+      { name: "Sublime Text", value: "subl" },
+      { name: "Vim", value: "vim" },
+      { name: "Emacs", value: "emacs" }
+    ];
+  }
+});
+
 // src/commands/interactive.ts
 var interactive_exports = {};
 __export(interactive_exports, {
@@ -1270,8 +1487,10 @@ async function initBranch(defaultName, ctx) {
   });
   const branchName = `${defaultName}#${branch}`;
   const baseProject = projects[defaultName];
-  const branchConfig = deepAssign2({}, baseProject, { branch });
-  delete branchConfig.name;
+  const { name: _excludedName, ...mergedConfig } = deepAssign2({}, baseProject, {
+    branch
+  });
+  const branchConfig = mergedConfig;
   projects[branchName] = branchConfig;
   config.set("projects", projects);
   log.info("Your branch configuration has been initialized.");
@@ -1315,7 +1534,6 @@ async function switchBranch(projectName, ctx) {
 }
 async function manageProjects(ctx) {
   const { config } = ctx;
-  await EventRegistry.initialize();
   const projects = config.getProjects();
   const hasProjects = Object.keys(projects).length > 0;
   const choices = [
@@ -1392,7 +1610,6 @@ async function openProject(projectName, ctx) {
     log.error(`Project '${projectName}' not found.`);
     return;
   }
-  await EventRegistry.initialize();
   const projectConfig = projects[projectName];
   const projectCfg = { ...projectConfig, name: projectName };
   const projectEnv = ProjectEnvironment.load(projectCfg, config.getDefaults());
@@ -1402,7 +1619,7 @@ async function openProject(projectName, ctx) {
   );
   for (const event of events) {
     const eventHandler = EventRegistry.getEventByName(event);
-    if (eventHandler && eventHandler.processing) {
+    if (eventHandler) {
       await eventHandler.processing.processEvent({
         project: projectEnv.project,
         isShellMode: false,
@@ -1711,193 +1928,36 @@ Branch configurations for '${projectName}':
     console.log();
   }
 }
-var IDE_CHOICES;
 var init_interactive = __esm({
   "src/commands/interactive.ts"() {
     "use strict";
     init_environment();
     init_registry();
-    IDE_CHOICES = [
-      { name: "Visual Studio Code", value: "vscode" },
-      { name: "IntelliJ IDEA", value: "idea" },
-      { name: "Atom", value: "atom" }
-    ];
+    init_constants();
   }
 });
 
-// src/commands/index.ts
-init_config();
-init_environment();
-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 } from "child_process";
-import { promisify } from "util";
-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 "${sessionName}"`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  getSessionName(projectName) {
-    return `${this.sessionPrefix}${projectName}`;
-  }
-  async killSession(sessionName) {
-    try {
-      await exec(`tmux kill-session -t "${sessionName}"`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async createSplitSession(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async createThreePaneSession(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`);
-    await exec(`tmux set-option -t "${sessionName}:0.2" remain-on-exit on`);
-    await exec(`tmux resize-pane -t "${sessionName}:0.2" -y 10`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async createTwoPaneNpmSession(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    if (await this.sessionExists(sessionName)) {
-      await this.killSession(sessionName);
-    }
-    await exec(`tmux new-session -d -s "${sessionName}" -c "${projectPath}"`);
-    await exec(`tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`);
-    await exec(`tmux set-option -t "${sessionName}:0.1" remain-on-exit on`);
-    await exec(`tmux select-pane -t "${sessionName}:0.0"`);
-    return sessionName;
-  }
-  async attachToSession(sessionName) {
-    if (process.env.TMUX) {
-      await exec(`tmux switch-client -t "${sessionName}"`);
-    } 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) {
-        spawn("tmux", ["-CC", "attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      } else {
-        spawn("tmux", ["attach-session", "-t", sessionName], {
-          stdio: "inherit",
-          detached: true
-        });
-      }
-    }
-  }
-  buildShellCommands(projectName, projectPath, claudeArgs = []) {
-    const sessionName = this.getSessionName(projectName);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    return [
-      `# Create tmux split session for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildThreePaneShellCommands(projectName, projectPath, claudeArgs = [], npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-    return [
-      `# Create tmux three-pane session for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}" '${claudeCommand}'`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}"`,
-      `tmux split-window -v -t "${sessionName}:0.1" -c "${projectPath}" '${npmCommand}'`,
-      `tmux set-option -t "${sessionName}:0.2" remain-on-exit on`,
-      `tmux resize-pane -t "${sessionName}:0.2" -y 10`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  buildTwoPaneNpmShellCommands(projectName, projectPath, npmCommand = "npm run dev") {
-    const sessionName = this.getSessionName(projectName);
-    return [
-      `# Create tmux two-pane session with npm for ${projectName}`,
-      `tmux has-session -t "${sessionName}" 2>/dev/null && tmux kill-session -t "${sessionName}"`,
-      `tmux new-session -d -s "${sessionName}" -c "${projectPath}"`,
-      `tmux split-window -h -t "${sessionName}" -c "${projectPath}" '${npmCommand}'`,
-      `tmux set-option -t "${sessionName}:0.1" remain-on-exit on`,
-      `tmux select-pane -t "${sessionName}:0.0"`,
-      this.getAttachCommand(sessionName)
-    ];
-  }
-  getAttachCommand(sessionName) {
-    if (process.env.TMUX) {
-      return `tmux switch-client -t "${sessionName}"`;
-    }
-    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 "${sessionName}"`;
-    }
-    return `tmux attach-session -t "${sessionName}"`;
-  }
-  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) => {
     if (options.debug) {
       log.setLogLevel("debug");
     }
-    await EventRegistry.initialize();
     if (projectArg) {
       await processProject(projectArg, options, ctx);
     } else {
@@ -2004,32 +2064,47 @@ function resolveCommandDependencies(requestedCommands, project) {
   }
   return [...new Set(resolved)];
 }
-async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+function getClaudeArgs(project) {
+  const claudeConfig = project.events.claude;
+  return typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+}
+async function getNpmCommand(project) {
+  const npmConfig = project.events.npm;
+  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
+  return NpmEvent2.getNpmCommand(npmConfig);
+}
+async function handleTmuxLayout(project, layout, options, shellCommands, events, ctx) {
   const { log } = ctx;
   const tmux = new TmuxManager();
-  const claudeConfig = project.events.claude;
-  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
+  const { isShellMode, dryRun } = options;
   let tmuxHandled = false;
   if (isShellMode) {
     if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildShellCommands(project.name, project.path.path, claudeArgs);
+      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");
-      shellCommands.push(`cd "${project.path.path}"`);
-      const claudeCommand = claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude";
-      shellCommands.push(claudeCommand);
+      const remainingEvents = events.filter((e) => !layout.handledEvents.includes(e));
+      buildFallbackCommandsWithEvents(shellCommands, project, layout, remainingEvents, ctx);
       tmuxHandled = true;
     }
   } else if (!dryRun) {
     if (await tmux.isTmuxAvailable()) {
       try {
-        const sessionName = await tmux.createSplitSession(
-          project.name,
-          project.path.path,
-          claudeArgs
-        );
+        const sessionName = await createTmuxSession(tmux, project, layout);
         await tmux.attachToSession(sessionName);
         tmuxHandled = true;
       } catch (error) {
@@ -2039,139 +2114,108 @@ async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands,
       log.debug("Tmux not available, falling back to normal event processing");
     }
   } else {
-    log.info(`Would create split tmux session '${project.name}' with Claude`);
+    log.info(layout.dryRunMessage);
     tmuxHandled = true;
   }
   if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "claude"].includes(e))) {
+    for (const event of events.filter((e) => layout.handledEvents.includes(e))) {
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
   }
-  if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "claude"].includes(e))) {
+  if (!dryRun && !isShellMode) {
+    for (const event of events.filter((e) => !layout.handledEvents.includes(e))) {
       await processEvent(event, { project, isShellMode, shellCommands }, ctx);
     }
   }
 }
-async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
-  const { log } = ctx;
-  const tmux = new TmuxManager();
-  const claudeConfig = project.events.claude;
-  const claudeArgs = typeof claudeConfig === "object" && claudeConfig.flags ? claudeConfig.flags : [];
-  const npmConfig = project.events.npm;
-  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
-  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
-  let tmuxHandled = false;
-  if (isShellMode) {
-    if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildThreePaneShellCommands(
+function buildLayoutShellCommands(tmux, project, layout) {
+  switch (layout.type) {
+    case "split-claude":
+      return tmux.buildShellCommands(project.name, project.path.path, layout.claudeArgs);
+    case "three-pane":
+      return tmux.buildThreePaneShellCommands(
         project.name,
         project.path.path,
-        claudeArgs,
-        npmCommand
+        layout.claudeArgs,
+        layout.npmCommand
       );
-      shellCommands.push(...commands);
-      tmuxHandled = true;
-    } else {
-      log.debug("Tmux not available, falling back to normal mode");
-      shellCommands.push(`cd "${project.path.path}"`);
-      shellCommands.push(claudeArgs.length > 0 ? `claude ${claudeArgs.join(" ")}` : "claude");
-      shellCommands.push(npmCommand);
-      tmuxHandled = true;
-    }
-  } else if (!dryRun) {
-    if (await tmux.isTmuxAvailable()) {
-      try {
-        const sessionName = await tmux.createThreePaneSession(
-          project.name,
-          project.path.path,
-          claudeArgs,
-          npmCommand
-        );
-        await tmux.attachToSession(sessionName);
-        tmuxHandled = true;
-      } catch (error) {
-        log.debug(`Failed to create tmux session: ${error.message}`);
-      }
-    } else {
-      log.debug("Tmux not available, falling back to normal event processing");
-    }
-  } else {
-    log.info(`Would create three-pane tmux session '${project.name}' with Claude and NPM`);
-    tmuxHandled = true;
-  }
-  if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+    case "two-pane-npm":
+      return tmux.buildTwoPaneNpmShellCommands(project.name, project.path.path, layout.npmCommand);
   }
-  if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
+}
+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 handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
-  const { log } = ctx;
-  const tmux = new TmuxManager();
-  const npmConfig = project.events.npm;
-  const { NpmEvent: NpmEvent2 } = await Promise.resolve().then(() => (init_npm(), npm_exports));
-  const npmCommand = NpmEvent2.getNpmCommand(npmConfig);
-  let tmuxHandled = false;
-  if (isShellMode) {
-    if (await tmux.isTmuxAvailable()) {
-      const commands = tmux.buildTwoPaneNpmShellCommands(
+async function createTmuxSession(tmux, project, layout) {
+  switch (layout.type) {
+    case "split-claude":
+      return tmux.createSplitSession(project.name, project.path.path, layout.claudeArgs);
+    case "three-pane":
+      return tmux.createThreePaneSession(
         project.name,
         project.path.path,
-        npmCommand
+        layout.claudeArgs,
+        layout.npmCommand
       );
-      shellCommands.push(...commands);
-      tmuxHandled = true;
-    } else {
-      log.debug("Tmux not available, falling back to normal mode");
-      shellCommands.push(`cd "${project.path.path}"`);
-      shellCommands.push(npmCommand);
-      tmuxHandled = true;
-    }
-  } else if (!dryRun) {
-    if (await tmux.isTmuxAvailable()) {
-      try {
-        const sessionName = await tmux.createTwoPaneNpmSession(
-          project.name,
-          project.path.path,
-          npmCommand
-        );
-        await tmux.attachToSession(sessionName);
-        tmuxHandled = true;
-      } catch (error) {
-        log.debug(`Failed to create tmux session: ${error.message}`);
-      }
-    } else {
-      log.debug("Tmux not available, falling back to normal event processing");
-    }
-  } else {
-    log.info(`Would create two-pane tmux session '${project.name}' with NPM`);
-    tmuxHandled = true;
-  }
-  if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
-  }
-  if (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+    case "two-pane-npm":
+      return tmux.createTwoPaneNpmSession(project.name, project.path.path, layout.npmCommand);
   }
 }
+async function handleSplitTerminal(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "split-claude",
+    handledEvents: ["cwd", "claude"],
+    dryRunMessage: `Would create split tmux session '${project.name}' with Claude`,
+    claudeArgs: getClaudeArgs(project),
+    npmCommand: null
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
+async function handleThreePaneLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "three-pane",
+    handledEvents: ["cwd", "claude", "npm"],
+    dryRunMessage: `Would create three-pane tmux session '${project.name}' with Claude and NPM`,
+    claudeArgs: getClaudeArgs(project),
+    npmCommand: await getNpmCommand(project)
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
+async function handleTwoPaneNpmLayout(project, isShellMode, dryRun, shellCommands, events, ctx) {
+  const layout = {
+    type: "two-pane-npm",
+    handledEvents: ["cwd", "npm"],
+    dryRunMessage: `Would create two-pane tmux session '${project.name}' with NPM`,
+    claudeArgs: [],
+    npmCommand: await getNpmCommand(project)
+  };
+  await handleTmuxLayout(project, layout, { isShellMode, dryRun }, shellCommands, events, ctx);
+}
 async function processEvent(event, context, ctx) {
   const { log } = ctx;
   log.debug(`Processing event ${event}`);
   const eventHandler = EventRegistry.getEventByName(event);
-  if (eventHandler && eventHandler.processing) {
-    await eventHandler.processing.processEvent(context);
-  } else {
+  if (!eventHandler) {
     log.debug(`No event handler found for: ${event}`);
+    return;
+  }
+  try {
+    await eventHandler.processing.processEvent(context);
+  } catch (error) {
+    log.error(`Failed to process event '${event}': ${error.message}`);
+    log.debug(`Event error stack: ${error.stack}`);
   }
 }
 async function showProjectHelp(projectName, ctx) {
@@ -2189,17 +2233,16 @@ Available commands for '${projectName}':`);
   for (const eventName of configuredEvents) {
     const eventHandler = EventRegistry.getEventByName(eventName);
     if (eventHandler) {
-      const metadata = eventHandler.metadata;
-      const config2 = projectConfig.events[eventName];
+      const eventConfig = projectConfig.events[eventName];
       let configDesc = "";
-      if (config2 !== true && config2 !== "true") {
-        if (typeof config2 === "object") {
-          configDesc = ` (${JSON.stringify(config2)})`;
+      if (eventConfig !== true && eventConfig !== "true") {
+        if (typeof eventConfig === "object") {
+          configDesc = ` (${JSON.stringify(eventConfig)})`;
         } else {
-          configDesc = ` (${config2})`;
+          configDesc = ` (${eventConfig})`;
         }
       }
-      console.log(`  ${eventName.padEnd(8)} - ${metadata.description}${configDesc}`);
+      console.log(`  ${eventName.padEnd(8)} - ${eventHandler.metadata.description}${configDesc}`);
     }
   }
   console.log("\nUsage examples:");
@@ -2213,6 +2256,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 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/config/index.ts
 import { Command as Command5 } from "commander";
@@ -2306,25 +2370,16 @@ function createConfigCommand(ctx) {
 
 // src/commands/manage.ts
 init_registry();
+init_constants();
 import { Command as Command6 } from "commander";
 import { select as select2, input as input5, confirm as confirm4, checkbox as checkbox2 } from "@inquirer/prompts";
 import File5 from "phylo";
-var IDE_CHOICES2 = [
-  { name: "Visual Studio Code", value: "vscode" },
-  { name: "Visual Studio Code (code)", value: "code" },
-  { name: "IntelliJ IDEA", value: "idea" },
-  { name: "Atom", value: "atom" },
-  { name: "Sublime Text", value: "subl" },
-  { name: "Vim", value: "vim" },
-  { name: "Emacs", value: "emacs" }
-];
 function createManageCommand(ctx) {
   const { log } = ctx;
   return new Command6("manage").description("Interactive project management").option("-d, --debug", "Enable debug logging").action(async (options) => {
     if (options.debug) {
       log.setLogLevel("debug");
     }
-    await EventRegistry.initialize();
     await mainMenu(ctx);
   });
 }
@@ -2406,7 +2461,7 @@ async function createProject(ctx) {
   }
   const ide = await select2({
     message: "Select IDE:",
-    choices: IDE_CHOICES2
+    choices: IDE_CHOICES
   });
   const homepage = await input5({
     message: "Project homepage URL (optional):",
@@ -2483,7 +2538,7 @@ async function editProject(ctx) {
   }
   const ide = await select2({
     message: "Select IDE:",
-    choices: IDE_CHOICES2,
+    choices: IDE_CHOICES,
     default: project.ide || "vscode"
   });
   const homepage = await input5({
@@ -2639,7 +2694,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) {
@@ -2667,6 +2722,9 @@ async function addProject(pathArg, options, ctx) {
       projectConfig.events.npm = scripts.dev ? "dev" : "start";
     }
   }
+  if (discovery.hasClaude) {
+    projectConfig.events.claude = true;
+  }
   config.setProject(projectName, projectConfig);
   log.info(`Added project '${projectName}'`);
   log.info(`  Path: ${relativePath}`);
@@ -2681,6 +2739,7 @@ function discoverProject(targetPath, log) {
     name: dirName,
     isNode: false,
     isBun: false,
+    hasClaude: false,
     detectedIde: null,
     packageJson: null
   };
@@ -2706,14 +2765,23 @@ function discoverProject(targetPath, log) {
     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 (existsSync(cursorDir)) {
+    discovery.detectedIde = "cursor";
+    log.debug("Detected Cursor (.cursor directory found)");
+  } else if (existsSync(vscodeDir)) {
+    discovery.detectedIde = "code";
     log.debug("Detected VS Code (.vscode directory found)");
   } else if (existsSync(ideaDir)) {
     discovery.detectedIde = "idea";
     log.debug("Detected IntelliJ IDEA (.idea directory found)");
   }
+  const claudeMdPath = resolve(targetPath, "CLAUDE.md");
+  if (existsSync(claudeMdPath)) {
+    discovery.hasClaude = true;
+    log.debug("Detected Claude Code project (CLAUDE.md found)");
+  }
   return discovery;
 }
 
@@ -2745,11 +2813,12 @@ 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", (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");
     }
+    await EventRegistry.initialize();
   }).action(
     async (project, options) => {
       if (options.debug) {
@@ -2766,10 +2835,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());