jettypod 4.4.116 → 4.4.120

package/apps/dashboard/electron/preload.js

@@ -46,6 +46,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
 
     // Project info
     getProjectName: () => ipcRenderer.invoke('db:getProjectName'),
+
   },
 
   // Claude subprocess management
@@ -76,6 +77,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // Project operations
   project: {
     openDialog: () => ipcRenderer.invoke('dialog:openProject'),
+    newProject: () => ipcRenderer.invoke('dialog:newProject'),
     getRecent: () => ipcRenderer.invoke('projects:getRecent'),
     addRecent: (path) => ipcRenderer.invoke('projects:addRecent', path),
     openRecent: (path) => ipcRenderer.invoke('projects:openRecent', path),
@@ -85,13 +87,32 @@ contextBridge.exposeInMainWorld('electronAPI', {
   claudeCode: {
     install: () => ipcRenderer.invoke('claudeCode:install'),
     isInstalled: () => ipcRenderer.invoke('claudeCode:isInstalled'),
+    isAuthenticated: () => ipcRenderer.invoke('claudeCode:isAuthenticated'),
+    login: () => ipcRenderer.invoke('claudeCode:login'),
     update: () => ipcRenderer.invoke('claudeCode:update'),
   },
 
-  // Access code gating
-  access: {
-    validate: (code) => ipcRenderer.invoke('access:validate', code),
-    getStatus: () => ipcRenderer.invoke('access:getStatus'),
+  // Subscription gating (legacy)
+  subscription: {
+    createCheckout: (plan) => ipcRenderer.invoke('subscription:createCheckout', plan),
+    activate: (customerId) => ipcRenderer.invoke('subscription:activate', customerId),
+    getStatus: () => ipcRenderer.invoke('subscription:getStatus'),
+  },
+
+  // Billing
+  billing: {
+    openCustomerPortal: () => ipcRenderer.invoke('billing:openCustomerPortal'),
+  },
+
+  // Auth (JWT-based)
+  auth: {
+    loginWithGoogle: () => ipcRenderer.invoke('auth:loginWithGoogle'),
+    saveToken: (token, user) => ipcRenderer.invoke('auth:saveToken', token, user),
+    getStatus: () => ipcRenderer.invoke('auth:getStatus'),
+    getToken: () => ipcRenderer.invoke('auth:getToken'),
+    logout: () => ipcRenderer.invoke('auth:logout'),
+    getPostLoginPath: () => ipcRenderer.invoke('auth:getPostLoginPath'),
+    hasLoggedInBefore: () => ipcRenderer.invoke('auth:hasLoggedInBefore'),
   },
 
   // Shell operations

package/apps/dashboard/electron/session-manager.js

@@ -0,0 +1,163 @@
+const fs = require('fs');
+const path = require('path');
+const { app } = require('electron');
+
+const UPDATE_SERVER_URL = 'https://jettypod-update-server.spangbaryn2.workers.dev';
+const HEARTBEAT_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+
+let heartbeatInterval = null;
+let updaterHeaders = {};
+let log = console.log;
+
+function setLogger(logFn) {
+  log = logFn;
+}
+
+function getAuthPath() {
+  return path.join(app.getPath('userData'), 'auth.json');
+}
+
+function readAuth() {
+  const authPath = getAuthPath();
+  if (!fs.existsSync(authPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveAuth(data) {
+  const authPath = getAuthPath();
+  const dir = path.dirname(authPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(authPath, JSON.stringify(data, null, 2));
+}
+
+function decodeJWT(token) {
+  const parts = token.split('.');
+  if (parts.length !== 3) return null;
+  try {
+    const payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+    return JSON.parse(Buffer.from(payload, 'base64').toString('utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function updateAutoUpdaterHeaders() {
+  const auth = readAuth();
+  if (auth && auth.token) {
+    updaterHeaders = { 'Authorization': `Bearer ${auth.token}` };
+  } else {
+    updaterHeaders = {};
+  }
+  return updaterHeaders;
+}
+
+async function heartbeatWithRetry(maxRetries = 3) {
+  const auth = readAuth();
+  if (!auth || !auth.token) {
+    log('[Session] No auth token for heartbeat');
+    return;
+  }
+
+  log('[Session] Heartbeat: checking /auth/me...');
+
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (attempt > 0) {
+      const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+      log(`[Session] Heartbeat retry ${attempt}/${maxRetries - 1} in ${delay}ms...`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+
+    try {
+      const response = await fetch(`${UPDATE_SERVER_URL}/auth/me`, {
+        headers: { 'Authorization': `Bearer ${auth.token}` },
+      });
+
+      if (!response.ok) {
+        log(`[Session] Heartbeat failed: ${response.status}`);
+        if (response.status >= 500) {
+          lastError = new Error(`Server error: ${response.status}`);
+          continue;
+        }
+        return;
+      }
+
+      const data = await response.json();
+
+      // If server returned a new token (plan changed), save it
+      if (data.token) {
+        const payload = decodeJWT(data.token);
+        const user = payload
+          ? { id: payload.sub, email: payload.email, plan: payload.plan }
+          : auth.user;
+        saveAuth({ token: data.token, user, savedAt: new Date().toISOString() });
+        log('[Session] Token refreshed from server');
+      } else if (data.user && data.user.plan !== auth.user?.plan) {
+        // Plan changed but no new token — update user info
+        saveAuth({ ...auth, user: data.user, savedAt: new Date().toISOString() });
+        log(`[Session] Plan updated: ${auth.user?.plan} → ${data.user.plan}`);
+      }
+
+      updateAutoUpdaterHeaders();
+      return;
+    } catch (error) {
+      lastError = error;
+      log(`[Session] Heartbeat error: ${error.message}`);
+    }
+  }
+
+  log(`[Session] Heartbeat failed after ${maxRetries} attempts: ${lastError?.message}`);
+}
+
+async function heartbeat() {
+  return heartbeatWithRetry();
+}
+
+function start() {
+  log('[Session] Starting session manager...');
+  updateAutoUpdaterHeaders();
+
+  // Run first heartbeat after a short delay (don't block startup)
+  setTimeout(heartbeat, 5000);
+
+  // Schedule periodic heartbeats
+  heartbeatInterval = setInterval(heartbeat, HEARTBEAT_INTERVAL_MS);
+
+  log('[Session] Session manager started (heartbeat every 4 hours)');
+  return true;
+}
+
+function stop() {
+  if (heartbeatInterval) {
+    clearInterval(heartbeatInterval);
+    heartbeatInterval = null;
+  }
+  log('[Session] Session manager stopped');
+}
+
+function isRunning() {
+  return heartbeatInterval !== null;
+}
+
+function getUpdaterHeaders() {
+  return updaterHeaders;
+}
+
+module.exports = {
+  start,
+  stop,
+  heartbeat,
+  readAuth,
+  saveAuth,
+  updateAutoUpdaterHeaders,
+  isRunning,
+  getUpdaterHeaders,
+  setLogger,
+  getAuthPath,
+};

package/apps/dashboard/electron-builder.config.js

@@ -314,12 +314,10 @@ module.exports = {
   // Rebuild native modules
   npmRebuild: true,
 
-  // Auto-update configuration - publish to GitHub Releases
+  // Auto-update configuration - generic provider pointing to update server
   publish: {
-    provider: 'github',
-    owner: 'spangbaryn',
-    repo: 'jettypod-source',
-    releaseType: 'release',
+    provider: 'generic',
+    url: 'https://jettypod-update-server.spangbaryn2.workers.dev/updates',
   },
 
   // Hooks for native module handling

package/apps/dashboard/hooks/useKanbanAnimation.ts

@@ -0,0 +1,29 @@
+import { useState, useCallback, useRef } from 'react';
+import type { KanbanData } from '@/lib/kanban-utils';
+
+export function useKanbanAnimation() {
+  const [externalAnimatingItemId, setExternalAnimatingItemId] = useState<number | null>(null);
+  const pendingDataRef = useRef<KanbanData | null>(null);
+
+  // Track items animated internally so WebSocket handler skips them
+  const lastInternallyAnimatedIdRef = useRef<number | null>(null);
+
+  const handleExternalAnimationComplete = useCallback(() => {
+    setExternalAnimatingItemId(null);
+    if (pendingDataRef.current) {
+      // Return the pending data for the caller to apply
+      const pending = pendingDataRef.current;
+      pendingDataRef.current = null;
+      return pending;
+    }
+    return null;
+  }, []);
+
+  return {
+    externalAnimatingItemId,
+    setExternalAnimatingItemId,
+    pendingDataRef,
+    lastInternallyAnimatedIdRef,
+    handleExternalAnimationComplete,
+  };
+}

package/apps/dashboard/hooks/useKanbanUndo.ts

@@ -0,0 +1,83 @@
+import { useState, useCallback } from 'react';
+import { UndoStack, type UndoAction } from '@/lib/undoStack';
+
+// Helper to format status for display
+function formatStatus(status: string): string {
+  switch (status) {
+    case 'in_progress': return 'In Flight';
+    case 'backlog': return 'Backlog';
+    case 'done': return 'Done';
+    default: return status;
+  }
+}
+
+interface UseKanbanUndoOptions {
+  onStatusChange: (id: number, newStatus: string, skipUndo?: boolean) => Promise<{ success: boolean; notFound?: boolean }>;
+  showToast: (message: string, type?: 'error' | 'info' | 'success') => void;
+}
+
+export function useKanbanUndo({ onStatusChange, showToast }: UseKanbanUndoOptions) {
+  const [undoStack] = useState(() => new UndoStack());
+  const [undoRedoVersion, setUndoRedoVersion] = useState(0);
+
+  const pushAction = useCallback((action: UndoAction) => {
+    undoStack.push(action);
+    setUndoRedoVersion(v => v + 1);
+  }, [undoStack]);
+
+  const handleUndo = useCallback(async (): Promise<UndoAction | null> => {
+    const action = undoStack.undo();
+    if (!action) return null;
+
+    const result = await onStatusChange(action.itemId, action.before, true);
+    setUndoRedoVersion(v => v + 1);
+
+    if (result.notFound) {
+      showToast(`Item no longer exists: "${action.itemTitle}" was deleted`, 'error');
+      return null;
+    }
+
+    if (!result.success) {
+      undoStack.push({
+        type: action.type,
+        itemId: action.itemId,
+        itemTitle: action.itemTitle,
+        before: action.after,
+        after: action.before,
+      });
+      return null;
+    }
+
+    showToast(`Undone: "${action.itemTitle}" moved back to ${formatStatus(action.before)}`);
+    return action;
+  }, [undoStack, onStatusChange, showToast]);
+
+  const handleRedo = useCallback(async (): Promise<UndoAction | null> => {
+    const action = undoStack.redo();
+    if (!action) return null;
+
+    const result = await onStatusChange(action.itemId, action.after, true);
+    setUndoRedoVersion(v => v + 1);
+
+    if (result.notFound) {
+      showToast(`Item no longer exists: "${action.itemTitle}" was deleted`, 'error');
+      return null;
+    }
+
+    if (!result.success) {
+      return null;
+    }
+
+    showToast(`Redone: "${action.itemTitle}" moved to ${formatStatus(action.after)}`);
+    return action;
+  }, [undoStack, onStatusChange, showToast]);
+
+  return {
+    undoStack,
+    pushAction,
+    handleUndo,
+    handleRedo,
+    canUndo: undoStack.canUndo(),
+    canRedo: undoStack.canRedo(),
+  };
+}

package/apps/dashboard/lib/backlog-parser.ts

@@ -0,0 +1,50 @@
+// Local keyword parser for fast backlog work item creation
+// Avoids spawning Claude CLI for obvious inputs
+
+export interface ParseResult {
+  type: 'epic' | 'feature' | 'chore' | 'bug';
+  title: string;
+}
+
+const FILLER_WORDS = /\b(um|uh|like|basically|we need|we should|can you|i want|i need|let's|or something|you know|kind of|sort of|maybe|probably|just|actually)\b/gi;
+
+const TYPE_PATTERNS: { type: ParseResult['type']; keywords: RegExp }[] = [
+  { type: 'bug', keywords: /\b(bug|broken|doesn't work|not working|crash|error|regression)\b/i },
+  { type: 'epic', keywords: /\b(system|full|complete|epic|initiative|project|roadmap)\b/i },
+  { type: 'chore', keywords: /\b(upgrade|refactor|migrate|update|version|infrastructure|cleanup|clean up|tooling|ci|cd|pipeline|lint|config)\b/i },
+  // feature is the default — no pattern needed
+];
+
+export function parseBacklogInput(input: string): ParseResult | null {
+  const trimmed = input.trim();
+  if (!trimmed || trimmed.length < 3) return null;
+
+  // Clean up filler words
+  let cleaned = trimmed.replace(FILLER_WORDS, ' ').replace(/\s+/g, ' ').trim();
+  if (!cleaned || cleaned.length < 3) return null;
+
+  // Detect type from keywords
+  let type: ParseResult['type'] = 'feature';
+  for (const pattern of TYPE_PATTERNS) {
+    if (pattern.keywords.test(cleaned)) {
+      type = pattern.type;
+      break;
+    }
+  }
+
+  // Check for comma-separated list → epic
+  if (cleaned.includes(',') && cleaned.split(',').filter(s => s.trim()).length >= 3) {
+    type = 'epic';
+  }
+
+  // Clean title: remove trailing period, capitalize first letter
+  let title = cleaned.replace(/\.$/, '').trim();
+  title = title.charAt(0).toUpperCase() + title.slice(1);
+
+  // Truncate to 60 chars
+  if (title.length > 60) {
+    title = title.substring(0, 57) + '...';
+  }
+
+  return { type, title };
+}

package/apps/dashboard/lib/claude-process-manager.ts

@@ -27,8 +27,10 @@ const pinnedSessions = new Set<string>();
 // Maximum concurrent Claude processes allowed
 const MAX_PROCESSES = 8;
 
-// Timeout for idle processes (30 minutes, only applies to unpinned sessions)
-const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+// Timeout for idle processes (2 hours, only applies to unpinned sessions).
+// Longer timeout reduces process respawn frequency, avoiding the cost of
+// context restoration (dumping full conversation history into a single message).
+const IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000;
 
 // ============================================================================
 // Auto Gate Emission
@@ -200,7 +202,8 @@ function cleanupGateState(sessionId: string): void {
 export function getOrCreateProcess(
   sessionId: string,
   cwd: string,
-  settingsPath?: string
+  settingsPath?: string,
+  options?: { model?: string }
 ): { emitter: EventEmitter; isNew: boolean } | { error: string } {
   const existing = processes.get(sessionId);
 
@@ -236,18 +239,33 @@ export function getOrCreateProcess(
     args.push('--settings', settingsPath);
   }
 
+  if (options?.model) {
+    args.push('--model', options.model);
+  }
+
   const claudeProcess = spawn('claude', args, {
     cwd,
     env: { ...process.env, JETTYPOD_SESSION_ID: sessionId },
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
-  // Handle stdout - stream JSON responses
+  // Handle stdout - stream JSON responses.
+  // Buffer incomplete lines across data events. Node.js delivers arbitrary
+  // chunks on pipes, so a single JSON line can be split across two events.
+  // Without buffering, split lines fail JSON.parse and critical events like
+  // `result` are lost — causing the chat panel to hang forever.
+  let stdoutBuffer = '';
   claudeProcess.stdout.on('data', (data: Buffer) => {
-    const lines = data.toString().split('\n').filter(line => line.trim());
+    stdoutBuffer += data.toString();
+    const lines = stdoutBuffer.split('\n');
+    // Last element is either '' (chunk ended with \n) or an incomplete line
+    stdoutBuffer = lines.pop() || '';
+
     for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
       try {
-        const parsed = JSON.parse(line);
+        const parsed = JSON.parse(trimmed);
 
         // Auto-detect workflow events and emit synthetic gate events
         const syntheticGates = detectGates(sessionId, parsed);
@@ -258,7 +276,7 @@ export function getOrCreateProcess(
         emitter.emit('data', parsed);
       } catch {
         // Non-JSON line, emit as raw text
-        emitter.emit('data', { type: 'text', content: line });
+        emitter.emit('data', { type: 'text', content: trimmed });
       }
     }
   });
@@ -299,7 +317,7 @@ export function getOrCreateProcess(
  * Send a user message to a session's Claude process via stdin.
  * The message is formatted as stream-json.
  */
-export function sendMessage(sessionId: string, message: string): boolean {
+export function sendMessage(sessionId: string, message: string, images?: Array<{ type: string; data: string }>): boolean {
   const proc = processes.get(sessionId);
 
   if (!proc || !isProcessHealthy(proc)) {
@@ -312,12 +330,33 @@ export function sendMessage(sessionId: string, message: string): boolean {
 
   proc.lastActivityAt = Date.now();
 
+  // Build content: plain string when no images, content blocks array when images present
+  let content: string | Array<Record<string, unknown>> = message;
+  if (images && images.length > 0) {
+    const contentBlocks: Array<Record<string, unknown>> = [];
+    for (const img of images) {
+      // Frontend sends dataUrl like "data:image/png;base64,iVBOR..."
+      // Strip the data URL prefix to get raw base64
+      const base64Data = img.data.replace(/^data:[^;]+;base64,/, '');
+      contentBlocks.push({
+        type: 'image',
+        source: {
+          type: 'base64',
+          media_type: img.type,
+          data: base64Data,
+        },
+      });
+    }
+    contentBlocks.push({ type: 'text', text: message });
+    content = contentBlocks;
+  }
+
   // Format as stream-json message
   const jsonMessage = JSON.stringify({
     type: 'user',
     message: {
       role: 'user',
-      content: message,
+      content,
     },
   });
 
@@ -484,7 +523,7 @@ export function cleanupIdleProcesses(): number {
   return cleaned;
 }
 
-// Start periodic cleanup (every 5 minutes)
+// Start periodic cleanup (every 15 minutes)
 setInterval(() => {
   cleanupIdleProcesses();
-}, 5 * 60 * 1000);
+}, 15 * 60 * 1000);

package/apps/dashboard/lib/constants.ts

@@ -0,0 +1,43 @@
+// Shared label/icon mappings used across KanbanBoard, WorkItemTree, and detail pages
+
+export const TYPE_ICONS: Record<string, string> = {
+  epic: '🎯',
+  feature: '✨',
+  chore: '🔧',
+  bug: '🐛',
+};
+
+export const TYPE_LABELS: Record<string, { icon: string; label: string }> = {
+  epic: { icon: '🎯', label: 'Epic' },
+  feature: { icon: '✨', label: 'Feature' },
+  chore: { icon: '🔧', label: 'Chore' },
+  bug: { icon: '🐛', label: 'Bug' },
+};
+
+export const STATUS_LABELS: Record<string, { label: string; color: string }> = {
+  backlog: { label: 'Backlog', color: 'bg-zinc-100 text-zinc-700 dark:bg-zinc-800 dark:text-zinc-300' },
+  todo: { label: 'Todo', color: 'bg-zinc-100 text-zinc-700 dark:bg-zinc-800 dark:text-zinc-300' },
+  in_progress: { label: 'In Progress', color: 'bg-blue-100 text-blue-700 dark:bg-blue-900 dark:text-blue-300' },
+  done: { label: 'Done', color: 'bg-green-100 text-green-700 dark:bg-green-900 dark:text-green-300' },
+  cancelled: { label: 'Cancelled', color: 'bg-red-100 text-red-700 dark:bg-red-900 dark:text-red-300' },
+};
+
+export const STATUS_COLORS: Record<string, string> = {
+  backlog: 'text-zinc-500',
+  todo: 'text-zinc-500',
+  in_progress: 'text-blue-600 dark:text-blue-400',
+  done: 'text-green-600 dark:text-green-400',
+  cancelled: 'text-red-500',
+};
+
+export const MODE_LABELS: Record<string, { label: string; color: string }> = {
+  speed: { label: 'speed', color: 'bg-amber-100 text-amber-800 dark:bg-amber-900/50 dark:text-amber-300' },
+  stable: { label: 'stable', color: 'bg-blue-100 text-blue-800 dark:bg-blue-900/50 dark:text-blue-300' },
+  production: { label: 'prod', color: 'bg-purple-100 text-purple-800 dark:bg-purple-900/50 dark:text-purple-300' },
+};
+
+export const MODE_LABELS_FULL: Record<string, { label: string; color: string }> = {
+  speed: { label: 'Speed Mode', color: 'bg-amber-100 text-amber-800 dark:bg-amber-900/50 dark:text-amber-300' },
+  stable: { label: 'Stable Mode', color: 'bg-blue-100 text-blue-800 dark:bg-blue-900/50 dark:text-blue-300' },
+  production: { label: 'Production Mode', color: 'bg-purple-100 text-purple-800 dark:bg-purple-900/50 dark:text-purple-300' },
+};

package/apps/dashboard/lib/db-bridge.ts

@@ -19,6 +19,12 @@ interface ElectronAPI {
       error?: string;
       path?: string;
     }>;
+    newProject: () => Promise<{
+      success: boolean;
+      canceled?: boolean;
+      error?: string;
+      path?: string;
+    }>;
     getRecent: () => Promise<RecentProject[]>;
     openRecent: (path: string) => Promise<{
       success: boolean;
@@ -32,6 +38,11 @@ interface ElectronAPI {
       error?: string;
     }>;
     isInstalled: () => Promise<boolean>;
+    isAuthenticated: () => Promise<boolean>;
+    login: () => Promise<{
+      success: boolean;
+      error?: string;
+    }>;
     update: () => Promise<{
       success: boolean;
       error?: string;
@@ -48,6 +59,26 @@ interface ElectronAPI {
       activatedAt?: string;
     }>;
   };
+  auth: {
+    loginWithGoogle: () => Promise<void>;
+    saveToken: (token: string, user: { email: string; plan?: string }) => Promise<void>;
+    getStatus: () => Promise<{
+      authenticated: boolean;
+      token?: string;
+      user?: { email: string; plan?: string };
+    }>;
+    getToken: () => Promise<string | null>;
+    logout: () => Promise<void>;
+    getPostLoginPath: () => Promise<string | null>;
+  };
+  subscription: {
+    createCheckout: (plan: string) => Promise<{ success: boolean; error?: string }>;
+    activate: (customerId: string) => Promise<{ success: boolean; error?: string }>;
+    getStatus: () => Promise<{ active: boolean; customerId?: string; activatedAt?: string }>;
+  };
+  billing: {
+    openCustomerPortal: () => Promise<{ success: boolean; error?: string }>;
+  };
   shell: {
     openPath: (filePath: string) => Promise<string>;
   };
@@ -123,6 +154,7 @@ export type {
   SessionWithFeature,
   SessionStatus,
   EnvVar,
+  WeeklyUsage,
 } from './db';
 
 // ==================== Kanban ====================
@@ -248,3 +280,4 @@ export function deleteEnvVar(name: string): void {
 export function getProjectName(): string {
   return directDb.getProjectName();
 }
+