jettypod 4.4.118 → 4.4.121

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

@@ -1,378 +0,0 @@
-import { spawnSync } from 'child_process';
-import { NextRequest, NextResponse } from 'next/server';
-import path from 'path';
-import fs from 'fs';
-import { appendSessionContent, getSessionContent, ConversationTurn } from '@/lib/db';
-import {
-  getOrCreateProcess,
-  sendMessage as sendProcessMessage,
-  killProcess,
-} from '@/lib/claude-process-manager';
-
-/**
- * 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;
-}
-
-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
-  const body = await request.json().catch(() => ({}));
-  const { message } = 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 would you like to add to the backlog?';
-
-    // 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()
-  });
-
-  // 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);
-
-  // 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);
-
-      // 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);
-        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);
-      }
-
-      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 });
-  }
-}

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

@@ -1,184 +0,0 @@
-import { NextResponse } from 'next/server';
-import { listSessions, createSession, linkSession, isLinkableWorkItem, getActiveSessionByWorkItem, getOrCreateSessionForWorkItem, closeSession, closeSessionByWorkItem, countActiveSessions, cleanupStaleSessions } from '@/lib/db';
-import { killProcess } from '@/lib/claude-process-manager';
-
-export const dynamic = 'force-dynamic';
-
-// Maximum number of concurrent active sessions
-const MAX_SESSIONS = 10;
-
-// Session title constraints
-const MAX_TITLE_LENGTH = 100;
-
-/**
- * Sanitize and validate session title
- * - Trims whitespace
- * - Removes control characters
- * - Enforces max length
- */
-function sanitizeTitle(title: string | undefined): string {
-  if (!title) return 'New Session';
-
-  // Remove control characters and trim whitespace
-  const sanitized = title
-    .replace(/[\x00-\x1F\x7F]/g, '') // Remove control characters
-    .trim();
-
-  // Return default if empty after sanitization
-  if (!sanitized) return 'New Session';
-
-  // Enforce max length
-  return sanitized.slice(0, MAX_TITLE_LENGTH);
-}
-
-// GET /api/claude/sessions - List all sessions with feature info
-export async function GET() {
-  try {
-    const sessions = listSessions();
-    // Convert numeric IDs to strings for frontend consistency
-    const normalizedSessions = sessions.map(session => ({
-      ...session,
-      id: String(session.id),
-      featureId: session.featureId ? String(session.featureId) : null,
-    }));
-    return NextResponse.json(normalizedSessions);
-  } catch (error) {
-    // Log error for debugging but return empty array to client
-    // This ensures dashboard renders without crashing when DB is unavailable
-    console.error('Failed to list sessions:', error);
-    return NextResponse.json([]);
-  }
-}
-
-// POST /api/claude/sessions - Create new unlinked session or get/create for work item
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const { title, workItemId } = body;
-
-    // Opportunistically clean up stale sessions before checking limits
-    // This ensures old orphaned/completed sessions don't block new session creation
-    cleanupStaleSessions();
-
-    // Check session limit before creating new sessions
-    const currentCount = countActiveSessions();
-    if (currentCount >= MAX_SESSIONS) {
-      return NextResponse.json({
-        error: `Session limit reached (${MAX_SESSIONS}). Close existing sessions to create new ones.`,
-        code: 'SESSION_LIMIT_REACHED',
-        currentCount,
-        maxSessions: MAX_SESSIONS
-      }, { status: 429 });
-    }
-
-    // If workItemId provided, use get-or-create pattern
-    if (workItemId) {
-      const result = getOrCreateSessionForWorkItem(workItemId);
-      if (!result.session) {
-        return NextResponse.json({
-          error: result.error,
-          redirectToId: result.redirectToId ? String(result.redirectToId) : undefined
-        }, { status: 400 });
-      }
-      return NextResponse.json({
-        id: String(result.session.id),
-        title: result.session.title,
-        created: result.created,
-        workItemId: result.session.work_item_id ? String(result.session.work_item_id) : null
-      });
-    }
-
-    // Otherwise create unlinked session with sanitized title
-    const sessionTitle = sanitizeTitle(title);
-    const sessionId = createSession(sessionTitle);
-    return NextResponse.json({ id: String(sessionId), title: sessionTitle, created: true });
-  } catch (error) {
-    console.error('Failed to create session:', error);
-    return NextResponse.json({ error: 'Failed to create session' }, { status: 500 });
-  }
-}
-
-// PATCH /api/claude/sessions - Link session to work item
-// Only links to: features, standalone chores, bugs
-// Rejects: epics, chores under features (redirects to parent feature)
-export async function PATCH(request: Request) {
-  try {
-    const body = await request.json();
-    const { sessionId, workItemId } = body;
-
-    if (!sessionId || !workItemId) {
-      return NextResponse.json({ error: 'sessionId and workItemId required' }, { status: 400 });
-    }
-
-    // Check if this work item type can have sessions
-    const linkCheck = isLinkableWorkItem(workItemId);
-    if (!linkCheck.linkable) {
-      return NextResponse.json({
-        error: linkCheck.reason,
-        redirectToId: linkCheck.redirectToId ? String(linkCheck.redirectToId) : undefined
-      }, { status: 400 });
-    }
-
-    // Check if work item already has an ACTIVE session
-    const existingSession = getActiveSessionByWorkItem(workItemId);
-    if (existingSession) {
-      return NextResponse.json({
-        error: 'Work item already has an active session',
-        existingSessionId: String(existingSession.id)
-      }, { status: 409 });
-    }
-
-    const result = linkSession(sessionId, workItemId);
-    if (!result.success) {
-      return NextResponse.json({
-        error: result.error,
-        redirectToId: result.redirectToId ? String(result.redirectToId) : undefined
-      }, { status: 400 });
-    }
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error('Failed to link session:', error);
-    return NextResponse.json({ error: 'Failed to link session' }, { status: 500 });
-  }
-}
-
-// DELETE /api/claude/sessions - Close a session
-// Use ?sessionId=X&type=standalone for standalone sessions (closes by claude_sessions.id)
-// Use ?sessionId=X&type=workitem for work-item sessions (closes by work_item_id)
-export async function DELETE(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const sessionId = searchParams.get('sessionId');
-    const sessionType = searchParams.get('type') || 'standalone'; // default to standalone for backwards compat
-
-    if (!sessionId) {
-      return NextResponse.json({ error: 'sessionId required' }, { status: 400 });
-    }
-
-    const id = parseInt(sessionId, 10);
-    let success: boolean;
-
-    // Kill any active Claude process for this session before closing
-    // For standalone sessions, the sessionId IS the process key
-    // For work-item sessions, we'd need to look up the session ID first
-    killProcess(sessionId);
-
-    if (sessionType === 'workitem') {
-      // Work-item sessions: sessionId is the work_item_id
-      success = closeSessionByWorkItem(id);
-    } else {
-      // Standalone sessions: sessionId is the claude_sessions.id
-      success = closeSession(id);
-    }
-
-    if (!success) {
-      return NextResponse.json({ error: 'Session not found' }, { status: 404 });
-    }
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error('Failed to close session:', error);
-    return NextResponse.json({ error: 'Failed to close session' }, { status: 500 });
-  }
-}

