@goscribe/server 1.0.11 → 1.1.1

package/dist/routers/workspace.js

@@ -1,10 +1,19 @@
 import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
-import { bucket } from '../lib/storage.js';
+import { supabaseClient } from '../lib/storage.js';
 import { ArtifactType } from '@prisma/client';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
+import { members } from './members.js';
+// Helper function to update and emit analysis progress
+async function updateAnalysisProgress(db, workspaceId, progress) {
+    await db.workspace.update({
+        where: { id: workspaceId },
+        data: { analysisProgress: progress }
+    });
+    await PusherService.emitAnalysisProgress(workspaceId, progress);
+}
 // Helper function to calculate search relevance score
 function calculateRelevance(query, ...texts) {
     const queryLower = query.toLowerCase();
@@ -88,11 +97,13 @@ export const workspace = router({
                 },
             },
         });
+        aiSessionService.initSession(ws.id, ctx.session.user.id);
         return ws;
     }),
     createFolder: authedProcedure
         .input(z.object({
         name: z.string().min(1).max(100),
+        color: z.string().optional(),
         parentId: z.string().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
@@ -100,11 +111,30 @@ export const workspace = router({
             data: {
                 name: input.name,
                 ownerId: ctx.session.user.id,
+                color: input.color ?? '#9D00FF',
                 parentId: input.parentId ?? null,
             },
         });
         return folder;
     }),
+    updateFolder: authedProcedure
+        .input(z.object({
+        id: z.string(),
+        name: z.string().min(1).max(100).optional(),
+        color: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const folder = await ctx.db.folder.update({ where: { id: input.id }, data: { name: input.name, color: input.color ?? '#9D00FF' } });
+        return folder;
+    }),
+    deleteFolder: authedProcedure
+        .input(z.object({
+        id: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const folder = await ctx.db.folder.delete({ where: { id: input.id } });
+        return folder;
+    }),
     get: authedProcedure
         .input(z.object({
         id: z.string(),
@@ -122,57 +152,28 @@ export const workspace = router({
             throw new TRPCError({ code: 'NOT_FOUND' });
         return ws;
     }),
-    share: authedProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .query(async ({ ctx, input }) => {
-        const ws = await ctx.db.workspace.findFirst({
-            where: { id: input.id, ownerId: ctx.session.user.id },
+    getStats: authedProcedure
+        .query(async ({ ctx }) => {
+        const workspaces = await ctx.db.workspace.findMany({
+            where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
         });
-        if (!ws)
-            throw new TRPCError({ code: 'NOT_FOUND' });
-        // generate a unique share link if not exists
-        if (!ws.shareLink) {
-            const shareLink = [...Array(30)].map(() => (Math.random() * 36 | 0).toString(36)).join('');
-            const updated = await ctx.db.workspace.update({
-                where: { id: ws.id },
-                data: { shareLink },
-            });
-            return { shareLink: updated.shareLink };
-        }
-    }),
-    join: authedProcedure
-        .input(z.object({
-        shareLink: z.string().min(10).max(100),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        const ws = await ctx.db.workspace.findFirst({
-            where: { shareLink: input.shareLink },
+        const folders = await ctx.db.folder.findMany({
+            where: { OR: [{ ownerId: ctx.session.user.id }] },
         });
-        if (!ws)
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Workspace not found' });
-        if (ws.ownerId === ctx.session.user.id) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'Cannot join your own workspace' });
-        }
-        // add to sharedWith if not already
-        const alreadyShared = await ctx.db.workspace.findFirst({
-            where: { id: ws.id, sharedWith: { some: { id: ctx.session.user.id } } },
+        const lastUpdated = await ctx.db.workspace.findFirst({
+            where: { OR: [{ ownerId: ctx.session.user.id }, { sharedWith: { some: { id: ctx.session.user.id } } }] },
+            orderBy: { updatedAt: 'desc' },
         });
-        if (alreadyShared) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: 'Already joined this workspace' });
-        }
-        await ctx.db.workspace.update({
-            where: { id: ws.id },
-            data: { sharedWith: { connect: { id: ctx.session.user.id } } },
+        const spaceLeft = await ctx.db.fileAsset.aggregate({
+            where: { workspaceId: { in: workspaces.map(ws => ws.id) }, userId: ctx.session.user.id },
+            _sum: { size: true },
         });
         return {
-            id: ws.id,
-            title: ws.title,
-            description: ws.description,
-            ownerId: ws.ownerId,
-            createdAt: ws.createdAt,
-            updatedAt: ws.updatedAt,
+            workspaces: workspaces.length,
+            folders: folders.length,
+            lastUpdated: lastUpdated?.updatedAt,
+            spaceUsed: spaceLeft._sum?.size ?? 0,
+            spaceLeft: 1000000000 - (spaceLeft._sum?.size ?? 0) || 0,
         };
     }),
     update: authedProcedure
@@ -180,6 +181,8 @@ export const workspace = router({
         id: z.string(),
         name: z.string().min(1).max(100).optional(),
         description: z.string().max(500).optional(),
+        color: z.string().optional(),
+        icon: z.string().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
         const existed = await ctx.db.workspace.findFirst({
@@ -192,6 +195,8 @@ export const workspace = router({
             data: {
                 title: input.name ?? existed.title,
                 description: input.description,
+                color: input.color ?? existed.color,
+                icon: input.icon ?? existed.icon,
             },
         });
         return updated;
@@ -255,24 +260,27 @@ export const workspace = router({
                 },
             });
             // 2. Generate signed URL for direct upload
-            const [url] = await bucket
-                .file(`${ctx.session.user.id}/${record.id}-${file.filename}`)
-                .getSignedUrl({
-                action: "write",
-                expires: Date.now() + 5 * 60 * 1000, // 5 min
-                contentType: file.contentType,
-            });
+            const objectKey = `${ctx.session.user.id}/${record.id}-${file.filename}`;
+            const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+                .from('files')
+                .createSignedUploadUrl(objectKey); // 5 minutes
+            if (signedUrlError) {
+                throw new TRPCError({
+                    code: 'INTERNAL_SERVER_ERROR',
+                    message: `Failed to generate upload URL: ${signedUrlError.message}`
+                });
+            }
             // 3. Update record with bucket info
             await ctx.db.fileAsset.update({
                 where: { id: record.id },
                 data: {
-                    bucket: bucket.name,
-                    objectKey: `${ctx.session.user.id}/${record.id}-${file.filename}`,
+                    bucket: 'files',
+                    objectKey: objectKey,
                 },
             });
             results.push({
                 fileId: record.id,
-                uploadUrl: url,
+                uploadUrl: signedUrlData.signedUrl,
             });
         }
         return results;
@@ -291,11 +299,13 @@ export const workspace = router({
                 userId: ctx.session.user.id,
             },
         });
-        // Delete from GCS (best-effort)
+        // Delete from Supabase Storage (best-effort)
         for (const file of files) {
             if (file.bucket && file.objectKey) {
-                const gcsFile = bucket.file(file.objectKey);
-                gcsFile.delete({ ignoreNotFound: true }).catch((err) => {
+                supabaseClient.storage
+                    .from(file.bucket)
+                    .remove([file.objectKey])
+                    .catch((err) => {
                     console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
                 });
             }
@@ -339,11 +349,47 @@ export const workspace = router({
             console.error('❌ Workspace not found', { workspaceId: input.workspaceId, userId: ctx.session.user.id });
             throw new TRPCError({ code: 'NOT_FOUND' });
         }
-        console.log('✅ Workspace verified', { workspaceId: workspace.id, workspaceTitle: workspace.title });
-        // Convert base64 to buffer
-        console.log('📁 Converting base64 to buffer...');
+        const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
+        await ctx.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { fileBeingAnalyzed: true },
+        });
+        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',
+                    },
+                }
+            });
+        }
+        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;
+        }
         const fileBuffer = Buffer.from(input.file.content, 'base64');
-        console.log('✅ File buffer created', { bufferSize: fileBuffer.length });
         // // Check AI service health first
         // console.log('🏥 Checking AI service health...');
         // const isHealthy = await aiSessionService.checkHealth();
@@ -356,41 +402,115 @@ export const workspace = router({
         //   });
         // }
         // console.log('✅ AI service is healthy');
-        // Initialize AI session
-        console.log('🤖 Initializing AI session...');
-        const session = await aiSessionService.initSession(input.workspaceId);
-        console.log('✅ AI session initialized', { sessionId: session.id });
         const fileObj = new File([fileBuffer], input.file.filename, { type: input.file.contentType });
-        const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
-        console.log('📤 Uploading file to AI service...', { filename: input.file.filename, fileType });
-        await aiSessionService.uploadFile(session.id, fileObj, fileType);
-        console.log('✅ File uploaded to AI service');
-        console.log('🚀 Starting LLM session...');
-        try {
-            await aiSessionService.startLLMSession(session.id);
-            console.log('✅ LLM session started');
-        }
-        catch (error) {
-            console.error('❌ Failed to start LLM session:', error);
-            throw error;
-        }
-        // Analyze the file first
-        console.log('🔍 Analyzing file...', { fileType });
-        await PusherService.emitTaskComplete(input.workspaceId, 'file_analysis_start', { filename: input.file.filename, fileType });
+        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',
+                },
+            }
+        });
         try {
             if (fileType === 'image') {
-                await aiSessionService.analyseImage(session.id);
-                console.log('✅ Image analysis completed');
+                await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id);
             }
             else {
-                await aiSessionService.analysePDF(session.id);
-                console.log('✅ PDF analysis completed');
+                await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id);
             }
-            await PusherService.emitTaskComplete(input.workspaceId, 'file_analysis_complete', { filename: input.file.filename, fileType });
+            await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                status: 'generating_artifacts',
+                filename: input.file.filename,
+                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 file:', error);
-            await PusherService.emitError(input.workspaceId, `Failed to analyze ${fileType}: ${error}`, 'file_analysis');
+            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',
+                    },
+                }
+            });
             throw error;
         }
         const results = {
@@ -403,9 +523,31 @@ export const workspace = router({
         };
         // Generate artifacts
         if (input.generateStudyGuide) {
-            await PusherService.emitTaskComplete(input.workspaceId, 'study_guide_load_start', { filename: input.file.filename });
-            const content = await aiSessionService.generateStudyGuide(session.id);
-            await PusherService.emitTaskComplete(input.workspaceId, 'study_guide_info', { contentLength: content.length });
+            await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                status: 'generating_study_guide',
+                filename: input.file.filename,
+                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 },
             });
