VIBN Frontend for Coolify deployment

app/api/projects/[projectId]/knowledge/upload-document/route.ts

@@ -0,0 +1,146 @@
+import { NextResponse } from 'next/server';
+import { getAdminAuth, getAdminDb } from '@/lib/firebase/admin';
+import { createKnowledgeItem } from '@/lib/server/knowledge';
+import type { KnowledgeSourceMeta } from '@/lib/types/knowledge';
+// import { chunkDocument } from '@/lib/utils/document-chunker'; // Not needed - Extractor AI handles chunking
+import { getStorage } from 'firebase-admin/storage';
+
+export const maxDuration = 60;
+
+export async function POST(
+  request: Request,
+  context: { params: Promise<{ projectId: string }> | { projectId: string } }
+) {
+  try {
+    // Verify auth
+    const authHeader = request.headers.get('Authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const idToken = authHeader.split('Bearer ')[1];
+    const adminAuth = getAdminAuth();
+    
+    let userId: string;
+    try {
+      const decodedToken = await adminAuth.verifyIdToken(idToken);
+      userId = decodedToken.uid;
+    } catch (error) {
+      return NextResponse.json({ error: 'Invalid token' }, { status: 401 });
+    }
+
+    // Handle async params in Next.js 16
+    const params = 'then' in context.params ? await context.params : context.params;
+    const projectId = params.projectId;
+
+    if (!projectId) {
+      return NextResponse.json({ error: 'Missing projectId' }, { status: 400 });
+    }
+
+    // Parse multipart form data
+    const formData = await request.formData();
+    const file = formData.get('file') as File;
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    const adminDb = getAdminDb();
+    const projectSnap = await adminDb.collection('projects').doc(projectId).get();
+    if (!projectSnap.exists) {
+      return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+    }
+
+    console.log(`[upload-document] Uploading ${file.name}, size=${file.size}`);
+
+    // Read file content
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    const content = buffer.toString('utf-8');
+
+    // Upload original file to Firebase Storage
+    const storage = getStorage();
+    const bucket = storage.bucket();
+    const storagePath = `projects/${projectId}/documents/${Date.now()}_${file.name}`;
+    const fileRef = bucket.file(storagePath);
+
+    await fileRef.save(buffer, {
+      metadata: {
+        contentType: file.type,
+        metadata: {
+          uploadedBy: userId,
+          projectId,
+          originalFilename: file.name,
+          uploadedAt: new Date().toISOString(),
+        },
+      },
+    });
+
+    // Make file publicly accessible (or use signed URLs if you want private)
+    await fileRef.makePublic();
+    const publicUrl = `https://storage.googleapis.com/${bucket.name}/${storagePath}`;
+
+    console.log(`[upload-document] File saved to Storage: ${publicUrl}`);
+
+    // Store whole document as single knowledge_item (no chunking)
+    // Extractor AI will collaboratively chunk important sections later
+    const sourceMeta: KnowledgeSourceMeta = {
+      origin: 'other',
+      url: publicUrl,
+      filename: file.name,
+      createdAtOriginal: new Date().toISOString(),
+      importance: 'primary',
+      tags: ['document', 'uploaded', 'pending_extraction'],
+    };
+
+    const knowledgeItem = await createKnowledgeItem({
+      projectId,
+      sourceType: 'imported_document',
+      title: file.name,
+      content: content,
+      sourceMeta,
+    });
+
+    console.log(`[upload-document] Stored whole document as knowledge_item: ${knowledgeItem.id}`);
+
+    const knowledgeItemIds = [knowledgeItem.id];
+
+    // Create a summary record in contextSources for UI display
+    const contextSourcesRef = adminDb.collection('projects').doc(projectId).collection('contextSources');
+    await contextSourcesRef.add({
+      type: 'document',
+      name: file.name,
+      summary: `Document (${content.length} characters) - pending extraction`,
+      url: publicUrl,
+      connectedAt: new Date(),
+      metadata: {
+        totalChars: content.length,
+        fileSize: file.size,
+        mimeType: file.type,
+        storagePath,
+        knowledgeItemId: knowledgeItem.id,
+        uploadedBy: userId,
+        status: 'pending_extraction',
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      filename: file.name,
+      url: publicUrl,
+      knowledgeItemId: knowledgeItem.id,
+      status: 'stored',
+      message: 'Document stored. Extractor AI will review and chunk important sections.',
+    });
+  } catch (error) {
+    console.error('[upload-document] Failed to upload document', error);
+    return NextResponse.json(
+      {
+        error: 'Failed to upload document',
+        details: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 },
+    );
+  }
+}
+