jettypod 4.4.120 → 4.4.121

package/apps/dashboard/README.md

@@ -1,36 +0,0 @@
-This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
-
-## Getting Started
-
-First, run the development server:
-
-```bash
-npm run dev
-# or
-yarn dev
-# or
-pnpm dev
-# or
-bun dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
-
-You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
-
-This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
-
-## Learn More
-
-To learn more about Next.js, take a look at the following resources:
-
-- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
-- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
-
-You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
-
-## Deploy on Vercel
-
-The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
-
-Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

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

@@ -1,446 +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';
-
-/**
- * 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 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 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 {
-    // 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);
-
-  // 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();
-
-  // 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
-      let assistantResponse = '';
-      let responseComplete = false;
-
-      // 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()) {
-          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;
-          clearInterval(heartbeatInterval);
-
-          // Save assistant response to session content (if not already saved)
-          saveAssistantResponse();
-
-          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
-          currentEmitter.off('data', onData);
-          currentEmitter.off('error', onError);
-          currentEmitter.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;
-        // Persist error to database (#1000098)
-        appendSessionContentByWorkItem(workItemIdNum, {
-          role: 'error',
-          content: err.content,
-          timestamp: new Date().toISOString()
-        });
-        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();
-
-        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
-      currentEmitter.on('data', onData);
-      currentEmitter.on('error', onError);
-      currentEmitter.on('close', onClose);
-
-      // Send the message to the persistent process
-      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
-      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
-          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;
-
-        // Re-attach listeners to new emitter
-        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, 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, {
-          role: 'error',
-          content: errorContent,
-          timestamp: new Date().toISOString()
-        });
-        safeEnqueue(encoder.encode(`data: ${JSON.stringify({
-          type: 'error',
-          content: errorContent
-        })}\n\n`));
-        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, {
-    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 });
-}