2

server/src/services/realtime.ts

@@ -701,7 +701,7 @@ export function initRealtime(httpServer: HttpServer): Server {
     });
 
     // ═══════════════════════════════════════════════
-    //  PROJECT SYNC  (upload to HF storage)
+    //  PROJECT SYNC  (sync to /data storage)
     // ═══════════════════════════════════════════════
     socket.on('project_sync', async (data: { projectId: string }, callback?: (response: any) => void) => {
       try {
@@ -715,15 +715,14 @@ export function initRealtime(httpServer: HttpServer): Server {
           return;
         }
 
-        const { uploadToHFStorage } = await import('./storage');
-        const result = await uploadToHFStorage(
+        const { uploadToStorage } = await import('./storage');
+        const result = await uploadToStorage(
           `projects/${user.userId}/${data.projectId}.enc`,
-          Buffer.from(project.encrypted_data),
-          `Project: ${project.name}`
+          Buffer.from(project.encrypted_data)
         );
 
         if (result.success) {
-          if (callback) callback({ message: 'Project synced to cloud storage' });
+          if (callback) callback({ message: 'Project synced to storage' });
         } else {
           if (callback) callback({ error: 'Sync failed', details: result.message });
         }

server/src/services/storage.ts

@@ -1,91 +1,49 @@
-import { config } from '../config';
+import fs from 'fs';
+import path from 'path';
 
-interface HFStorageResult {
-  success: boolean;
-  message?: string;
-}
+const STORAGE_ROOT = process.env.STORAGE_PATH || '/data';
 
-export async function uploadToHFStorage(
-  path: string,
-  data: Buffer,
-  description?: string
-): Promise<HFStorageResult> {
-  if (!config.hf.token || !config.hf.repoId) {
-    console.warn('HF storage not configured. Skipping upload.');
-    return { success: false, message: 'HF storage not configured' };
+function ensureDir(dir: string) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
+}
 
+export async function uploadToStorage(
+  filePath: string,
+  data: Buffer,
+): Promise<{ success: boolean; message?: string }> {
   try {
-    const url = `https://huggingface.co/api/repos/${config.hf.repoId}/storage/${path}`;
-    const response = await fetch(url, {
-      method: 'PUT',
-      headers: {
-        Authorization: `Bearer ${config.hf.token}`,
-        'Content-Type': 'application/octet-stream',
-        ...(description ? { 'X-Description': description } : {}),
-      },
-      body: data,
-    });
-
-    if (!response.ok) {
-      throw new Error(`HF storage upload failed: ${response.statusText}`);
-    }
-
+    const fullPath = path.join(STORAGE_ROOT, filePath);
+    ensureDir(path.dirname(fullPath));
+    fs.writeFileSync(fullPath, data);
     return { success: true };
   } catch (error: any) {
-    console.error('HF storage upload error:', error.message);
+    console.error('Storage write error:', error.message);
     return { success: false, message: error.message };
   }
 }
 
-export async function downloadFromHFStorage(path: string): Promise<Buffer | null> {
-  if (!config.hf.token || !config.hf.repoId) {
-    console.warn('HF storage not configured. Skipping download.');
-    return null;
-  }
-
+export async function downloadFromStorage(filePath: string): Promise<Buffer | null> {
   try {
-    const url = `https://huggingface.co/api/repos/${config.hf.repoId}/storage/${path}`;
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bearer ${config.hf.token}`,
-      },
-    });
-
-    if (!response.ok) {
-      if (response.status === 404) return null;
-      throw new Error(`HF storage download failed: ${response.statusText}`);
-    }
-
-    return Buffer.from(await response.arrayBuffer());
+    const fullPath = path.join(STORAGE_ROOT, filePath);
+    if (!fs.existsSync(fullPath)) return null;
+    return fs.readFileSync(fullPath);
   } catch (error: any) {
-    console.error('HF storage download error:', error.message);
+    console.error('Storage read error:', error.message);
     return null;
   }
 }
 
-export async function deleteFromHFStorage(path: string): Promise<HFStorageResult> {
-  if (!config.hf.token || !config.hf.repoId) {
-    return { success: false, message: 'HF storage not configured' };
-  }
-
+export async function deleteFromStorage(filePath: string): Promise<{ success: boolean; message?: string }> {
   try {
-    const url = `https://huggingface.co/api/repos/${config.hf.repoId}/storage/${path}`;
-    const response = await fetch(url, {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${config.hf.token}`,
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error(`HF storage delete failed: ${response.statusText}`);
+    const fullPath = path.join(STORAGE_ROOT, filePath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
     }
-
     return { success: true };
   } catch (error: any) {
-    console.error('HF storage delete error:', error.message);
+    console.error('Storage delete error:', error.message);
     return { success: false, message: error.message };
   }
 }