jettypod 4.4.109 → 4.4.111

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto-resolve generated files during merge by keeping the current branch version
+cucumber-results.json merge=ours

package/apps/dashboard/app/access-code/page.tsx

@@ -0,0 +1,110 @@
+'use client';
+
+import { useState } from 'react';
+import Image from 'next/image';
+
+export default function AccessCodePage() {
+  const [code, setCode] = useState('');
+  const [error, setError] = useState<string | null>(null);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+
+    if (!code.trim()) {
+      setError('Please enter an access code.');
+      return;
+    }
+
+    if (!window.electronAPI?.isElectron) {
+      setError('Access code validation is only available in the desktop app.');
+      return;
+    }
+
+    setIsSubmitting(true);
+
+    try {
+      const result = await window.electronAPI.access.validate(code.trim());
+
+      if (!result.success) {
+        setError(result.error || 'Invalid access code.');
+        setIsSubmitting(false);
+        return;
+      }
+
+      // Access granted - navigate to main app
+      window.location.href = '/';
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to validate access code.');
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <div className="flex flex-col items-center justify-center min-h-screen bg-white dark:bg-zinc-900 p-8">
+      <div className="max-w-md w-full space-y-8">
+        {/* Logo */}
+        <div className="flex flex-col items-center space-y-4">
+          <Image
+            src="/jettypod_wordmark.png"
+            alt="JettyPod"
+            width={160}
+            height={40}
+            priority
+          />
+          <h1 className="text-2xl font-semibold text-zinc-900 dark:text-zinc-100 text-center">
+            Enter Access Code
+          </h1>
+          <p className="text-zinc-500 dark:text-zinc-400 text-center">
+            Enter your access code to get started with JettyPod.
+          </p>
+        </div>
+
+        {/* Error */}
+        {error && (
+          <div className="bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 text-red-700 dark:text-red-400 px-4 py-3 rounded-lg text-sm">
+            {error}
+          </div>
+        )}
+
+        {/* Form */}
+        <form onSubmit={handleSubmit} className="pt-4 space-y-4">
+          <input
+            type="text"
+            value={code}
+            onChange={(e) => setCode(e.target.value)}
+            placeholder="Access code"
+            autoFocus
+            disabled={isSubmitting}
+            className="w-full px-4 py-3 rounded-xl border border-zinc-300 dark:border-zinc-600 bg-white dark:bg-zinc-800 text-zinc-900 dark:text-zinc-100 placeholder-zinc-400 dark:placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-zinc-400 dark:focus:ring-zinc-500 disabled:opacity-50"
+            data-testid="access-code-input"
+          />
+          <button
+            type="submit"
+            disabled={isSubmitting}
+            className="w-full py-3 px-6 rounded-xl font-medium transition-all duration-200 hover:-translate-y-1 hover:scale-[1.01] active:translate-y-0 active:scale-100 disabled:opacity-50 disabled:pointer-events-none"
+            style={{
+              cursor: isSubmitting ? 'default' : 'pointer',
+              background: 'linear-gradient(145deg, #ffffff 0%, #faf9f7 10%, #f0f4f4 35%, #c8d9da 55%, #819D9F 90%)',
+              color: '#3d4d4e',
+              boxShadow: `
+                0 1px 1px rgba(0, 0, 0, 0.02),
+                0 2px 4px rgba(0, 0, 0, 0.03),
+                0 6px 12px rgba(0, 0, 0, 0.05),
+                0 12px 24px rgba(0, 0, 0, 0.06),
+                0 20px 40px rgba(129, 157, 159, 0.2),
+                0 32px 64px rgba(129, 157, 159, 0.18),
+                inset 0 2px 4px rgba(255, 255, 255, 1),
+                inset 0 -2px 4px rgba(129, 157, 159, 0.05)
+              `,
+            }}
+            data-testid="access-code-submit"
+          >
+            {isSubmitting ? 'Validating...' : 'Continue'}
+          </button>
+        </form>
+      </div>
+    </div>
+  );
+}

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