@@ -427,13 +569,33 @@ export const workspace = router({
                 data: { artifactId: artifact.id, version: lastVersion ? lastVersion.version + 1 : 1, content: content, createdById: ctx.session.user.id },
             });
             results.artifacts.studyGuide = artifact;
-            // Emit Pusher notification
-            await PusherService.emitStudyGuideComplete(input.workspaceId, artifact);
         }
         if (input.generateFlashcards) {
-            await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_load_start', { filename: input.file.filename });
-            const content = await aiSessionService.generateFlashcardQuestions(session.id, 10, 'medium');
-            await PusherService.emitTaskComplete(input.workspaceId, 'flash_card_info', { contentLength: content.length });
+            await updateAnalysisProgress(ctx.db, input.workspaceId, {
+                status: 'generating_flashcards',
+                filename: input.file.filename,
+                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,
@@ -444,7 +606,7 @@ export const workspace = router({
             });
             // Parse JSON flashcard content
             try {
-                const flashcardData = JSON.parse(content);
+                const flashcardData = content;
                 let createdCards = 0;
                 for (let i = 0; i < Math.min(flashcardData.length, 10); i++) {
                     const card = flashcardData[i];
@@ -482,90 +644,36 @@ export const workspace = router({
                 }
             }
             results.artifacts.flashcards = artifact;
-            // Emit Pusher notification
-            await PusherService.emitFlashcardComplete(input.workspaceId, artifact);
         }
-        if (input.generateWorksheet) {
-            await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_load_start', { filename: input.file.filename });
-            const content = await aiSessionService.generateWorksheetQuestions(session.id, 8, 'medium');
-            await PusherService.emitTaskComplete(input.workspaceId, 'worksheet_info', { contentLength: content.length });
-            const artifact = await ctx.db.artifact.create({
-                data: {
-                    workspaceId: input.workspaceId,
-                    type: ArtifactType.WORKSHEET,
-                    title: `Worksheet - ${input.file.filename}`,
-                    createdById: ctx.session.user.id,
+        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',
                 },
-            });
-            // Parse JSON worksheet content
-            try {
-                const worksheetData = JSON.parse(content);
-                // The actual worksheet data is in last_response as JSON
-                let actualWorksheetData = worksheetData;
-                if (worksheetData.last_response) {
-                    try {
-                        actualWorksheetData = JSON.parse(worksheetData.last_response);
-                    }
-                    catch (parseError) {
-                        console.error('❌ Failed to parse last_response JSON:', parseError);
-                        console.log('📋 Raw last_response:', worksheetData.last_response);
-                    }
-                }
-                // Handle different JSON structures
-                const problems = actualWorksheetData.problems || actualWorksheetData.questions || actualWorksheetData || [];
-                let createdQuestions = 0;
-                for (let i = 0; i < Math.min(problems.length, 8); i++) {
-                    const problem = problems[i];
-                    const prompt = problem.question || problem.prompt || `Question ${i + 1}`;
-                    const answer = problem.answer || problem.solution || `Answer ${i + 1}`;
-                    const type = problem.type || 'TEXT';
-                    const options = problem.options || [];
-                    await ctx.db.worksheetQuestion.create({
-                        data: {
-                            artifactId: artifact.id,
-                            prompt: prompt,
-                            answer: answer,
-                            difficulty: 'MEDIUM',
-                            order: i,
-                            meta: {
-                                type: type,
-                                options: options.length > 0 ? options : undefined
-                            },
-                        },
-                    });
-                    createdQuestions++;
-                }
-            }
-            catch (parseError) {
-                console.error('❌ Failed to parse worksheet JSON, using fallback parsing:', 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, 8); i++) {
-                    const line = lines[i];
-                    if (line.includes(' - ')) {
-                        const [prompt, answer] = line.split(' - ');
-                        await ctx.db.worksheetQuestion.create({
-                            data: {
-                                artifactId: artifact.id,
-                                prompt: prompt.trim(),
-                                answer: answer.trim(),
-                                difficulty: 'MEDIUM',
-                                order: i,
-                                meta: { type: 'TEXT', },
-                            },
-                        });
-                    }
-                }
             }
-            results.artifacts.worksheet = artifact;
-            // Emit Pusher notification
-            await PusherService.emitWorksheetComplete(input.workspaceId, artifact);
-        }
-        await PusherService.emitTaskComplete(input.workspaceId, 'analysis_cleanup_start', { filename: input.file.filename });
-        aiSessionService.deleteSession(session.id);
-        await PusherService.emitTaskComplete(input.workspaceId, 'analysis_cleanup_complete', { filename: input.file.filename });
-        // Emit overall completion notification
-        await PusherService.emitOverallComplete(input.workspaceId, input.file.filename, results.artifacts);
+        });
         return results;
     }),
     search: authedProcedure
