episoda 0.2.98 → 0.2.100

package/dist/daemon/daemon-process.js

@@ -2786,7 +2786,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.98",
+      version: "0.2.100",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8485,8 +8485,10 @@ ${message}`;
           "--output-format",
           "stream-json",
           // Structured streaming output
-          "--verbose"
+          "--verbose",
           // Required for stream-json with --print
+          "--include-partial-messages"
+          // EP1191: Enable incremental streaming chunks
         ];
         if (session.credentials.preferredModel) {
           args.push("--model", session.credentials.preferredModel);
@@ -8644,14 +8646,25 @@ ${message}`;
       });
       let stdoutBuffer = "";
       let extractedSessionId;
+      let stdoutEventCount = 0;
+      let chunksSent = 0;
+      const streamStartTime = Date.now();
       childProcess.stdout?.on("data", (data) => {
-        stdoutBuffer += data.toString();
+        const rawData = data.toString();
+        stdoutBuffer += rawData;
+        stdoutEventCount++;
+        if (stdoutEventCount <= 5) {
+          console.log(`[AgentManager] EP1191: stdout event ${stdoutEventCount} - ${rawData.length} chars: ${rawData.substring(0, 200)}${rawData.length > 200 ? "..." : ""}`);
+        }
         const lines = stdoutBuffer.split("\n");
         stdoutBuffer = lines.pop() || "";
         for (const line of lines) {
           if (!line.trim()) continue;
           try {
             const parsed = JSON.parse(line);
+            if (stdoutEventCount <= 10 || chunksSent === 0) {
+              console.log(`[AgentManager] EP1191: Parsed event type: ${parsed.type}`);
+            }
             if (provider === "codex") {
               switch (parsed.type) {
                 case "thread.started":
@@ -8687,6 +8700,10 @@ ${message}`;
                   if (parsed.message?.content) {
                     for (const block of parsed.message.content) {
                       if (block.type === "text" && block.text) {
+                        chunksSent++;
+                        if (chunksSent <= 5) {
+                          console.log(`[AgentManager] EP1191: Sending chunk ${chunksSent} via assistant event - ${block.text.length} chars`);
+                        }
                         onChunk(block.text);
                       }
                     }
@@ -8694,6 +8711,10 @@ ${message}`;
                   break;
                 case "content_block_delta":
                   if (parsed.delta?.text) {
+                    chunksSent++;
+                    if (chunksSent <= 5) {
+                      console.log(`[AgentManager] EP1191: Sending chunk ${chunksSent} via content_block_delta - ${parsed.delta.text.length} chars`);
+                    }
                     onChunk(parsed.delta.text);
                   }
                   break;
@@ -8735,7 +8756,8 @@ ${message}`;
         stderrBuffer += data.toString();
       });
       childProcess.on("exit", (code, signal) => {
-        console.log(`[AgentManager] ${provider} CLI exited for session ${sessionId}: code=${code}, signal=${signal}`);
+        const duration = Date.now() - streamStartTime;
+        console.log(`[AgentManager] EP1191: ${provider} CLI exited for session ${sessionId}: code=${code}, signal=${signal}, duration=${duration}ms, stdoutEvents=${stdoutEventCount}, chunksSent=${chunksSent}`);
         this.processes.delete(sessionId);
         this.removePidFile(sessionId);
         if (code === 0) {
@@ -10143,8 +10165,14 @@ var Daemon = class _Daemon {
         const cmd = message.command;
         console.log(`[Daemon] EP912: Received agent command for ${projectId}:`, cmd.action);
         client.updateActivity();
+        let daemonChunkCount = 0;
+        const daemonStreamStart = Date.now();
         const createStreamingCallbacks = (sessionId, commandId) => ({
           onChunk: async (chunk) => {
+            daemonChunkCount++;
+            if (daemonChunkCount <= 5) {
+              console.log(`[Daemon] EP1191: Forwarding chunk ${daemonChunkCount} via WebSocket - ${chunk.length} chars`);
+            }
             try {
               await client.send({
                 type: "agent_result",
@@ -10156,6 +10184,8 @@ var Daemon = class _Daemon {
             }
           },
           onComplete: async (claudeSessionId) => {
+            const duration = Date.now() - daemonStreamStart;
+            console.log(`[Daemon] EP1191: Stream complete - ${daemonChunkCount} chunks forwarded in ${duration}ms`);
             try {
               await client.send({
                 type: "agent_result",
@@ -10167,6 +10197,8 @@ var Daemon = class _Daemon {
             }
           },
           onError: async (error) => {
+            const duration = Date.now() - daemonStreamStart;
+            console.log(`[Daemon] EP1191: Stream error after ${daemonChunkCount} chunks in ${duration}ms - ${error}`);
             try {
               await client.send({
                 type: "agent_result",
@@ -10924,130 +10956,8 @@ var Daemon = class _Daemon {
     }
   }
   // EP1025: Removed cleanupModuleWorktree - was dead code (never called).
-  // Worktree cleanup is handled by server's cleanupWorktreeAsync which sends
-  // worktree_remove command via WebSocket, handled by GitExecutor.executeWorktreeRemove.
-  /**
-   * EP1047: Process pending cleanup queue entries for this machine
-   *
-   * @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
-   * 2. For each task, attempt worktree removal
-   * 3. Report success/failure back to server
-   */
-  async reconcilePendingCleanups(projectId, projectPath) {
-    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.machineUuid}`);
-    try {
-      const config = await (0, import_core13.loadConfig)();
-      if (!config) {
-        console.log("[Daemon] EP1047: No config loaded, skipping cleanup reconciliation");
-        return;
-      }
-      const apiUrl = config.api_url || "https://episoda.dev";
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 1e4);
-      let response;
-      try {
-        response = await fetchWithAuth(
-          `${apiUrl}/api/cli/background-ops?machine_id=${this.machineUuid}`,
-          { signal: controller.signal }
-        );
-      } finally {
-        clearTimeout(timeoutId);
-      }
-      if (!response.ok) {
-        console.warn(`[Daemon] EP1051: Failed to fetch background operations: ${response.status}`);
-        return;
-      }
-      const data = await response.json();
-      const tasks = data.tasks || [];
-      if (tasks.length === 0) {
-        console.log("[Daemon] EP1051: No pending background operations");
-        return;
-      }
-      console.log(`[Daemon] EP1051: Processing ${tasks.length} pending operation(s)`);
-      const projectRoot = await findProjectRoot(projectPath);
-      if (!projectRoot) {
-        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] EP1051: Failed to initialize worktree manager");
-        return;
-      }
-      for (const task of tasks) {
-        const moduleUid = task.payload.module_uid || task.target_id;
-        console.log(`[Daemon] EP1051: Processing ${task.operation_type} for ${moduleUid} (task ${task.id})`);
-        try {
-          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 {
-              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] EP1051: Error processing operation for ${moduleUid}:`, error.message);
-          await this.reportOperationResult(apiUrl, task.id, "retry", {
-            code: "OPERATION_EXCEPTION",
-            message: error.message
-          });
-        }
-      }
-      console.log("[Daemon] EP1051: Operation reconciliation complete");
-    } catch (error) {
-      console.error("[Daemon] EP1051: Operation reconciliation error:", error instanceof Error ? error.message : error);
-      throw error;
-    }
-  }
-  /**
-   * EP1051: Report background operation result to server
-   */
-  async reportOperationResult(apiUrl, taskId, action, error) {
-    try {
-      const response = await fetchWithAuth(`${apiUrl}/api/cli/background-ops`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          task_id: taskId,
-          action,
-          error
-        })
-      });
-      if (!response.ok) {
-        console.warn(`[Daemon] EP1051: Failed to report operation result: ${response.status}`);
-      }
-    } catch (err) {
-      console.warn(`[Daemon] EP1051: Error reporting operation result: ${err.message}`);
-    }
-  }
+  // EP1188: Background ops queue removed - worktree cleanup now handled by Inngest events
+  // (worktree/cleanup) which send WebSocket commands to connected daemons via ws-proxy.
   /**
    * EP1002: Handle worktree_setup command from server
    * This provides a unified setup flow for both local and cloud environments.