@@ -1,19 +1,54 @@
-import { spawn, spawnSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import { NextRequest, NextResponse } from 'next/server';
 import path from 'path';
+import fs from 'fs';
+import { appendSessionContentByWorkItem, getSessionContentByWorkItem, 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';
 
-interface ConversationMessage {
-  type: string;
-  content?: string;
-  tool_name?: string;
-  tool_input?: Record<string, unknown>;
-  result?: string;
+/**
+ * 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`;
 }
 
 function isClaudeCliAvailable(): boolean {
@@ -26,25 +61,16 @@ function isValidWorkItemId(id: string): boolean {
   return !isNaN(parsed) && parsed > 0 && String(parsed) === id;
 }
 
-function buildConversationContext(history: ConversationMessage[]): string {
-  return history
-    .filter(msg => msg.type === 'user' || msg.type === 'assistant' || msg.type === 'text')
-    .map(msg => {
-      if (msg.type === 'user') {
-        return `User: ${msg.content}`;
-      } else {
-        return `Assistant: ${msg.content}`;
-      }
-    })
-    .join('\n\n');
-}
-
 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(
@@ -61,9 +87,9 @@ export async function POST(
     );
   }
 
-  // Get the message and conversation history
+  // Get the message (conversationHistory no longer needed - persistent process maintains context)
   const body = await request.json().catch(() => ({}));
-  const { message, conversationHistory = [] } = body;
+  const { message } = body;
 
   if (!message || typeof message !== 'string') {
     return NextResponse.json(
@@ -72,68 +98,265 @@ export async function POST(
     );
   }
 
+  // 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()
+  });
+
   // Get or create worktree for this work item
   const workItem = {
     id: parseInt(workItemId, 10),
     title: `Work item ${workItemId}`
   };
 
-  const repoPath = path.resolve(process.cwd());
+  const repoPath = getProjectRoot();
   const workResult = await worktreeFacade.startWork(workItem, { repoPath });
   const 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 }
+    );
+  }
 
-  // Build prompt with conversation context
-  const context = buildConversationContext(conversationHistory);
-  const prompt = context
-    ? `Previous conversation:\n${context}\n\nUser: ${message}\n\nPlease respond to the user's message. Continue working on the task if needed.`
-    : message;
+  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) {
-      const claude = spawn('claude', [
-        '-p', prompt,
-        '--output-format', 'stream-json',
-        '--verbose',
-        '--dangerously-skip-permissions'
-      ], {
-        cwd: claudeCwd,
-        env: { ...process.env },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      claude.stdout.on('data', (data: Buffer) => {
-        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 {
-            const sseData = `data: ${JSON.stringify({ type: 'text', content: line })}\n\n`;
-            controller.enqueue(encoder.encode(sseData));
+      // 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;
           }
         }
-      });
 
-      claude.stderr.on('data', (data: Buffer) => {
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: data.toString() })}\n\n`;
+        // 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));
-      });
+      };
 
-      claude.on('close', (code) => {
-        const sseData = `data: ${JSON.stringify({ type: 'done', exitCode: code })}\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()
+        });
+        const sseData = `data: ${JSON.stringify({ type: 'error', content: err.content })}\n\n`;
         controller.enqueue(encoder.encode(sseData));
-        controller.close();
-      });
+      };
+
+      const onClose = (info: { exitCode: number }) => {
+        if (responseComplete) return;
+        responseComplete = true;
+
+        // Save any collected response (if not already saved)
+        saveAssistantResponse();
 
-      claude.on('error', (err) => {
-        const sseData = `data: ${JSON.stringify({ type: 'error', content: err.message })}\n\n`;
+        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();
+      }
     },
   });
 

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

@@ -0,0 +1,24 @@
+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,12 +1,31 @@
 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 {
@@ -54,8 +73,8 @@ export async function POST(
     title: title || `Work item ${workItemId}`
   };
 
-  // Determine the repo path (go up from the API route to project root)
-  const repoPath = path.resolve(process.cwd());
+  // 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 });
@@ -79,12 +98,18 @@ Please start working on this ${workItemType}. Use the appropriate tools to imple
   const stream = new ReadableStream({
     start(controller) {
       // Spawn Claude CLI with streaming JSON output in the worktree directory
-      const claude = spawn('claude', [
+      // 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',
-        '--dangerously-skip-permissions'
-      ], {
+        '--permission-mode', 'bypassPermissions',
+      ];
+      if (settingsPath) {
+        claudeArgs.push('--settings', settingsPath);
+      }
+      const claude = spawn('claude', claudeArgs, {
         cwd: claudeCwd,
         env: { ...process.env },
         stdio: ['ignore', 'pipe', 'pipe'],

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

@@ -0,0 +1,52 @@
+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 }
+    );
+  }
+}