jettypod 4.4.120 → 4.4.121

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

@@ -1,525 +0,0 @@
-import { spawnSync } from 'child_process';
-import { NextRequest, NextResponse } from 'next/server';
-import path from 'path';
-import fs from 'fs';
-import { appendSessionContent, getSessionContent, getSession, createWorkItem, updateWorkItemDescription, ConversationTurn } from '@/lib/db';
-import {
-  getOrCreateProcess,
-  sendMessage as sendProcessMessage,
-  killProcess,
-} from '@/lib/claude-process-manager';
-import { parseBacklogInput } from '@/lib/backlog-parser';
-
-/**
- * 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';
-
-// Cache the CLI availability check so we only pay the spawnSync cost once per process lifetime
-let claudeCliAvailable: boolean | null = null;
-
-function isClaudeCliAvailable(): boolean {
-  if (claudeCliAvailable !== null) return claudeCliAvailable;
-  const result = spawnSync('which', ['claude'], { encoding: 'utf-8' });
-  claudeCliAvailable = result.status === 0 && result.stdout.trim().length > 0;
-  return claudeCliAvailable;
-}
-
-/**
- * Build a context restoration prefix from stored conversation history.
- * Prepended to the user's message when a Claude process was respawned.
- */
-function buildContextPrefix(history: ConversationTurn[]): string {
-  if (history.length === 0) return '';
-
-  // Only include user and assistant messages (skip errors)
-  const relevant = history.filter(t => t.role === 'user' || t.role === 'assistant');
-  if (relevant.length === 0) return '';
-
-  const lines = relevant.map(t => {
-    const label = t.role === 'user' ? 'User' : 'Assistant';
-    return `${label}: ${t.content}`;
-  });
-
-  return `[Session context restored — your process was restarted. Previous conversation:]\n\n${lines.join('\n\n')}\n\n[End of restored context. New message from user:]\n\n`;
-}
-
-function isValidSessionId(id: string): boolean {
-  const parsed = parseInt(id, 10);
-  return !isNaN(parsed) && parsed > 0 && String(parsed) === id;
-}
-
-// Backlog question gate data
-const BACKLOG_QUESTION_GATE = JSON.stringify({
-  question: 'Done. What now?',
-  options: [
-    { id: 'finished', label: 'Finished adding to the backlog', description: 'Close this tab' },
-    { id: 'add-details', label: 'Add details', description: 'Describe what this work item involves' },
-    { id: 'create-another', label: 'Create another work item', description: 'Add another item to the backlog' },
-  ],
-});
-
-/**
- * Build a synthetic SSE response from an array of text chunks.
- * Each chunk becomes a separate assistant message event.
- */
-function buildSyntheticSSE(chunks: string[]): Response {
-  const encoder = new TextEncoder();
-  const stream = new ReadableStream({
-    start(controller) {
-      for (const text of chunks) {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({
-          type: 'assistant',
-          message: { content: [{ type: 'text', text }] }
-        })}\n\n`));
-      }
-      controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
-      controller.close();
-    }
-  });
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
-  });
-}
-
-/**
- * Handle the full "Add to Backlog" conversation flow without spawning Claude CLI.
- * Returns a Response for handled cases, or null to fall through to Claude CLI.
- */
-function handleBacklogMessage(sessionIdNum: number, message: string): Response | null {
-  // Check conversation history to determine state
-  const history = getSessionContent(sessionIdNum);
-  const lastAssistant = [...history].reverse().find(t => t.role === 'assistant')?.content || '';
-
-  // Option: "Finished adding to the backlog" — handled client-side (tab closes)
-  // This shouldn't normally reach the server, but handle gracefully if it does
-  if (message === 'Finished adding to the backlog') {
-    appendSessionContent(sessionIdNum, {
-      role: 'assistant',
-      content: 'Done!',
-      timestamp: new Date().toISOString()
-    });
-    return buildSyntheticSSE(['Done!']);
-  }
-
-  // Option: "Add details" — prompt for details
-  if (message === 'Add details') {
-    const promptText = 'Tell me more about this work item.';
-    appendSessionContent(sessionIdNum, {
-      role: 'assistant',
-      content: promptText,
-      timestamp: new Date().toISOString()
-    });
-    return buildSyntheticSSE([promptText]);
-  }
-
-  // Option: "Create another work item" — prompt for name
-  if (message === 'Create another work item') {
-    const promptText = 'What should we call this next one?';
-    appendSessionContent(sessionIdNum, {
-      role: 'assistant',
-      content: promptText,
-      timestamp: new Date().toISOString()
-    });
-    return buildSyntheticSSE([promptText]);
-  }
-
-  // State: user is adding details (previous message was "Tell me more...")
-  if (lastAssistant.includes('Tell me more about this work item')) {
-    // Find the last created work item ID from history
-    const workItemMatch = [...history].reverse()
-      .find(t => t.role === 'assistant' && /Created \w+ #(\d+):/.test(t.content))
-      ?.content.match(/Created \w+ #(\d+):/);
-
-    if (workItemMatch) {
-      const workItemId = parseInt(workItemMatch[1], 10);
-      try {
-        updateWorkItemDescription(workItemId, message);
-        const confirmText = `Updated description for #${workItemId}.`;
-        appendSessionContent(sessionIdNum, {
-          role: 'assistant',
-          content: confirmText + `\n[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`,
-          timestamp: new Date().toISOString()
-        });
-        return buildSyntheticSSE([
-          confirmText,
-          `[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`,
-        ]);
-      } catch (err) {
-        console.error('[backlog] Failed to update description:', err);
-      }
-    }
-    // Fall through to Claude CLI if we can't find the work item
-    return null;
-  }
-
-  // Default state: user is providing a work item name — try local parsing
-  const parsed = parseBacklogInput(message);
-  if (parsed) {
-    try {
-      const workItem = createWorkItem(parsed.type, parsed.title);
-      const confirmText = `Created ${parsed.type} #${workItem.id}: ${parsed.title}`;
-      const cardGate = `[GATE:work-item-card]${JSON.stringify({ id: workItem.id, type: workItem.type, title: workItem.title, status: 'backlog' })}[/GATE]`;
-      const questionGate = `[GATE:question]${BACKLOG_QUESTION_GATE}[/GATE]`;
-
-      appendSessionContent(sessionIdNum, {
-        role: 'assistant',
-        content: confirmText + '\n' + cardGate + '\n' + questionGate,
-        timestamp: new Date().toISOString()
-      });
-
-      // Send as separate SSE events so stream manager processes each gate independently
-      return buildSyntheticSSE([confirmText, cardGate, questionGate]);
-    } catch (err) {
-      console.error('[backlog-parser] Failed to create work item:', err);
-    }
-  }
-
-  // Can't parse locally — fall through to Claude CLI with haiku
-  return null;
-}
-
-export async function POST(
-  request: NextRequest,
-  { params }: { params: Promise<{ sessionId: string }> }
-) {
-  const { sessionId } = await params;
-
-  // Check for debug mode - shows synthetic messages for troubleshooting (#1000104)
-  const { searchParams } = new URL(request.url);
-  const showSynthetic = searchParams.get('debug') === 'true';
-
-  // Validate session ID
-  if (!isValidSessionId(sessionId)) {
-    return NextResponse.json(
-      { type: 'error', message: 'Invalid session' },
-      { status: 400 }
-    );
-  }
-
-  // Check if Claude CLI is available
-  if (!isClaudeCliAvailable()) {
-    return NextResponse.json(
-      { type: 'error', message: 'Claude CLI not found' },
-      { status: 503 }
-    );
-  }
-
-  // Get the message and optional images
-  const body = await request.json().catch(() => ({}));
-  const { message, images } = body;
-
-  if (!message || typeof message !== 'string') {
-    return NextResponse.json(
-      { type: 'error', message: 'Message is required' },
-      { status: 400 }
-    );
-  }
-
-  // Handle empty/whitespace-only input gracefully
-  const trimmedMessage = message.trim();
-  if (!trimmedMessage) {
-    // Save empty user message to session
-    const sessionIdNum = parseInt(sessionId, 10);
-    appendSessionContent(sessionIdNum, {
-      role: 'user',
-      content: message,
-      timestamp: new Date().toISOString()
-    });
-
-    // Return a helpful response without invoking Claude
-    const clarificationMessage = 'I didn\'t catch that. What should we call this work item?';
-
-    // Save assistant response to session
-    appendSessionContent(sessionIdNum, {
-      role: 'assistant',
-      content: clarificationMessage,
-      timestamp: new Date().toISOString()
-    });
-
-    const encoder = new TextEncoder();
-    const emptyInputResponse = new ReadableStream({
-      start(controller) {
-        const response = {
-          type: 'assistant',
-          message: {
-            content: [{ type: 'text', text: clarificationMessage }]
-          }
-        };
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(response)}\n\n`));
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', exitCode: 0 })}\n\n`));
-        controller.close();
-      }
-    });
-
-    return new Response(emptyInputResponse, {
-      headers: {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-      },
-    });
-  }
-
-  // Save user message to session content
-  const sessionIdNum = parseInt(sessionId, 10);
-  appendSessionContent(sessionIdNum, {
-    role: 'user',
-    content: message,
-    timestamp: new Date().toISOString()
-  });
-
-  // Fast backlog creation: handle the full conversation flow locally
-  const session = getSession(sessionIdNum);
-  if (session?.title === 'Add to Backlog') {
-    const backlogResponse = handleBacklogMessage(sessionIdNum, trimmedMessage);
-    if (backlogResponse) return backlogResponse;
-    // If null, fall through to Claude CLI
-  }
-
-  // Determine model for CLI: backlog sessions use haiku for faster responses
-  const isBacklogSession = session?.title === 'Add to Backlog';
-  const processOptions = isBacklogSession ? { model: 'haiku' } : undefined;
-
-  // Standalone sessions run in main repo (no worktree)
-  const claudeCwd = getProjectRoot();
-  const settingsPath = getSettingsPath(claudeCwd);
-
-  // Get or create persistent Claude process for this session
-  const processResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath, processOptions);
-
-  // Check if we hit the process limit
-  if ('error' in processResult) {
-    return NextResponse.json(
-      { type: 'error', message: processResult.error },
-      { status: 503 }
-    );
-  }
-
-  const { emitter, isNew } = processResult;
-
-  // If process was just spawned for an existing session, restore conversation context
-  // by prepending stored history to the user's message so Claude has full context
-  let messageToSend = trimmedMessage;
-  if (isNew) {
-    // Load history saved BEFORE this message (the current message was already appended above)
-    const history = getSessionContent(sessionIdNum);
-    // Exclude the message we just appended (last user turn)
-    const priorHistory = history.slice(0, -1);
-    const prefix = buildContextPrefix(priorHistory);
-    if (prefix) {
-      messageToSend = prefix + trimmedMessage;
-    }
-  }
-
-  // Create a readable stream for SSE
-  const encoder = new TextEncoder();
-
-  // Track cleanup state outside the stream so cancel() can access it
-  let activeEmitter = emitter;
-  let responseComplete = false;
-  let onData: ((parsed: Record<string, unknown>) => void) | null = null;
-  let onError: ((err: { type: string; content: string }) => void) | null = null;
-  let onClose: ((info: { exitCode: number }) => void) | null = null;
-
-  const removeListeners = () => {
-    if (onData) activeEmitter.off('data', onData);
-    if (onError) activeEmitter.off('error', onError);
-    if (onClose) activeEmitter.off('close', onClose);
-  };
-
-  const stream = new ReadableStream({
-    start(controller) {
-      // Collect assistant response text for saving to session content
-      let assistantResponse = '';
-
-      // Track if we've saved the response (to avoid duplicate saves)
-      let responseSaved = false;
-
-      // Helper to save assistant response if not already saved
-      const saveAssistantResponse = () => {
-        if (!responseSaved && assistantResponse.trim()) {
-          appendSessionContent(sessionIdNum, {
-            role: 'assistant',
-            content: assistantResponse.trim(),
-            timestamp: new Date().toISOString()
-          });
-          responseSaved = true;
-        }
-      };
-
-      // Handle data from the persistent process
-      onData = (parsed: Record<string, unknown>) => {
-        if (responseComplete) return;
-
-        // Skip synthetic messages (skill prompt injections) unless in debug mode (#1000104)
-        // These are internal system prompts that shouldn't normally appear in the conversation
-        if (parsed.isSynthetic === true && !showSynthetic) {
-          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;
-              }
-              // When Claude invokes the Skill tool, save accumulated response immediately
-              // This prevents losing content when skills are invoked and the turn ends differently
-              if (block.type === 'tool_use' && block.name === 'Skill') {
-                saveAssistantResponse();
-                // Reset for potential post-skill content (Bug #1000097)
-                // Without this, responseSaved=true blocks saving any content after the skill
-                assistantResponse = '';
-                responseSaved = false;
-              }
-            }
-          }
-        } 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 - this indicates Claude is done with this turn
-        if (parsed.type === 'result') {
-          responseComplete = true;
-
-          // 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`));
-
-          // Remove listeners and close
-          removeListeners();
-          controller.close();
-          return;
-        }
-
-        const sseData = `data: ${JSON.stringify(parsed)}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-      };
-
-      onError = (err: { type: string; content: string }) => {
-        if (responseComplete) return;
-        // Persist error to database (#1000098)
-        appendSessionContent(sessionIdNum, {
-          role: 'error',
-          content: err.content,
-          timestamp: new Date().toISOString()
-        });
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: err.content })}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-      };
-
-      onClose = (info: { exitCode: number }) => {
-        if (responseComplete) return;
-        responseComplete = true;
-
-        // 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();
-      };
-
-      // Attach listeners
-      emitter.on('data', onData);
-      emitter.on('error', onError);
-      emitter.on('close', onClose);
-
-      // Send the message to the persistent process (with context prefix if respawned)
-      let sent = sendProcessMessage(sessionId, messageToSend, images);
-
-      // Bug #1000096: If send failed, the process may have died after getOrCreateProcess
-      // Try to create a fresh process and retry once
-      if (!sent) {
-        // Kill any zombie process and create fresh one
-        killProcess(sessionId);
-
-        const retryResult = getOrCreateProcess(sessionId, claudeCwd, settingsPath, processOptions);
-        if ('error' in retryResult) {
-          // Hit process limit on retry - return error
-          controller.enqueue(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();
-          return;
-        }
-        const { emitter: newEmitter } = retryResult;
-
-        // Re-attach listeners to new emitter
-        removeListeners();
-        activeEmitter = newEmitter;
-        newEmitter.on('data', onData!);
-        newEmitter.on('error', onError!);
-        newEmitter.on('close', onClose!);
-
-        // Retry send (with context prefix since this is also a fresh process)
-        sent = sendProcessMessage(sessionId, messageToSend, images);
-      }
-
-      if (!sent) {
-        // Still failed after retry - give clear error
-        const errorContent = 'Claude process is unavailable. The process may have crashed or failed to start. Please try again.';
-        // Persist error to database (#1000098)
-        appendSessionContent(sessionIdNum, {
-          role: 'error',
-          content: errorContent,
-          timestamp: new Date().toISOString()
-        });
-        controller.enqueue(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();
-      }
-    },
-    cancel() {
-      // Client disconnected - clean up listeners to prevent writes to closed controller
-      responseComplete = true;
-      removeListeners();
-    },
-  });
-
-  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]/pin/route.ts

@@ -1,24 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { pinSession, unpinSession } from '@/lib/claude-process-manager';
-
-export const dynamic = 'force-dynamic';
-
-// POST /api/claude/sessions/[sessionId]/pin - Pin session to prevent idle cleanup
-export async function POST(
-  _request: NextRequest,
-  { params }: { params: Promise<{ sessionId: string }> }
-) {
-  const { sessionId } = await params;
-  pinSession(sessionId);
-  return NextResponse.json({ pinned: true });
-}
-
-// DELETE /api/claude/sessions/[sessionId]/pin - Unpin session to allow idle cleanup
-export async function DELETE(
-  _request: NextRequest,
-  { params }: { params: Promise<{ sessionId: string }> }
-) {
-  const { sessionId } = await params;
-  unpinSession(sessionId);
-  return NextResponse.json({ pinned: false });
-}

package/apps/dashboard/app/api/claude/sessions/cleanup/route.ts

@@ -1,34 +0,0 @@
-import { NextResponse } from 'next/server';
-import { cleanupStaleSessions } from '@/lib/db';
-
-export const dynamic = 'force-dynamic';
-
-// Default retention period in days for completed sessions
-const DEFAULT_RETENTION_DAYS = 30;
-
-// POST /api/claude/sessions/cleanup - Prune orphaned and old completed sessions
-// Query params:
-//   - retentionDays: number of days to keep completed sessions (default: 30)
-export async function POST(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const retentionDays = parseInt(searchParams.get('retentionDays') || String(DEFAULT_RETENTION_DAYS), 10);
-
-    // Validate retention days
-    if (isNaN(retentionDays) || retentionDays < 0) {
-      return NextResponse.json({ error: 'Invalid retentionDays parameter' }, { status: 400 });
-    }
-
-    const deletedCount = cleanupStaleSessions(retentionDays);
-
-    return NextResponse.json({
-      success: true,
-      deletedCount,
-      retentionDays,
-      message: `Cleaned up ${deletedCount} stale session(s)`
-    });
-  } catch (error) {
-    console.error('Failed to cleanup sessions:', error);
-    return NextResponse.json({ error: 'Failed to cleanup sessions' }, { status: 500 });
-  }
-}