@goscribe/server 1.0.7 → 1.0.9

package/dist/routers/workspace.js

@@ -2,22 +2,70 @@ import { z } from 'zod';
 import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
 import { bucket } from '../lib/storage.js';
+import { ArtifactType } from '@prisma/client';
+import { aiSessionService } from '../lib/ai-session.js';
+import PusherService from '../lib/pusher.js';
+// Helper function to calculate search relevance score
+function calculateRelevance(query, ...texts) {
+    const queryLower = query.toLowerCase();
+    let score = 0;
+    for (const text of texts) {
+        if (!text)
+            continue;
+        const textLower = text.toLowerCase();
+        // Exact match gets highest score
+        if (textLower.includes(queryLower)) {
+            score += 10;
+        }
+        // Word boundary matches get good score
+        const words = queryLower.split(/\s+/);
+        for (const word of words) {
+            if (word.length > 2 && textLower.includes(word)) {
+                score += 5;
+            }
+        }
+        // Partial matches get lower score
+        const queryChars = queryLower.split('');
+        let consecutiveMatches = 0;
+        for (const char of queryChars) {
+            if (textLower.includes(char)) {
+                consecutiveMatches++;
+            }
+            else {
+                consecutiveMatches = 0;
+            }
+        }
+        score += consecutiveMatches * 0.1;
+    }
+    return score;
+}
 export const workspace = router({
     // List current user's workspaces
     list: authedProcedure
-        .query(async ({ ctx }) => {
+        .input(z.object({
+        parentId: z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
         const workspaces = await ctx.db.workspace.findMany({
             where: {
                 ownerId: ctx.session.user.id,
+                folderId: input.parentId ?? null,
             },
             orderBy: { updatedAt: 'desc' },
         });
-        return workspaces;
+        const folders = await ctx.db.folder.findMany({
+            where: {
+                ownerId: ctx.session.user.id,
+                parentId: input.parentId ?? null,
+            },
+        });
+        return { workspaces, folders };
     }),
     create: authedProcedure
         .input(z.object({
         name: z.string().min(1).max(100),
         description: z.string().max(500).optional(),
+        parentId: z.string().optional(),
     }))
         .mutation(async ({ ctx, input }) => {
         const ws = await ctx.db.workspace.create({
@@ -25,25 +73,111 @@ export const workspace = router({
                 title: input.name,
                 description: input.description,
                 ownerId: ctx.session.user.id,
+                folderId: input.parentId ?? null,
+                artifacts: {
+                    create: {
+                        type: ArtifactType.FLASHCARD_SET,
+                        title: "New Flashcard Set",
+                    },
+                    createMany: {
+                        data: [
+                            { type: ArtifactType.WORKSHEET, title: "Worksheet 1" },
+                            { type: ArtifactType.WORKSHEET, title: "Worksheet 2" },
+                        ],
+                    },
+                },
             },
         });
         return ws;
     }),
+    createFolder: authedProcedure
+        .input(z.object({
+        name: z.string().min(1).max(100),
+        parentId: z.string().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const folder = await ctx.db.folder.create({
+            data: {
+                name: input.name,
+                ownerId: ctx.session.user.id,
+                parentId: input.parentId ?? null,
+            },
+        });
+        return folder;
+    }),
     get: authedProcedure
         .input(z.object({
-        id: z.string().uuid(),
+        id: z.string(),
     }))
         .query(async ({ ctx, input }) => {
         const ws = await ctx.db.workspace.findFirst({
             where: { id: input.id, ownerId: ctx.session.user.id },
+            include: {
+                artifacts: true,
+                folder: true,
+                uploads: true,
+            },
         });
         if (!ws)
             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 },
+        });
+        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 },
+        });
+        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 } } },
+        });
+        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 } } },
+        });
+        return {
+            id: ws.id,
+            title: ws.title,
+            description: ws.description,
+            ownerId: ws.ownerId,
+            createdAt: ws.createdAt,
+            updatedAt: ws.updatedAt,
+        };
+    }),
     update: authedProcedure
         .input(z.object({
-        id: z.string().uuid(),
+        id: z.string(),
         name: z.string().min(1).max(100).optional(),
         description: z.string().max(500).optional(),
     }))
