jettypod 4.4.116 → 4.4.120

package/apps/dashboard/contexts/ConnectionStatusContext.tsx

@@ -1,21 +1,43 @@
 'use client';
 
-import { createContext, useContext, useState, type ReactNode } from 'react';
+import { createContext, useContext, useState, useEffect, useRef, useMemo, type ReactNode } from 'react';
 
 export type ConnectionStatus = 'connected' | 'reconnecting' | 'disconnected';
 
+const DISCONNECT_DELAY_MS = 5000;
+
 interface ConnectionStatusContextValue {
   status: ConnectionStatus;
   setStatus: (status: ConnectionStatus) => void;
+  showDisconnected: boolean;
 }
 
 const ConnectionStatusContext = createContext<ConnectionStatusContextValue | null>(null);
 
 export function ConnectionStatusProvider({ children }: { children: ReactNode }) {
   const [status, setStatus] = useState<ConnectionStatus>('disconnected');
+  const [showDisconnected, setShowDisconnected] = useState(false);
+  const timerRef = useRef<NodeJS.Timeout | null>(null);
+
+  useEffect(() => {
+    if (status === 'connected') {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      setShowDisconnected(false);
+    } else {
+      timerRef.current = setTimeout(() => {
+        setShowDisconnected(true);
+      }, DISCONNECT_DELAY_MS);
+    }
+
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, [status]);
+
+  const value = useMemo(() => ({ status, setStatus, showDisconnected }), [status, showDisconnected]);
 
   return (
-    <ConnectionStatusContext.Provider value={{ status, setStatus }}>
+    <ConnectionStatusContext.Provider value={value}>
       {children}
     </ConnectionStatusContext.Provider>
   );
@@ -24,8 +46,7 @@ export function ConnectionStatusProvider({ children }: { children: ReactNode })
 export function useConnectionStatus() {
   const context = useContext(ConnectionStatusContext);
   if (!context) {
-    // Return a safe default when used outside the provider
-    return { status: 'disconnected' as ConnectionStatus, setStatus: () => {} };
+    return { status: 'disconnected' as ConnectionStatus, setStatus: () => {}, showDisconnected: false };
   }
   return context;
 }

package/apps/dashboard/contexts/UsageContext.tsx

@@ -0,0 +1,155 @@
+'use client';
+
+import { createContext, useContext, useState, useEffect, useCallback, useMemo, type ReactNode } from 'react';
+import { useWebSocket, type WebSocketMessage } from '../hooks/useWebSocket';
+import { getWebSocketUrl } from '../lib/utils';
+
+const FREE_WEEKLY_LIMIT = 20;
+const API_BASE = 'https://jettypod-update-server.spangbaryn2.workers.dev';
+
+interface UsageState {
+  used: number;
+  limit: number;
+  remaining: number;
+  allowed: boolean;
+  plan: string;
+  loading: boolean;
+}
+
+interface UsageContextValue extends UsageState {
+  refresh: () => Promise<void>;
+}
+
+const UsageContext = createContext<UsageContextValue | null>(null);
+
+export function UsageProvider({ children }: { children: ReactNode }) {
+  const [state, setState] = useState<UsageState>({
+    used: 0,
+    limit: FREE_WEEKLY_LIMIT,
+    remaining: FREE_WEEKLY_LIMIT,
+    allowed: true,
+    plan: 'free',
+    loading: true,
+  });
+
+  const fetchUsage = useCallback(async () => {
+    // Get plan from auth (if Electron)
+    let plan = 'free';
+    try {
+      if (window.electronAPI?.isElectron) {
+        const status = await window.electronAPI.auth.getStatus();
+        if (status.authenticated && status.user) {
+          plan = status.user.plan || 'free';
+        }
+
+        // Check server-side plan — the local JWT may be stale
+        if (plan === 'free') {
+          const token = await window.electronAPI.auth.getToken();
+          if (token) {
+            try {
+              const res = await fetch(`${API_BASE}/auth/me`, {
+                headers: { 'Authorization': `Bearer ${token}` },
+              });
+              if (res.ok) {
+                const data = await res.json() as { user: { plan: string; email: string }; token?: string };
+                if (data.user.plan !== 'free') {
+                  plan = data.user.plan;
+                  // Server issued a fresh JWT with updated plan — save it locally
+                  if (data.token) {
+                    await window.electronAPI.auth.saveToken(data.token, data.user);
+                  }
+                }
+              }
+            } catch {
+              // Network error — fall through with local plan
+            }
+          }
+        }
+      }
+    } catch {
+      // Auth unavailable — default to free
+    }
+
+    // Paid plans have unlimited usage
+    if (plan !== 'free') {
+      setState({
+        used: 0,
+        limit: Infinity,
+        remaining: Infinity,
+        allowed: true,
+        plan,
+        loading: false,
+      });
+      return;
+    }
+
+    // Free plan — count from local DB via API route
+    try {
+      const res = await fetch('/api/usage');
+      console.log('[usage] UsageContext fetch status:', res.status);
+      if (!res.ok) {
+        console.error('[usage] UsageContext fetch not ok:', res.status, res.statusText);
+        setState(prev => ({ ...prev, allowed: true, loading: false }));
+        return;
+      }
+      const usage = await res.json();
+      console.log('[usage] UsageContext received:', usage);
+      setState({
+        used: typeof usage.used === 'number' ? usage.used : 0,
+        limit: typeof usage.limit === 'number' ? usage.limit : FREE_WEEKLY_LIMIT,
+        remaining: typeof usage.remaining === 'number' ? usage.remaining : FREE_WEEKLY_LIMIT,
+        allowed: typeof usage.allowed === 'boolean' ? usage.allowed : true,
+        plan,
+        loading: false,
+      });
+    } catch (err) {
+      console.error('[usage] UsageContext fetch error:', err);
+      setState(prev => ({ ...prev, allowed: true, loading: false }));
+    }
+  }, []);
+
+  // Fetch on mount
+  useEffect(() => {
+    fetchUsage();
+  }, [fetchUsage]);
+
+  // Refresh on window focus
+  useEffect(() => {
+    const handleFocus = () => fetchUsage();
+    window.addEventListener('focus', handleFocus);
+    return () => window.removeEventListener('focus', handleFocus);
+  }, [fetchUsage]);
+
+  // Refresh on WebSocket db_change events (e.g., CLI creates a work item)
+  const handleWsMessage = useCallback((message: WebSocketMessage) => {
+    if (message.type === 'db_change') {
+      fetchUsage();
+    }
+  }, [fetchUsage]);
+
+  useWebSocket({ url: getWebSocketUrl(), onMessage: handleWsMessage });
+
+  const value = useMemo(() => ({ ...state, refresh: fetchUsage }), [state, fetchUsage]);
+
+  return (
+    <UsageContext.Provider value={value}>
+      {children}
+    </UsageContext.Provider>
+  );
+}
+
+export function useUsage() {
+  const context = useContext(UsageContext);
+  if (!context) {
+    return {
+      used: 0,
+      limit: FREE_WEEKLY_LIMIT,
+      remaining: FREE_WEEKLY_LIMIT,
+      allowed: true,
+      plan: 'free',
+      loading: false,
+      refresh: async () => {},
+    };
+  }
+  return context;
+}

package/apps/dashboard/contexts/usageHelpers.js

@@ -0,0 +1,9 @@
+function checkUsageLimit(plan, used, limit) {
+  if (plan !== 'free') {
+    return { allowed: true, used: 0, limit: Infinity, remaining: Infinity };
+  }
+  const remaining = Math.max(0, limit - used);
+  return { allowed: remaining > 0, used, limit, remaining };
+}
+
+module.exports = { checkUsageLimit };

package/apps/dashboard/electron/ipc-handlers.js

@@ -96,14 +96,20 @@ function getDbPath() {
 function getDb() {
   if (!cachedDb) {
     const dbPath = getDbPath();
-    cachedDb = new Database(dbPath);
-    cachedDb.pragma('journal_mode = WAL');
-    cachedDb.pragma('foreign_keys = ON');
-    // Run pending migrations to handle old project databases
     try {
-      runMigrations(cachedDb);
+      cachedDb = new Database(dbPath);
+      cachedDb.pragma('journal_mode = WAL');
+      cachedDb.pragma('foreign_keys = ON');
+      // Run pending migrations to handle old project databases
+      try {
+        runMigrations(cachedDb);
+      } catch (err) {
+        console.error('Failed to run migrations:', err);
+      }
     } catch (err) {
-      console.error('Failed to run migrations:', err);
+      console.error(`[DB] Failed to open database at ${dbPath}:`, err.message);
+      cachedDb = null;
+      throw err;
     }
   }
   return cachedDb;
@@ -165,48 +171,8 @@ function registerIpcHandlers() {
     `).all();
     const epicMap = new Map(epics.map(e => [e.id, e.title]));
 
-    // Get all chores that belong to features
-    const featureChores = db.prepare(`
-      SELECT c.id, c.type, c.title, c.description, c.status, c.parent_id, c.epic_id,
-             c.branch_name, c.mode, c.phase, c.completed_at, c.created_at,
-             wc.current_step, wc.total_steps
-      FROM work_items c
-      INNER JOIN work_items f ON c.parent_id = f.id
-      LEFT JOIN workflow_checkpoints wc ON wc.work_item_id = c.id
-      WHERE c.type = 'chore' AND f.type = 'feature'
-      ORDER BY c.id
-    `).all();
-
-    const choresByFeature = new Map();
-    for (const chore of featureChores) {
-      if (chore.parent_id) {
-        const existing = choresByFeature.get(chore.parent_id) || [];
-        existing.push(chore);
-        choresByFeature.set(chore.parent_id, existing);
-      }
-    }
-
-    // Get all bugs that belong to features
-    const featureBugs = db.prepare(`
-      SELECT b.id, b.type, b.title, b.description, b.status, b.parent_id, b.epic_id,
-             b.branch_name, b.mode, b.phase, b.completed_at, b.created_at
-      FROM work_items b
-      INNER JOIN work_items f ON b.parent_id = f.id
-      WHERE b.type = 'bug' AND f.type = 'feature'
-      ORDER BY b.id
-    `).all();
-
-    const bugsByFeature = new Map();
-    for (const bug of featureBugs) {
-      if (bug.parent_id) {
-        const existing = bugsByFeature.get(bug.parent_id) || [];
-        existing.push(bug);
-        bugsByFeature.set(bug.parent_id, existing);
-      }
-    }
-
-    // Get kanban-eligible items
-    const allItems = db.prepare(`
+    // Single query: get all non-epic work items with parent type and workflow progress
+    const allWorkItems = db.prepare(`
       SELECT w.id, w.type, w.title, w.description, w.status, w.parent_id, w.epic_id,
              w.branch_name, w.mode, w.phase, w.completed_at, w.created_at, w.display_order,
              p.type as parent_type,
@@ -215,10 +181,27 @@ function registerIpcHandlers() {
       LEFT JOIN work_items p ON w.parent_id = p.id
       LEFT JOIN workflow_checkpoints wc ON wc.work_item_id = w.id
       WHERE w.type IN ('feature', 'chore', 'bug')
-        AND (w.parent_id IS NULL OR p.type = 'epic')
       ORDER BY COALESCE(w.display_order, w.id)
     `).all();
 
+    // Partition: children of features vs kanban-eligible items
+    const choresByFeature = new Map();
+    const bugsByFeature = new Map();
+    const allItems = [];
+
+    for (const item of allWorkItems) {
+      if (item.parent_type === 'feature') {
+        // Child of a feature — group by parent
+        const map = item.type === 'bug' ? bugsByFeature : choresByFeature;
+        const existing = map.get(item.parent_id) || [];
+        existing.push(item);
+        map.set(item.parent_id, existing);
+      } else {
+        // Top-level or under epic — kanban item
+        allItems.push(item);
+      }
+    }
+
     const inFlight = [];
     const backlogGroups = new Map();
     const doneGroups = new Map();
@@ -660,7 +643,58 @@ function registerIpcHandlers() {
     return listDevServers();
   });
 
-  // ==================== Project Dialog ====================
+  // ==================== New Project Dialog ====================
+  ipcMain.handle('dialog:newProject', async () => {
+    const mainWindow = BrowserWindow.getFocusedWindow();
+
+    const result = await dialog.showSaveDialog(mainWindow, {
+      title: 'Create New Project',
+      buttonLabel: 'Create',
+      nameFieldLabel: 'Project Name:',
+      showsTagField: false,
+    });
+
+    if (result.canceled || !result.filePath) {
+      return { success: false, canceled: true };
+    }
+
+    const projectPath = result.filePath;
+
+    // Create the directory
+    try {
+      fs.mkdirSync(projectPath, { recursive: true });
+    } catch (mkdirError) {
+      return {
+        success: false,
+        error: `Failed to create directory: ${mkdirError.message}`
+      };
+    }
+
+    // Initialize JettyPod in the new directory
+    try {
+      initializeJettypod(projectPath);
+    } catch (initError) {
+      return {
+        success: false,
+        error: `Failed to initialize JettyPod: ${initError.message}`
+      };
+    }
+
+    // Reset DB and project root BEFORE async call to prevent stale state
+    // during await (other IPC handlers could fire while we're waiting)
+    closeDb();
+    cachedDb = null;
+    projectRoot = projectPath;
+
+    const { setProjectRoot } = require('./main');
+    await setProjectRoot(projectPath);
+
+    addRecentProject(projectPath);
+
+    return { success: true, path: projectPath };
+  });
+
+  // ==================== Open Project Dialog ====================
   ipcMain.handle('dialog:openProject', async () => {
     const mainWindow = BrowserWindow.getFocusedWindow();
 
@@ -689,17 +723,15 @@ function registerIpcHandlers() {
       }
     }
 
-    // Update the project root (also persists as last-selected and sets env var)
-    // Await ensures Next.js dev server is synced before renderer reloads
-    const { setProjectRoot } = require('./main');
-    await setProjectRoot(selectedPath);
-
-    // Reset the cached database connection so it reconnects to the new project
+    // Reset DB and project root BEFORE async call to prevent stale state
+    // during await (other IPC handlers could fire while we're waiting)
     closeDb();
     cachedDb = null;
     projectRoot = selectedPath;
 
-    // Add to recent projects list
+    const { setProjectRoot } = require('./main');
+    await setProjectRoot(selectedPath);
+
     addRecentProject(selectedPath);
 
     return { success: true, path: selectedPath };
@@ -737,17 +769,15 @@ function registerIpcHandlers() {
       }
     }
 
-    // Update the project root (also persists as last-selected and sets env var)
-    // Await ensures Next.js dev server is synced before renderer reloads
-    const { setProjectRoot } = require('./main');
-    await setProjectRoot(projectPath);
-
-    // Reset the cached database connection so it reconnects to the new project
+    // Reset DB and project root BEFORE async call to prevent stale state
+    // during await (other IPC handlers could fire while we're waiting)
     closeDb();
     cachedDb = null;
     projectRoot = projectPath;
 
-    // Update recent projects (move to top)
+    const { setProjectRoot } = require('./main');
+    await setProjectRoot(projectPath);
+
     addRecentProject(projectPath);
 
     return { success: true, path: projectPath };
@@ -769,46 +799,209 @@ function registerIpcHandlers() {
     return await updateClaudeCode();
   });
 
-  // ==================== Access Code Gating ====================
-  ipcMain.handle('access:validate', (event, code) => {
-    // Speed mode: accept any non-empty code
-    // Real validation will be added in stable mode
-    if (!code || code.trim() === '') {
-      return { success: false, error: 'Access code is required' };
+  ipcMain.handle('claudeCode:isAuthenticated', async () => {
+    const { checkClaudeCodeAuthenticated } = require('./main');
+    return await checkClaudeCodeAuthenticated();
+  });
+
+  ipcMain.handle('claudeCode:login', async () => {
+    const { loginClaudeCode } = require('./main');
+    return await loginClaudeCode();
+  });
+
+  // ==================== Subscription Gating ====================
+
+  const UPDATE_SERVER_URL = 'https://jettypod-update-server.spangbaryn2.workers.dev';
+
+  ipcMain.handle('subscription:createCheckout', async (event, plan) => {
+    try {
+      // Include JWT auth header so checkout session gets user_id in metadata
+      const headers = { 'Content-Type': 'application/json' };
+      const authPath = path.join(app.getPath('userData'), 'auth.json');
+      if (fs.existsSync(authPath)) {
+        try {
+          const authData = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+          if (authData.token) {
+            headers['Authorization'] = `Bearer ${authData.token}`;
+          }
+        } catch {
+          // Continue without auth if read fails
+        }
+      }
+
+      const response = await fetch(`${UPDATE_SERVER_URL}/checkout/create-session`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ plan: plan || 'monthly' }),
+      });
+
+      if (!response.ok) {
+        return { success: false, error: 'Failed to create checkout session' };
+      }
+
+      const data = await response.json();
+      if (data.url) {
+        const { shell } = require('electron');
+        shell.openExternal(data.url);
+        return { success: true };
+      }
+      return { success: false, error: 'No checkout URL returned' };
+    } catch (error) {
+      return { success: false, error: `Checkout failed: ${error.message}` };
     }
+  });
 
-    // Store the access grant
-    const accessPath = path.join(app.getPath('userData'), 'access-granted.json');
-    const accessData = {
-      activated: true,
-      activatedAt: new Date().toISOString(),
-      code: code.trim()
-    };
+  ipcMain.handle('billing:openCustomerPortal', async () => {
+    try {
+      const headers = { 'Content-Type': 'application/json' };
+      const authPath = path.join(app.getPath('userData'), 'auth.json');
+      if (fs.existsSync(authPath)) {
+        try {
+          const authData = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+          if (authData.token) {
+            headers['Authorization'] = `Bearer ${authData.token}`;
+          }
+        } catch {
+          // Continue without auth if read fails
+        }
+      }
+
+      const response = await fetch(`${UPDATE_SERVER_URL}/billing/customer-portal`, {
+        method: 'POST',
+        headers,
+      });
+
+      if (!response.ok) {
+        return { success: false, error: 'Failed to open billing portal' };
+      }
+
+      const data = await response.json();
+      if (data.url) {
+        shell.openExternal(data.url);
+        return { success: true };
+      }
+      return { success: false, error: 'No portal URL returned' };
+    } catch (error) {
+      return { success: false, error: `Billing portal failed: ${error.message}` };
+    }
+  });
+
+  ipcMain.handle('subscription:activate', async (event, customerId) => {
+    if (!customerId || !customerId.trim().startsWith('cus_')) {
+      return { success: false, error: 'Invalid customer ID. It should start with cus_' };
+    }
 
     try {
-      // Ensure directory exists
-      const dir = path.dirname(accessPath);
+      // Validate against the update server
+      const response = await fetch(`${UPDATE_SERVER_URL}/subscription/validate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ customerId: customerId.trim() }),
+      });
+
+      const result = await response.json();
+      if (!result.valid) {
+        return { success: false, error: result.error || 'No active subscription found' };
+      }
+
+      // Store the subscription
+      const subPath = path.join(app.getPath('userData'), 'subscription.json');
+      const subData = {
+        customerId: customerId.trim(),
+        activatedAt: new Date().toISOString(),
+      };
+
+      const dir = path.dirname(subPath);
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
       }
-      fs.writeFileSync(accessPath, JSON.stringify(accessData, null, 2));
+      fs.writeFileSync(subPath, JSON.stringify(subData, null, 2));
       return { success: true };
     } catch (error) {
-      return { success: false, error: `Failed to save access: ${error.message}` };
+      return { success: false, error: `Activation failed: ${error.message}` };
+    }
+  });
+
+  ipcMain.handle('subscription:getStatus', () => {
+    const subPath = path.join(app.getPath('userData'), 'subscription.json');
+    if (!fs.existsSync(subPath)) {
+      return { active: false };
+    }
+
+    try {
+      const data = JSON.parse(fs.readFileSync(subPath, 'utf-8'));
+      return { active: !!data.customerId, customerId: data.customerId, activatedAt: data.activatedAt };
+    } catch {
+      return { active: false };
+    }
+  });
+
+  // ==================== Auth (JWT-based) ====================
+
+  ipcMain.handle('auth:loginWithGoogle', () => {
+    const { shell } = require('electron');
+    shell.openExternal(`${UPDATE_SERVER_URL}/auth/google`);
+    return { success: true };
+  });
+
+  ipcMain.handle('auth:saveToken', (event, token, user) => {
+    const authPath = path.join(app.getPath('userData'), 'auth.json');
+    const dir = path.dirname(authPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(authPath, JSON.stringify({ token, user, savedAt: new Date().toISOString() }, null, 2));
+
+    // Mark that the user has logged in at least once (persists across logout)
+    const markerPath = path.join(app.getPath('userData'), 'has-logged-in');
+    if (!fs.existsSync(markerPath)) {
+      fs.writeFileSync(markerPath, new Date().toISOString());
     }
+
+    return { success: true };
   });
 
-  ipcMain.handle('access:getStatus', () => {
-    const accessPath = path.join(app.getPath('userData'), 'access-granted.json');
-    if (!fs.existsSync(accessPath)) {
-      return { activated: false };
+  ipcMain.handle('auth:getStatus', () => {
+    const authPath = path.join(app.getPath('userData'), 'auth.json');
+    if (!fs.existsSync(authPath)) {
+      return { authenticated: false };
     }
 
     try {
-      const data = JSON.parse(fs.readFileSync(accessPath, 'utf-8'));
-      return { activated: !!data.activated, activatedAt: data.activatedAt };
+      const data = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+      return { authenticated: !!data.token, token: data.token, user: data.user };
+    } catch {
+      return { authenticated: false };
+    }
+  });
+
+  ipcMain.handle('auth:getToken', () => {
+    const authPath = path.join(app.getPath('userData'), 'auth.json');
+    if (!fs.existsSync(authPath)) return null;
+
+    try {
+      const data = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+      return data.token || null;
+    } catch {
+      return null;
+    }
+  });
+
+  ipcMain.handle('auth:logout', () => {
+    const authPath = path.join(app.getPath('userData'), 'auth.json');
+    if (fs.existsSync(authPath)) {
+      fs.unlinkSync(authPath);
+    }
+    // Note: does NOT delete has-logged-in marker — returning users see /login, not /signup
+    return { success: true };
+  });
+
+  ipcMain.handle('auth:hasLoggedInBefore', () => {
+    try {
+      const markerPath = path.join(app.getPath('userData'), 'has-logged-in');
+      return fs.existsSync(markerPath);
     } catch {
-      return { activated: false };
+      return false;
     }
   });