@goscribe/server 1.0.7 → 1.0.9

package/dist/lib/ai-session.d.ts

@@ -0,0 +1,26 @@
+export interface AISession {
+    id: string;
+    workspaceId: string;
+    status: 'initialized' | 'processing' | 'ready' | 'error';
+    files: string[];
+    instructionText?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare class AISessionService {
+    private sessions;
+    initSession(workspaceId: string): Promise<AISession>;
+    uploadFile(sessionId: string, file: File, fileType: 'image' | 'pdf'): Promise<void>;
+    setInstruction(sessionId: string, instructionText: string): Promise<void>;
+    startLLMSession(sessionId: string): Promise<void>;
+    generateStudyGuide(sessionId: string): Promise<string>;
+    generateFlashcardQuestions(sessionId: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string>;
+    generateWorksheetQuestions(sessionId: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string>;
+    analysePDF(sessionId: string): Promise<string>;
+    analyseImage(sessionId: string): Promise<string>;
+    getSession(sessionId: string): AISession | undefined;
+    getSessionsByUserAndWorkspace(userId: string, workspaceId: string): AISession[];
+    deleteSession(sessionId: string): boolean;
+    checkHealth(): Promise<boolean>;
+}
+export declare const aiSessionService: AISessionService;

package/dist/lib/ai-session.js

@@ -0,0 +1,343 @@
+import { TRPCError } from '@trpc/server';
+// External AI service configuration
+const AI_SERVICE_URL = 'https://txp-tckxn64wn5vtgip72-kzoemq8qw-custom.service.onethingrobot.com/upload';
+const AI_RESPONSE_URL = 'https://txp-tckxn64wn5vtgip72-kzoemq8qw-custom.service.onethingrobot.com/last_response';
+export class AISessionService {
+    constructor() {
+        this.sessions = new Map();
+    }
+    // Initialize a new AI session
+    async initSession(workspaceId) {
+        const sessionId = `${workspaceId}`;
+        const formData = new FormData();
+        formData.append('command', 'init_session');
+        formData.append('id', sessionId);
+        // Retry logic for AI service
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                console.log(`🤖 AI Session init attempt ${attempt}/${maxRetries} for workspace ${workspaceId}`);
+                const response = await fetch(AI_SERVICE_URL, {
+                    method: 'POST',
+                    body: formData,
+                });
+                console.log(`📡 AI Service response status: ${response.status} ${response.statusText}`);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error(`❌ AI Service error response:`, errorText);
+                    throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
+                }
+                const result = await response.json();
+                console.log(`📋 AI Service result:`, result);
+                // If we get a response with a message, consider it successful
+                if (!result.message) {
+                    throw new Error(`AI service error: No response message`);
+                }
+                const session = {
+                    id: sessionId,
+                    workspaceId,
+                    status: 'initialized',
+                    files: [],
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                };
+                this.sessions.set(sessionId, session);
+                console.log(`✅ AI Session initialized successfully on attempt ${attempt}`);
+                return session;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error('Unknown error');
+                console.error(`❌ AI Session init attempt ${attempt} failed:`, lastError.message);
+                if (attempt < maxRetries) {
+                    const delay = Math.pow(2, attempt) * 1000; // Exponential backoff: 2s, 4s, 8s
+                    console.log(`⏳ Retrying in ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        console.error(`💥 All ${maxRetries} attempts failed. Last error:`, lastError?.message);
+        throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: `Failed to initialize AI session after ${maxRetries} attempts: ${lastError?.message || 'Unknown error'}`,
+        });
+    }
+    // Upload file to AI session
+    async uploadFile(sessionId, file, fileType) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const command = fileType === 'image' ? 'append_image' : 'append_pdflike';
+        const formData = new FormData();
+        formData.append('command', command);
+        formData.append('file', file);
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            console.log(`📋 Upload result:`, result);
+            if (!result.message) {
+                throw new Error(`AI service error: No response message`);
+            }
+            // Update session
+            session.files.push(file.name);
+            session.updatedAt = new Date();
+            this.sessions.set(sessionId, session);
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Set instruction text
+    async setInstruction(sessionId, instructionText) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'set_instruct');
+        formData.append('instruction_text', instructionText);
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            console.log(`📋 Set instruction result:`, result);
+            if (!result.message) {
+                throw new Error(`AI service error: No response message`);
+            }
+            // Update session
+            session.instructionText = instructionText;
+            session.updatedAt = new Date();
+            this.sessions.set(sessionId, session);
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to set instruction: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Start LLM session
+    async startLLMSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'start_LLM_session');
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            console.log(`📋 Start LLM result:`, result);
+            if (!result.message) {
+                throw new Error(`AI service error: No response message`);
+            }
+            // Update session
+            session.status = 'ready';
+            session.updatedAt = new Date();
+            this.sessions.set(sessionId, session);
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to start LLM session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Generate study guide
+    async generateStudyGuide(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'generate_study_guide');
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            // Get the generated content from the response endpoint
+            const contentResponse = await fetch(AI_RESPONSE_URL);
+            if (!contentResponse.ok) {
+                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
+            }
+            return (await contentResponse.json())['last_response'];
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate study guide: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Generate flashcard questions
+    async generateFlashcardQuestions(sessionId, numQuestions, difficulty) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'generate_flashcard_questions');
+        formData.append('num_questions', numQuestions.toString());
+        formData.append('difficulty', difficulty);
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            // Get the generated content from the response endpoint
+            const contentResponse = await fetch(AI_RESPONSE_URL);
+            if (!contentResponse.ok) {
+                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
+            }
+            return (await contentResponse.json())['last_response'];
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate flashcard questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Generate worksheet questions
+    async generateWorksheetQuestions(sessionId, numQuestions, difficulty) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'generate_worksheet_questions');
+        formData.append('num_questions', numQuestions.toString());
+        formData.append('difficulty', difficulty);
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            // Get the generated content from the response endpoint
+            const contentResponse = await fetch(AI_RESPONSE_URL);
+            if (!contentResponse.ok) {
+                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
+            }
+            return (await contentResponse.json())['last_response'];
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate worksheet questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Analyse PDF
+    async analysePDF(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'analyse_pdf');
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            return result.message || 'PDF analysis completed';
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to analyse PDF: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Analyse Image
+    async analyseImage(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        }
+        const formData = new FormData();
+        formData.append('command', 'analyse_img');
+        try {
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+            }
+            const result = await response.json();
+            return result.message || 'Image analysis completed';
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to analyse image: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
+    // Get session by ID
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    // Get sessions by user and workspace
+    getSessionsByUserAndWorkspace(userId, workspaceId) {
+        return Array.from(this.sessions.values()).filter(session => session.workspaceId === workspaceId);
+    }
+    // Delete session
+    deleteSession(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    // Check if AI service is available
+    async checkHealth() {
+        try {
+            console.log('🏥 Checking AI service health...');
+            const response = await fetch(AI_SERVICE_URL, {
+                method: 'POST',
+                body: new FormData(), // Empty form data
+            });
+            console.log(`🏥 AI Service health check status: ${response.status}`);
+            return response.ok;
+        }
+        catch (error) {
+            console.error('🏥 AI Service health check failed:', error);
+            return false;
+        }
+    }
+}
+// Global instance
+export const aiSessionService = new AISessionService();

package/dist/lib/auth.js

@@ -2,28 +2,32 @@
 import crypto from "node:crypto";
 // Custom HMAC cookie: auth_token = base64(userId).hex(hmacSHA256(base64(userId), secret))
 export function verifyCustomAuthCookie(cookieValue) {
-    if (!cookieValue)
+    if (!cookieValue) {
         return null;
-    const secret = process.env.CUSTOM_AUTH_SECRET;
-    if (!secret)
+    }
+    const secret = process.env.AUTH_SECRET;
+    if (!secret) {
         return null;
+    }
     const parts = cookieValue.split(".");
-    if (parts.length !== 2)
+    if (parts.length !== 2) {
         return null;
+    }
     const [base64UserId, signatureHex] = parts;
     let userId;
     try {
         const buf = Buffer.from(base64UserId, "base64url");
         userId = buf.toString("utf8");
     }
-    catch {
+    catch (error) {
         return null;
     }
     const hmac = crypto.createHmac("sha256", secret);
     hmac.update(base64UserId);
     const expected = hmac.digest("hex");
-    if (!timingSafeEqualHex(signatureHex, expected))
+    if (!timingSafeEqualHex(signatureHex, expected)) {
         return null;
+    }
     return { userId };
 }
 function timingSafeEqualHex(a, b) {

package/dist/lib/inference.d.ts

@@ -0,0 +1,2 @@
+declare function inference(prompt: string, tag: string): Promise<Response>;
+export default inference;

package/dist/lib/inference.js

@@ -0,0 +1,21 @@
+async function inference(prompt, tag) {
+    try {
+        const response = await fetch("https://proxy-ai.onrender.com/api/cohere/inference", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                prompt: prompt,
+                model: "command-r-plus",
+                max_tokens: 2000,
+            }),
+        });
+        return response;
+    }
+    catch (error) {
+        console.error('Inference error:', error);
+        throw error;
+    }
+}
+export default inference;

package/dist/lib/pusher.d.ts

@@ -0,0 +1,14 @@
+import Pusher from 'pusher';
+export declare const pusher: Pusher;
+export declare class PusherService {
+    static emitTaskComplete(workspaceId: string, event: string, data: any): Promise<void>;
+    static emitAnalysisComplete(workspaceId: string, analysisType: string, result: any): Promise<void>;
+    static emitStudyGuideComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitFlashcardComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitPodcastComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitOverallComplete(workspaceId: string, filename: string, artifacts: any): Promise<void>;
+    static emitError(workspaceId: string, error: string, analysisType?: string): Promise<void>;
+    static emitChannelEvent(channelId: string, event: string, data: any): Promise<void>;
+}
+export default PusherService;

package/dist/lib/pusher.js

@@ -0,0 +1,94 @@
+import Pusher from 'pusher';
+// Server-side Pusher instance
+export const pusher = new Pusher({
+    appId: process.env.PUSHER_APP_ID || '',
+    key: process.env.PUSHER_KEY || '',
+    secret: process.env.PUSHER_SECRET || '',
+    cluster: process.env.PUSHER_CLUSTER || 'us2',
+    useTLS: true,
+});
+// Pusher service for managing notifications
+export class PusherService {
+    // Emit task completion notification
+    static async emitTaskComplete(workspaceId, event, data) {
+        try {
+            const channel = `workspace_${workspaceId}`;
+            const eventName = `${workspaceId}_${event}`;
+            await pusher.trigger(channel, eventName, data);
+            console.log(`📡 Pusher notification sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            console.error('❌ Pusher notification error:', error);
+        }
+    }
+    // Emit AI analysis completion
+    static async emitAnalysisComplete(workspaceId, analysisType, result) {
+        await this.emitTaskComplete(workspaceId, `${analysisType}_ended`, {
+            type: analysisType,
+            result,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit study guide completion
+    static async emitStudyGuideComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'studyguide', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit flashcard completion
+    static async emitFlashcardComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'flashcard', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit worksheet completion
+    static async emitWorksheetComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'worksheet', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit podcast completion
+    static async emitPodcastComplete(workspaceId, artifact) {
+        await this.emitAnalysisComplete(workspaceId, 'podcast', {
+            artifactId: artifact.id,
+            title: artifact.title,
+            status: 'completed'
+        });
+    }
+    // Emit overall analysis completion
+    static async emitOverallComplete(workspaceId, filename, artifacts) {
+        await this.emitTaskComplete(workspaceId, 'analysis_ended', {
+            filename,
+            artifacts,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit error notification
+    static async emitError(workspaceId, error, analysisType) {
+        const event = analysisType ? `${analysisType}_error` : 'analysis_error';
+        await this.emitTaskComplete(workspaceId, event, {
+            error,
+            analysisType,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    // Emit channel-specific events (for chat messages)
+    static async emitChannelEvent(channelId, event, data) {
+        try {
+            const channel = channelId; // Use channelId directly as channel name
+            const eventName = `${channelId}_${event}`;
+            await pusher.trigger(channel, eventName, data);
+            console.log(`📡 Pusher notification sent: ${eventName} to ${channel}`);
+        }
+        catch (error) {
+            console.error('❌ Pusher notification error:', error);
+        }
+    }
+}
+export default PusherService;

package/dist/lib/storage.d.ts

@@ -1,3 +1,11 @@
-import { Storage } from "@google-cloud/storage";
-export declare const storage: Storage;
+export interface UploadResult {
+    url: string;
+    signedUrl?: string;
+    objectKey: string;
+}
+export declare function uploadToGCS(fileBuffer: Buffer, fileName: string, contentType: string, makePublic?: boolean): Promise<UploadResult>;
+export declare function generateSignedUrl(objectKey: string, expiresInHours?: number): Promise<string>;
+export declare function deleteFromGCS(objectKey: string): Promise<void>;
+export declare function makeFilePublic(objectKey: string): Promise<void>;
+export declare function makeFilePrivate(objectKey: string): Promise<void>;
 export declare const bucket: import("@google-cloud/storage").Bucket;

package/dist/lib/storage.js

@@ -1,10 +1,67 @@
 // src/server/lib/gcs.ts
-import { Storage } from "@google-cloud/storage";
-export const storage = new Storage({
-    projectId: process.env.GCP_PROJECT_ID,
-    credentials: {
+import { Storage } from '@google-cloud/storage';
+import { v4 as uuidv4 } from 'uuid';
+// Initialize Google Cloud Storage
+const storage = new Storage({
+    projectId: process.env.GCP_PROJECT_ID || process.env.GOOGLE_CLOUD_PROJECT_ID,
+    credentials: process.env.GCP_CLIENT_EMAIL && process.env.GCP_PRIVATE_KEY ? {
         client_email: process.env.GCP_CLIENT_EMAIL,
         private_key: process.env.GCP_PRIVATE_KEY?.replace(/\\n/g, "\n"),
-    },
+    } : undefined,
+    keyFilename: process.env.GOOGLE_CLOUD_KEY_FILE || process.env.GCP_KEY_FILE,
 });
-export const bucket = storage.bucket(process.env.GCP_BUCKET);
+const bucketName = process.env.GCP_BUCKET || process.env.GOOGLE_CLOUD_BUCKET_NAME || 'your-bucket-name';
+export async function uploadToGCS(fileBuffer, fileName, contentType, makePublic = false) {
+    const bucket = storage.bucket(bucketName);
+    const objectKey = `podcasts/${uuidv4()}_${fileName}`;
+    const file = bucket.file(objectKey);
+    // Upload the file
+    await file.save(fileBuffer, {
+        metadata: {
+            contentType,
+        },
+        public: makePublic,
+    });
+    const url = `gs://${bucketName}/${objectKey}`;
+    // Generate signed URL for private files
+    let signedUrl;
+    if (!makePublic) {
+        const [signedUrlResult] = await file.getSignedUrl({
+            version: 'v4',
+            action: 'read',
+            expires: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
+        });
+        signedUrl = signedUrlResult;
+    }
+    return {
+        url,
+        signedUrl,
+        objectKey,
+    };
+}
+export async function generateSignedUrl(objectKey, expiresInHours = 24) {
+    const bucket = storage.bucket(bucketName);
+    const file = bucket.file(objectKey);
+    const [signedUrl] = await file.getSignedUrl({
+        version: 'v4',
+        action: 'read',
+        expires: Date.now() + expiresInHours * 60 * 60 * 1000,
+    });
+    return signedUrl;
+}
+export async function deleteFromGCS(objectKey) {
+    const bucket = storage.bucket(bucketName);
+    const file = bucket.file(objectKey);
+    await file.delete();
+}
+export async function makeFilePublic(objectKey) {
+    const bucket = storage.bucket(bucketName);
+    const file = bucket.file(objectKey);
+    await file.makePublic();
+}
+export async function makeFilePrivate(objectKey) {
+    const bucket = storage.bucket(bucketName);
+    const file = bucket.file(objectKey);
+    await file.makePrivate();
+}
+export const bucket = storage.bucket(bucketName);