jettypod 4.4.118 → 4.4.121

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

@@ -1,386 +0,0 @@
-import { spawnSync } from 'child_process';
-import { NextRequest, NextResponse } from 'next/server';
-import path from 'path';
-import fs from 'fs';
-import { appendSessionContentByWorkItem, getSessionContentByWorkItem, getWorkItem, ConversationTurn } 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';
-
-/**
- * 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 '';
-
-  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`;
-}
-
-// 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;
-}
-
-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;
-
-  // Check for debug mode - shows synthetic messages for troubleshooting (#1000104)
-  const { searchParams } = new URL(request.url);
-  const showSynthetic = searchParams.get('debug') === 'true';
-
-  // 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 message (conversationHistory no longer needed - persistent process maintains context)
-  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 content
-    const workItemIdNum = parseInt(workItemId, 10);
-    appendSessionContentByWorkItem(workItemIdNum, {
-      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 me to help with?';
-
-    // Save assistant response to session content
-    appendSessionContentByWorkItem(workItemIdNum, {
-      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 workItemIdNum = parseInt(workItemId, 10);
-  appendSessionContentByWorkItem(workItemIdNum, {
-    role: 'user',
-    content: message,
-    timestamp: new Date().toISOString()
-  });
-
-  // Check if this is a conversational work item (skip worktree)
-  const workItemData = getWorkItem(workItemIdNum);
-  const isConversational = workItemData?.conversational === 1;
-
-  const repoPath = getProjectRoot();
-  let claudeCwd: string;
-
-  if (isConversational) {
-    // 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;
-  }
-
-  const settingsPath = getSettingsPath(repoPath);
-
-  // Use workItemId prefixed with 'wi-' to avoid collision with standalone session IDs
-  const processSessionId = `wi-${workItemId}`;
-
-  // Get or create persistent Claude process for this work item
-  const processResult = getOrCreateProcess(processSessionId, 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
-  let messageToSend = trimmedMessage;
-  if (isNew) {
-    const history = getSessionContentByWorkItem(workItemIdNum);
-    // 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();
-
-  const stream = new ReadableStream({
-    start(controller) {
-      // Collect assistant response text for saving to session content
-      let assistantResponse = '';
-      let responseComplete = false;
-
-      // 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()) {
-          appendSessionContentByWorkItem(workItemIdNum, {
-            role: 'assistant',
-            content: assistantResponse.trim(),
-            timestamp: new Date().toISOString()
-          });
-          responseSaved = true;
-        }
-      };
-
-      // Handle data from the persistent process
-      const 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
-          emitter.off('data', onData);
-          emitter.off('error', onError);
-          emitter.off('close', onClose);
-          controller.close();
-          return;
-        }
-
-        const sseData = `data: ${JSON.stringify(parsed)}\n\n`;
-        controller.enqueue(encoder.encode(sseData));
-      };
-
-      const onError = (err: { type: string; content: string }) => {
-        if (responseComplete) return;
-        // Persist error to database (#1000098)
-        appendSessionContentByWorkItem(workItemIdNum, {
-          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));
-      };
-
-      const 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
-      let sent = sendProcessMessage(processSessionId, messageToSend);
-
-      // 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(processSessionId);
-
-        const retryResult = getOrCreateProcess(processSessionId, 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
-        emitter.off('data', onData);
-        emitter.off('error', onError);
-        emitter.off('close', onClose);
-        newEmitter.on('data', onData);
-        newEmitter.on('error', onError);
-        newEmitter.on('close', onClose);
-
-        // Retry send
-        sent = sendProcessMessage(processSessionId, 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)
-        appendSessionContentByWorkItem(workItemIdNum, {
-          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();
-      }
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-    },
-  });
-}

package/apps/dashboard/app/api/claude/[workItemId]/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/[workItemId]/pin - Pin work item session to prevent idle cleanup
-export async function POST(
-  _request: NextRequest,
-  { params }: { params: Promise<{ workItemId: string }> }
-) {
-  const { workItemId } = await params;
-  pinSession(`wi-${workItemId}`);
-  return NextResponse.json({ pinned: true });
-}
-
-// DELETE /api/claude/[workItemId]/pin - Unpin work item session to allow idle cleanup
-export async function DELETE(
-  _request: NextRequest,
-  { params }: { params: Promise<{ workItemId: string }> }
-) {
-  const { workItemId } = await params;
-  unpinSession(`wi-${workItemId}`);
-  return NextResponse.json({ pinned: false });
-}

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

@@ -1,167 +0,0 @@
-import { spawn, 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 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);
-
-  // Create a readable stream that we'll pipe Claude's output to
-  const encoder = new TextEncoder();
-
-  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));
-          }
-        }
-      });
-
-      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();
-      });
-    },
-  });
-
-  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 }
-    );
-  }
-}