jettypod 4.4.120 → 4.4.121

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

@@ -1,280 +0,0 @@
-import { spawnSync } from 'child_process';
-import { NextRequest, NextResponse } from 'next/server';
-import path from 'path';
-import fs from 'fs';
-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
-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,
- * so we use JETTYPOD_PROJECT_PATH env var which is set correctly by the Electron main process.
- */
-function getProjectRoot(): string {
-  return process.env.JETTYPOD_PROJECT_PATH || path.resolve(process.cwd());
-}
-
-/**
- * Get the settings path if it exists, otherwise return undefined.
- * Claude CLI can run without explicit settings, so this is optional.
- */
-function getSettingsPath(projectRoot: string): string | undefined {
-  const settingsPath = path.join(projectRoot, '.claude/settings.json');
-  return fs.existsSync(settingsPath) ? settingsPath : undefined;
-}
-
-export const dynamic = 'force-dynamic';
-
-function isClaudeCliAvailable(): boolean {
-  const result = spawnSync('which', ['claude'], { encoding: 'utf-8' });
-  return result.status === 0 && result.stdout.trim().length > 0;
-}
-
-function isValidWorkItemId(id: string): boolean {
-  const parsed = parseInt(id, 10);
-  return !isNaN(parsed) && parsed > 0 && String(parsed) === id;
-}
-
-export async function POST(
-  request: NextRequest,
-  { params }: { params: Promise<{ workItemId: string }> }
-) {
-  const { workItemId } = await params;
-
-  // Validate work item ID
-  if (!isValidWorkItemId(workItemId)) {
-    return NextResponse.json(
-      { type: 'error', message: 'Invalid work item' },
-      { status: 400 }
-    );
-  }
-
-  // Check if Claude CLI is available
-  if (!isClaudeCliAvailable()) {
-    return NextResponse.json(
-      { type: 'error', message: 'Claude CLI not found' },
-      { status: 503 }
-    );
-  }
-
-  // Get the work item context to build the prompt
-  const body = await request.json().catch(() => ({}));
-  const { title, description, type } = body;
-
-  // Determine work item type label for the prompt
-  const workItemType = type || 'chore';
-
-  // Get or create worktree for this work item
-  const workItem = {
-    id: parseInt(workItemId, 10),
-    title: title || `Work item ${workItemId}`
-  };
-
-  // Determine the repo path - use env var in packaged apps, fallback to cwd
-  const repoPath = getProjectRoot();
-
-  // Check for existing worktree or create one
-  const workResult = await worktreeFacade.startWork(workItem, { repoPath });
-
-  // Use worktree path if available, otherwise fall back to main repo
-  const claudeCwd = workResult.path;
-
-  // Build the prompt for Claude based on work item type
-  const prompt = `You are working on ${workItemType} #${workItemId}: ${title || 'Unknown task'}
-${description ? `\nDescription: ${description}` : ''}
-
-Please start working on this ${workItemType}. Use the appropriate tools to implement the required changes.`;
-
-  // Register session in database before spawning Claude
-  const sessionTitle = title || `Work item ${workItemId}`;
-  registerSession(parseInt(workItemId, 10), sessionTitle);
-
-  // 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) {
-      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;
-        }
-        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?.();
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
-  });
-}

package/apps/dashboard/app/api/claude/sessions/[sessionId]/content/route.ts

@@ -1,52 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { getSessionContent, getSessionContentByWorkItem } from '@/lib/db';
-
-export const dynamic = 'force-dynamic';
-
-function isValidSessionId(id: string): boolean {
-  const parsed = parseInt(id, 10);
-  return !isNaN(parsed) && parsed > 0 && String(parsed) === id;
-}
-
-// GET /api/claude/sessions/[sessionId]/content - Get session conversation history
-// Use ?by=workitem to look up by work_item_id instead of session id
-export async function GET(
-  request: NextRequest,
-  { params }: { params: Promise<{ sessionId: string }> }
-) {
-  const { sessionId } = await params;
-  const { searchParams } = new URL(request.url);
-  const lookupBy = searchParams.get('by');
-
-  if (!isValidSessionId(sessionId)) {
-    return NextResponse.json(
-      { error: 'Invalid session ID' },
-      { status: 400 }
-    );
-  }
-
-  try {
-    const id = parseInt(sessionId, 10);
-    const dbContent = lookupBy === 'workitem'
-      ? getSessionContentByWorkItem(id)
-      : getSessionContent(id);
-
-    // Transform DB format (role) to frontend format (type)
-    // DB stores: { role: 'user'|'assistant'|'error', content, timestamp }
-    // Frontend expects: { type: 'user'|'assistant'|'error', content, timestamp }
-    // Includes error messages persisted during conversation (#1000098, #1000099)
-    const content = dbContent.map(msg => ({
-      type: msg.role,
-      content: msg.content,
-      timestamp: msg.timestamp,
-    }));
-
-    return NextResponse.json({ content });
-  } catch (error) {
-    console.error('Failed to get session content:', error);
-    return NextResponse.json(
-      { error: 'Failed to get session content' },
-      { status: 500 }
-    );
-  }
-}