@goscribe/server 1.1.1 → 1.1.3

package/dist/routers/workspace.js

@@ -6,6 +6,7 @@ import { ArtifactType } from '@prisma/client';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
 import { members } from './members.js';
+import { logger } from '../lib/logger.js';
 // Helper function to update and emit analysis progress
 async function updateAnalysisProgress(db, workspaceId, progress) {
     await db.workspace.update({
@@ -233,6 +234,20 @@ export const workspace = router({
         }
         return { folder, parents };
     }),
+    getSharedWith: authedProcedure
+        .input(z.object({
+        id: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const user = await ctx.db.user.findFirst({ where: { id: ctx.session.user.id } });
+        if (!user || !user.email)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const sharedWith = await ctx.db.workspace.findMany({ where: { members: { some: { userId: ctx.session.user.id } } } });
+        const invitations = await ctx.db.workspaceInvitation.findMany({ where: { email: user.email, acceptedAt: null }, include: {
+                workspace: true,
+            } });
+        return { shared: sharedWith, invitations };
+    }),
     uploadFiles: authedProcedure
         .input(z.object({
         id: z.string(),
@@ -319,28 +334,52 @@ export const workspace = router({
         });
         return true;
     }),
+    getFileUploadUrl: authedProcedure
+        .input(z.object({
+        workspaceId: z.string(),
+        filename: z.string(),
+        contentType: z.string(),
+        size: z.number(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
+        const fileAsset = await ctx.db.fileAsset.create({
+            data: {
+                workspaceId: input.workspaceId,
+                name: input.filename,
+                mimeType: input.contentType,
+                size: input.size,
+                userId: ctx.session.user.id,
+                bucket: 'media',
+                objectKey: objectKey,
+            },
+        });
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+            .from('media')
+            .createSignedUploadUrl(objectKey); // 5 minutes
+        if (signedUrlError) {
+            throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
+        }
+        await ctx.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { needsAnalysis: true },
+        });
+        return {
+            fileId: fileAsset.id,
+            uploadUrl: signedUrlData.signedUrl,
+        };
+    }),
     uploadAndAnalyzeMedia: authedProcedure
         .input(z.object({
         workspaceId: z.string(),
-        file: z.object({
-            filename: z.string(),
-            contentType: z.string(),
-            size: z.number(),
-            content: z.string(), // Base64 encoded file content
-        }),
+        files: z.array(z.object({
+            id: z.string(),
+        })),
         generateStudyGuide: z.boolean().default(true),
         generateFlashcards: z.boolean().default(true),
         generateWorksheet: z.boolean().default(true),
     }))
         .mutation(async ({ ctx, input }) => {
-        console.log('🚀 uploadAndAnalyzeMedia started', {
-            workspaceId: input.workspaceId,
-            filename: input.file.filename,
-            fileSize: input.file.size,
-            generateStudyGuide: input.generateStudyGuide,
-            generateFlashcards: input.generateFlashcards,
-            generateWorksheet: input.generateWorksheet
-        });
         // Verify workspace ownership
         const workspace = await ctx.db.workspace.findFirst({
             where: { id: input.workspaceId, ownerId: ctx.session.user.id }
@@ -349,129 +388,102 @@ export const workspace = router({
             console.error('❌ Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
             throw new TRPCError({ code: 'NOT_FOUND' });
         }
-        const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
-        await ctx.db.workspace.update({
-            where: { id: input.workspaceId },
-            data: { fileBeingAnalyzed: true },
+        // Check if analysis is already in progress
+        if (workspace.fileBeingAnalyzed) {
+            throw new TRPCError({
+                code: 'CONFLICT',
+                message: 'File analysis is already in progress for this workspace. Please wait for it to complete.'
+            });
+        }
+        // Fetch files from database
+        const files = await ctx.db.fileAsset.findMany({
+            where: {
+                id: { in: input.files.map(file => file.id) },
+                workspaceId: input.workspaceId,
+                userId: ctx.session.user.id,
+            },
         });
-        try {
-            await updateAnalysisProgress(ctx.db, input.workspaceId, {
-                status: 'starting',
-                filename: input.file.filename,
-                fileType,
-                startedAt: new Date().toISOString(),
-                steps: {
-                    fileUpload: {
-                        order: 1,
-                        status: 'pending',
-                    },
-                    fileAnalysis: {
-                        order: 2,
-                        status: 'pending',
-                    },
-                    studyGuide: {
-                        order: 3,
-                        status: input.generateStudyGuide ? 'pending' : 'skipped',
-                    },
-                    flashcards: {
-                        order: 4,
-                        status: input.generateFlashcards ? 'pending' : 'skipped',
-                    },
-                }
+        if (files.length === 0) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'No files found with the provided IDs'
             });
         }
-        catch (error) {
-            console.error('❌ Failed to update analysis progress:', error);
+        // Validate all files have bucket and objectKey
+        for (const file of files) {
+            if (!file.bucket || !file.objectKey) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: `File ${file.id} does not have bucket or objectKey set`
+                });
+            }
+        }
+        // Use the first file for progress tracking and artifact naming
+        const primaryFile = files[0];
+        const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
+        try {
+            // Set analysis in progress flag
             await ctx.db.workspace.update({
                 where: { id: input.workspaceId },
-                data: { fileBeingAnalyzed: false },
+                data: { fileBeingAnalyzed: true },
             });
-            await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
-            throw error;
-        }
-        const fileBuffer = Buffer.from(input.file.content, 'base64');
-        // // Check AI service health first
-        // console.log('🏥 Checking AI service health...');
-        // const isHealthy = await aiSessionService.checkHealth();
-        // if (!isHealthy) {
-        //   console.error('❌ AI service is not available');
-        //   await PusherService.emitError(input.workspaceId, 'AI service is currently unavailable');
-        //   throw new TRPCError({
-        //     code: 'SERVICE_UNAVAILABLE',
-        //     message: 'AI service is currently unavailable. Please try again later.',
-        //   });
-        // }
-        // console.log('✅ AI service is healthy');
-        const fileObj = new File([fileBuffer], input.file.filename, { type: input.file.contentType });
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'uploading',
-            filename: input.file.filename,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-                fileUpload: {
-                    order: 1,
-                    status: 'in_progress',
-                },
-                fileAnalysis: {
-                    order: 2,
-                    status: 'pending',
-                },
-                studyGuide: {
-                    order: 3,
-                    status: input.generateStudyGuide ? 'pending' : 'skipped',
-                },
-                flashcards: {
-                    order: 4,
-                    status: input.generateFlashcards ? 'pending' : 'skipped',
-                },
-            }
-        });
-        await aiSessionService.uploadFile(input.workspaceId, ctx.session.user.id, fileObj, fileType);
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'analyzing',
-            filename: input.file.filename,
-            fileType,
-            startedAt: new Date().toISOString(),
-            steps: {
-                fileUpload: {
-                    order: 1,
-                    status: 'completed',
-                },
-                fileAnalysis: {
-                    order: 2,
-                    status: 'in_progress',
-                },
-                studyGuide: {
-                    order: 3,
-                    status: input.generateStudyGuide ? 'pending' : 'skipped',
-                },
-                flashcards: {
-                    order: 4,
-                    status: input.generateFlashcards ? 'pending' : 'skipped',
+            PusherService.emitAnalysisProgress(input.workspaceId, {
+                status: 'starting',
+                filename: primaryFile.name,
+                fileType,
+                startedAt: new Date().toISOString(),
+                steps: {
+                    fileUpload: { order: 1, status: 'pending' },
                 },
+            });
+            try {
+                await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                    status: 'starting',
+                    filename: primaryFile.name,
+                    fileType,
+                    startedAt: new Date().toISOString(),
+                    steps: {
+                        fileUpload: {
+                            order: 1,
+                            status: 'pending',
+                        },
+                        fileAnalysis: {
+                            order: 2,
+                            status: 'pending',
+                        },
+                        studyGuide: {
+                            order: 3,
+                            status: input.generateStudyGuide ? 'pending' : 'skipped',
+                        },
+                        flashcards: {
+                            order: 4,
+                            status: input.generateFlashcards ? 'pending' : 'skipped',
+                        },
+                    }
+                });
             }
-        });
-        try {
-            if (fileType === 'image') {
-                await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id);
-            }
-            else {
-                await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id);
+            catch (error) {
+                console.error('❌ Failed to update analysis progress:', error);
+                await ctx.db.workspace.update({
+                    where: { id: input.workspaceId },
+                    data: { fileBeingAnalyzed: false },
+                });
+                await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+                throw error;
             }
             await updateAnalysisProgress(ctx.db, input.workspaceId, {
-                status: 'generating_artifacts',
-                filename: input.file.filename,
+                status: 'uploading',
+                filename: primaryFile.name,
                 fileType,
                 startedAt: new Date().toISOString(),
                 steps: {
                     fileUpload: {
                         order: 1,
-                        status: 'completed',
+                        status: 'in_progress',
                     },
                     fileAnalysis: {
                         order: 2,
-                        status: 'completed',
+                        status: 'pending',
                     },
                     studyGuide: {
                         order: 3,
@@ -483,49 +495,53 @@ export const workspace = router({
                     },
                 }
             });
-        }
-        catch (error) {
-            console.error('❌ Failed to analyze file:', error);
-            await updateAnalysisProgress(ctx.db, input.workspaceId, {
-                status: 'error',
-                filename: input.file.filename,
-                fileType,
-                error: `Failed to analyze ${fileType}: ${error}`,
-                startedAt: new Date().toISOString(),
-                steps: {
-                    fileUpload: {
-                        order: 1,
-                        status: 'completed',
-                    },
-                    fileAnalysis: {
-                        order: 2,
-                        status: 'error',
-                    },
-                    studyGuide: {
-                        order: 3,
-                        status: 'skipped',
-                    },
-                    flashcards: {
-                        order: 4,
-                        status: 'skipped',
-                    },
+            // Process all files using the new process_file endpoint
+            for (const file of files) {
+                // TypeScript: We already validated bucket and objectKey exist above
+                if (!file.bucket || !file.objectKey) {
+                    continue; // Skip if somehow missing (shouldn't happen due to validation above)
+                }
+                const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                    .from(file.bucket)
+                    .createSignedUrl(file.objectKey, 24 * 60 * 60); // 24 hours expiry
+                if (signedUrlError) {
+                    await ctx.db.workspace.update({
+                        where: { id: input.workspaceId },
+                        data: { fileBeingAnalyzed: false },
+                    });
+                    throw new TRPCError({
+                        code: 'INTERNAL_SERVER_ERROR',
+                        message: `Failed to generate signed URL for file ${file.name}: ${signedUrlError.message}`
+                    });
+                }
+                const fileUrl = signedUrlData.signedUrl;
+                const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+                // Use maxPages for large PDFs (>50 pages) to limit processing
+                const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+                const processResult = await aiSessionService.processFile(input.workspaceId, ctx.session.user.id, fileUrl, currentFileType, maxPages);
+                if (processResult.status === 'error') {
+                    logger.error(`Failed to process file ${file.name}:`, processResult.error);
+                    // Continue processing other files even if one fails
+                    // Optionally, you could throw an error or mark this file as failed
+                }
+                else {
+                    logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+                    // Store the comprehensive description in aiTranscription field
+                    await ctx.db.fileAsset.update({
+                        where: { id: file.id },
+                        data: {
+                            aiTranscription: {
+                                comprehensiveDescription: processResult.comprehensiveDescription,
+                                textContent: processResult.textContent,
+                                imageDescriptions: processResult.imageDescriptions,
+                            },
+                        }
+                    });
                 }
-            });
-            throw error;
-        }
-        const results = {
-            filename: input.file.filename,
-            artifacts: {
-                studyGuide: null,
-                flashcards: null,
-                worksheet: null,
             }
-        };
-        // Generate artifacts
-        if (input.generateStudyGuide) {
             await updateAnalysisProgress(ctx.db, input.workspaceId, {
-                status: 'generating_study_guide',
-                filename: input.file.filename,
+                status: 'analyzing',
+                filename: primaryFile.name,
                 fileType,
                 startedAt: new Date().toISOString(),
                 steps: {
@@ -535,11 +551,11 @@ export const workspace = router({
                     },
                     fileAnalysis: {
                         order: 2,
-                        status: 'completed',
+                        status: 'in_progress',
                     },
                     studyGuide: {
                         order: 3,
-                        status: 'in_progress',
+                        status: input.generateStudyGuide ? 'pending' : 'skipped',
                     },
                     flashcards: {
                         order: 4,
@@ -547,35 +563,218 @@ export const workspace = router({
                     },
                 }
             });
-            const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
-            let artifact = await ctx.db.artifact.findFirst({
-                where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
-            });
-            if (!artifact) {
-                artifact = await ctx.db.artifact.create({
+            try {
+                // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
+                // const hasPDF = files.some(f => !f.mimeType.startsWith('image/'));
+                // if (hasPDF) {
+                //   await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id, file.id);
+                // } else {
+                //   // If all files are images, analyze them
+                //   for (const file of files) {
+                //     await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id, file.id);
+                //   }
+                // }
+                await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                    status: 'generating_artifacts',
+                    filename: primaryFile.name,
+                    fileType,
+                    startedAt: new Date().toISOString(),
+                    steps: {
+                        fileUpload: {
+                            order: 1,
+                            status: 'completed',
+                        },
+                        fileAnalysis: {
+                            order: 2,
+                            status: 'completed',
+                        },
+                        studyGuide: {
+                            order: 3,
+                            status: input.generateStudyGuide ? 'pending' : 'skipped',
+                        },
+                        flashcards: {
+                            order: 4,
+                            status: input.generateFlashcards ? 'pending' : 'skipped',
+                        },
+                    }
+                });
+            }
+            catch (error) {
+                console.error('❌ Failed to analyze files:', error);
+                await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                    status: 'error',
+                    filename: primaryFile.name,
+                    fileType,
+                    error: `Failed to analyze ${fileType}: ${error}`,
+                    startedAt: new Date().toISOString(),
+                    steps: {
+                        fileUpload: {
+                            order: 1,
+                            status: 'completed',
+                        },
+                        fileAnalysis: {
+                            order: 2,
+                            status: 'error',
+                        },
+                        studyGuide: {
+                            order: 3,
+                            status: 'skipped',
+                        },
+                        flashcards: {
+                            order: 4,
+                            status: 'skipped',
+                        },
+                    }
+                });
+                await ctx.db.workspace.update({
+                    where: { id: input.workspaceId },
+                    data: { fileBeingAnalyzed: false },
+                });
+                throw error;
+            }
+            const results = {
+                filename: primaryFile.name,
+                artifacts: {
+                    studyGuide: null,
+                    flashcards: null,
+                    worksheet: null,
+                }
+            };
+            // Generate artifacts
+            if (input.generateStudyGuide) {
+                await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                    status: 'generating_study_guide',
+                    filename: primaryFile.name,
+                    fileType,
+                    startedAt: new Date().toISOString(),
+                    steps: {
+                        fileUpload: {
+                            order: 1,
+                            status: 'completed',
+                        },
+                        fileAnalysis: {
+                            order: 2,
+                            status: 'completed',
+                        },
+                        studyGuide: {
+                            order: 3,
+                            status: 'in_progress',
+                        },
+                        flashcards: {
+                            order: 4,
+                            status: input.generateFlashcards ? 'pending' : 'skipped',
+                        },
+                    }
+                });
+                const content = await aiSessionService.generateStudyGuide(input.workspaceId, ctx.session.user.id);
+                let artifact = await ctx.db.artifact.findFirst({
+                    where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+                });
+                if (!artifact) {
+                    const fileNames = files.map(f => f.name).join(', ');
+                    artifact = await ctx.db.artifact.create({
+                        data: {
+                            workspaceId: input.workspaceId,
+                            type: ArtifactType.STUDY_GUIDE,
+                            title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
+                            createdById: ctx.session.user.id,
+                        },
+                    });
+                }
+                const lastVersion = await ctx.db.artifactVersion.findFirst({
+                    where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
+                    orderBy: { version: 'desc' },
+                });
+                await ctx.db.artifactVersion.create({
+                    data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+                });
+                results.artifacts.studyGuide = artifact;
+            }
+            if (input.generateFlashcards) {
+                await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                    status: 'generating_flashcards',
+                    filename: primaryFile.name,
+                    fileType,
+                    startedAt: new Date().toISOString(),
+                    steps: {
+                        fileUpload: {
+                            order: 1,
+                            status: 'completed',
+                        },
+                        fileAnalysis: {
+                            order: 2,
+                            status: 'completed',
+                        },
+                        studyGuide: {
+                            order: 3,
+                            status: input.generateStudyGuide ? 'completed' : 'skipped',
+                        },
+                        flashcards: {
+                            order: 4,
+                            status: 'in_progress',
+                        },
+                    }
+                });
+                const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
+                const artifact = await ctx.db.artifact.create({
                     data: {
                         workspaceId: input.workspaceId,
-                        type: ArtifactType.STUDY_GUIDE,
-                        title: `Study Guide - ${input.file.filename}`,
+                        type: ArtifactType.FLASHCARD_SET,
+                        title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
                         createdById: ctx.session.user.id,
                     },
                 });
+                // Parse JSON flashcard content
+                try {
+                    const flashcardData = content;
+                    let createdCards = 0;
+                    for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
+                        const card = flashcardData[i];
+                        const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
+                        const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
+                        await ctx.db.flashcard.create({
+                            data: {
+                                artifactId: artifact.id,
+                                front: front,
+                                back: back,
+                                order: i,
+                                tags: ['ai-generated', 'medium'],
+                            },
+                        });
+                        createdCards++;
+                    }
+                }
+                catch (parseError) {
+                    // Fallback to text parsing if JSON fails
+                    const lines = content.split('\n').filter(line => line.trim());
+                    for (let i = 0; i < Math.min(lines.length, 10); i++) {
+                        const line = lines[i];
+                        if (line.includes(' - ')) {
+                            const [front, back] = line.split(' - ');
+                            await ctx.db.flashcard.create({
+                                data: {
+                                    artifactId: artifact.id,
+                                    front: front.trim(),
+                                    back: back.trim(),
+                                    order: i,
+                                    tags: ['ai-generated', 'medium'],
+                                },
+                            });
+                        }
+                    }
+                }
+                results.artifacts.flashcards = artifact;
             }
-            const lastVersion = await ctx.db.artifactVersion.findFirst({
-                where: { artifact: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE } },
-                orderBy: { version: 'desc' },
-            });
-            await ctx.db.artifactVersion.create({
-                data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
+            await ctx.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: false },
             });
-            results.artifacts.studyGuide = artifact;
-        }
-        if (input.generateFlashcards) {
             await updateAnalysisProgress(ctx.db, input.workspaceId, {
-                status: 'generating_flashcards',
-                filename: input.file.filename,
+                status: 'completed',
+                filename: primaryFile.name,
                 fileType,
                 startedAt: new Date().toISOString(),
+                completedAt: new Date().toISOString(),
                 steps: {
                     fileUpload: {
                         order: 1,
@@ -591,90 +790,21 @@ export const workspace = router({
                     },
                     flashcards: {
                         order: 4,
-                        status: 'in_progress',
+                        status: input.generateFlashcards ? 'completed' : 'skipped',
                     },
                 }
             });
-            const content = await aiSessionService.generateFlashcardQuestions(input.workspaceId, ctx.session.user.id, 10, 'medium');
-            const artifact = await ctx.db.artifact.create({
-                data: {
-                    workspaceId: input.workspaceId,
-                    type: ArtifactType.FLASHCARD_SET,
-                    title: `Flashcards - ${input.file.filename}`,
-                    createdById: ctx.session.user.id,
-                },
+            return results;
+        }
+        catch (error) {
+            console.error('❌ Failed to update analysis progress:', error);
+            await ctx.db.workspace.update({
+                where: { id: input.workspaceId },
+                data: { fileBeingAnalyzed: false },
             });
-            // Parse JSON flashcard content
-            try {
-                const flashcardData = content;
-                let createdCards = 0;
-                for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
-                    const card = flashcardData[i];
-                    const front = card.term || card.front || card.question || card.prompt || `Question ${i + 1}`;
-                    const back = card.definition || card.back || card.answer || card.solution || `Answer ${i + 1}`;
-                    await ctx.db.flashcard.create({
-                        data: {
-                            artifactId: artifact.id,
-                            front: front,
-                            back: back,
-                            order: i,
-                            tags: ['ai-generated', 'medium'],
-                        },
-                    });
-                    createdCards++;
-                }
-            }
-            catch (parseError) {
-                // Fallback to text parsing if JSON fails
-                const lines = content.split('\n').filter(line => line.trim());
-                for (let i = 0; i < Math.min(lines.length, 10); i++) {
-                    const line = lines[i];
-                    if (line.includes(' - ')) {
-                        const [front, back] = line.split(' - ');
-                        await ctx.db.flashcard.create({
-                            data: {
-                                artifactId: artifact.id,
-                                front: front.trim(),
-                                back: back.trim(),
-                                order: i,
-                                tags: ['ai-generated', 'medium'],
-                            },
-                        });
-                    }
-                }
-            }
-            results.artifacts.flashcards = artifact;
+            await PusherService.emitError(input.workspaceId, `Failed to update analysis progress: ${error}`, 'file_analysis');
+            throw error;
         }
-        await ctx.db.workspace.update({
-            where: { id: input.workspaceId },
-            data: { fileBeingAnalyzed: false },
-        });
-        await updateAnalysisProgress(ctx.db, input.workspaceId, {
-            status: 'completed',
-            filename: input.file.filename,
-            fileType,
-            startedAt: new Date().toISOString(),
-            completedAt: new Date().toISOString(),
-            steps: {
-                fileUpload: {
-                    order: 1,
-                    status: 'completed',
-                },
-                fileAnalysis: {
-                    order: 2,
-                    status: 'completed',
-                },
-                studyGuide: {
-                    order: 3,
-                    status: input.generateStudyGuide ? 'completed' : 'skipped',
-                },
-                flashcards: {
-                    order: 4,
-                    status: input.generateFlashcards ? 'completed' : 'skipped',
-                },
-            }
-        });
-        return results;
     }),
     search: authedProcedure
         .input(z.object({