@goscribe/server 1.0.8 → 1.0.10

package/src/lib/ai-session.ts

@@ -0,0 +1,412 @@
+import { TRPCError } from '@trpc/server';
+
+// External AI service configuration
+const AI_SERVICE_URL = 'https://7gzvf7uib04yp9-61016.proxy.runpod.net/upload';
+const AI_RESPONSE_URL = 'https://7gzvf7uib04yp9-61016.proxy.runpod.net/last_response';
+
+export interface AISession {
+  id: string;
+  workspaceId: string;
+  status: 'initialized' | 'processing' | 'ready' | 'error';
+  files: string[];
+  instructionText?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export class AISessionService {
+  private sessions = new Map<string, AISession>();
+
+  // Initialize a new AI session
+  async initSession(workspaceId: string, user: string): Promise<AISession> {
+    const sessionId = `${workspaceId}`;
+    
+    const formData = new FormData();
+    formData.append('command', 'init_session');
+    formData.append('session', sessionId);
+    formData.append('user', user);
+
+    // Retry logic for AI service
+    const maxRetries = 3;
+    let lastError: Error | null = 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: AISession = {
+          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: string, file: File, fileType: 'image' | 'pdf'): Promise<void> {
+    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: string, instructionText: string): Promise<void> {
+    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: string): Promise<void> {
+    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: string): Promise<string> {
+    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: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string> {
+    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: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string> {
+    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: string): Promise<string> {
+    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: string): Promise<string> {
+    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: string): AISession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  // Get sessions by user and workspace
+  getSessionsByUserAndWorkspace(userId: string, workspaceId: string): AISession[] {
+    return Array.from(this.sessions.values()).filter(
+      session => session.workspaceId === workspaceId
+    );
+  }
+
+  // Delete session
+  deleteSession(sessionId: string): boolean {
+    return this.sessions.delete(sessionId);
+  }
+
+  // Check if AI service is available
+  async checkHealth(): Promise<boolean> {
+    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/src/lib/inference.ts

@@ -0,0 +1,21 @@
+async function inference(prompt: string, tag: string) {
+    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/src/lib/pusher.ts

@@ -0,0 +1,104 @@
+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: string, event: string, data: any) {
+    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: string, analysisType: string, result: any) {
+    await this.emitTaskComplete(workspaceId, `${analysisType}_ended`, {
+      type: analysisType,
+      result,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  // Emit study guide completion
+  static async emitStudyGuideComplete(workspaceId: string, artifact: any) {
+    await this.emitAnalysisComplete(workspaceId, 'studyguide', {
+      artifactId: artifact.id,
+      title: artifact.title,
+      status: 'completed'
+    });
+  }
+
+  // Emit flashcard completion
+  static async emitFlashcardComplete(workspaceId: string, artifact: any) {
+    await this.emitAnalysisComplete(workspaceId, 'flashcard', {
+      artifactId: artifact.id,
+      title: artifact.title,
+      status: 'completed'
+    });
+  }
+
+  // Emit worksheet completion
+  static async emitWorksheetComplete(workspaceId: string, artifact: any) {
+    await this.emitAnalysisComplete(workspaceId, 'worksheet', {
+      artifactId: artifact.id,
+      title: artifact.title,
+      status: 'completed'
+    });
+  }
+
+  // Emit podcast completion
+  static async emitPodcastComplete(workspaceId: string, artifact: any) {
+    await this.emitAnalysisComplete(workspaceId, 'podcast', {
+      artifactId: artifact.id,
+      title: artifact.title,
+      status: 'completed'
+    });
+  }
+
+  // Emit overall analysis completion
+  static async emitOverallComplete(workspaceId: string, filename: string, artifacts: any) {
+    await this.emitTaskComplete(workspaceId, 'analysis_ended', {
+      filename,
+      artifacts,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  // Emit error notification
+  static async emitError(workspaceId: string, error: string, analysisType?: string) {
+    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: string, event: string, data: any) {
+    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/src/lib/storage.ts

@@ -1,13 +1,96 @@
 // src/server/lib/gcs.ts
-import { Storage } from "@google-cloud/storage";
+import { Storage } from '@google-cloud/storage';
+import { v4 as uuidv4 } from 'uuid';
 
-export const storage = new Storage({
-  projectId: process.env.GCP_PROJECT_ID,
-  credentials: {
+// 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 interface UploadResult {
+  url: string;
+  signedUrl?: string;
+  objectKey: string;
+}
+
+export async function uploadToGCS(
+  fileBuffer: Buffer,
+  fileName: string,
+  contentType: string,
+  makePublic: boolean = false
+): Promise<UploadResult> {
+  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: string | undefined;
+  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: string, expiresInHours: number = 24): Promise<string> {
+  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: string): Promise<void> {
+  const bucket = storage.bucket(bucketName);
+  const file = bucket.file(objectKey);
+  
+  await file.delete();
+}
+
+export async function makeFilePublic(objectKey: string): Promise<void> {
+  const bucket = storage.bucket(bucketName);
+  const file = bucket.file(objectKey);
+  
+  await file.makePublic();
+}
+
+export async function makeFilePrivate(objectKey: string): Promise<void> {
+  const bucket = storage.bucket(bucketName);
+  const file = bucket.file(objectKey);
+  
+  await file.makePrivate();
+}
+
+
+export const bucket = storage.bucket(bucketName);

package/src/routers/_app.ts

@@ -4,12 +4,18 @@ import { auth } from './auth.js';
 import { workspace } from './workspace.js';
 import { flashcards } from './flashcards.js';
 import { worksheets } from './worksheets.js';
+import { studyguide } from './studyguide.js';
+import { podcast } from './podcast.js';
+import { chat } from './chat.js';
 
 export const appRouter = router({
   auth,
   workspace,
   flashcards,
   worksheets,
+  studyguide,
+  podcast,
+  chat,
 });
 
 // Export type for client inference

package/src/routers/auth.ts

@@ -67,22 +67,26 @@ export const auth = router({
       // Create custom auth token
       const authToken = createCustomAuthToken(user.id);
 
-      // Set the cookie immediately after successful login
+      const isProduction = (process.env.NODE_ENV === "production" || process.env.RENDER) as boolean;
+
       const cookieValue = serialize("auth_token", authToken, {
         httpOnly: true,
-        secure: process.env.NODE_ENV === "production",
-        sameSite: "lax",
+        secure: isProduction, // true for production/HTTPS, false for localhost
+        sameSite: isProduction ? "none" : "lax", // none for cross-origin, lax for same-origin
         path: "/",
+        domain: isProduction ? "server-w8mz.onrender.com" : undefined,
         maxAge: 60 * 60 * 24 * 30, // 30 days
       });
       
       ctx.res.setHeader("Set-Cookie", cookieValue);
 
+
       return { 
         id: user.id, 
         email: user.email, 
         name: user.name, 
-        image: user.image 
+        image: user.image,
+        token: authToken
       };
     }),
   getSession: publicProcedure.query(async ({ ctx }) => {