jettypod 4.4.80 → 4.4.82

package/apps/dashboard/components/DragContext.tsx

@@ -117,11 +117,9 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
   }, []);
 
   const startDrag = useCallback((item: WorkItem, cardRect: DOMRect, pointerX: number, pointerY: number) => {
-    console.log('[DragContext] startDrag called', { item: item.id, cardRect, pointerX, pointerY });
     // Calculate offset from pointer to card's top-left corner
     const offsetX = pointerX - cardRect.left;
     const offsetY = pointerY - cardRect.top;
-    console.log('[DragContext] Setting drag state', { offsetX, offsetY, width: cardRect.width });
     setDragOffset({ x: offsetX, y: offsetY });
     setDragPosition({ x: pointerX, y: pointerY });
     setDraggedCardWidth(cardRect.width);
@@ -171,16 +169,6 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
   const overlayX = dragPosition.x - dragOffset.x;
   const overlayY = dragPosition.y - dragOffset.y;
 
-  // Debug: log portal render conditions
-  console.log('[DragContext] Portal render check', {
-    hasDraggedItem: !!draggedItem,
-    hasRenderOverlay: !!renderDragOverlay,
-    hasDocument: typeof document !== 'undefined',
-    overlayX,
-    overlayY,
-    draggedCardWidth,
-  });
-
   return (
     <DragContext.Provider
       value={{
@@ -215,32 +203,11 @@ export function DragProvider({ children, renderDragOverlay }: DragProviderProps)
               pointerEvents: 'none',
               transform: 'scale(1.02)',
               boxShadow: '0 10px 30px rgba(0, 0, 0, 0.2)',
-              border: '4px solid red',
-              background: 'rgba(255, 0, 0, 0.1)',
-            }}
-          >
-            {renderDragOverlay(draggedItem)}
-          </div>,
-          document.body
-        )
-      }
-      {/* TEST: Always-visible portal to verify createPortal works */}
-      {typeof document !== 'undefined' &&
-        createPortal(
-          <div
-            style={{
-              position: 'fixed',
-              bottom: 20,
-              right: 20,
-              padding: '10px 20px',
-              background: 'green',
-              color: 'white',
-              fontWeight: 'bold',
-              zIndex: 9999,
               borderRadius: 8,
+              overflow: 'hidden',
             }}
           >
-            Portal Works! Dragging: {draggedItem ? `#${draggedItem.id}` : 'none'}
+            {renderDragOverlay(draggedItem)}
           </div>,
           document.body
         )

package/apps/dashboard/components/DraggableCard.tsx

@@ -21,14 +21,10 @@ export function DraggableCard({ item, children, disabled = false }: DraggableCar
   }
 
   const handleDragStart = (_event: MouseEvent | TouchEvent | PointerEvent, info: PanInfo) => {
-    console.log('[DraggableCard] handleDragStart fired', { itemId: item.id, point: info.point });
     wasDraggingRef.current = true;
     if (cardRef.current) {
       const rect = cardRef.current.getBoundingClientRect();
-      console.log('[DraggableCard] Card rect:', rect);
       startDrag(item, rect, info.point.x, info.point.y);
-    } else {
-      console.warn('[DraggableCard] cardRef.current is null!');
     }
   };
 

package/lib/database.js

@@ -390,27 +390,151 @@ async function waitForMigrations() {
   }
 }
 
+/**
+ * Attempt to recover work.db from JSON snapshots
+ * Used when database is missing or corrupted
+ * @returns {Promise<{recovered: boolean, itemCount: number}>} Recovery result
+ */
+async function recoverFromSnapshots() {
+  const snapshotsDir = path.join(getJettypodDir(), 'snapshots');
+  const jsonPath = path.join(snapshotsDir, 'work.json');
+
+  // Check if snapshots exist
+  if (!fs.existsSync(jsonPath)) {
+    return { recovered: false, itemCount: 0, reason: 'No snapshot file found' };
+  }
+
+  // Read and parse snapshot
+  let data;
+  try {
+    const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+    data = JSON.parse(jsonContent);
+  } catch (err) {
+    return { recovered: false, itemCount: 0, reason: `Failed to read snapshot: ${err.message}` };
+  }
+
+  // Close existing connection and delete corrupted file
+  await closeDb();
+  const dbFilePath = getDbPath();
+
+  // Remove corrupted database files (including WAL files)
+  const filesToRemove = [dbFilePath, `${dbFilePath}-wal`, `${dbFilePath}-shm`];
+  for (const file of filesToRemove) {
+    if (fs.existsSync(file)) {
+      fs.unlinkSync(file);
+    }
+  }
+
+  // Reset singleton to force fresh connection
+  resetDb();
+
+  // Create fresh database (this will create schema)
+  const database = getDb();
+  await waitForMigrations();
+
+  // Import data from snapshot
+  const tableNames = Object.keys(data);
+  let totalItems = 0;
+
+  for (const tableName of tableNames) {
+    const rows = data[tableName];
+    if (!rows || rows.length === 0) continue;
+
+    // Get column names from first row
+    const columns = Object.keys(rows[0]);
+    const placeholders = columns.map(() => '?').join(', ');
+    const columnNames = columns.join(', ');
+    const insertSql = `INSERT INTO ${tableName} (${columnNames}) VALUES (${placeholders})`;
+
+    for (const row of rows) {
+      const values = columns.map(col => row[col]);
+      await new Promise((resolve, reject) => {
+        database.run(insertSql, values, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+      totalItems++;
+    }
+  }
+
+  return { recovered: true, itemCount: totalItems };
+}
+
 /**
  * Run startup validation checks on the database
  * Call this early in application startup to detect corruption before operations fail
- * @returns {Promise<void>} Resolves if database is healthy, rejects with details if corrupted
- * @throws {Error} If database is corrupted or schema is invalid
+ * Automatically attempts recovery from snapshots if corruption is detected
+ * @returns {Promise<void>} Resolves if database is healthy (or recovered), rejects if unrecoverable
+ * @throws {Error} If database is corrupted and recovery fails
  */
 async function validateOnStartup() {
-  const database = getDb();
-  await waitForMigrations();
+  // Check if database file is missing
+  const dbFilePath = getDbPath();
+  const dbMissing = !fs.existsSync(dbFilePath);
+
+  if (dbMissing) {
+    // Try to recover from snapshots
+    console.log('⚠️  Database file missing, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      return;
+    } else {
+      // No snapshots - just create fresh DB (getDb will do this)
+      console.log('ℹ️  No snapshots found, creating fresh database');
+      getDb();
+      await waitForMigrations();
+      return;
+    }
+  }
+
+  // Database exists - check integrity
+  let database;
+  try {
+    database = getDb();
+    await waitForMigrations();
+  } catch (err) {
+    // Failed to even open the database - try recovery
+    console.log('⚠️  Database failed to open, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      return;
+    }
+    throw new Error(
+      `Database failed to open and recovery failed.\n` +
+      `Original error: ${err.message}\n` +
+      `Recovery error: ${result.reason}\n\n` +
+      `Manual recovery options:\n` +
+      `  1. Restore from backup: jettypod work restore-backup latest\n` +
+      `  2. Check ~/.jettypod-backups/ for global backups`
+    );
+  }
 
-  // Check file integrity first
+  // Check file integrity
   const integrity = await checkIntegrity(database);
   if (!integrity.ok) {
+    console.log('⚠️  Database corruption detected, attempting recovery from snapshots...');
+    const result = await recoverFromSnapshots();
+    if (result.recovered) {
+      console.log(`✅ Recovered ${result.itemCount} items from snapshots`);
+      // Verify the recovered database
+      const newDb = getDb();
+      const newIntegrity = await checkIntegrity(newDb);
+      if (newIntegrity.ok) {
+        return;
+      }
+    }
+
+    // Recovery failed or still corrupted
     const errorList = integrity.errors.join('\n  - ');
     throw new Error(
-      `Database integrity check failed. The database file may be corrupted.\n` +
+      `Database integrity check failed and automatic recovery was unsuccessful.\n` +
       `Errors found:\n  - ${errorList}\n\n` +
-      `Recovery options:\n` +
+      `Manual recovery options:\n` +
       `  1. Restore from backup: jettypod work restore-backup latest\n` +
-      `  2. Rebuild from snapshots: The JSON snapshots in .jettypod/snapshots/ can restore your data\n` +
-      `  3. Check ~/.jettypod-backups/ for global backups`
+      `  2. Check ~/.jettypod-backups/ for global backups`
     );
   }
 
@@ -428,6 +552,7 @@ module.exports = {
   validateSchema,
   checkIntegrity,
   validateOnStartup,
+  recoverFromSnapshots,
   dbPath,  // Deprecated: use getDbPath() for dynamic path
   jettypodDir  // Deprecated: use getJettypodDir() for dynamic path
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.80",
+  "version": "4.4.82",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {