jettypod 4.4.118 → 4.4.120

package/.env

@@ -1,7 +1,7 @@
 CLOUDFLARE_API_TOKEN=qaygaUeCLS8RQA5FVsJxnsA02c8b8qWyiLgNSM1X
 STRIPE_SECRET_KEY=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
 STRIPE_WEBHOOK_SECRET=whsec_pkup32kvrcf3g5h8VmtjLfYU9WIWdAb6
-GOOGLE_CLIENT_ID=172847259733-r87e20pjv97290kuusm7ov7uams515mm.apps.googleusercontent.com
-GOOGLE_CLIENT_SECRET=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
+GOOGLE_CLIENT_ID=816982147727-7ceu0dge0ton30q1d09dgcos9h62orjo.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=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
 JWT_SECRET=bKYWqg7IR45K9CrA5BRmzXPQoWK6Vv4okZKpGmYD6o4=
 RESEND_API_KEY=re_Tg7gAVGE_LVKhjnyLkpDgYmkzQvYXmCwc

package/apps/dashboard/app/api/claude/[workItemId]/message/route.ts

@@ -9,10 +9,6 @@ import {
   killProcess,
 } from '@/lib/claude-process-manager';
 
-// Import worktree facade for worktree management
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const worktreeFacade = require('../../../../../../../lib/worktree-facade');
-
 /**
  * Get the project root path for Claude CLI operations.
  * In packaged Electron apps, process.cwd() returns the app bundle's Resources directory,
@@ -92,9 +88,9 @@ export async function POST(
     );
   }
 
-  // Get the message (conversationHistory no longer needed - persistent process maintains context)
+  // Get the message and optional images
   const body = await request.json().catch(() => ({}));
-  const { message } = body;
+  const { message, images } = body;
 
   if (!message || typeof message !== 'string') {
     return NextResponse.json(
@@ -167,13 +163,22 @@ export async function POST(
     // Conversational chores run from main repo — no worktree needed
     claudeCwd = repoPath;
   } else {
-    // Get or create worktree for this work item
-    const workItem = {
-      id: parseInt(workItemId, 10),
-      title: `Work item ${workItemId}`
-    };
-    const workResult = await worktreeFacade.startWork(workItem, { repoPath });
-    claudeCwd = workResult.path;
+    // Non-conversational: attempt to create worktree via lazy-loaded facade.
+    // worktree-facade depends on the CLI's sqlite3 module which is not a dashboard
+    // dependency — lazy-load to avoid crashing the entire route module at import time.
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const worktreeFacade = require('../../../../../../../lib/worktree-facade');
+      const workItem = {
+        id: parseInt(workItemId, 10),
+        title: `Work item ${workItemId}`
+      };
+      const workResult = await worktreeFacade.startWork(workItem, { repoPath });
+      claudeCwd = workResult.path;
+    } catch {
+      // Worktree creation unavailable or failed — fall back to main repo
+      claudeCwd = repoPath;
+    }
   }
 
   const settingsPath = getSettingsPath(repoPath);
@@ -209,6 +214,9 @@ export async function POST(
   // Create a readable stream for SSE
   const encoder = new TextEncoder();
 
+  // Cleanup function hoisted so cancel() can access it when client disconnects
+  let cleanupStreamListeners: (() => void) | null = null;
+
   const stream = new ReadableStream({
     start(controller) {
       // Collect assistant response text for saving to session content
@@ -218,6 +226,43 @@ export async function POST(
       // Track if we've saved the response (to avoid duplicate saves)
       let responseSaved = false;
 
+      // Track active emitter (may change during retry)
+      let currentEmitter = emitter;
+
+      // Safe enqueue — if the stream has been closed (client disconnect, error),
+      // enqueue() throws. Without this wrapper, the error propagates through
+      // the EventEmitter chain and crashes the process manager's stdout handler,
+      // silently killing all subsequent events for this session.
+      const safeEnqueue = (data: Uint8Array): boolean => {
+        try {
+          controller.enqueue(data);
+          return true;
+        } catch {
+          // Stream is dead — clean up
+          if (!responseComplete) {
+            responseComplete = true;
+            saveAssistantResponse();
+            currentEmitter.off('data', onData);
+            currentEmitter.off('error', onError);
+            currentEmitter.off('close', onClose);
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+          }
+          return false;
+        }
+      };
+
+      // SSE heartbeat — send a comment every 15s to keep the connection alive.
+      // During long tool executions (jettypod work start, npm test, etc.) the
+      // SSE stream can be idle for 30+ seconds. Proxies and HTTP middleware
+      // may close idle connections, killing the stream mid-session.
+      const heartbeatInterval = setInterval(() => {
+        if (responseComplete) {
+          clearInterval(heartbeatInterval);
+          return;
+        }
+        safeEnqueue(encoder.encode(': heartbeat\n\n'));
+      }, 15_000);
+
       // Helper to save assistant response if not already saved
       const saveAssistantResponse = () => {
         if (!responseSaved && assistantResponse.trim()) {
@@ -272,26 +317,23 @@ export async function POST(
         // Check for result message - this indicates Claude is done with this turn
         if (parsed.type === 'result') {
           responseComplete = true;
+          clearInterval(heartbeatInterval);
 
           // Save assistant response to session content (if not already saved)
           saveAssistantResponse();
 
-          const sseData = `data: ${JSON.stringify(parsed)}\n\n`;
-          controller.enqueue(encoder.encode(sseData));
-
-          // Send done event and close stream
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify(parsed)}\n\n`));
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
 
           // Remove listeners and close
-          emitter.off('data', onData);
-          emitter.off('error', onError);
-          emitter.off('close', onClose);
-          controller.close();
+          currentEmitter.off('data', onData);
+          currentEmitter.off('error', onError);
+          currentEmitter.off('close', onClose);
+          try { controller.close(); } catch { /* already closed */ }
           return;
         }
 