@@ -64,7 +198,7 @@ export const workspace = router({
     }),
     delete: authedProcedure
         .input(z.object({
-        id: z.string().uuid(),
+        id: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         const deleted = await ctx.db.workspace.deleteMany({
@@ -74,9 +208,29 @@ export const workspace = router({
             throw new TRPCError({ code: 'NOT_FOUND' });
         return true;
     }),
+    getFolderInformation: authedProcedure
+        .input(z.object({
+        id: z.string(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const folder = await ctx.db.folder.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
+        // find all of its parents
+        if (!folder)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const parents = [];
+        let current = folder;
+        while (current.parentId) {
+            const parent = await ctx.db.folder.findFirst({ where: { id: current.parentId, ownerId: ctx.session.user.id } });
+            if (!parent)
+                break;
+            parents.push(parent);
+            current = parent;
+        }
+        return { folder, parents };
+    }),
     uploadFiles: authedProcedure
         .input(z.object({
-        id: z.string().uuid(),
+        id: z.string(),
         files: z.array(z.object({
             filename: z.string().min(1).max(255),
             contentType: z.string().min(1).max(100),
@@ -125,8 +279,8 @@ export const workspace = router({
     }),
     deleteFiles: authedProcedure
         .input(z.object({
-        fileId: z.array(z.string().uuid()),
-        id: z.string().uuid(),
+        fileId: z.array(z.string()),
+        id: z.string(),
     }))
         .mutation(async ({ ctx, input }) => {
         // ensure files are in the user's workspace
@@ -155,4 +309,295 @@ export const workspace = router({
         });
         return true;
     }),
+    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
+        }),
+        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 }
+        });
+        if (!workspace) {
+            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 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();
+        // 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');
+        // 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 });
+        try {
+            if (fileType === 'image') {
+                await aiSessionService.analyseImage(session.id);
+                console.log('✅ Image analysis completed');
+            }
+            else {
+                await aiSessionService.analysePDF(session.id);
+                console.log('✅ PDF analysis completed');
+            }
+            await PusherService.emitTaskComplete(input.workspaceId, 'file_analysis_complete', { filename: input.file.filename, fileType });
+        }
+        catch (error) {
+            console.error('❌ Failed to analyze file:', error);
+            await PusherService.emitError(input.workspaceId, `Failed to analyze ${fileType}: ${error}`, 'file_analysis');
+            throw error;
+        }
+        const results = {
+            filename: input.file.filename,
+            artifacts: {
+                studyGuide: null,
+                flashcards: null,
+                worksheet: null,
+            }
+        };
+        // 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 });
+            let artifact = await ctx.db.artifact.findFirst({
+                where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
+            });
+            if (!artifact) {
+                artifact = await ctx.db.artifact.create({
+                    data: {
+                        workspaceId: input.workspaceId,
+                        type: ArtifactType.STUDY_GUIDE,
+                        title: `Study Guide - ${input.file.filename}`,
+                        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;
+            // 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 });
+            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,
+                },
+            });
+            // Parse JSON flashcard content
+            try {
+                const flashcardData = JSON.parse(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;
+            // 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,
+                },
+            });
+            // 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
+        .input(z.object({
+        query: z.string(),
+        limit: z.number().min(1).max(100).default(20),
+    }))
+        .query(async ({ ctx, input }) => {
+        const { query } = input;
+        const workspaces = await ctx.db.workspace.findMany({
+            where: {
+                ownerId: ctx.session.user.id,
+                OR: [
+                    {
+                        title: {
+                            contains: query,
+                            mode: 'insensitive',
+                        },
+                    },
+                    {
+                        description: {
+                            contains: query,
+                            mode: 'insensitive',
+                        },
+                    },
+                ],
+            },
+            orderBy: {
+                updatedAt: 'desc',
+            },
+            take: input.limit,
+        });
+        return workspaces;
+    })
 });

package/dist/server.d.ts

@@ -1 +1 @@
-export {};
+import 'dotenv/config';

package/dist/server.js

@@ -1,3 +1,4 @@
+import 'dotenv/config';
 import express from 'express';
 import cors from 'cors';
 import helmet from 'helmet';
@@ -12,12 +13,16 @@ async function main() {
     // Middlewares
     app.use(helmet());
     app.use(cors({
-        origin: "http://localhost:3000", // your Next.js dev URL
+        origin: process.env.FRONTEND_URL || "http://localhost:3000",
         credentials: true, // allow cookies
+        methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'Set-Cookie'],
+        exposedHeaders: ['Set-Cookie'],
     }));
     app.use(morgan('dev'));
     app.use(compression());
-    app.use(express.json());
+    app.use(express.json({ limit: '50mb' }));
+    app.use(express.urlencoded({ limit: '50mb', extended: true }));
     // Health (plain Express)
     app.get('/', (_req, res) => {
         res.json({ ok: true, service: 'trpc-express', ts: Date.now() });

package/dist/trpc.d.ts

@@ -4,7 +4,7 @@ export declare const router: import("@trpc/server").TRPCRouterBuilder<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: any;
+        cookies: Record<string, string | undefined>;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
@@ -15,20 +15,20 @@ export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, $ContextOverrides, unknown>;
 export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 /** Exported authed procedure */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<{
@@ -36,7 +36,7 @@ export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilde
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: any;
+    cookies: Record<string, string | undefined>;
 }, object, {
     session: any;
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,9 +12,10 @@
     }
   },
   "scripts": {
-    "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
+    "dev": "tsx watch src/server.ts",
     "build": "npx prisma generate && tsc -p .",
-    "start": "node --experimental-specifier-resolution=node dist/server.js"
+    "start": "node --experimental-specifier-resolution=node dist/server.js",
+    "seed": "node --experimental-specifier-resolution=node prisma/seed.mjs"
   },
   "author": "",
   "license": "MIT",
@@ -22,8 +23,11 @@
     "@auth/express": "^0.11.0",
     "@auth/prisma-adapter": "^2.10.0",
     "@google-cloud/storage": "^7.17.0",
+    "@goscribe/server": "^1.0.8",
     "@prisma/client": "^6.14.0",
     "@trpc/server": "^11.5.0",
+    "@types/uuid": "^10.0.0",
+    "@vingeray/editorjs-markdown-converter": "^0.1.2",
     "bcryptjs": "^3.0.2",
     "compression": "^1.8.1",
     "cookie": "^1.0.2",
@@ -33,6 +37,9 @@
     "helmet": "^8.1.0",
     "morgan": "^1.10.1",
     "prisma": "^6.14.0",
+    "pusher": "^5.2.0",
+    "pusher-js": "^8.4.0",
+    "socket.io": "^4.8.1",
     "superjson": "^2.2.2",
     "zod": "^4.1.1"
   },
@@ -47,6 +54,7 @@
     "ts-node-dev": "^2.0.0",
     "tsc-alias": "^1.8.16",
     "tsc-esm-fix": "^3.1.2",
+    "tsx": "^4.20.6",
     "typescript": "^5.9.2",
     "typescript-transform-paths": "^3.5.5"
   }