Update server.js

server.js

@@ -1,12 +1,12 @@
 // ============================================================
-// PIXELDRIVE v2.1 - Fix Range Decrypt, Robust Cache, Icons
+// PIXELDRIVE v2.2 - Sharp Streaming Pipeline (Fast & Stable)
 // ============================================================
 
 import express from 'express';
 import session from 'express-session';
 import multer from 'multer';
 import Database from 'better-sqlite3';
-import { PNG } from 'pngjs';
+import sharp from 'sharp';           // <--- REMPLACE pngjs
 import Bottleneck from 'bottleneck';
 import { randomBytes, createHash, scrypt, timingSafeEqual, createCipheriv, createDecipheriv } from 'crypto';
 import { promisify } from 'util';
@@ -14,8 +14,10 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import { unlink } from 'fs/promises';
+import { pipeline, Transform } from 'stream';
+import { promisify as pify } from 'util';
 
-// --- CRYPTO & CONFIG ---
+const pipelineAsync = pify(pipeline);
 const scryptAsync = promisify(scrypt);
 const getFileKey = (fid, secret) => createHash('sha256').update(`${secret}:file:${fid}`).digest();
 
@@ -24,28 +26,23 @@ const DATA_DIR = process.env.DATA_DIR || '/data';
 const DB_PATH = `${DATA_DIR}/pixeldrive.db`;
 const IMGBB_API_KEY = process.env.IMGBB_API_KEY;
 const PORT = parseInt(process.env.PORT) || 7860;
-const CHUNK_TARGET_SIZE = 31 * 1024 * 1024;
-const PNG_BPP = 4;
-const SESSION_SECRET = process.env.SESSION_SECRET || randomBytes(32).toString('hex');
+const CHUNK_TARGET_SIZE = 31 * 1024 * 1024; // 31 Mo
+const PNG_BPP = 4; // RGBA
+const SESSION_SECRET = process.env.SESSION_SECRET;
+if (!SESSION_SECRET || SESSION_SECRET.length < 32) { console.error("❌ SESSION_SECRET manquant ou <32 chars dans .env"); process.exit(1); }
 const ADMIN_USER = process.env.ADMIN_USER || 'admin';
 const ADMIN_PASS = process.env.ADMIN_PASS || 'changeme';
+if (!IMGBB_API_KEY) { console.error("❌ IMGBB_API_KEY manquante !"); process.exit(1); }
 
 // CACHE CONFIG
-const CACHE_MAX_BYTES = 12 * 1024 * 1024 * 1024; // 12 Go
-const CACHE_TTL_MS = 15 * 60 * 1000; // 15 min
-
-if (!IMGBB_API_KEY) { console.error("❌ IMGBB_API_KEY manquante !"); process.exit(1); }
+const CACHE_MAX_BYTES = 12 * 1024 * 1024 * 1024;
+const CACHE_TTL_MS = 15 * 60 * 1000;
 
 // ============================================================
