workon 3.2.0 → 3.2.1

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"() {
@@ -347,7 +348,7 @@ var init_cwd = __esm({
               shellCommands.push(`cd "${projectPath}"`);
             } else {
               const shell = process.env.SHELL || "/bin/bash";
-              spawn2(shell, [], {
+              spawn(shell, [], {
                 cwd: projectPath,
                 stdio: "inherit"
               });
@@ -377,7 +378,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"() {
@@ -422,7 +423,7 @@ var init_ide = __esm({
             if (isShellMode) {
               shellCommands.push(`${ide} "${projectPath}" &`);
             } else {
-              spawn3(ide, [projectPath], {
+              spawn2(ide, [projectPath], {
                 detached: true,
                 stdio: "ignore"
               }).unref();
@@ -453,7 +454,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 +515,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 +547,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 +643,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 +687,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 +785,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 +824,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 +925,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 +994,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 +1028,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 +1043,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 +1061,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 +1094,23 @@ var init_registry = __esm({
   }
 });
 
+// src/types/constants.ts
+var IDE_CHOICES;
+var init_constants = __esm({
+  "src/types/constants.ts"() {
+    "use strict";
+    IDE_CHOICES = [
+      { 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 +1282,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 +1329,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 +1405,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 +1414,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,23 +1723,19 @@ 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();
+init_registry();
 import { Command as Command8 } from "commander";
 import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { join, dirname } from "path";
@@ -1742,8 +1750,20 @@ import { Command } from "commander";
 import File4 from "phylo";
 
 // src/lib/tmux.ts
-import { exec as execCallback, spawn } from "child_process";
+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-";
@@ -1757,18 +1777,18 @@ var TmuxManager = class {
   }
   async sessionExists(sessionName) {
     try {
-      await exec(`tmux has-session -t "${sessionName}"`);
+      await exec(`tmux has-session -t '${escapeForSingleQuotes(sessionName)}'`);
       return true;
     } catch {
       return false;
     }
   }
   getSessionName(projectName) {
-    return `${this.sessionPrefix}${projectName}`;
+    return `${this.sessionPrefix}${sanitizeForShell(projectName)}`;
   }
   async killSession(sessionName) {
     try {
-      await exec(`tmux kill-session -t "${sessionName}"`);
+      await exec(`tmux kill-session -t '${escapeForSingleQuotes(sessionName)}'`);
       return true;
     } catch {
       return false;
@@ -1776,53 +1796,72 @@ var TmuxManager = class {
   }
   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";
-    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"`);
+    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";
-    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"`);
+    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 "${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"`);
+    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 "${sessionName}"`);
+      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) {
-        spawn("tmux", ["-CC", "attach-session", "-t", sessionName], {
+        spawn7("tmux", ["-CC", "attach-session", "-t", sessionName], {
           stdio: "inherit",
           detached: true
         });
       } else {
-        spawn("tmux", ["attach-session", "-t", sessionName], {
+        spawn7("tmux", ["attach-session", "-t", sessionName], {
           stdio: "inherit",
           detached: true
         });
@@ -1831,53 +1870,64 @@ var TmuxManager = class {
   }
   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 ${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"`,
+      `# 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 ${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"`,
+      `# 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 ${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"`,
+      `# 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 "${sessionName}"`;
+      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 "${sessionName}"`;
+      return `tmux -CC attach-session -t '${escapedSession}'`;
     }
-    return `tmux attach-session -t "${sessionName}"`;
+    return `tmux attach-session -t '${escapedSession}'`;
   }
   async listWorkonSessions() {
     try {
@@ -1897,7 +1947,6 @@ function createOpenCommand(ctx) {
     if (options.debug) {
       log.setLogLevel("debug");
     }
-    await EventRegistry.initialize();
     if (projectArg) {
       await processProject(projectArg, options, ctx);
     } else {
@@ -2004,32 +2053,34 @@ 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 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);
+      buildFallbackCommands(shellCommands, project, layout);
       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 +2090,103 @@ 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))) {
+    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;
+    case "two-pane-npm":
+      return tmux.buildTwoPaneNpmShellCommands(project.name, project.path.path, layout.npmCommand);
   }
-  if (!tmuxHandled && !dryRun) {
-    for (const event of events.filter((e) => ["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+}
+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 (!dryRun) {
-    for (const event of events.filter((e) => !["cwd", "claude", "npm"].includes(e))) {
-      await processEvent(event, { project, isShellMode, shellCommands }, ctx);
-    }
+  if (layout.npmCommand) {
+    shellCommands.push(layout.npmCommand);
   }
 }
-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 +2204,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:");
@@ -2306,25 +2320,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 +2411,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 +2488,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({
@@ -2745,11 +2750,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).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) {