episoda 0.2.62 → 0.2.64

package/dist/daemon/daemon-process.js

@@ -2726,7 +2726,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.62",
+      version: "0.2.64",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -7091,23 +7091,40 @@ var WorktreeManager = class _WorktreeManager {
   /**
    * Initialize worktree manager from existing project root
    * EP971: All projects use worktree architecture
+   * EP1093: Added debug logging for cloud container diagnostics
    * @returns true if valid project, false otherwise
    */
   async initialize() {
+    const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
     if (!fs15.existsSync(this.bareRepoPath)) {
+      if (debug) {
+        console.log(`[WorktreeManager] initialize: .bare not found at ${this.bareRepoPath}`);
+      }
       return false;
     }
     if (!fs15.existsSync(this.configPath)) {
+      if (debug) {
+        console.log(`[WorktreeManager] initialize: config not found at ${this.configPath}`);
+      }
       return false;
     }
     try {
       const config = this.readConfig();
       if (config === null) {
+        if (debug) {
+          console.log(`[WorktreeManager] initialize: readConfig returned null`);
+        }
         return false;
       }
+      if (debug) {
+        console.log(`[WorktreeManager] initialize: config loaded, projectId=${config.projectId}`);
+      }
       await this.ensureFetchRefspecConfigured();
       return true;
-    } catch {
+    } catch (error) {
+      if (debug) {
+        console.log(`[WorktreeManager] initialize: exception - ${error.message}`);
+      }
       return false;
     }
   }
@@ -7719,20 +7736,43 @@ function getEpisodaRoot() {
   return process.env.EPISODA_ROOT || path16.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
+  const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
+  if (debug) {
+    console.log(`[WorktreeManager] isWorktreeProject: checking ${projectRoot}`);
+  }
   const manager = new WorktreeManager(projectRoot);
-  return manager.initialize();
+  const result = await manager.initialize();
+  if (debug) {
+    console.log(`[WorktreeManager] isWorktreeProject: ${projectRoot} -> ${result}`);
+  }
+  return result;
 }
 async function findProjectRoot(startPath) {
   let current = path16.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
+  const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
+  if (debug) {
+    console.log(`[WorktreeManager] findProjectRoot: start=${startPath}, episodaRoot=${episodaRoot}`);
+  }
   if (!current.startsWith(episodaRoot)) {
+    if (debug) {
+      console.log(`[WorktreeManager] findProjectRoot: ${current} is not under ${episodaRoot}`);
+    }
     return null;
   }
   for (let i = 0; i < 10; i++) {
     const bareDir = path16.join(current, ".bare");
     const episodaDir = path16.join(current, ".episoda");
+    if (debug) {
+      const bareExists = fs15.existsSync(bareDir);
+      const episodaExists = fs15.existsSync(episodaDir);
+      console.log(`[WorktreeManager] findProjectRoot: checking ${current} (.bare=${bareExists}, .episoda=${episodaExists})`);
+    }
     if (fs15.existsSync(bareDir) && fs15.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
+        if (debug) {
+          console.log(`[WorktreeManager] findProjectRoot: found valid project at ${current}`);
+        }
         return current;
       }
     }
@@ -7742,6 +7782,9 @@ async function findProjectRoot(startPath) {
     }
     current = parent;
   }
+  if (debug) {
+    console.log(`[WorktreeManager] findProjectRoot: no project found`);
+  }
   return null;
 }
 