@@ -598,6 +706,20 @@ export const workspace = router({
             },
             take: input.limit,
         });
+        // Update analysisProgress for each workspace with search metadata
+        const workspaceUpdates = workspaces.map(ws => ctx.db.workspace.update({
+            where: { id: ws.id },
+            data: {
+                analysisProgress: {
+                    lastSearched: new Date().toISOString(),
+                    searchQuery: query,
+                    matchedIn: ws.title.toLowerCase().includes(query.toLowerCase()) ? 'title' : 'description',
+                }
+            }
+        }));
+        await Promise.all(workspaceUpdates);
         return workspaces;
-    })
+    }),
+    // Members sub-router
+    members,
 });

package/dist/server.js

@@ -7,6 +7,7 @@ import compression from 'compression';
 import * as trpcExpress from '@trpc/server/adapters/express';
 import { appRouter } from './routers/_app.js';
 import { createContext } from './context.js';
+import { logger } from './lib/logger.js';
 const PORT = process.env.PORT ? Number(process.env.PORT) : 3001;
 async function main() {
     const app = express();
@@ -19,7 +20,14 @@ async function main() {
         allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'Set-Cookie'],
         exposedHeaders: ['Set-Cookie'],
     }));
-    app.use(morgan('dev'));
+    // Custom morgan middleware with logger integration
+    app.use(morgan('combined', {
+        stream: {
+            write: (message) => {
+                logger.info(message.trim(), 'HTTP');
+            }
+        }
+    }));
     app.use(compression());
     app.use(express.json({ limit: '50mb' }));
     app.use(express.urlencoded({ limit: '50mb', extended: true }));
@@ -33,11 +41,11 @@ async function main() {
         createContext,
     }));
     app.listen(PORT, () => {
-        console.log(`✅ Server ready on http://localhost:${PORT}`);
-        console.log(`➡️  tRPC endpoint at http://localhost:${PORT}/trpc`);
+        logger.info(`Server ready on http://localhost:${PORT}`, 'SERVER');
+        logger.info(`tRPC endpoint at http://localhost:${PORT}/trpc`, 'SERVER');
     });
 }
 main().catch((err) => {
-    console.error('Failed to start server', err);
+    logger.error('Failed to start server', 'SERVER', undefined, err);
     process.exit(1);
 });