Fix Hugging Face Spaces deployment: Handle file permissions and production environment

🔧 Production File Permissions:
- Use /tmp directory for uploads and database in production (NODE_ENV=production)
- Add error handling for mkdir operations that fail due to permissions
- Graceful fallback when directory creation fails

🚀 Hugging Face Spaces Compatibility:
- Detect production environment and use writable /tmp paths
- Added ENABLE_UPLOADS environment variable to control file upload functionality
- Fallback routes for disabled uploads with helpful error messages

💾 Database & Storage Fixes:
- SQLite database path: /tmp/knowledgebridge.db in production
- Upload directory: /tmp/uploads in production vs ./uploads in development
- Error handling for permission denied scenarios

🎯 Graceful Degradation:
- App continues to work even when file operations fail
- Clear error messages explaining disabled functionality
- Traditional search and external sources still available

🔒 Environment Detection:
- Automatic detection of production vs development environment
- Optional ENABLE_UPLOADS=true to force enable uploads in production
- Conditional route registration based on environment capabilities

This fixes the EACCES permission denied error when creating /app/uploads directory
in containerized environments like Hugging Face Spaces.

client/src/components/knowledge-base/document-upload.tsx

@@ -148,11 +148,15 @@ export default function DocumentUpload() {
           body: formData,
         });
 
+        const result = await response.json();
+
         if (!response.ok) {
-          throw new Error(`Upload failed: ${response.statusText}`);
+          // Handle disabled uploads gracefully
+          if (response.status === 503) {
+            throw new Error(result.message || 'File uploads are disabled in this environment');
+          }
+          throw new Error(result.message || `Upload failed: ${response.statusText}`);
         }
-
-        const result = await response.json();
         
         if (result.success && result.documents?.length > 0) {
           const document = result.documents[0];

server/file-upload.ts

@@ -4,24 +4,40 @@ import fs from 'fs';
 import crypto from 'crypto';
 import { Request } from 'express';
 
-// Ensure uploads directory exists
-const uploadsDir = path.join(process.cwd(), 'uploads');
-if (!fs.existsSync(uploadsDir)) {
-  fs.mkdirSync(uploadsDir, { recursive: true });
+// Use /tmp for uploads in production environments (like Hugging Face Spaces)
+// This ensures we have write permissions
+const uploadsDir = process.env.NODE_ENV === 'production' 
+  ? path.join('/tmp', 'uploads')
+  : path.join(process.cwd(), 'uploads');
+
+// Safely create uploads directory with error handling
+try {
+  if (!fs.existsSync(uploadsDir)) {
+    fs.mkdirSync(uploadsDir, { recursive: true });
+  }
+} catch (error) {
+  console.warn(`Failed to create uploads directory at ${uploadsDir}:`, error);
+  console.log('File uploads will be disabled');
 }
 
 // Configure multer for file uploads
 const storage = multer.diskStorage({
   destination: (req, file, cb) => {
-    // Create subdirectories by date for organization
-    const dateDir = new Date().toISOString().split('T')[0];
-    const fullPath = path.join(uploadsDir, dateDir);
-    
-    if (!fs.existsSync(fullPath)) {
-      fs.mkdirSync(fullPath, { recursive: true });
+    try {
+      // Create subdirectories by date for organization
+      const dateDir = new Date().toISOString().split('T')[0];
+      const fullPath = path.join(uploadsDir, dateDir);
+      
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+      }
+      
+      cb(null, fullPath);
+    } catch (error) {
+      console.error('Failed to create upload directory:', error);
+      // Fallback to base uploads directory
+      cb(null, uploadsDir);
     }
-    
-    cb(null, fullPath);
   },
   filename: (req, file, cb) => {
     // Generate unique filename with timestamp and random string

server/routes.ts

@@ -7,6 +7,7 @@ import { smartIngestionService } from "./smart-ingestion";
 import { nebiusClient } from "./nebius-client";
 import { modalClient } from "./modal-client";
 import documentRoutes from "./document-routes";
+import uploadFallbackRoutes from "./upload-fallback";
 
 interface GitHubRepo {
   id: number;
@@ -1140,8 +1141,16 @@ Provide a brief, engaging explanation (2-3 sentences) that would be pleasant to
     }
   });
 
-  // Register document routes
-  app.use("/api/documents", documentRoutes);
+  // Register document routes - use fallback in production environments without persistent storage
+  const isDocumentUploadEnabled = process.env.NODE_ENV !== 'production' || process.env.ENABLE_UPLOADS === 'true';
+  
+  if (isDocumentUploadEnabled) {
+    console.log('✅ Document uploads enabled');
+    app.use("/api/documents", documentRoutes);
+  } else {
+    console.log('ℹ️  Document uploads disabled - using fallback routes');
+    app.use("/api/documents", uploadFallbackRoutes);
+  }
 
   const httpServer = createServer(app);
   return httpServer;

server/sqlite-storage.ts

@@ -19,14 +19,25 @@ import { IStorage } from './storage';
 export class SQLiteStorage implements IStorage {
   private db: Database.Database;
 
-  constructor(dbPath = './data/knowledgebridge.db') {
-    // Ensure data directory exists
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+  constructor(dbPath?: string) {
+    // Use /tmp for database in production environments (like Hugging Face Spaces)
+    const defaultPath = process.env.NODE_ENV === 'production'
+      ? '/tmp/knowledgebridge.db'
+      : './data/knowledgebridge.db';
+    
+    const finalPath = dbPath || defaultPath;
+    
+    // Ensure data directory exists with error handling
+    const dir = path.dirname(finalPath);
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    } catch (error) {
+      console.warn(`Failed to create database directory at ${dir}:`, error);
     }
 
-    this.db = new Database(dbPath);
+    this.db = new Database(finalPath);
     this.initializeTables();
   }
 

server/upload-fallback.ts

@@ -0,0 +1,76 @@
+import { Router } from 'express';
+
+const router = Router();
+
+/**
+ * Fallback routes for file upload functionality when uploads are disabled
+ * (e.g., in production environments without persistent storage)
+ */
+
+router.post('/upload', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'File uploads disabled',
+    message: 'File uploads are currently disabled in this environment. This is typically the case in demo environments or spaces without persistent storage.',
+    suggestion: 'You can still use the search functionality with external sources, or deploy the application with persistent storage to enable document uploads.'
+  });
+});
+
+router.post('/process/:id', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'Document processing disabled',
+    message: 'Document processing is disabled when file uploads are not available.'
+  });
+});
+
+router.post('/process/batch', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'Batch processing disabled',
+    message: 'Batch processing is disabled when file uploads are not available.'
+  });
+});
+
+router.post('/index/build', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'Index building disabled',
+    message: 'Vector index building is disabled when document uploads are not available.'
+  });
+});
+
+router.post('/search/vector', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'Vector search disabled',
+    message: 'Vector search is disabled when no documents have been uploaded and processed.'
+  });
+});
+
+router.get('/list', async (req, res) => {
+  res.json({
+    success: true,
+    documents: [],
+    totalCount: 0,
+    message: 'No documents available - file uploads are disabled in this environment'
+  });
+});
+
+router.get('/status/:id', async (req, res) => {
+  res.status(404).json({
+    success: false,
+    error: 'Document not found',
+    message: 'Document processing is disabled in this environment'
+  });
+});
+
+router.delete('/:id', async (req, res) => {
+  res.status(503).json({
+    success: false,
+    error: 'Document deletion disabled',
+    message: 'Document operations are disabled when file uploads are not available.'
+  });
+});
+
+export default router;