-// LRU CACHE AVEC TAILLE RÉELLE (Buffer.length)
+// LRU CACHE
 // ============================================================
 class ChunkCache {
-  constructor(maxBytes, ttlMs) {
-    this.maxBytes = maxBytes; this.ttlMs = ttlMs;
-    this.map = new Map(); // key -> {buf, size, at}
-    this.currentBytes = 0;
-    setInterval(() => this._cleanup(), 60000).unref();
-  }
+  constructor(maxBytes, ttlMs) { this.maxBytes = maxBytes; this.ttlMs = ttlMs; this.map = new Map(); this.currentBytes = 0; setInterval(() => this._cleanup(), 60000).unref(); }
   _key(fid, idx) { return `${fid}:${idx}`; }
   _cleanup() { const now = Date.now(); for(const [k, v] of this.map) if(now - v.at > this.ttlMs) this._del(k); }
   _del(key) { const v = this.map.get(key); if(v) { this.currentBytes -= v.size; this.map.delete(key); } }
@@ -84,10 +81,19 @@ const adminExists = db.prepare('SELECT 1 FROM users WHERE username = ?').get(ADM
 if (!adminExists) { const salt = randomBytes(16); const hash = await scryptAsync(ADMIN_PASS, salt, 32); db.prepare('INSERT INTO users (username, password_hash, salt, is_admin) VALUES (?, ?, ?, 1)').run(ADMIN_USER, hash, salt); console.log(`✅ Admin: ${ADMIN_USER} / ${ADMIN_PASS}`); }
 
 // ============================================================
-// PNG ENGINE
+// CRYPTO STREAMS
 // ============================================================
-function dataToPngBuffer(dataBuffer) { const pc = Math.ceil(dataBuffer.length / PNG_BPP); const w = Math.ceil(Math.sqrt(pc)); const h = Math.ceil(pc / w); const png = new PNG({ width: w, height: h, colorType: 6, filterType: 4 }); png.data.set(dataBuffer); return new Promise((res, rej) => { const c=[]; png.on('data',d=>c.push(d)).on('end',()=>res(Buffer.concat(c))).on('error',rej); png.pack(); }); }
-function pngBufferToData(pngBuffer, expectedLength) { return new Promise((res, rej) => { const png=new PNG(); png.on('parsed',()=>res(png.data.subarray(0,expectedLength))).on('error',rej); png.parse(pngBuffer); }); }
+class EncryptTransform extends Transform {
+  constructor(key, iv) { super(); this.cipher = createCipheriv('aes-256-gcm', key, iv); this.iv = iv; this.tag = null; this.started = false; }
+  _transform(chunk, enc, cb) { try { if(!this.started) { this.started = true; this.push(this.iv); } this.push(this.cipher.update(chunk)); cb(); } catch(e) { cb(e); } }
+  _flush(cb) { try { this.push(this.cipher.final()); this.tag = this.cipher.getAuthTag(); this.push(this.tag); cb(); } catch(e) { cb(e); } }
+}
+
+class DecryptTransform extends Transform {
+  constructor(key, iv, tag) { super(); this.decipher = createDecipheriv('aes-256-gcm', key, iv); this.decipher.setAuthTag(tag); }
+  _transform(chunk, enc, cb) { try { this.push(this.decipher.update(chunk)); cb(); } catch(e) { cb(e); } }
+  _flush(cb) { try { this.push(this.decipher.final()); cb(); } catch(e) { cb(e); } }
+}
 
 // ============================================================
 // IMGBB QUEUE
@@ -97,77 +103,60 @@ async function imgbbUpload(buf) { return imgbbLimiter.schedule(async () => { con
 async function imgbbDelete(u) { if(!u) return; return imgbbLimiter.schedule(async()=>{try{await fetch(u,{method:'GET'})}catch(e){}}); }
 
 // ============================================================
-// UPLOAD STATUS TRACKER
+// UPLOAD STATUS
 // ============================================================
 const uploadStatus = new Map();
 function setStatus(fid, data) { uploadStatus.set(fid, { ...uploadStatus.get(fid), ...data, updated: Date.now() }); }
 function getStatus(fid) { return uploadStatus.get(fid) || { stage: 'waiting' }; }
-function clearStatus(fid) { setTimeout(()=>uploadStatus.delete(fid), 60000); } // Keep for 1min after done
+function clearStatus(fid) { setTimeout(()=>uploadStatus.delete(fid), 60000); }
 
 // ============================================================
-// HELPERS: RANGE & STREAMING (CORRIGÉ)
+// HELPERS RANGE / DECRYPT
 // ============================================================
 function parseRange(header, total) { if(!header) return null; const parts = header.replace('bytes=', '').split('-'); const start = parseInt(parts[0], 10); const end = parts[1] ? parseInt(parts[1], 10) : total - 1; if(isNaN(start)||isNaN(end)||start>end||end>=total) return null; return { start, end, length: end - start + 1 }; }
 
-// Core: Get Decrypted Chunk Buffer (Cache or Fetch+Decrypt+Verify)
 async function getDecryptedChunk(fileId, chunkIdx, ch, fileKey) {
-  // 1. Cache
   const cached = chunkCache.get(fileId, chunkIdx);
   if(cached) return cached;
-
-  // 2. Fetch IMGBB
   const r = await fetch(ch.imgbb_url);
   if(!r.ok) throw new Error(`IMGBB DL Failed: ${r.status}`);
   const pngBuf = Buffer.from(await r.arrayBuffer());
-
-  // 3. Decode PNG
-  const payload = await pngBufferToData(pngBuf, ch.byte_size);
-
-  // 4. VERIFY HASH (CRITICAL FOR RANGE REQUESTS)
+  
+  // Sharp pour décoder PNG -> Raw RGB (Buffer)
+  const { data, info } = await sharp(pngBuf).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  // data.length = width * height * 4. Mais payload réel = ch.byte_size.
+  const payload = data.subarray(0, ch.byte_size);
+  
   const sha = createHash('sha256').update(payload).digest('hex');
-  if(sha !== ch.sha256) throw new Error(`Hash Mismatch Chunk ${chunkIdx} (Corrupted IMGBB or DB)`);
-
-  // 5. Decrypt
+  if(sha !== ch.sha256) throw new Error(`Hash Mismatch Chunk ${chunkIdx}`);
+  
   const iv = payload.subarray(0, 12);
   const tag = payload.subarray(12, 28);
   const enc = payload.subarray(28);
   const decipher = createDecipheriv('aes-256-gcm', fileKey, iv);
   decipher.setAuthTag(tag);
   const decrypted = Buffer.concat([decipher.update(enc), decipher.final()]);
-
-  // 6. Cache & Return
+  
   chunkCache.set(fileId, chunkIdx, decrypted);
   return decrypted;
 }
 
-// Stream Full (Download)
 async function streamFull(res, file, chunks, fileKey) {
-  res.setHeader('Content-Length', file.size);
-  res.setHeader('Accept-Ranges', 'bytes');
+  res.setHeader('Content-Length', file.size); res.setHeader('Accept-Ranges', 'bytes');
   for(const ch of chunks) { res.write(await getDecryptedChunk(file.id, ch.idx, ch, fileKey)); }
   res.end();
 }
 
-// Stream Range (Video/Audio Seek) - LOGIQUE CORRIGÉE
 async function streamRange(res, file, chunks, fileKey, range) {
   const { start, end, length } = range;
-  res.status(206);
-  res.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`);
-  res.setHeader('Accept-Ranges', 'bytes');
-  res.setHeader('Content-Length', length);
-  res.setHeader('Content-Type', file.mime);
-
+  res.status(206); res.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`); res.setHeader('Accept-Ranges', 'bytes'); res.setHeader('Content-Length', length); res.setHeader('Content-Type', file.mime);
   let currentByte = 0;
   for(const ch of chunks) {
     const decryptedBuf = await getDecryptedChunk(file.id, ch.idx, ch, fileKey);
-    const chunkSize = decryptedBuf.length; // VRAIE TAILLE DÉCHIFFRÉE
-    const chunkStart = currentByte;
-    const chunkEnd = currentByte + chunkSize - 1;
-
-    if(chunkEnd < start) { currentByte += chunkSize; continue; } // Avant range
-    if(chunkStart > end) break; // Après range
-
-    // Overlap
+    const chunkSize = decryptedBuf.length;
+    const chunkStart = currentByte; const chunkEnd = currentByte + chunkSize - 1;
+    if(chunkEnd < start) { currentByte += chunkSize; continue; }
+    if(chunkStart > end) break;
     const neededStart = Math.max(0, start - chunkStart);
     const neededEnd = Math.min(chunkSize - 1, end - chunkStart);
     res.write(decryptedBuf.subarray(neededStart, neededEnd + 1));
@@ -186,54 +175,111 @@ const upload = multer({ dest: `${DATA_DIR}/tmp_uploads`, limits: { fileSize: 4 *
 const requireAuth = (req,res,next) => req.session.userId ? next() : res.status(401).json({error:'Non connecté'});
 const requireAdmin = (req,res,next) => req.session.isAdmin ? next() : res.status(403).json({error:'Admin requis'});
 
-// ============================================================
-// API AUTH
-// ============================================================
+// AUTH
 app.post('/api/auth/register', async (req,res)=>{ const {username,password}=req.body; if(!username||!password) return res.status(400).json({error:'Champs manquants'}); try{const salt=randomBytes(16);const hash=await scryptAsync(password,salt,32);db.prepare('INSERT INTO users(username,password_hash,salt)VALUES(?,?,?)').run(username,hash,salt);res.json({ok:true});}catch(e){res.status(409).json({error:'Existe'});} });
 app.post('/api/auth/login', async (req,res)=>{ const {username,password}=req.body; const u=db.prepare('SELECT*FROM users WHERE username=?').get(username); if(!u) return res.status(401).json({error:'Invalide'}); const h=await scryptAsync(password,u.salt,32); if(!timingSafeEqual(h,u.password_hash)) return res.status(401).json({error:'Invalide'}); req.session.userId=u.id;req.session.isAdmin=!!u.is_admin;req.session.username=u.username; res.json({ok:true,user:{username:u.username,isAdmin:!!u.is_admin}}); });
 app.post('/api/auth/logout', (req,res)=>req.session.destroy(()=>res.json({ok:true})));
 app.get('/api/auth/me', (req,res)=>req.session.userId?res.json({user:{username:req.session.username,isAdmin:req.session.isAdmin}}):res.status(401).json({error:'Non connecté'}));
 
-// ============================================================
-// API DRIVE
-// ============================================================
+// FS LIST / MKDIR
 app.get('/api/fs/list', requireAuth, (req,res)=>{ const pid=req.query.parent_id||null; const items=db.prepare('SELECT id,name,mime,size,chunk_count,created_at FROM files WHERE owner_id=? AND (parent_id IS ? OR parent_id=?) ORDER BY (mime=?) DESC,name').all(req.session.userId,pid,pid,'application/vnd.pixeldrive.folder'); res.json({items}); });
 app.post('/api/fs/mkdir', requireAuth, (req,res)=>{ const {name,parent_id}=req.body; if(!name||name.includes('/')) return res.status(400).json({error:'Nom invalide'}); const id=uuidv4(); db.prepare('INSERT INTO files(id,owner_id,parent_id,name,mime)VALUES(?,?,?,?,?)').run(id,req.session.userId,parent_id||null,name,'application/vnd.pixeldrive.folder'); res.json({ok:true,id}); });
 
-// UPLOAD
+// ============================================================
+// UPLOAD : PIPELINE STREAMING (SHARP + CRYPTO)
+// ============================================================
 app.post('/api/fs/upload', requireAuth, upload.single('file'), async (req,res)=>{
   if(!req.file) return res.status(400).json({error:'Fichier manquant'});
   const pid=req.body.parent_id||null; const name=req.file.originalname; const mime=req.file.mimetype||'application/octet-stream';
   const tmpPath=req.file.path; const fid=uuidv4(); const fKey=getFileKey(fid, SESSION_SECRET); const iv=randomBytes(12);
-  setStatus(fid, { owner: req.session.userId, stage: 'receiving', progress: 0, total: req.file.size, current: 0, fileName: name, startTime: Date.now(), speed: 0, eta: 0, chunksTotal: 0, chunksDone: 0 });
+  
+  setStatus(fid, { owner: req.session.userId, stage: 'starting', progress: 0, total: req.file.size, current: 0, fileName: name, startTime: Date.now(), speed: 0, eta: 0, chunksTotal: 0, chunksDone: 0 });
+
   try{
     db.prepare('INSERT INTO files(id,owner_id,parent_id,name,mime,size,chunk_count)VALUES(?,?,?,?,?,0,0)').run(fid,req.session.userId,pid,name,mime);
-    const fs=await import('fs'); const rs=fs.createReadStream(tmpPath,{highWaterMark:1024*1024}); let buf=Buffer.alloc(0); let tSize=0; let cIdx=0; const startTime=Date.now();
-    setStatus(fid, { stage: 'chunking', chunksTotal: Math.ceil(req.file.size / CHUNK_TARGET_SIZE) });
-    for await(const ch of rs){ buf=Buffer.concat([buf,ch]); tSize+=ch.length; const elapsed=(Date.now()-startTime)/1000; const sp=elapsed>0?tSize/elapsed/1024/1024:0; const et=sp>0?(req.file.size-tSize)/sp/1024/1024:0; setStatus(fid,{progress:tSize,current:tSize,speed:sp,eta:et,stage:'chunking'}); while(buf.length>=CHUNK_TARGET_SIZE){await processChunk(buf.subarray(0,CHUNK_TARGET_SIZE),cIdx++);buf=buf.subarray(CHUNK_TARGET_SIZE);} }
-    if(buf.length>0) await processChunk(buf,cIdx);
+    
+    const fs = await import('fs');
+    const readStream = fs.createReadStream(tmpPath, { highWaterMark: 1024 * 1024 }); // 1MB read buffer
+    
+    let totalBytes = 0;
+    let chunkIdx = 0;
+    let currentChunkBuffer = Buffer.alloc(0);
+    const startTime = Date.now();
+    
+    setStatus(fid, { stage: 'uploading', chunksTotal: Math.ceil(req.file.size / CHUNK_TARGET_SIZE) });
+
+    // Boucle de lecture fichier source
+    for await (const chunk of readStream) {
+      currentChunkBuffer = Buffer.concat([currentChunkBuffer, chunk]);
+      totalBytes += chunk.length;
+      
+      const elapsed = (Date.now() - startTime) / 1000;
+      const speed = elapsed > 0 ? totalBytes / elapsed / 1024 / 1024 : 0;
+      const eta = speed > 0 ? (req.file.size - totalBytes) / speed / 1024 / 1024 : 0;
+      setStatus(fid, { progress: totalBytes, current: totalBytes, speed, eta });
+
+      // Traiter les chunks complets
+      while (currentChunkBuffer.length >= CHUNK_TARGET_SIZE) {
+        const rawChunk = currentChunkBuffer.subarray(0, CHUNK_TARGET_SIZE);
+        currentChunkBuffer = currentChunkBuffer.subarray(CHUNK_TARGET_SIZE);
+        await processAndUploadChunk(rawChunk, chunkIdx++);
+        setStatus(fid, { chunksDone: chunkIdx, currentChunk: chunkIdx });
+      }
+    }
+    
+    // Dernier chunk
+    if (currentChunkBuffer.length > 0) {
+      await processAndUploadChunk(currentChunkBuffer, chunkIdx++);
+      setStatus(fid, { chunksDone: chunkIdx, currentChunk: chunkIdx });
+    }
+
     setStatus(fid, { stage: 'finalizing', progress: req.file.size });
-    db.prepare('UPDATE files SET size=?,chunk_count=? WHERE id=?').run(tSize,cIdx,fid);
-    setStatus(fid, { stage: 'done', progress: tSize, chunksDone: cIdx, chunksTotal: cIdx }); clearStatus(fid);
-    res.json({ok:true,fileId:fid,chunks:cIdx,size:tSize});
-  }catch(e){console.error('[UPLOAD]',e);setStatus(fid,{stage:'error',error:e.message});clearStatus(fid);res.status(500).json({error:e.message});}
+    db.prepare('UPDATE files SET size=?,chunk_count=? WHERE id=?').run(totalBytes, chunkIdx, fid);
+    
+    setStatus(fid, { stage: 'done', progress: totalBytes, chunksDone: chunkIdx, chunksTotal: chunkIdx }); clearStatus(fid);
+    res.json({ok:true,fileId:fid,chunks:chunkIdx,size:totalBytes});
+
+  }catch(e){ console.error('[UPLOAD]', e); setStatus(fid,{stage:'error',error:e.message}); clearStatus(fid); res.status(500).json({error:e.message}); }
   finally{ try{await unlink(tmpPath);}catch(e){} }
 
-  async function processChunk(raw,idx){
-    setStatus(fid, { stage: 'encrypting', currentChunk: idx+1 });
-    const cipher=createCipheriv('aes-256-gcm',fKey,iv); const enc=Buffer.concat([cipher.update(raw),cipher.final()]); const tag=cipher.getAuthTag();
-    const payload=Buffer.concat([iv,tag,enc]);
-    setStatus(fid, { stage: 'png_encoding' }); const pngBuf=await dataToPngBuffer(payload);
-    setStatus(fid, { stage: 'uploading_imgbb', currentChunk: idx+1 }); const {url,delete_url,width,height}=await imgbbUpload(pngBuf);
-    const sha=createHash('sha256').update(payload).digest('hex');
-    db.prepare('INSERT INTO chunks(file_id,idx,imgbb_url,imgbb_delete_url,sha256,byte_size,pixel_w,pixel_h)VALUES(?,?,?,?,?,?,?,?)').run(fid,idx,url,delete_url,sha,payload.length,width,height);
-    setStatus(fid, { chunksDone: idx+1 });
+  // --- Traitement 1 Chunk : Encrypt -> Sharp PNG -> IMGBB ---
+  async function processAndUploadChunk(rawChunk, idx) {
+    setStatus(fid, { stage: 'processing_chunk', currentChunk: idx + 1 });
+    
+    // 1. Chiffrement Stream (Raw -> Encrypted Payload IV+TAG+DATA)
+    // On utilise un pipeline en mémoire pour récupérer le buffer chiffré complet
+    // Car Sharp a besoin du buffer complet pour connaître dimensions (ou on calcule nous-même)
+    // Ici on chiffre en mémoire (31Mo max, OK pour RAM)
+    const cipher = createCipheriv('aes-256-gcm', fKey, iv);
+    const encrypted = Buffer.concat([cipher.update(rawChunk), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const payload = Buffer.concat([iv, tag, encrypted]); // Payload complet
+
+    // 2. Sharp PNG Encoding (Streaming/Buffer -> PNG Buffer)
+    // Calcul dimensions optimales
+    const pixelCount = Math.ceil(payload.length / PNG_BPP);
+    const w = Math.ceil(Math.sqrt(pixelCount));
+    const h = Math.ceil(pixelCount / w);
+    
+    // Sharp: Raw RGBA Buffer -> PNG Buffer (Très rapide, natif)
+    const pngBuf = await sharp(payload, { raw: { width: w, height: h, channels: 4 } })
+      .png({ compressionLevel: 3, palette: false }) // Level 3 = bon compromis vitesse/taille
+      .toBuffer();
+
+    // 3. Upload IMGBB
+    setStatus(fid, { stage: 'uploading_imgbb', currentChunk: idx + 1 });
+    const { url, delete_url, width, height } = await imgbbUpload(pngBuf);
+
+    // 4. Hash & DB
+    const sha = createHash('sha256').update(payload).digest('hex');
+    db.prepare('INSERT INTO chunks(file_id,idx,imgbb_url,imgbb_delete_url,sha256,byte_size,pixel_w,pixel_h)VALUES(?,?,?,?,?,?,?,?)')
+      .run(fid, idx, url, delete_url, sha, payload.length, width, height);
   }
 });
 
 app.get('/api/fs/upload/status/:fid', requireAuth, (req,res)=>{ const s=getStatus(req.params.fid); if(!s||s.owner!==req.session.userId) return res.status(404).json({error:'Not found'}); res.json(s); });
 
-// DOWNLOAD (Range Support)
+// DOWNLOAD / PREVIEW (Identique, utilise getDecryptedChunk optimisé)
 app.get('/api/fs/download/:fid', requireAuth, async (req,res)=>{
   const file=db.prepare('SELECT*FROM files WHERE id=? AND owner_id=?').get(req.params.fid,req.session.userId);
   if(!file) return res.status(404).json({error:'Introuvable'}); if(file.mime==='application/vnd.pixeldrive.folder') return res.status(400).json({error:'Dossier'});
@@ -245,7 +291,6 @@ app.get('/api/fs/download/:fid', requireAuth, async (req,res)=>{
   else await streamFull(res, file, chunks, getFileKey(file.id, SESSION_SECRET));
 });
 
-// PREVIEW (Range Support Critical)
 app.get('/api/fs/preview/:fid', requireAuth, async (req,res)=>{
   const file=db.prepare('SELECT*FROM files WHERE id=? AND owner_id=?').get(req.params.fid,req.session.userId);
   if(!file) return res.status(404).send('Not found');
@@ -259,16 +304,13 @@ app.get('/api/fs/preview/:fid', requireAuth, async (req,res)=>{
   else await streamFull(res, file, chunks, getFileKey(file.id, SESSION_SECRET));
 });
 
-// DELETE
 app.delete('/api/fs/:fid', requireAuth, async (req,res)=>{
   const file=db.prepare('SELECT*FROM files WHERE id=? AND owner_id=?').get(req.params.fid,req.session.userId); if(!file) return res.status(404).json({error:'Introuvable'});
   const chunks=db.prepare('SELECT imgbb_delete_url, idx FROM chunks WHERE file_id=?').all(file.id); chunks.forEach(c=>{imgbbDelete(c.imgbb_delete_url); chunkCache._del(`${file.id}:${c.idx}`);});
   db.prepare('DELETE FROM files WHERE id=?').run(file.id); res.json({ok:true,deletedChunks:chunks.length});
 });
 
-// ============================================================
-// SHARES (PUBLIC)
-// ============================================================
+// SHARES
 app.post('/api/fs/share/:fid', requireAuth, (req,res)=>{ const file=db.prepare('SELECT id FROM files WHERE id=? AND owner_id=? AND mime!=?').get(req.params.fid, req.session.userId, 'application/vnd.pixeldrive.folder'); if(!file) return res.status(404).json({error:'Fichier introuvable ou dossier'}); const {type}=req.body; if(!['download','embed'].includes(type)) return res.status(400).json({error:'Type invalide'}); let share=db.prepare('SELECT token FROM shares WHERE file_id=? AND type=?').get(file.id,type); if(!share){const token=randomBytes(16).toString('hex');db.prepare('INSERT INTO shares(token,file_id,type)VALUES(?,?,?)').run(token,file.id,type);share={token};} const base=`${req.protocol}://${req.get('host')}`; const url=`${base}/s/${type[0]}/${share.token}`; res.json({ok:true,url,type,token:share.token}); });
 app.get('/api/fs/shares/:fid', requireAuth, (req,res)=>{ const file=db.prepare('SELECT id FROM files WHERE id=? AND owner_id=?').get(req.params.fid,req.session.userId); if(!file) return res.status(404).json({error:'Introuvable'}); const shares=db.prepare('SELECT token,type,created_at FROM shares WHERE file_id=?').all(file.id); const base=`${req.protocol}://${req.get('host')}`; res.json({shares:shares.map(s=>({...s,url:`${base}/s/${s.type[0]}/${s.token}`}))}); });
 app.delete('/api/fs/share/:fid/:type', requireAuth, (req,res)=>{ const file=db.prepare('SELECT id FROM files WHERE id=? AND owner_id=?').get(req.params.fid,req.session.userId); if(!file) return res.status(404).json({error:'Introuvable'}); db.prepare('DELETE FROM shares WHERE file_id=? AND type=?').run(file.id,req.params.type); res.json({ok:true}); });
@@ -285,6 +327,6 @@ app.get('/api/admin/stats', requireAuth, requireAdmin, (req,res)=>{ const u=db.p
 // STATIC
 app.get('/', (req,res)=>res.sendFile(join(__dirname, 'public.html')));
 
-const server=app.listen(PORT,'0.0.0.0',()=>console.log(`🚀 PixelDrive v2.1 running on http://0.0.0.0:${PORT} | Cache: 12GB LRU`));
+const server=app.listen(PORT,'0.0.0.0',()=>console.log(`🚀 PixelDrive v2.2 (Sharp) running on http://0.0.0.0:${PORT} | Cache: 12GB LRU`));
 process.on('SIGTERM',()=>{server.close(()=>{db.close();process.exit(0);});});
 process.on('SIGINT',()=>{server.close(()=>{db.close();process.exit(0);});});