workon 3.2.1 → 3.2.2

package/dist/cli.js

@@ -345,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";
-              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 +425,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 +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 &`];
           }
         };
       }
@@ -1094,12 +1098,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" },
@@ -1732,215 +1937,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) => {
@@ -2069,12 +2080,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 +2122,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 +2143,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 +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";
@@ -2644,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) {
@@ -2672,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}`);
@@ -2686,6 +2739,7 @@ function discoverProject(targetPath, log) {
     name: dirName,
     isNode: false,
     isBun: false,
+    hasClaude: false,
     detectedIde: null,
     packageJson: null
   };
@@ -2711,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;
 }
 
@@ -2750,7 +2813,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 +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());