-        const sseData = `data: ${JSON.stringify(parsed)}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify(parsed)}\n\n`));
       };
 
       const onError = (err: { type: string; content: string }) => {
@@ -302,29 +344,39 @@ export async function POST(
           content: err.content,
           timestamp: new Date().toISOString()
         });
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: err.content })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', content: err.content })}\n\n`));
       };
 
       const onClose = (info: { exitCode: number }) => {
         if (responseComplete) return;
         responseComplete = true;
+        clearInterval(heartbeatInterval);
 
         // Save any collected response (if not already saved)
         saveAssistantResponse();
 
-        const sseData = `data: ${JSON.stringify({ type: 'done', exitCode: info.exitCode })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-        controller.close();
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: info.exitCode })}\n\n`));
+        try { controller.close(); } catch { /* already closed */ }
+      };
+
+      // Expose cleanup so cancel() can call it when client disconnects
+      cleanupStreamListeners = () => {
+        if (responseComplete) return;
+        responseComplete = true;
+        clearInterval(heartbeatInterval);
+        saveAssistantResponse();
+        currentEmitter.off('data', onData);
+        currentEmitter.off('error', onError);
+        currentEmitter.off('close', onClose);
       };
 
       // Attach listeners
-      emitter.on('data', onData);
-      emitter.on('error', onError);
-      emitter.on('close', onClose);
+      currentEmitter.on('data', onData);
+      currentEmitter.on('error', onError);
+      currentEmitter.on('close', onClose);
 
       // Send the message to the persistent process
-      let sent = sendProcessMessage(processSessionId, messageToSend);
+      let sent = sendProcessMessage(processSessionId, messageToSend, images);
 
       // If send failed, the process may have died after getOrCreateProcess
       // Try to create a fresh process and retry once
@@ -335,30 +387,33 @@ export async function POST(
         const retryResult = getOrCreateProcess(processSessionId, claudeCwd, settingsPath);
         if ('error' in retryResult) {
           // Hit process limit on retry - return error
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+          clearInterval(heartbeatInterval);
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({
             type: 'error',
             content: retryResult.error
           })}\n\n`));
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
-          controller.close();
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
+          try { controller.close(); } catch { /* already closed */ }
           return;
         }
         const { emitter: newEmitter } = retryResult;
 
         // Re-attach listeners to new emitter
-        emitter.off('data', onData);
-        emitter.off('error', onError);
-        emitter.off('close', onClose);
-        newEmitter.on('data', onData);
-        newEmitter.on('error', onError);
-        newEmitter.on('close', onClose);
+        currentEmitter.off('data', onData);
+        currentEmitter.off('error', onError);
+        currentEmitter.off('close', onClose);
+        currentEmitter = newEmitter;
+        currentEmitter.on('data', onData);
+        currentEmitter.on('error', onError);
+        currentEmitter.on('close', onClose);
 
         // Retry send
-        sent = sendProcessMessage(processSessionId, messageToSend);
+        sent = sendProcessMessage(processSessionId, messageToSend, images);
       }
 
       if (!sent) {
         // Still failed after retry - give clear error
+        clearInterval(heartbeatInterval);
         const errorContent = 'Claude process is unavailable. The process may have crashed or failed to start. Please try again.';
         // Persist error to database (#1000098)
         appendSessionContentByWorkItem(workItemIdNum, {
@@ -366,14 +421,19 @@ export async function POST(
           content: errorContent,
           timestamp: new Date().toISOString()
         });
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({
           type: 'error',
           content: errorContent
         })}\n\n`));
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
-        controller.close();
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
+        try { controller.close(); } catch { /* already closed */ }
       }
     },
