more logs

src/lib/components/AutoTrainerScanner/AutoTrainerScanner.svelte

@@ -32,6 +32,12 @@
     error: null as string | null
   });
   
+  // Promise tracking for current image processing
+  let currentImagePromise: {
+    resolve: (value: any) => void;
+    reject: (error: any) => void;
+  } | null = null;
+  
   let showDetails = $state(false);
   let isInitializing = $state(false);
   let shouldStop = $state(false);
@@ -122,13 +128,20 @@
         // Fetch remote image
         const imageFile = await fetchRemoteImage(nextImage.remoteUrl, nextImage.imagePath);
         
+        // Create a Promise that will be resolved by the completion callback
+        const imageProcessingPromise = new Promise<void>((resolve, reject) => {
+          currentImagePromise = { resolve, reject };
+        });
+        
         // Queue the image in PicletGenerator
         if (picletGenerator) {
           picletGenerator.queueTrainerImage(imageFile, nextImage.imagePath);
         }
         
         // Wait for this image to be processed before continuing
-        // (The onTrainerImageCompleted callback will handle the database update)
+        console.log(`🔧 DEBUG: Waiting for completion of ${nextImage.imagePath}...`);
+        await imageProcessingPromise;
+        console.log(`✅ DEBUG: Completed processing of ${nextImage.imagePath}, moving to next image`);
         
       } catch (error) {
         console.error(`Failed to process ${nextImage.imagePath}:`, error);
@@ -136,12 +149,15 @@
           nextImage.imagePath, 
           error instanceof Error ? error.message : 'Unknown error'
         );
+        
+        // Reject the current promise if it exists
+        if (currentImagePromise) {
+          currentImagePromise.reject(error);
+          currentImagePromise = null;
+        }
       }
       
       await updateProgress();
-      
-      // Small delay between images
-      await new Promise(resolve => setTimeout(resolve, 1000));
     }
   }
   
@@ -159,26 +175,32 @@
   
   async function onTrainerImageCompleted(imagePath: string, picletId: number) {
     console.log(`✅ Trainer image completed: ${imagePath} -> Piclet ID: ${picletId}`);
-    console.log(`🔧 DEBUG: Marking ${imagePath} as completed in database...`);
     
     try {
       await markImageProcessingCompleted(imagePath, picletId);
-      console.log(`✅ DEBUG: Successfully marked ${imagePath} as completed`);
     } catch (error) {
-      console.error(`❌ DEBUG: Failed to mark ${imagePath} as completed:`, error);
+      console.error(`❌ Failed to mark ${imagePath} as completed:`, error);
     }
     
     await updateProgress();
     
-    // Check what getNextPendingImage returns after this update
-    const nextImage = await getNextPendingImage();
-    console.log(`🔧 DEBUG: Next pending image after completion:`, nextImage?.imagePath || 'null');
+    // Resolve the current image processing promise
+    if (currentImagePromise) {
+      currentImagePromise.resolve(undefined);
+      currentImagePromise = null;
+    }
   }
   
   async function onTrainerImageFailed(imagePath: string, error: string) {
     console.error(`❌ Trainer image failed: ${imagePath} -> ${error}`);
     await markImageProcessingFailed(imagePath, error);
     await updateProgress();
+    
+    // Resolve the current image processing promise (failed images should still allow progression)
+    if (currentImagePromise) {
+      currentImagePromise.resolve(undefined);
+      currentImagePromise = null;
+    }
   }
   
   function formatImageName(imagePath: string | null): string {

src/lib/db/trainerScanning.ts

@@ -116,19 +116,11 @@ export async function markImageProcessingCompleted(
   imagePath: string, 
   picletInstanceId: number
 ): Promise<void> {
-  console.log(`🔧 DB DEBUG: markImageProcessingCompleted called for: ${imagePath}`);
-  
-  try {
-    await updateScanProgress(imagePath, {
-      status: 'completed',
-      picletInstanceId,
-      completedAt: new Date()
-    });
-    console.log(`✅ DB DEBUG: Successfully updated ${imagePath} to completed status`);
-  } catch (error) {
-    console.error(`❌ DB DEBUG: Failed to update ${imagePath}:`, error);
-    throw error;
-  }
+  await updateScanProgress(imagePath, {
+    status: 'completed',
+    picletInstanceId,
+    completedAt: new Date()
+  });
 }
 
 // Mark image processing as failed