episoda 0.2.57 → 0.2.59

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.57",
+      version: "0.2.59",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2798,6 +2798,10 @@ function isValidUUID(str) {
   return uuidRegex.test(str);
 }
 async function getMachineId() {
+  const envMachineId = process.env.EPISODA_MACHINE_ID;
+  if (envMachineId) {
+    return envMachineId;
+  }
   const machineIdPath = path.join((0, import_core.getConfigDir)(), "machine-id");
   try {
     if (fs.existsSync(machineIdPath)) {
@@ -9261,73 +9265,81 @@ var Daemon = class _Daemon {
       let response;
       try {
         response = await fetchWithAuth(
-          `${apiUrl}/api/cli/cleanup-queue?machine_id=${this.deviceId}`,
+          `${apiUrl}/api/cli/background-ops?machine_id=${this.deviceId}`,
           { signal: controller.signal }
         );
       } finally {
         clearTimeout(timeoutId);
       }
       if (!response.ok) {
-        console.warn(`[Daemon] EP1047: Failed to fetch cleanup tasks: ${response.status}`);
+        console.warn(`[Daemon] EP1051: Failed to fetch background operations: ${response.status}`);
         return;
       }
       const data = await response.json();
       const tasks = data.data?.tasks || [];
       if (tasks.length === 0) {
-        console.log("[Daemon] EP1047: No pending cleanup tasks");
+        console.log("[Daemon] EP1051: No pending background operations");
         return;
       }
-      console.log(`[Daemon] EP1047: Processing ${tasks.length} pending cleanup task(s)`);
+      console.log(`[Daemon] EP1051: Processing ${tasks.length} pending operation(s)`);
       const projectRoot = await findProjectRoot(projectPath);
       if (!projectRoot) {
-        console.warn("[Daemon] EP1047: Could not find project root, skipping cleanup reconciliation");
+        console.warn("[Daemon] EP1051: Could not find project root, skipping operation reconciliation");
         return;
       }
       const worktreeManager = new WorktreeManager(projectRoot);
       if (!await worktreeManager.initialize()) {
-        console.warn("[Daemon] EP1047: Failed to initialize worktree manager");
+        console.warn("[Daemon] EP1051: Failed to initialize worktree manager");
         return;
       }
       for (const task of tasks) {
         const moduleUid = task.payload.module_uid || task.target_id;
-        console.log(`[Daemon] EP1047: Processing cleanup for ${moduleUid} (task ${task.id})`);
+        console.log(`[Daemon] EP1051: Processing ${task.operation_type} for ${moduleUid} (task ${task.id})`);
         try {
-          const result = await worktreeManager.removeWorktree(moduleUid, true);
-          if (result.success) {
-            console.log(`[Daemon] EP1047: Successfully cleaned up worktree for ${moduleUid}`);
-            await this.reportCleanupResult(apiUrl, task.id, "complete");
-          } else {
-            if (result.error?.includes("not found") || result.error?.includes("No worktree found")) {
-              console.log(`[Daemon] EP1047: Worktree ${moduleUid} already removed, marking complete`);
-              await this.reportCleanupResult(apiUrl, task.id, "complete");
+          if (task.operation_type === "worktree_cleanup") {
+            const result = await worktreeManager.removeWorktree(moduleUid, true);
+            if (result.success) {
+              console.log(`[Daemon] EP1051: Successfully cleaned up worktree for ${moduleUid}`);
+              await this.reportOperationResult(apiUrl, task.id, "complete");
             } else {
-              console.warn(`[Daemon] EP1047: Cleanup failed for ${moduleUid}: ${result.error}`);
-              await this.reportCleanupResult(apiUrl, task.id, "retry", {
-                code: "CLEANUP_ERROR",
-                message: result.error || "Unknown error"
-              });
+              if (result.error?.includes("not found") || result.error?.includes("No worktree found")) {
+                console.log(`[Daemon] EP1051: Worktree ${moduleUid} already removed, marking complete`);
+                await this.reportOperationResult(apiUrl, task.id, "complete");
+              } else {
+                console.warn(`[Daemon] EP1051: Cleanup failed for ${moduleUid}: ${result.error}`);
+                await this.reportOperationResult(apiUrl, task.id, "retry", {
+                  code: "OPERATION_ERROR",
+                  message: result.error || "Unknown error"
+                });
+              }
             }
+          } else {
+            console.warn(`[Daemon] EP1051: Unknown operation type: ${task.operation_type}`);
+            await this.reportOperationResult(apiUrl, task.id, "fail", {
+              code: "UNKNOWN_OPERATION_TYPE",
+              message: `Daemon cannot process operation type: ${task.operation_type}`
+            });
           }
         } catch (error) {
-          console.error(`[Daemon] EP1047: Error processing cleanup for ${moduleUid}:`, error.message);
-          await this.reportCleanupResult(apiUrl, task.id, "retry", {
-            code: "CLEANUP_EXCEPTION",
+          console.error(`[Daemon] EP1051: Error processing operation for ${moduleUid}:`, error.message);
+          await this.reportOperationResult(apiUrl, task.id, "retry", {
+            code: "OPERATION_EXCEPTION",
             message: error.message
           });
         }
       }
-      console.log("[Daemon] EP1047: Cleanup reconciliation complete");
+      console.log("[Daemon] EP1051: Operation reconciliation complete");
     } catch (error) {
-      console.error("[Daemon] EP1047: Cleanup reconciliation error:", error instanceof Error ? error.message : error);
+      console.error("[Daemon] EP1051: Operation reconciliation error:", error instanceof Error ? error.message : error);
       throw error;
     }
   }
   /**
-   * EP1047: Report cleanup task result to server
+   * EP1051: Report background operation result to server
    */
-  async reportCleanupResult(apiUrl, taskId, action, error) {
+  async reportOperationResult(apiUrl, taskId, action, error) {
     try {
-      const response = await fetchWithAuth(`${apiUrl}/api/cli/cleanup-queue`, {
+      const response = await fetchWithAuth(`${apiUrl}/api/cli/background-ops`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -9337,10 +9349,10 @@ var Daemon = class _Daemon {
         })
       });
       if (!response.ok) {
-        console.warn(`[Daemon] EP1047: Failed to report cleanup result: ${response.status}`);
+        console.warn(`[Daemon] EP1051: Failed to report operation result: ${response.status}`);
       }
     } catch (err) {
-      console.warn(`[Daemon] EP1047: Error reporting cleanup result: ${err.message}`);
+      console.warn(`[Daemon] EP1051: Error reporting operation result: ${err.message}`);
     }
   }
   /**