episoda 0.2.67 → 0.2.69

package/dist/daemon/daemon-process.js

@@ -2337,12 +2337,18 @@ var require_websocket_client = __commonJS({
       /**
        * EP701: Emit a client-side event to registered handlers
        * Used for events like 'disconnected' that originate from the client, not server
+       * EP1095: Fixed to handle async handlers - catches both sync errors and promise rejections
        */
       emit(event) {
         const handlers = this.eventHandlers.get(event.type) || [];
         handlers.forEach((handler) => {
           try {
-            handler(event);
+            const result = handler(event);
+            if (result && typeof result === "object" && "catch" in result && typeof result.catch === "function") {
+              result.catch((error) => {
+                console.error(`[EpisodaClient] Async handler error for ${event.type}:`, error);
+              });
+            }
           } catch (error) {
             console.error(`[EpisodaClient] Handler error for ${event.type}:`, error);
           }
@@ -2730,7 +2736,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.67",
+      version: "0.2.69",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8902,6 +8908,27 @@ var Daemon = class _Daemon {
       console.log(`[Daemon] EP949: Received token refresh for ${projectId}`);
       client.updateToken(tokenMsg.accessToken);
     });
+    client.on("machine_uuid_update", async (message) => {
+      try {
+        const uuidMsg = message;
+        if (uuidMsg.machineUuid) {
+          this.machineUuid = uuidMsg.machineUuid;
+          console.log(`[Daemon] EP1095: Machine UUID updated: ${this.machineUuid}`);
+          await this.cacheMachineUuid(uuidMsg.machineUuid);
+          this.syncMachineProjectPath(projectId, projectPath).catch((err) => {
+            console.warn("[Daemon] EP1095: Deferred project path sync failed:", err.message);
+          });
+          const connection2 = this.connections.get(projectPath);
+          if (connection2) {
+            this.reconcileWorktrees(projectId, projectPath, connection2.client).catch((err) => {
+              console.warn("[Daemon] EP1095: Deferred reconciliation failed:", err.message);
+            });
+          }
+        }
+      } catch (error) {
+        console.error("[Daemon] EP1095: Error handling machine_uuid_update:", error instanceof Error ? error.message : error);
+      }
+    });
     client.on("disconnected", (event) => {
       const disconnectEvent = event;
       console.log(`[Daemon] Connection closed for ${projectId}: code=${disconnectEvent.code}, willReconnect=${disconnectEvent.willReconnect}`);
@@ -8984,12 +9011,47 @@ var Daemon = class _Daemon {
     process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
     process.on("SIGINT", () => shutdownHandler("SIGINT"));
   }
+  /**
+   * EP1095: Get git directory and working directory for a project path
+   * Handles both traditional (.git directory) and worktree (.bare directory) structures
+   * Returns { gitDir, workDir } where:
+   * - gitDir: The --git-dir value to use with git commands
+   * - workDir: The directory to run git commands in (cwd)
+   */
+  getGitDirs(projectPath) {
+    const bareDir = path19.join(projectPath, ".bare");
+    const gitPath = path19.join(projectPath, ".git");
+    if (fs18.existsSync(bareDir) && fs18.statSync(bareDir).isDirectory()) {
+      return { gitDir: bareDir, workDir: projectPath };
+    }
+    if (fs18.existsSync(gitPath) && fs18.statSync(gitPath).isDirectory()) {
+      return { gitDir: null, workDir: projectPath };
+    }
+    if (fs18.existsSync(gitPath) && fs18.statSync(gitPath).isFile()) {
+      return { gitDir: null, workDir: projectPath };
+    }
+    const entries = fs18.readdirSync(projectPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("EP")) {
+        const worktreePath = path19.join(projectPath, entry.name);
+        const worktreeGit = path19.join(worktreePath, ".git");
+        if (fs18.existsSync(worktreeGit)) {
+          return { gitDir: null, workDir: worktreePath };
+        }
+      }
+    }
+    if (fs18.existsSync(bareDir)) {
+      return { gitDir: bareDir, workDir: projectPath };
+    }
+    return { gitDir: null, workDir: projectPath };
+  }
   /**
    * EP595: Configure git with user and workspace ID for post-checkout hook
    * EP655: Added machineId for device isolation in multi-device environments
    * EP725: Added projectId for main branch badge tracking
    * EP726: Added machineUuid (UUID) for unified device identification
    * EP1091: Renamed deviceId param to machineUuid for consistency
+   * EP1095: Added worktree structure support (uses .bare as gitDir)
    *
    * This stores the IDs in .git/config so the post-checkout hook can
    * update module.checkout_* fields when git operations happen from terminal.
@@ -8997,29 +9059,31 @@ var Daemon = class _Daemon {
   async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, machineUuid) {
     try {
       const { execSync: execSync9 } = await import("child_process");
-      execSync9(`git config episoda.userId ${userId}`, {
-        cwd: projectPath,
+      const { gitDir, workDir } = this.getGitDirs(projectPath);
+      const gitCmd = gitDir ? `git --git-dir="${gitDir}"` : "git";
+      execSync9(`${gitCmd} config episoda.userId ${userId}`, {
+        cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`git config episoda.workspaceId ${workspaceId}`, {
-        cwd: projectPath,
+      execSync9(`${gitCmd} config episoda.workspaceId ${workspaceId}`, {
+        cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`git config episoda.machineId ${machineId}`, {
-        cwd: projectPath,
+      execSync9(`${gitCmd} config episoda.machineId ${machineId}`, {
+        cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`git config episoda.projectId ${projectId}`, {
-        cwd: projectPath,
+      execSync9(`${gitCmd} config episoda.projectId ${projectId}`, {
+        cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
       if (machineUuid) {
-        execSync9(`git config episoda.deviceId ${machineUuid}`, {
-          cwd: projectPath,
+        execSync9(`${gitCmd} config episoda.deviceId ${machineUuid}`, {
+          cwd: workDir,
           encoding: "utf8",
           stdio: "pipe"
         });
@@ -9031,6 +9095,7 @@ var Daemon = class _Daemon {
   }
   /**
    * EP610: Install git hooks from bundled files
+   * EP1095: Added worktree structure support (hooks in .bare/hooks)
    *
    * Installs post-checkout and pre-commit hooks to enable:
    * - Branch tracking (post-checkout updates module.checkout_* fields)
@@ -9038,10 +9103,29 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path19.join(projectPath, ".git", "hooks");
+    let hooksDir;
+    const bareHooksDir = path19.join(projectPath, ".bare", "hooks");
+    const gitHooksDir = path19.join(projectPath, ".git", "hooks");
+    if (fs18.existsSync(bareHooksDir)) {
+      hooksDir = bareHooksDir;
+    } else if (fs18.existsSync(gitHooksDir) && fs18.statSync(path19.join(projectPath, ".git")).isDirectory()) {
+      hooksDir = gitHooksDir;
+    } else {
+      const parentBareHooks = path19.join(projectPath, "..", ".bare", "hooks");
+      if (fs18.existsSync(parentBareHooks)) {
+        hooksDir = parentBareHooks;
+      } else {
+        console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
+        return;
+      }
+    }
     if (!fs18.existsSync(hooksDir)) {
-      console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
-      return;
+      try {
+        fs18.mkdirSync(hooksDir, { recursive: true });
+      } catch (error) {
+        console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
+        return;
+      }
     }
     for (const hookName of hooks) {
       try {