@@ -7964,8 +8007,8 @@ var Daemon = class _Daemon {
   // 60 seconds
   constructor() {
     this.machineId = "";
-    this.deviceId = null;
-    // EP726: Cached device UUID from server
+    this.machineUuid = null;
+    // EP1091: Renamed from deviceId for platform terminology alignment
     this.deviceName = null;
     // EP661: Cached device name from server
     this.flyMachineId = null;
@@ -8024,9 +8067,9 @@ var Daemon = class _Daemon {
     this.machineId = await getMachineId();
     console.log(`[Daemon] Machine ID: ${this.machineId}`);
     const config = await (0, import_core12.loadConfig)();
-    if (config?.device_id) {
-      this.deviceId = config.device_id;
-      console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
+    if (config?.machine_uuid || config?.device_id) {
+      this.machineUuid = config.machine_uuid || config.device_id || null;
+      console.log(`[Daemon] Loaded cached Machine UUID: ${this.machineUuid}`);
     }
     await this.ipcServer.start();
     console.log("[Daemon] IPC server started");
@@ -8078,8 +8121,10 @@ var Daemon = class _Daemon {
       return {
         running: true,
         machineId: this.machineId,
-        deviceId: this.deviceId,
-        // EP726: UUID for unified device identification
+        machineUuid: this.machineUuid,
+        // EP1091: New preferred field name
+        deviceId: this.machineUuid,
+        // EP726: Kept for backward compatibility
         hostname: os8.hostname(),
         platform: os8.platform(),
         arch: os8.arch(),
@@ -8791,18 +8836,19 @@ var Daemon = class _Daemon {
       this.liveConnections.add(projectPath);
       this.pendingConnections.delete(projectPath);
       const authMessage = message;
+      const effectiveMachineUuid = authMessage.machineUuid || authMessage.deviceId;
       if (authMessage.userId && authMessage.workspaceId) {
-        await this.configureGitUser(projectPath, authMessage.userId, authMessage.workspaceId, this.machineId, projectId, authMessage.deviceId);
+        await this.configureGitUser(projectPath, authMessage.userId, authMessage.workspaceId, this.machineId, projectId, effectiveMachineUuid);
         await this.installGitHooks(projectPath);
       }
       if (authMessage.deviceName) {
         this.deviceName = authMessage.deviceName;
         console.log(`[Daemon] Device name: ${this.deviceName}`);
       }
-      if (authMessage.deviceId) {
-        this.deviceId = authMessage.deviceId;
-        console.log(`[Daemon] Device ID (UUID): ${this.deviceId}`);
-        await this.cacheDeviceId(authMessage.deviceId);
+      if (effectiveMachineUuid) {
+        this.machineUuid = effectiveMachineUuid;
+        console.log(`[Daemon] Machine UUID: ${this.machineUuid}`);
+        await this.cacheMachineUuid(effectiveMachineUuid);
       }
       if (authMessage.flyMachineId) {
         this.flyMachineId = authMessage.flyMachineId;
@@ -8824,9 +8870,6 @@ var Daemon = class _Daemon {
       this.reconcileWorktrees(projectId, projectPath, client).catch((err) => {
         console.warn("[Daemon] EP1003: Reconciliation report failed:", err.message);
       });
-      this.reconcilePendingCleanups(projectId, projectPath).catch((err) => {
-        console.warn("[Daemon] EP1047: Cleanup queue reconciliation failed:", err.message);
-      });
     });
     client.on("module_state_changed", async (message) => {
       if (message.type === "module_state_changed") {
@@ -8836,7 +8879,7 @@ var Daemon = class _Daemon {
           console.log(`[Daemon] EP1003: State change for non-local module ${moduleUid} (mode: ${devMode || "unknown"})`);
           return;
         }
-        if (checkoutMachineId && checkoutMachineId !== this.deviceId) {
+        if (checkoutMachineId && checkoutMachineId !== this.machineUuid) {
           console.log(`[Daemon] EP1003: State change for ${moduleUid} handled by different machine: ${checkoutMachineId}`);
           return;
         }
@@ -8941,12 +8984,13 @@ var Daemon = class _Daemon {
    * 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 deviceId (UUID) for unified device identification
+   * EP726: Added machineUuid (UUID) for unified device identification
+   * EP1091: Renamed deviceId param to machineUuid for consistency
    *
    * This stores the IDs in .git/config so the post-checkout hook can
    * update module.checkout_* fields when git operations happen from terminal.
    */
-  async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
+  async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, machineUuid) {
     try {
       const { execSync: execSync9 } = await import("child_process");
       execSync9(`git config episoda.userId ${userId}`, {
@@ -8969,14 +9013,14 @@ var Daemon = class _Daemon {
         encoding: "utf8",
         stdio: "pipe"
       });
-      if (deviceId) {
-        execSync9(`git config episoda.deviceId ${deviceId}`, {
+      if (machineUuid) {
+        execSync9(`git config episoda.deviceId ${machineUuid}`, {
           cwd: projectPath,
           encoding: "utf8",
           stdio: "pipe"
         });
       }
-      console.log(`[Daemon] Configured git for project: episoda.userId=${userId}, machineId=${machineId}, projectId=${projectId}${deviceId ? `, deviceId=${deviceId}` : ""}`);
+      console.log(`[Daemon] Configured git for project: episoda.userId=${userId}, machineId=${machineId}, projectId=${projectId}${machineUuid ? `, machineUuid=${machineUuid}` : ""}`);
     } catch (error) {
       console.warn(`[Daemon] Failed to configure git user for ${projectPath}:`, error instanceof Error ? error.message : error);
     }
@@ -9018,30 +9062,34 @@ var Daemon = class _Daemon {
     }
   }
   /**
-   * EP726: Cache device UUID to config file
+   * EP726: Cache machine UUID to config file
+   * EP1091: Renamed from cacheDeviceId, writes machine_uuid (new) and device_id (backward compat)
    *
-   * Persists the device_id (UUID) received from the server so it's available
+   * Persists the machine UUID received from the server so it's available
    * on daemon restart without needing to re-register the device.
    */
-  async cacheDeviceId(deviceId) {
+  async cacheMachineUuid(machineUuid) {
     try {
       const config = await (0, import_core12.loadConfig)();
       if (!config) {
-        console.warn("[Daemon] Cannot cache device ID - no config found");
+        console.warn("[Daemon] Cannot cache machine UUID - no config found");
         return;
       }
-      if (config.device_id === deviceId) {
+      if (config.machine_uuid === machineUuid) {
         return;
       }
       const updatedConfig = {
         ...config,
-        device_id: deviceId,
+        machine_uuid: machineUuid,
+        // EP1091: New preferred field
+        device_id: machineUuid,
+        // Backward compatibility
         machine_id: this.machineId
       };
       await (0, import_core12.saveConfig)(updatedConfig);
-      console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
+      console.log(`[Daemon] Cached machine UUID to config: ${machineUuid}`);
     } catch (error) {
-      console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
+      console.warn("[Daemon] Failed to cache machine UUID:", error instanceof Error ? error.message : error);
     }
   }
   /**
@@ -9102,14 +9150,14 @@ var Daemon = class _Daemon {
    */
   async syncMachineProjectPath(projectId, projectPath) {
     try {
-      if (!this.deviceId) {
-        console.warn("[Daemon] EP995: Cannot sync project path - deviceId not available");
+      if (!this.machineUuid) {
+        console.warn("[Daemon] EP995: Cannot sync project path - machineUuid not available");
         return;
       }
       const config = await (0, import_core12.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
-      const response = await fetchWithAuth(`${apiUrl}/api/account/machines/${this.deviceId}`, {
+      const response = await fetchWithAuth(`${apiUrl}/api/account/machines/${this.machineUuid}`, {
         method: "PATCH",
         headers: {
           "Content-Type": "application/json"
@@ -9190,8 +9238,8 @@ var Daemon = class _Daemon {
   async reconcileWorktrees(projectId, projectPath, client) {
     console.log(`[Daemon] EP1003: Starting reconciliation report for project ${projectId}`);
     try {
-      if (!this.deviceId) {
-        console.log("[Daemon] EP1003: Cannot reconcile - deviceId not available yet");
+      if (!this.machineUuid) {
+        console.log("[Daemon] EP1003: Cannot reconcile - machineUuid not available yet");
         return;
       }
       const config = await (0, import_core12.loadConfig)();
@@ -9202,7 +9250,7 @@ var Daemon = class _Daemon {
       let modulesResponse;
       try {
         modulesResponse = await fetchWithAuth(
-          `${apiUrl}/api/modules?state=doing,review&dev_mode=local&checkout_machine_id=${this.deviceId}&project_id=${projectId}`,
+          `${apiUrl}/api/modules?state=doing,review&dev_mode=local&checkout_machine_id=${this.machineUuid}&project_id=${projectId}`,
           { signal: controller.signal }
         );
       } finally {
@@ -9251,7 +9299,7 @@ var Daemon = class _Daemon {
       }
       const report = {
         projectId,
-        machineId: this.deviceId,
+        machineId: this.machineUuid,
         modules: moduleStatuses,
         orphanTunnels: orphanTunnels.length > 0 ? orphanTunnels : void 0
       };
@@ -9272,8 +9320,11 @@ var Daemon = class _Daemon {
   /**
    * EP1047: Process pending cleanup queue entries for this machine
    *
-   * On daemon startup/reconnect, fetch pending worktree cleanup tasks from the queue
-   * and process them. This catches any cleanups missed while the daemon was offline.
+   * @deprecated EP1091: No longer called on connect. Server-side cron now processes
+   * the cleanup queue and sends WebSocket commands to connected daemons. This is
+   * more reliable than daemon-side polling since it works even if daemon stays connected.
+   *
+   * Kept for potential manual invocation or debugging purposes.
    *
    * Flow:
    * 1. Query server for pending cleanup tasks for this machine
@@ -9281,11 +9332,11 @@ var Daemon = class _Daemon {
    * 3. Report success/failure back to server
    */
   async reconcilePendingCleanups(projectId, projectPath) {
-    if (!this.deviceId) {
-      console.log("[Daemon] EP1047: Cannot reconcile cleanups - deviceId not available yet");
+    if (!this.machineUuid) {
+      console.log("[Daemon] EP1047: Cannot reconcile cleanups - machineUuid not available yet");
       return;
     }
-    console.log(`[Daemon] EP1047: Checking for pending cleanup tasks for machine ${this.deviceId}`);
+    console.log(`[Daemon] EP1047: Checking for pending cleanup tasks for machine ${this.machineUuid}`);
     try {
       const config = await (0, import_core12.loadConfig)();
       if (!config) {
@@ -9298,7 +9349,7 @@ var Daemon = class _Daemon {
       let response;
       try {
         response = await fetchWithAuth(
-          `${apiUrl}/api/cli/background-ops?machine_id=${this.deviceId}`,
+          `${apiUrl}/api/cli/background-ops?machine_id=${this.machineUuid}`,
           { signal: controller.signal }
         );
       } finally {