+    cancel() {
+      // Called when client disconnects — clean up listeners to prevent
+      // "Controller is already closed" errors from orphaned event handlers
+      cleanupStreamListeners?.();
+    },
   });
 
   return new Response(stream, {

package/apps/dashboard/app/api/claude/[workItemId]/route.ts

@@ -1,8 +1,13 @@
-import { spawn, spawnSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import { NextRequest, NextResponse } from 'next/server';
 import path from 'path';
 import fs from 'fs';
-import { registerSession, updateSessionStatus } from '@/lib/db';
+import { registerSession, appendSessionContentByWorkItem } from '@/lib/db';
+import {
+  getOrCreateProcess,
+  sendMessage as sendProcessMessage,
+  killProcess,
+} from '@/lib/claude-process-manager';
 
 // Import worktree facade for worktree management
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -92,68 +97,176 @@ Please start working on this ${workItemType}. Use the appropriate tools to imple
   const sessionTitle = title || `Work item ${workItemId}`;
   registerSession(parseInt(workItemId, 10), sessionTitle);
 
-  // Create a readable stream that we'll pipe Claude's output to
+  // Use claude-process-manager for proper stdout buffering and gate detection.
+  // The inline spawn previously used here had no buffering — split JSON messages
+  // were silently lost, and no synthetic gate events (cards) were emitted.
+  const settingsPath = getSettingsPath(repoPath);
+  const processSessionId = `wi-${workItemId}`;
+  const workItemIdNum = parseInt(workItemId, 10);
+
+  const processResult = getOrCreateProcess(processSessionId, claudeCwd, settingsPath);
+
+  if ('error' in processResult) {
+    return NextResponse.json(
+      { type: 'error', message: processResult.error },
+      { status: 503 }
+    );
+  }
+
+  const { emitter } = processResult;
+
+  // Create SSE stream from the process emitter
   const encoder = new TextEncoder();
+  let cleanupStreamListeners: (() => void) | null = null;
 
   const stream = new ReadableStream({
     start(controller) {
-      // Spawn Claude CLI with streaming JSON output in the worktree directory
-      // Use bypassPermissions mode + explicit settings path (if exists) to enable hooks while avoiding prompts
-      const settingsPath = getSettingsPath(repoPath);
-      const claudeArgs = [
-        '-p', prompt,
-        '--output-format', 'stream-json',
-        '--verbose',
-        '--permission-mode', 'bypassPermissions',
-      ];
-      if (settingsPath) {
-        claudeArgs.push('--settings', settingsPath);
-      }
-      const claude = spawn('claude', claudeArgs, {
-        cwd: claudeCwd,
-        env: { ...process.env },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      claude.stdout.on('data', (data: Buffer) => {
-        // Parse each line of streaming JSON and send as SSE
-        const lines = data.toString().split('\n').filter(line => line.trim());
-        for (const line of lines) {
-          try {
-            const parsed = JSON.parse(line);
-            const sseData = `data: ${JSON.stringify(parsed)}\n\n`;
-            controller.enqueue(encoder.encode(sseData));
-          } catch {
-            // If not valid JSON, send as raw text
-            const sseData = `data: ${JSON.stringify({ type: 'text', content: line })}\n\n`;
-            controller.enqueue(encoder.encode(sseData));
+      let assistantResponse = '';
+      let responseComplete = false;
+      let responseSaved = false;
+
+      // Safe enqueue — prevents crashes when stream is already closed
+      const safeEnqueue = (data: Uint8Array): boolean => {
+        try {
+          controller.enqueue(data);
+          return true;
+        } catch {
+          if (!responseComplete) {
+            responseComplete = true;
+            saveAssistantResponse();
+            emitter.off('data', onData);
+            emitter.off('error', onError);
+            emitter.off('close', onClose);
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+          }
+          return false;
+        }
+      };
+
+      // SSE heartbeat to prevent connection timeouts during long tool executions
+      const heartbeatInterval = setInterval(() => {
+        if (responseComplete) {
+          clearInterval(heartbeatInterval);
+          return;
+        }
+        safeEnqueue(encoder.encode(': heartbeat\n\n'));
+      }, 15_000);
+
+      const saveAssistantResponse = () => {
+        if (!responseSaved && assistantResponse.trim()) {
+          appendSessionContentByWorkItem(workItemIdNum, {
+            role: 'assistant',
+            content: assistantResponse.trim(),
+            timestamp: new Date().toISOString()
+          });
+          responseSaved = true;
+        }
+      };
+
+      const onData = (parsed: Record<string, unknown>) => {
+        if (responseComplete) return;
+
+        // Collect text content for session storage
+        if (parsed.type === 'assistant' && parsed.message) {
+          const msg = parsed.message as { content?: Array<{ type: string; text?: string; name?: string }> };
+          if (msg.content) {
+            for (const block of msg.content) {
+              if (block.type === 'text' && block.text) {
+                if (assistantResponse && !assistantResponse.endsWith('\n')) {
+                  assistantResponse += '\n\n';
+                }
+                assistantResponse += block.text;
+              }
+            }
           }
+        } else if (parsed.type === 'content_block_delta') {
+          const delta = parsed.delta as { text?: string } | undefined;
+          if (delta?.text) {
+            assistantResponse += delta.text;
+          }
+        }
+
+        // Check for result message - Claude is done with this turn
+        if (parsed.type === 'result') {
+          responseComplete = true;
+          clearInterval(heartbeatInterval);
+          saveAssistantResponse();
+
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify(parsed)}\n\n`));
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
+
+          emitter.off('data', onData);
+          emitter.off('error', onError);
+          emitter.off('close', onClose);
+          try { controller.close(); } catch { /* already closed */ }
+          return;
+        }
+
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify(parsed)}\n\n`));
+      };
+
+      const onError = (err: { type: string; content: string }) => {
+        if (responseComplete) return;
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', content: err.content })}\n\n`));
+      };
+
+      const onClose = (info: { exitCode: number }) => {
+        if (responseComplete) return;
+        responseComplete = true;
+        clearInterval(heartbeatInterval);
+        saveAssistantResponse();
+
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: info.exitCode })}\n\n`));
+        try { controller.close(); } catch { /* already closed */ }
+      };
+
+      cleanupStreamListeners = () => {
+        if (responseComplete) return;
+        responseComplete = true;
+        clearInterval(heartbeatInterval);
+        saveAssistantResponse();
+        emitter.off('data', onData);
+        emitter.off('error', onError);
+        emitter.off('close', onClose);
+      };
+
+      emitter.on('data', onData);
+      emitter.on('error', onError);
+      emitter.on('close', onClose);
+
+      // Send the initial prompt as first message
+      let sent = sendProcessMessage(processSessionId, prompt);
+
+      // If send failed, retry with fresh process
+      if (!sent) {
+        killProcess(processSessionId);
+        const retryResult = getOrCreateProcess(processSessionId, claudeCwd, settingsPath);
+        if ('error' in retryResult) {
+          clearInterval(heartbeatInterval);
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', content: retryResult.error })}\n\n`));
+          safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
+          try { controller.close(); } catch { /* already closed */ }
+          return;
         }
-      });
-
-      claude.stderr.on('data', (data: Buffer) => {
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: data.toString() })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-      });
-
-      claude.on('close', (code) => {
-        // Update session status based on exit code
-        const status = code === 0 ? 'completed' : 'error';
-        updateSessionStatus(parseInt(workItemId, 10), status);
-
-        const sseData = `data: ${JSON.stringify({ type: 'done', exitCode: code })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-        controller.close();
-      });
-
-      claude.on('error', (err) => {
-        // Mark session as error on spawn failure
-        updateSessionStatus(parseInt(workItemId, 10), 'error');
-
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: err.message })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-        controller.close();
-      });
+        const { emitter: newEmitter } = retryResult;
+        emitter.off('data', onData);
+        emitter.off('error', onError);
+        emitter.off('close', onClose);
+        newEmitter.on('data', onData);
+        newEmitter.on('error', onError);
+        newEmitter.on('close', onClose);
+        sent = sendProcessMessage(processSessionId, prompt);
+      }
+
+      if (!sent) {
+        clearInterval(heartbeatInterval);
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', content: 'Claude process unavailable' })}\n\n`));
+        safeEnqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 1 })}\n\n`));
+        try { controller.close(); } catch { /* already closed */ }
+      }
+    },
+    cancel() {
+      cleanupStreamListeners?.();
     },
   });