package/apps/dashboard/app/api/decisions/[id]/route.ts

@@ -1,25 +0,0 @@
-import { NextResponse } from 'next/server';
-import { getDecision } from '@/lib/db';
-
-export const dynamic = 'force-dynamic';
-
-interface RouteContext {
-  params: Promise<{ id: string }>;
-}
-
-export async function GET(request: Request, context: RouteContext) {
-  const { id } = await context.params;
-  const decisionId = parseInt(id, 10);
-
-  if (isNaN(decisionId)) {
-    return NextResponse.json({ error: 'Invalid decision ID' }, { status: 400 });
-  }
-
-  const decision = getDecision(decisionId);
-
-  if (!decision) {
-    return NextResponse.json({ error: 'Decision not found' }, { status: 404 });
-  }
-
-  return NextResponse.json(decision);
-}

package/apps/dashboard/app/api/internal/set-project/route.ts

@@ -1,17 +0,0 @@
-import { NextResponse } from 'next/server';
-import { closeDb } from '@/lib/db';
-
-// Internal endpoint called by the Electron main process to update the project path
-// in the Next.js child process after a project switch. In dev mode, Next.js runs as
-// a separate process and doesn't share process.env with Electron.
-export async function POST(request: Request) {
-  const { projectPath } = await request.json();
-
-  // Update env var so all subsequent db.ts / test-results-db.ts calls use the new path
-  process.env.JETTYPOD_PROJECT_PATH = projectPath || '';
-
-  // Close the cached DB connection so it reconnects to the new project on next access
-  closeDb();
-
-  return NextResponse.json({ success: true });
-}

package/apps/dashboard/app/api/kanban/route.ts

@@ -1,15 +0,0 @@
-import { NextResponse } from 'next/server';
-import { getKanbanData } from '@/lib/db';
-
-export const dynamic = 'force-dynamic';
-
-export async function GET() {
-  const data = getKanbanData();
-
-  // Convert Maps to arrays for JSON serialization
-  return NextResponse.json({
-    inFlight: data.inFlight,
-    backlog: Array.from(data.backlog.entries()),
-    done: Array.from(data.done.entries()),
-  });
-}