From 0fa3a818ae15c632a3d1eff5380842f30aee0688 Mon Sep 17 00:00:00 2001
From: wisecolt <wisecolt@gmail.com>
Date: Mon, 2 Feb 2026 11:35:05 +0300
Subject: [PATCH] feat(rclone): Google Drive entegrasyonu ekle
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Dockerfile ve docker-compose yapılandırması Rclone ve FUSE için güncellendi.
Backend API'leri Rclone durumunu, ayarlarını, yetkilendirmesini ve mount işlemlerini
yönetmek için eklendi. İndirmeler tamamlandığında (Torrent, YouTube, Mail.ru)
dosyaların otomatik veya manuel olarak Google Drive'a taşınması sağlandı.
Dosya sistemi hem yerel hem de mount edilmiş GDrive yollarını destekleyecek şekilde
güncellendi. Ayarlar ve Dosyalar arayüzüne ilgili kontroller eklendi.
---
 .env.example                       |   24 +
 Dockerfile                         |    2 +-
 client/src/routes/Files.svelte     |   31 +-
 client/src/routes/Settings.svelte  |  270 ++++++++
 client/src/routes/Transfers.svelte |   84 ++-
 docker-compose.yml                 |   16 +
 server/server.js                   | 1036 +++++++++++++++++++++++++---
 7 files changed, 1349 insertions(+), 114 deletions(-)

diff --git a/.env.example b/.env.example
index b3f06bf..1d844f8 100644
--- a/.env.example
+++ b/.env.example
@@ -43,3 +43,27 @@ WEBDAV_PATH=/webdav
 WEBDAV_READONLY=1
 # WebDAV index yeniden oluşturma süresi (ms).
 WEBDAV_INDEX_TTL=60000
+
+# --- Rclone / Google Drive ---
+# Rclone entegrasyonunu aç/kapat
+RCLONE_ENABLED=0
+# Rclone config dosyası konumu (container içinde)
+RCLONE_CONFIG_PATH=/config/rclone/rclone.conf
+# Google Drive mount edilecek dizin (container içinde)
+RCLONE_MOUNT_DIR=/app/server/gdrive
+# Rclone remote adı
+RCLONE_REMOTE_NAME=dupe
+# Google Drive içinde kullanılacak klasör adı
+RCLONE_REMOTE_PATH=Dupe
+# Rclone mount tazeleme/poll süresi
+RCLONE_POLL_INTERVAL=1m
+# Rclone dizin cache süresi
+RCLONE_DIR_CACHE_TIME=1m
+# Rclone VFS cache modu (off, minimal, writes, full)
+RCLONE_VFS_CACHE_MODE=full
+# Rclone VFS cache dizini
+RCLONE_VFS_CACHE_DIR=/app/server/cache/rclone-vfs
+# Rclone debug log (taşıma hatalarını detaylı loglamak için)
+RCLONE_DEBUG_MODE_LOG=0
+# Media stream debug log (akış kaynağını loglamak için)
+MEDIA_DEBUG_LOG=0
diff --git a/Dockerfile b/Dockerfile
index 8cc139e..aa72cb9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,7 +8,7 @@ RUN npm run build
 
 # Build server
 FROM node:22-slim
-RUN apt-get update && apt-get install -y ffmpeg curl aria2 && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y ffmpeg curl aria2 rclone fuse3 && rm -rf /var/lib/apt/lists/*
 RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /usr/local/bin/yt-dlp \
   && chmod a+rx /usr/local/bin/yt-dlp
 WORKDIR /app/server
diff --git a/client/src/routes/Files.svelte b/client/src/routes/Files.svelte
index a71a3d2..2332ee7 100644
--- a/client/src/routes/Files.svelte
+++ b/client/src/routes/Files.svelte
@@ -604,6 +604,27 @@
     refreshMovieCount();
     refreshTvShowCount();
   }
+
+  async function moveToGdrive(entry) {
+    if (!entry?.name) return;
+    const ok = confirm("Bu öğe GDrive'a taşınsın mı?");
+    if (!ok) return;
+    try {
+      const resp = await apiFetch("/api/rclone/move", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: entry.name })
+      });
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        alert(data?.error || "GDrive taşıma başarısız oldu.");
+        return;
+      }
+      await loadFiles();
+    } catch (err) {
+      alert(err?.message || "GDrive taşıma başarısız oldu.");
+    }
+  }
   function formatSize(bytes) {
     if (!bytes) return "0 MB";
     if (bytes < 1e6) return (bytes / 1e3).toFixed(1) + " KB";
@@ -1237,7 +1258,7 @@
       const button = event.currentTarget;
       const rect = button.getBoundingClientRect();
       const menuWidth = 160;
-      const menuHeight = 140; // Yaklaşık menü yüksekliği
+      const menuHeight = 180; // Yaklaşık menü yüksekliği
       
       // Üç noktanın son noktası ile menünün sol kenarını hizala
       // Düğme genişliği 34px, son nokta sağ kenara yakın
@@ -2389,6 +2410,14 @@
       </button>
       <div class="menu-divider"></div>
     {/if}
+    <button
+      class="menu-item"
+      on:click|stopPropagation={() => moveToGdrive(activeMenu)}
+    >
+      <i class="fa-solid fa-cloud-arrow-up"></i>
+      <span>GDrive'a Taşı</span>
+    </button>
+    <div class="menu-divider"></div>
     <button
       class="menu-item delete"
       on:click|stopPropagation={() => deleteFile(activeMenu)}
diff --git a/client/src/routes/Settings.svelte b/client/src/routes/Settings.svelte
index 080b5b5..b93cf27 100644
--- a/client/src/routes/Settings.svelte
+++ b/client/src/routes/Settings.svelte
@@ -5,6 +5,7 @@
   const tabs = [
     { id: "general", label: "General", icon: "fa-solid fa-sliders" },
     { id: "youtube", label: "YouTube", icon: "fa-brands fa-youtube" },
+    { id: "rclone", label: "Rclone", icon: "fa-solid fa-cloud" },
     { id: "advanced", label: "Advanced", icon: "fa-solid fa-gear" }
   ];
 
@@ -21,6 +22,19 @@
   let error = null;
   let success = null;
 
+  let rcloneStatus = null;
+  let rcloneLoading = false;
+  let rcloneSaving = false;
+  let rcloneAuthUrl = "";
+  let rcloneToken = "";
+  let rcloneClientId = "";
+  let rcloneClientSecret = "";
+  let rcloneAutoMove = false;
+  let rcloneAutoMount = false;
+  let rcloneRemoteName = "";
+  let rcloneRemotePath = "";
+  let rcloneMountDir = "";
+
   async function loadCookies() {
     loadingCookies = true;
     error = null;
@@ -111,9 +125,136 @@
     }
   }
 
+  async function loadRcloneStatus() {
+    rcloneLoading = true;
+    error = null;
+    try {
+      const resp = await apiFetch("/api/rclone/status");
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      const data = await resp.json();
+      rcloneStatus = data;
+      rcloneAutoMove = Boolean(data?.autoMove);
+      rcloneAutoMount = Boolean(data?.autoMount);
+      rcloneRemoteName = data?.remoteName || "";
+      rcloneRemotePath = data?.remotePath || "";
+      rcloneMountDir = data?.mountDir || "";
+    } catch (err) {
+      error = err?.message || "Rclone durumu alınamadı.";
+    } finally {
+      rcloneLoading = false;
+    }
+  }
+
+  async function saveRcloneSettings() {
+    if (rcloneSaving) return;
+    rcloneSaving = true;
+    error = null;
+    success = null;
+    try {
+      const resp = await apiFetch("/api/rclone/settings", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          autoMove: rcloneAutoMove,
+          autoMount: rcloneAutoMount,
+          remoteName: rcloneRemoteName,
+          remotePath: rcloneRemotePath,
+          mountDir: rcloneMountDir
+        })
+      });
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${resp.status}`);
+      }
+      success = "Rclone ayarları kaydedildi.";
+      await loadRcloneStatus();
+    } catch (err) {
+      error = err?.message || "Rclone ayarları kaydedilemedi.";
+    } finally {
+      rcloneSaving = false;
+    }
+  }
+
+  async function requestRcloneAuthUrl() {
+    error = null;
+    success = null;
+    try {
+      const resp = await apiFetch("/api/rclone/auth-url");
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${resp.status}`);
+      }
+      rcloneAuthUrl = data.url || "";
+    } catch (err) {
+      error = err?.message || "Auth URL alınamadı.";
+    }
+  }
+
+  async function applyRcloneToken() {
+    if (!rcloneToken) {
+      error = "Token zorunlu.";
+      return;
+    }
+    error = null;
+    success = null;
+    try {
+      const resp = await apiFetch("/api/rclone/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          token: rcloneToken,
+          clientId: rcloneClientId,
+          clientSecret: rcloneClientSecret,
+          remoteName: rcloneRemoteName
+        })
+      });
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${resp.status}`);
+      }
+      success = "Token kaydedildi.";
+      await loadRcloneStatus();
+    } catch (err) {
+      error = err?.message || "Token kaydedilemedi.";
+    }
+  }
+
+  async function startRcloneMount() {
+    error = null;
+    success = null;
+    try {
+      const resp = await apiFetch("/api/rclone/mount", { method: "POST" });
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${resp.status}`);
+      }
+      success = "Rclone mount başlatıldı.";
+      await loadRcloneStatus();
+    } catch (err) {
+      error = err?.message || "Rclone mount başlatılamadı.";
+    }
+  }
+
+  async function stopRcloneMount() {
+    error = null;
+    success = null;
+    try {
+      const resp = await apiFetch("/api/rclone/unmount", { method: "POST" });
+      const data = await resp.json().catch(() => ({}));
+      if (!resp.ok || !data?.ok) {
+        throw new Error(data?.error || `HTTP ${resp.status}`);
+      }
+      success = "Rclone mount durduruldu.";
+      await loadRcloneStatus();
+    } catch (err) {
+      error = err?.message || "Rclone mount durdurulamadı.";
+    }
+  }
+
   onMount(() => {
     loadCookies();
     loadYoutubeSettings();
+    loadRcloneStatus();
   });
 
   function formatDate(ts) {
@@ -236,6 +377,135 @@
     </div>
   {:else if activeTab === "general"}
     <div class="card muted">Genel ayarlar burada yer alacak.</div>
+  {:else if activeTab === "rclone"}
+    <div class="card">
+      <div class="card-header">
+        <div class="title">
+          <i class="fa-solid fa-cloud"></i>
+          <span>Google Drive (Rclone)</span>
+        </div>
+      </div>
+
+      <div class="field inline compact left-align">
+        <label class="checkbox-row">
+          <input
+            type="checkbox"
+            bind:checked={rcloneAutoMove}
+            disabled={rcloneLoading || rcloneSaving}
+          />
+          <span>İndirince otomatik taşı</span>
+        </label>
+        <label class="checkbox-row">
+          <input
+            type="checkbox"
+            bind:checked={rcloneAutoMount}
+            disabled={rcloneLoading || rcloneSaving}
+          />
+          <span>Başlangıçta otomatik mount</span>
+        </label>
+      </div>
+
+      <div class="field inline compact left-align">
+        <div class="inline-field">
+          <label for="rclone-remote">Remote adı</label>
+          <input
+            id="rclone-remote"
+            type="text"
+            bind:value={rcloneRemoteName}
+            disabled={rcloneLoading || rcloneSaving}
+          />
+        </div>
+        <div class="inline-field">
+          <label for="rclone-path">Drive klasörü</label>
+          <input
+            id="rclone-path"
+            type="text"
+            bind:value={rcloneRemotePath}
+            disabled={rcloneLoading || rcloneSaving}
+          />
+        </div>
+      </div>
+
+      <div class="field">
+        <label for="rclone-mount">Mount dizini</label>
+        <input
+          id="rclone-mount"
+          type="text"
+          bind:value={rcloneMountDir}
+          disabled={rcloneLoading || rcloneSaving}
+        />
+      </div>
+
+      <div class="actions">
+        <button class="btn" on:click={loadRcloneStatus} disabled={rcloneLoading || rcloneSaving}>
+          <i class="fa-solid fa-rotate"></i> Yenile
+        </button>
+        <button class="btn primary" on:click={saveRcloneSettings} disabled={rcloneLoading || rcloneSaving}>
+          <i class="fa-solid fa-floppy-disk"></i> Kaydet
+        </button>
+      </div>
+
+      <div class="field">
+        <label>Yetkilendirme</label>
+        <div class="actions">
+          <button class="btn" on:click={requestRcloneAuthUrl}>
+            <i class="fa-solid fa-link"></i> Auth URL al
+          </button>
+        </div>
+        {#if rcloneAuthUrl}
+          <input type="text" readonly value={rcloneAuthUrl} />
+        {/if}
+      </div>
+
+      <div class="field">
+        <label for="rclone-client-id">Client ID (opsiyonel)</label>
+        <input id="rclone-client-id" type="text" bind:value={rcloneClientId} />
+      </div>
+      <div class="field">
+        <label for="rclone-client-secret">Client Secret (opsiyonel)</label>
+        <input id="rclone-client-secret" type="text" bind:value={rcloneClientSecret} />
+      </div>
+      <div class="field">
+        <label for="rclone-token">Token</label>
+        <textarea id="rclone-token" bind:value={rcloneToken} placeholder="rclone authorize çıktısındaki token JSON'u"></textarea>
+      </div>
+
+      <div class="actions">
+        <button class="btn" on:click={applyRcloneToken}>
+          <i class="fa-solid fa-key"></i> Token Kaydet
+        </button>
+        <button class="btn" on:click={startRcloneMount}>
+          <i class="fa-solid fa-play"></i> Mount Başlat
+        </button>
+        <button class="btn" on:click={stopRcloneMount}>
+          <i class="fa-solid fa-stop"></i> Mount Durdur
+        </button>
+      </div>
+
+      {#if rcloneStatus}
+        <div class="card muted" style="margin-top:10px;">
+          <div>Enabled: {rcloneStatus.enabled ? "Evet" : "Hayır"}</div>
+          <div>Mounted: {rcloneStatus.mounted ? "Evet" : "Hayır"}</div>
+          <div>Remote: {rcloneStatus.remoteConfigured ? "Hazır" : "Eksik"}</div>
+          {#if rcloneStatus.lastError}
+            <div>Son hata: {rcloneStatus.lastError}</div>
+          {/if}
+        </div>
+      {/if}
+
+      {#if error}
+        <div class="alert error" style="margin-top:10px;">
+          <i class="fa-solid fa-circle-exclamation"></i>
+          {error}
+        </div>
+      {/if}
+      {#if success}
+        <div class="alert success" style="margin-top:10px;">
+          <i class="fa-solid fa-circle-check"></i>
+          {success}
+        </div>
+      {/if}
+    </div>
   {:else if activeTab === "advanced"}
     <div class="card muted">Gelişmiş ayarlar burada yer alacak.</div>
   {/if}
diff --git a/client/src/routes/Transfers.svelte b/client/src/routes/Transfers.svelte
index 0da202a..10e4d50 100644
--- a/client/src/routes/Transfers.svelte
+++ b/client/src/routes/Transfers.svelte
@@ -9,6 +9,8 @@
   let totalDownloaded = 0;
   let totalDownloadSpeed = 0;
   let pollTimer;
+  let moveToGdriveDefault = false;
+  let loadingRcloneStatus = false;
 
   // Modal / player state
   let showModal = false;
@@ -79,11 +81,28 @@
     updateTransferStats();
   }
 
+  async function loadRcloneStatus() {
+    loadingRcloneStatus = true;
+    try {
+      const resp = await apiFetch("/api/rclone/status");
+      if (!resp.ok) return;
+      const data = await resp.json().catch(() => ({}));
+      if (typeof data?.autoMove === "boolean") {
+        moveToGdriveDefault = data.autoMove;
+      }
+    } catch (err) {
+      console.warn("Rclone durumu alınamadı:", err);
+    } finally {
+      loadingRcloneStatus = false;
+    }
+  }
+
   async function upload(e) {
     const f = e.target.files?.[0];
     if (!f) return;
     const fd = new FormData();
     fd.append("torrent", f);
+    fd.append("moveToGdrive", moveToGdriveDefault ? "1" : "0");
     await apiFetch("/api/transfer", { method: "POST", body: fd }); // ✅
     await list();
   }
@@ -132,7 +151,7 @@
       await apiFetch("/api/transfer", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ magnet: input })
+        body: JSON.stringify({ magnet: input, moveToGdrive: moveToGdriveDefault })
       });
       await list();
       return;
@@ -142,7 +161,7 @@
       const resp = await apiFetch("/api/youtube/download", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ url: normalizedYoutube })
+        body: JSON.stringify({ url: normalizedYoutube, moveToGdrive: moveToGdriveDefault })
       });
       if (!resp.ok) {
         const data = await resp.json().catch(() => null);
@@ -157,7 +176,7 @@
       const resp = await apiFetch("/api/mailru/download", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ url: normalizedMailRu })
+        body: JSON.stringify({ url: normalizedMailRu, moveToGdrive: moveToGdriveDefault })
       });
       if (!resp.ok) {
         const data = await resp.json().catch(() => null);
@@ -369,6 +388,18 @@
     }
   }
 
+  async function toggleTransferGdrive(infoHash, enabled) {
+    try {
+      await apiFetch(`/api/transfer/${infoHash}/gdrive`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ enabled: enabled ? "1" : "0" })
+      });
+    } catch (err) {
+      console.warn("GDrive toggle hatası:", err);
+    }
+  }
+
   function streamURL(hash, index = 0) {
     const base = `${API}/stream/${hash}?index=${index}`;
     return withToken(base);
@@ -581,6 +612,7 @@
     for (const file of torrentsToUpload) {
       const fd = new FormData();
       fd.append("torrent", file);
+      fd.append("moveToGdrive", moveToGdriveDefault ? "1" : "0");
       await apiFetch("/api/transfer", { method: "POST", body: fd });
     }
 
@@ -603,6 +635,7 @@
   onMount(() => {
     list(); // 🔒 token'lı liste çekimi
     wsConnect(); // 🔒 token'lı WebSocket
+    loadRcloneStatus();
     addGlobalDragListeners();
     const slider = document.querySelector(".volume-slider");
     if (slider) {
@@ -642,6 +675,14 @@
       <label class="btn-primary" on:click={handleUrlInput}>
         <i class="fa-solid fa-magnet btn-icon"></i> ADD URL
       </label>
+      <label class="gdrive-toggle">
+        <input
+          type="checkbox"
+          bind:checked={moveToGdriveDefault}
+          disabled={loadingRcloneStatus}
+        />
+        <span>GDrive'a taşı</span>
+      </label>
     </div>
     <div style="display:flex; gap:10px;" title="Total Transfer Speed">
       <div class="transfer-info-box">
@@ -734,6 +775,15 @@
                 {/if}
               </div>
               <div style="display:flex; gap:5px;">
+                <label class="gdrive-toggle compact" on:click|stopPropagation>
+                  <input
+                    type="checkbox"
+                    checked={t.moveToGdrive}
+                    on:change={(e) =>
+                      toggleTransferGdrive(t.infoHash, e.target.checked)}
+                  />
+                  <span>GDrive</span>
+                </label>
                 {#if t.type === "torrent" || !t.type}
                   <button
                     class="toggle-btn"
@@ -815,6 +865,12 @@
             <div class="progress-text">
               {#if t.type === "mailru" && t.status === "awaiting_match"}
                 Eşleştirme bekleniyor
+              {:else if (t.progress || 0) >= 1 && t.moveToGdrive && t.moveStatus === "moving"}
+                GDrive'a Taşınıyor.. • 100.0% • {(t.downloaded / 1e6).toFixed(1)} MB
+              {:else if (t.progress || 0) >= 1 && t.moveToGdrive && t.moveStatus === "done"}
+                GDrive ✓ • 100.0% • {(t.downloaded / 1e6).toFixed(1)} MB
+              {:else if (t.progress || 0) >= 1 && t.moveToGdrive && t.moveStatus === "error"}
+                GDrive Hata • 100.0% • {(t.downloaded / 1e6).toFixed(1)} MB
               {:else if (t.progress || 0) < 1}
                 {(t.progress * 100).toFixed(1)}% •
                 {t.downloaded ? (t.downloaded / 1e6).toFixed(1) : 0} MB •
@@ -1502,4 +1558,26 @@
   .more-item:hover {
     background: #f1f5f9;
   }
+
+  .gdrive-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 12px;
+    color: #444;
+    background: #f7f7f7;
+    border: 1px solid #e2e2e2;
+    border-radius: 8px;
+    padding: 6px 10px;
+  }
+
+  .gdrive-toggle.compact {
+    padding: 4px 6px;
+    font-size: 11px;
+    background: #fff;
+  }
+
+  .gdrive-toggle input {
+    accent-color: #4caf50;
+  }
 </style>
diff --git a/docker-compose.yml b/docker-compose.yml
index 7a69c20..c22ab04 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -7,7 +7,14 @@ services:
     volumes:
       - ./downloads:/app/server/downloads
       - ./cache:/app/server/cache
+      - ./rclone:/config/rclone
     restart: unless-stopped
+    cap_add:
+      - SYS_ADMIN
+    security_opt:
+      - apparmor:unconfined
+    devices:
+      - /dev/fuse:/dev/fuse
     # Login credentials for basic auth
     environment:
       USERNAME: ${USERNAME}
@@ -25,3 +32,12 @@ services:
       WEBDAV_PATH: ${WEBDAV_PATH}
       WEBDAV_READONLY: ${WEBDAV_READONLY}
       WEBDAV_INDEX_TTL: ${WEBDAV_INDEX_TTL}
+      RCLONE_ENABLED: ${RCLONE_ENABLED}
+      RCLONE_CONFIG_PATH: ${RCLONE_CONFIG_PATH}
+      RCLONE_MOUNT_DIR: ${RCLONE_MOUNT_DIR}
+      RCLONE_REMOTE_NAME: ${RCLONE_REMOTE_NAME}
+      RCLONE_REMOTE_PATH: ${RCLONE_REMOTE_PATH}
+      RCLONE_POLL_INTERVAL: ${RCLONE_POLL_INTERVAL}
+      RCLONE_DIR_CACHE_TIME: ${RCLONE_DIR_CACHE_TIME}
+      RCLONE_VFS_CACHE_MODE: ${RCLONE_VFS_CACHE_MODE}
+      RCLONE_VFS_CACHE_DIR: ${RCLONE_VFS_CACHE_DIR}
diff --git a/server/server.js b/server/server.js
index 1695182..13dec99 100644
--- a/server/server.js
+++ b/server/server.js
@@ -19,6 +19,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const app = express();
+app.set("trust proxy", true);
 const upload = multer({ dest: path.join(__dirname, "uploads") });
 const client = new WebTorrent();
 const torrents = new Map();
@@ -39,6 +40,25 @@ const WEBDAV_READONLY = !["0", "false", "no", "off"].includes(
   String(process.env.WEBDAV_READONLY || "1").toLowerCase()
 );
 const WEBDAV_INDEX_TTL = Number(process.env.WEBDAV_INDEX_TTL || 60000);
+const RCLONE_ENABLED = ["1", "true", "yes", "on"].includes(
+  String(process.env.RCLONE_ENABLED || "").toLowerCase()
+);
+const RCLONE_CONFIG_PATH =
+  process.env.RCLONE_CONFIG_PATH || "/config/rclone/rclone.conf";
+const RCLONE_MOUNT_DIR =
+  process.env.RCLONE_MOUNT_DIR || path.join(__dirname, "gdrive");
+const RCLONE_REMOTE_NAME = process.env.RCLONE_REMOTE_NAME || "dupe";
+const RCLONE_REMOTE_PATH = process.env.RCLONE_REMOTE_PATH || "Dupe";
+const RCLONE_POLL_INTERVAL = process.env.RCLONE_POLL_INTERVAL || "1m";
+const RCLONE_DIR_CACHE_TIME = process.env.RCLONE_DIR_CACHE_TIME || "1m";
+const RCLONE_VFS_CACHE_MODE =
+  process.env.RCLONE_VFS_CACHE_MODE || "full";
+const RCLONE_DEBUG_MODE_LOG = ["1", "true", "yes", "on"].includes(
+  String(process.env.RCLONE_DEBUG_MODE_LOG || "").toLowerCase()
+);
+const MEDIA_DEBUG_LOG = ["1", "true", "yes", "on"].includes(
+  String(process.env.MEDIA_DEBUG_LOG || "").toLowerCase()
+);
 
 // --- İndirilen dosyalar için klasör oluştur ---
 const DOWNLOAD_DIR = path.join(__dirname, "downloads");
@@ -64,6 +84,10 @@ const TV_DATA_ROOT = path.join(CACHE_DIR, "tv_data");
 const ANIME_DATA_ROOT = path.join(CACHE_DIR, "anime_data");
 const YT_DATA_ROOT = path.join(CACHE_DIR, "yt_data");
 const WEBDAV_ROOT = path.join(CACHE_DIR, "webdav");
+const RCLONE_VFS_CACHE_DIR =
+  process.env.RCLONE_VFS_CACHE_DIR || path.join(CACHE_DIR, "rclone-vfs");
+const GDRIVE_ROOT = path.join(RCLONE_MOUNT_DIR, RCLONE_REMOTE_PATH);
+const RCLONE_SETTINGS_PATH = path.join(CACHE_DIR, "rclone.json");
 const ANIME_ROOT_FOLDER = "_anime";
 const ROOT_TRASH_REGISTRY = path.join(CACHE_DIR, "root-trash.json");
 const MUSIC_EXTENSIONS = new Set([
@@ -86,7 +110,8 @@ for (const dir of [
   TV_DATA_ROOT,
   ANIME_DATA_ROOT,
   YT_DATA_ROOT,
-  WEBDAV_ROOT
+  WEBDAV_ROOT,
+  RCLONE_VFS_CACHE_DIR
 ]) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
@@ -184,7 +209,7 @@ function enumerateVideoFiles(rootFolder) {
   const safe = sanitizeRelative(rootFolder);
   if (!safe) return [];
 
-  const baseDir = path.join(DOWNLOAD_DIR, safe);
+  const baseDir = resolveRootDir(safe);
   if (!fs.existsSync(baseDir)) return [];
 
   const videos = [];
@@ -654,20 +679,493 @@ function upsertInfoFile(savePath, partial) {
 function readInfoForRoot(rootFolder) {
   const safe = sanitizeRelative(rootFolder);
   if (!safe) return null;
-  const target = path.join(DOWNLOAD_DIR, safe, INFO_FILENAME);
-  if (!fs.existsSync(target)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(target, "utf-8"));
-  } catch (err) {
-    console.warn(`⚠️ info.json okunamadı (${target}): ${err.message}`);
-    return null;
+  const candidates = [
+    path.join(DOWNLOAD_DIR, safe, INFO_FILENAME),
+    path.join(GDRIVE_ROOT, safe, INFO_FILENAME)
+  ];
+  for (const target of candidates) {
+    if (!fs.existsSync(target)) continue;
+    try {
+      return JSON.parse(fs.readFileSync(target, "utf-8"));
+    } catch (err) {
+      console.warn(`⚠️ info.json okunamadı (${target}): ${err.message}`);
+      return null;
+    }
   }
+  return null;
 }
 
 function sanitizeRelative(relPath) {
   return relPath.replace(/^[\\/]+/, "");
 }
 
+function getStorageRoots() {
+  const roots = [DOWNLOAD_DIR];
+  if (RCLONE_ENABLED && fs.existsSync(GDRIVE_ROOT)) {
+    roots.push(GDRIVE_ROOT);
+  }
+  return roots;
+}
+
+function listStorageRootFolders() {
+  const roots = getStorageRoots();
+  const seen = new Set();
+  const entries = [];
+  for (const base of roots) {
+    if (!fs.existsSync(base)) continue;
+    let dirs = [];
+    try {
+      dirs = fs.readdirSync(base, { withFileTypes: true });
+    } catch (err) {
+      continue;
+    }
+    for (const dirent of dirs) {
+      if (!dirent.isDirectory()) continue;
+      const name = sanitizeRelative(dirent.name);
+      if (!name || seen.has(name)) continue;
+      seen.add(name);
+      entries.push({ rootFolder: name, baseDir: base });
+    }
+  }
+  return entries;
+}
+
+function resolveStoragePath(relPath) {
+  const safe = sanitizeRelative(relPath);
+  if (!safe) return null;
+  for (const base of getStorageRoots()) {
+    const full = path.join(base, safe);
+    if (fs.existsSync(full)) return full;
+  }
+  return null;
+}
+
+function resolveRootDir(rootFolder) {
+  const safe = sanitizeRelative(rootFolder);
+  if (!safe) return null;
+  const local = path.join(DOWNLOAD_DIR, safe);
+  if (fs.existsSync(local)) return local;
+  const gdrive = path.join(GDRIVE_ROOT, safe);
+  if (fs.existsSync(gdrive)) return gdrive;
+  return null;
+}
+
+let rcloneProcess = null;
+let rcloneLastError = null;
+const rcloneAuthSessions = new Map();
+
+function logRcloneMoveError(context, error) {
+  if (!error) return;
+  console.warn(`☁️ Rclone taşıma hatası (${context}): ${error}`);
+  if (RCLONE_DEBUG_MODE_LOG) {
+    console.warn("☁️ Rclone taşıma hata detayı:", { context, error });
+  }
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitForFileStable(filePath, attempts = 5, intervalMs = 2000) {
+  if (!filePath || !fs.existsSync(filePath)) return false;
+  let prevSize = null;
+  let prevMtime = null;
+  for (let i = 0; i < attempts; i += 1) {
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      return false;
+    }
+    const size = stat.size;
+    const mtime = stat.mtimeMs;
+    if (prevSize !== null && prevMtime !== null) {
+      if (size === prevSize && mtime === prevMtime) return true;
+    }
+    prevSize = size;
+    prevMtime = mtime;
+    await sleep(intervalMs);
+  }
+  return false;
+}
+
+function parseRcloneTokenFromText(text) {
+  if (!text || !text.includes("access_token")) return null;
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start < 0 || end <= start) return null;
+  const snippet = text.slice(start, end + 1);
+  try {
+    return JSON.parse(snippet);
+  } catch (err) {
+    return null;
+  }
+}
+
+function cleanupRcloneAuthSession(sessionId) {
+  const session = rcloneAuthSessions.get(sessionId);
+  if (!session) return;
+  if (session.child && !session.child.killed) {
+    try {
+      session.child.kill("SIGTERM");
+    } catch {}
+  }
+  rcloneAuthSessions.delete(sessionId);
+}
+
+function loadRcloneSettings() {
+  if (!fs.existsSync(RCLONE_SETTINGS_PATH)) {
+    return {
+      autoMove: false,
+      autoMount: false,
+      remoteName: RCLONE_REMOTE_NAME,
+      remotePath: RCLONE_REMOTE_PATH,
+      mountDir: RCLONE_MOUNT_DIR,
+      configPath: RCLONE_CONFIG_PATH
+    };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(RCLONE_SETTINGS_PATH, "utf-8"));
+    return {
+      autoMove: Boolean(data.autoMove),
+      autoMount: Boolean(data.autoMount),
+      remoteName: data.remoteName || RCLONE_REMOTE_NAME,
+      remotePath: data.remotePath || RCLONE_REMOTE_PATH,
+      mountDir: data.mountDir || RCLONE_MOUNT_DIR,
+      configPath: data.configPath || RCLONE_CONFIG_PATH
+    };
+  } catch (err) {
+    console.warn(`⚠️ rclone ayarları okunamadı: ${err.message}`);
+    return {
+      autoMove: false,
+      autoMount: false,
+      remoteName: RCLONE_REMOTE_NAME,
+      remotePath: RCLONE_REMOTE_PATH,
+      mountDir: RCLONE_MOUNT_DIR,
+      configPath: RCLONE_CONFIG_PATH
+    };
+  }
+}
+
+function saveRcloneSettings(partial) {
+  const current = loadRcloneSettings();
+  const next = { ...current, ...partial };
+  try {
+    fs.writeFileSync(RCLONE_SETTINGS_PATH, JSON.stringify(next, null, 2), "utf-8");
+  } catch (err) {
+    console.warn(`⚠️ rclone ayarları yazılamadı: ${err.message}`);
+  }
+  return next;
+}
+
+function isRcloneMounted(mountDir) {
+  if (!mountDir) return false;
+  try {
+    const mounts = fs.readFileSync("/proc/mounts", "utf-8");
+    return mounts
+      .split("\n")
+      .some((line) => line.split(" ")[1] === mountDir);
+  } catch (err) {
+    return false;
+  }
+}
+
+function ensureRcloneDirs(settings) {
+  if (!settings?.mountDir) return;
+  if (!fs.existsSync(settings.mountDir)) {
+    fs.mkdirSync(settings.mountDir, { recursive: true });
+  }
+  if (!fs.existsSync(RCLONE_VFS_CACHE_DIR)) {
+    fs.mkdirSync(RCLONE_VFS_CACHE_DIR, { recursive: true });
+  }
+}
+
+function startRcloneMount(settings) {
+  if (!RCLONE_ENABLED) {
+    return { ok: false, error: "Rclone kapalı." };
+  }
+  if (rcloneProcess && !rcloneProcess.killed) {
+    return { ok: true, alreadyRunning: true };
+  }
+
+  const configPath = settings.configPath || RCLONE_CONFIG_PATH;
+  const mountDir = settings.mountDir || RCLONE_MOUNT_DIR;
+  const remoteName = settings.remoteName || RCLONE_REMOTE_NAME;
+  const remotePath = settings.remotePath || RCLONE_REMOTE_PATH;
+
+  ensureRcloneDirs({ mountDir });
+
+  const args = [
+    "mount",
+    `${remoteName}:${remotePath}`,
+    mountDir,
+    "--config",
+    configPath,
+    "--vfs-cache-mode",
+    RCLONE_VFS_CACHE_MODE,
+    "--cache-dir",
+    RCLONE_VFS_CACHE_DIR,
+    "--dir-cache-time",
+    RCLONE_DIR_CACHE_TIME,
+    "--poll-interval",
+    RCLONE_POLL_INTERVAL,
+    "--log-level",
+    "INFO"
+  ];
+
+  try {
+    rcloneProcess = spawn("rclone", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (err) {
+    rcloneLastError = err?.message || String(err);
+    return { ok: false, error: rcloneLastError };
+  }
+
+  rcloneProcess.stdout.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) console.log(`🌀 rclone: ${msg}`);
+  });
+  rcloneProcess.stderr.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) {
+      rcloneLastError = msg;
+      console.warn(`⚠️ rclone: ${msg}`);
+    }
+  });
+  rcloneProcess.on("exit", (code) => {
+    if (code !== 0) {
+      rcloneLastError = `rclone exit: ${code}`;
+      console.warn(`⚠️ rclone mount durdu (code ${code})`);
+    }
+    rcloneProcess = null;
+  });
+
+  return { ok: true };
+}
+
+function stopRcloneMount() {
+  if (!rcloneProcess) return { ok: true, alreadyStopped: true };
+  try {
+    rcloneProcess.kill("SIGTERM");
+    rcloneProcess = null;
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+
+async function moveRootFolderToGdrive(rootFolder) {
+  const safeRoot = sanitizeRelative(rootFolder);
+  if (!safeRoot) return { ok: false, error: "Geçersiz root" };
+  const sourceDir = path.join(DOWNLOAD_DIR, safeRoot);
+  if (!fs.existsSync(sourceDir)) {
+    return { ok: false, error: "Kaynak root bulunamadı" };
+  }
+  if (!fs.existsSync(GDRIVE_ROOT)) {
+    return { ok: false, error: "GDrive mount dizini bulunamadı" };
+  }
+  const targetDir = path.join(GDRIVE_ROOT, safeRoot);
+  if (fs.existsSync(targetDir)) {
+    return { ok: false, error: "GDrive'da aynı isimde klasör var" };
+  }
+  try {
+    const videoEntries = enumerateVideoFiles(safeRoot);
+    for (const entry of videoEntries) {
+      const absVideo = path.join(sourceDir, entry.relPath);
+      await waitForFileStable(absVideo, 6, 2000);
+    }
+    fs.renameSync(sourceDir, targetDir);
+  } catch (err) {
+    if (err?.code === "EXDEV") {
+      try {
+        fs.cpSync(sourceDir, targetDir, { recursive: true });
+        fs.rmSync(sourceDir, { recursive: true, force: true });
+      } catch (copyErr) {
+        return { ok: false, error: copyErr?.message || String(copyErr) };
+      }
+    } else {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  return { ok: true, targetDir };
+}
+
+async function movePathToGdrive(relPath) {
+  const safeRel = sanitizeRelative(relPath);
+  if (!safeRel) return { ok: false, error: "Geçersiz yol" };
+  const sourceFile = path.join(DOWNLOAD_DIR, safeRel);
+  if (fs.existsSync(sourceFile) && fs.statSync(sourceFile).isFile()) {
+    const targetFile = path.join(GDRIVE_ROOT, safeRel);
+    ensureDirForFile(targetFile);
+    try {
+      await waitForFileStable(sourceFile, 6, 2000);
+      fs.renameSync(sourceFile, targetFile);
+    } catch (err) {
+      if (err?.code === "EXDEV") {
+        try {
+          fs.copyFileSync(sourceFile, targetFile);
+          fs.rmSync(sourceFile, { force: true });
+        } catch (copyErr) {
+          return { ok: false, error: copyErr?.message || String(copyErr) };
+        }
+      } else {
+        return { ok: false, error: err?.message || String(err) };
+      }
+    }
+    return { ok: true, targetFile };
+  }
+  const rootFolder = rootFromRelPath(safeRel);
+  if (!rootFolder) return { ok: false, error: "Kök bulunamadı" };
+  return await moveRootFolderToGdrive(rootFolder);
+}
+
+function rcloneConfigHasRemote(remoteName) {
+  if (!fs.existsSync(RCLONE_CONFIG_PATH)) return false;
+  try {
+    const raw = fs.readFileSync(RCLONE_CONFIG_PATH, "utf-8");
+    const pattern = new RegExp(`\\[${remoteName}\\]`, "i");
+    return pattern.test(raw);
+  } catch (err) {
+    return false;
+  }
+}
+
+function writeRcloneConfig({
+  remoteName,
+  token,
+  clientId,
+  clientSecret,
+  scope = "drive"
+}) {
+  if (!remoteName || !token) {
+    return { ok: false, error: "remoteName ve token gerekli." };
+  }
+  const safeName = String(remoteName).trim();
+  if (!safeName) return { ok: false, error: "Geçersiz remoteName." };
+  const lines = [];
+  lines.push(`[${safeName}]`);
+  lines.push("type = drive");
+  if (clientId) lines.push(`client_id = ${clientId}`);
+  if (clientSecret) lines.push(`client_secret = ${clientSecret}`);
+  lines.push(`scope = ${scope}`);
+  lines.push(`token = ${token}`);
+  const content = lines.join("\n") + "\n";
+  try {
+    ensureDirForFile(RCLONE_CONFIG_PATH);
+    fs.writeFileSync(RCLONE_CONFIG_PATH, content, "utf-8");
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}
+
+function getRcloneAuthUrl(baseOrigin) {
+  return new Promise((resolve) => {
+    if (!RCLONE_ENABLED) {
+      resolve({ ok: false, error: "Rclone kapalı." });
+      return;
+    }
+    const now = Date.now();
+    for (const [id, session] of rcloneAuthSessions.entries()) {
+      if (now - session.createdAt > 15 * 60 * 1000) {
+        cleanupRcloneAuthSession(id);
+      }
+    }
+    for (const session of rcloneAuthSessions.values()) {
+      if (!session.done && session.url) {
+        resolve({ ok: true, url: session.url, sessionId: session.id });
+        return;
+      }
+    }
+    let resolved = false;
+    const sessionId = `rclone_${Date.now()}_${Math.random()
+      .toString(36)
+      .slice(2, 10)}`;
+    const child = spawn("rclone", ["authorize", "drive", "--auth-no-open-browser"]);
+    const session = {
+      id: sessionId,
+      child,
+      createdAt: Date.now(),
+      port: null,
+      url: null,
+      done: false,
+      error: null,
+      token: null
+    };
+    rcloneAuthSessions.set(sessionId, session);
+
+    const timeout = setTimeout(() => {
+      if (session.done || resolved) return;
+      session.error = "Auth URL zaman aşımı.";
+      cleanupRcloneAuthSession(sessionId);
+      resolved = true;
+      resolve({ ok: false, error: session.error });
+    }, 5 * 60 * 1000);
+
+    let outputBuffer = "";
+    const handleOutput = (data) => {
+      const text = data.toString();
+      outputBuffer += text;
+      if (!session.url) {
+        const match = outputBuffer.match(/https?:\/\/[^\s]+/i);
+        if (match) {
+          const rawUrl = match[0];
+          try {
+            const urlObj = new URL(rawUrl);
+            session.port = urlObj.port ? Number(urlObj.port) : null;
+            session.authPath = urlObj.pathname || "/auth";
+            const redirectUri = `${baseOrigin}/api/rclone/auth/callback/${sessionId}`;
+            urlObj.searchParams.set("redirect_uri", redirectUri);
+            const authQuery = urlObj.searchParams.toString();
+            session.url = `${baseOrigin}/api/rclone/auth/forward/${sessionId}${session.authPath}?${authQuery}`;
+            if (!resolved) {
+              resolved = true;
+              resolve({ ok: true, url: session.url, sessionId });
+            }
+          } catch (err) {
+            session.error = "Auth URL çözümlenemedi.";
+            cleanupRcloneAuthSession(sessionId);
+            if (!resolved) {
+              resolved = true;
+              resolve({ ok: false, error: session.error });
+            }
+          }
+        }
+      }
+
+      const token = parseRcloneTokenFromText(outputBuffer);
+      if (token && !session.done) {
+        session.done = true;
+        session.token = token;
+        const settings = loadRcloneSettings();
+        const result = writeRcloneConfig({
+          remoteName: settings.remoteName || RCLONE_REMOTE_NAME,
+          token,
+          clientId: settings.clientId,
+          clientSecret: settings.clientSecret
+        });
+        if (!result.ok) {
+          session.error = result.error;
+        }
+        clearTimeout(timeout);
+        cleanupRcloneAuthSession(sessionId);
+      }
+    };
+
+    child.stdout.on("data", handleOutput);
+    child.stderr.on("data", handleOutput);
+    child.on("error", (err) => {
+      if (session.done) return;
+      session.error = err?.message || String(err);
+      clearTimeout(timeout);
+      cleanupRcloneAuthSession(sessionId);
+      if (!resolved) {
+        resolved = true;
+        resolve({ ok: false, error: session.error });
+      }
+    });
+  });
+}
+
 function isPng(buffer) {
   return (
     buffer &&
@@ -776,7 +1274,7 @@ function normalizeYoutubeWatchUrl(value) {
   }
 }
 
-function startYoutubeDownload(url) {
+function startYoutubeDownload(url, { moveToGdrive = false } = {}) {
   const normalized = normalizeYoutubeWatchUrl(url);
   if (!normalized) return null;
   const ytSettings = loadYoutubeSettings();
@@ -796,6 +1294,9 @@ function startYoutubeDownload(url) {
     added: Date.now(),
     title: null,
     state: "downloading",
+    moveToGdrive: Boolean(moveToGdrive),
+    moveStatus: "idle",
+    moveError: null,
     progress: 0,
     downloaded: 0,
     totalBytes: 0,
@@ -1149,6 +1650,22 @@ async function finalizeYoutubeJob(job, exitCode) {
     scheduleSnapshotBroadcast();
     broadcastDiskSpace();
     console.log(`✅ YouTube indirmesi tamamlandı: ${job.title}`);
+
+    if (job.moveToGdrive) {
+      job.moveStatus = "moving";
+      job.moveError = null;
+      scheduleSnapshotBroadcast();
+      const moveResult = await moveRootFolderToGdrive(job.folderId);
+    if (moveResult.ok) {
+      job.moveStatus = "done";
+    } else {
+      job.moveStatus = "error";
+      job.moveError = moveResult.error || "GDrive taşıma hatası";
+      logRcloneMoveError(`youtube:${job.id}`, job.moveError);
+    }
+      broadcastFileUpdate("downloads");
+      scheduleSnapshotBroadcast();
+    }
   } catch (err) {
     job.state = "error";
     job.error = err?.message || "YouTube indirimi tamamlanamadı";
@@ -1298,7 +1815,10 @@ function mailruSnapshot(job) {
     files,
     selectedIndex: job.selectedIndex || 0,
     thumbnail: job.thumbnail || null,
-    status: job.state
+    status: job.state,
+    moveToGdrive: job.moveToGdrive || false,
+    moveStatus: job.moveStatus || "idle",
+    moveError: job.moveError || null
   };
 }
 
@@ -1413,7 +1933,7 @@ function attachMailRuThumbnail(job, filePath, relPath) {
   }, 1000);
 }
 
-function finalizeMailRuJob(job, exitCode) {
+async function finalizeMailRuJob(job, exitCode) {
   job.downloadSpeed = 0;
   stopMailRuProgressPolling(job);
   if (exitCode !== 0) {
@@ -1471,6 +1991,22 @@ function finalizeMailRuJob(job, exitCode) {
     scheduleSnapshotBroadcast();
     broadcastDiskSpace();
     console.log(`✅ Mail.ru indirmesi tamamlandı: ${job.title}`);
+
+    if (job.moveToGdrive) {
+      job.moveStatus = "moving";
+      job.moveError = null;
+      scheduleSnapshotBroadcast();
+      const moveResult = await movePathToGdrive(relPath);
+      if (moveResult.ok) {
+        job.moveStatus = "done";
+      } else {
+        job.moveStatus = "error";
+        job.moveError = moveResult.error || "GDrive taşıma hatası";
+        logRcloneMoveError(`mailru:${job.id}`, job.moveError);
+      }
+      broadcastFileUpdate("downloads");
+      scheduleSnapshotBroadcast();
+    }
   } catch (err) {
     job.state = "error";
     job.error = err?.message || "Mail.ru indirimi tamamlanamadı";
@@ -1526,7 +2062,9 @@ function launchMailRuJob(job) {
   child.stdout.on("data", handleChunk);
   child.stderr.on("data", handleChunk);
 
-  child.on("close", (code) => finalizeMailRuJob(job, code));
+  child.on("close", (code) => {
+    void finalizeMailRuJob(job, code);
+  });
   child.on("error", (err) => {
     job.state = "error";
     job.downloadSpeed = 0;
@@ -1542,7 +2080,7 @@ function launchMailRuJob(job) {
   });
 }
 
-async function startMailRuDownload(url) {
+async function startMailRuDownload(url, { moveToGdrive = false } = {}) {
   const normalized = normalizeMailRuUrl(url);
   if (!normalized) return null;
   const folderId = null;
@@ -1560,6 +2098,9 @@ async function startMailRuDownload(url) {
     added: Date.now(),
     title: null,
     fileName: null,
+    moveToGdrive: Boolean(moveToGdrive),
+    moveStatus: "idle",
+    moveError: null,
     state: "awaiting_match",
     progress: 0,
     downloaded: 0,
@@ -1846,7 +2387,10 @@ function youtubeSnapshot(job) {
     files,
     selectedIndex: job.selectedIndex || 0,
     thumbnail: job.thumbnail,
-    status: job.state
+    status: job.state,
+    moveToGdrive: job.moveToGdrive || false,
+    moveStatus: job.moveStatus || "idle",
+    moveError: job.moveError || null
   };
 }
 
@@ -2650,12 +3194,15 @@ function resolveMovieVideoAbsPath(metadata) {
   if (!videoPath) return null;
   videoPath = String(videoPath).replace(/\\/g, "/").replace(/^\/+/, "");
   const hasRoot = rootFolder && videoPath.startsWith(`${rootFolder}/`);
-  const absPath = hasRoot
+  let absPath = hasRoot
     ? path.join(DOWNLOAD_DIR, videoPath)
     : rootFolder
     ? path.join(DOWNLOAD_DIR, rootFolder, videoPath)
     : path.join(DOWNLOAD_DIR, videoPath);
-  return fs.existsSync(absPath) ? absPath : null;
+  if (fs.existsSync(absPath)) return absPath;
+  const rel = path.relative(DOWNLOAD_DIR, absPath);
+  const alt = path.join(GDRIVE_ROOT, rel);
+  return fs.existsSync(alt) ? alt : null;
 }
 
 function resolveEpisodeAbsPath(rootFolder, episode) {
@@ -2689,6 +3236,9 @@ function resolveEpisodeAbsPath(rootFolder, episode) {
 
   for (const absPath of candidates) {
     if (fs.existsSync(absPath)) return absPath;
+    const rel = path.relative(DOWNLOAD_DIR, absPath);
+    const alt = path.join(GDRIVE_ROOT, rel);
+    if (fs.existsSync(alt)) return alt;
   }
   return null;
 }
@@ -2720,7 +3270,9 @@ function rebuildWebdavIndex() {
 
   const shouldSkip = (relPath) => {
     if (!relPath) return true;
-    const normalized = relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+    const normalized = String(relPath)
+      .replace(/\\/g, "/")
+      .replace(/^\/+/, "");
     const segments = normalized.split("/").filter(Boolean);
     if (!segments.length) return true;
     return segments.some((seg) => seg.startsWith("yt_"));
@@ -2760,7 +3312,7 @@ function rebuildWebdavIndex() {
       }
       const absVideo = resolveMovieVideoAbsPath(metadata);
       if (!absVideo) continue;
-      if (shouldSkip(absVideo.replace(DOWNLOAD_DIR, ""))) continue;
+      if (shouldSkip(absVideo)) continue;
       const title =
         metadata?.title ||
         metadata?.matched_title ||
@@ -2836,7 +3388,7 @@ function rebuildWebdavIndex() {
             const episode = season.episodes[episodeKey];
             const absVideo = resolveEpisodeAbsPath(rootFolder, episode);
             if (!absVideo) continue;
-            if (shouldSkip(absVideo.replace(DOWNLOAD_DIR, ""))) continue;
+            if (shouldSkip(absVideo)) continue;
             const ext = path.extname(absVideo);
             if (!isVideoExt(ext)) continue;
             if (createdEpisodeCount === 0) {
@@ -2876,12 +3428,12 @@ function rebuildWebdavIndex() {
 
   const buildSeriesFromInfoJson = (categoryLabel, usedShowNames, coveredRoots) => {
     try {
-      const roots = fs.readdirSync(DOWNLOAD_DIR, { withFileTypes: true });
+      const roots = listStorageRootFolders();
       for (const dirent of roots) {
-        if (!dirent.isDirectory()) continue;
-        const rootFolder = dirent.name;
+        const rootFolder = dirent.rootFolder || dirent.name;
         if (coveredRoots?.has(rootFolder)) continue;
-        const infoPath = path.join(DOWNLOAD_DIR, rootFolder, "info.json");
+        const baseDir = dirent.baseDir || DOWNLOAD_DIR;
+        const infoPath = path.join(baseDir, rootFolder, "info.json");
         if (!fs.existsSync(infoPath)) continue;
         let info = null;
         try {
@@ -2896,7 +3448,7 @@ function rebuildWebdavIndex() {
         for (const [relPath, episode] of Object.entries(episodes)) {
           if (!episode) continue;
           if (shouldSkip(relPath)) continue;
-          const absVideo = path.join(DOWNLOAD_DIR, rootFolder, relPath);
+          const absVideo = path.join(baseDir, rootFolder, relPath);
           if (!fs.existsSync(absVideo)) continue;
           const ext = path.extname(absVideo).toLowerCase();
           if (!isVideoExt(ext)) continue;
@@ -5916,7 +6468,10 @@ function snapshot() {
         paused: paused || false, // Pause durumunu ekle
         files: entry?.filesSnapshot || [],
         selectedIndex,
-        thumbnail: entry?.thumbnail || null
+        thumbnail: entry?.thumbnail || null,
+        moveToGdrive: entry?.moveToGdrive || false,
+        moveStatus: entry?.moveStatus || "idle",
+        moveError: entry?.moveError || null
       };
     }
   );
@@ -5934,7 +6489,10 @@ function snapshot() {
   return combined;
 }
 
-function wireTorrent(torrent, { savePath, added, respond, restored = false }) {
+function wireTorrent(
+  torrent,
+  { savePath, added, respond, restored = false, moveToGdrive = false }
+) {
   torrents.set(torrent.infoHash, {
     torrent,
     selectedIndex: 0,
@@ -5946,7 +6504,10 @@ function wireTorrent(torrent, { savePath, added, respond, restored = false }) {
     thumbnailCheckedAt: 0,
     thumbnailQueued: false,
     bestVideoIndex: null,
-    rootFolder: savePath ? path.basename(savePath) : null
+    rootFolder: savePath ? path.basename(savePath) : null,
+    moveToGdrive: Boolean(moveToGdrive),
+    moveStatus: "idle",
+    moveError: null
   });
 
   const scheduleTorrentSnapshot = () => scheduleSnapshotBroadcast();
@@ -5981,7 +6542,10 @@ function onTorrentReady({ torrent, savePath, added, respond }) {
     thumbnailCheckedAt: existing.thumbnailCheckedAt || 0,
     thumbnailQueued: existing.thumbnailQueued || false,
     bestVideoIndex: selectedIndex,
-    rootFolder: savePath ? path.basename(savePath) : existing.rootFolder || null
+    rootFolder: savePath ? path.basename(savePath) : existing.rootFolder || null,
+    moveToGdrive: existing.moveToGdrive || false,
+    moveStatus: existing.moveStatus || "idle",
+    moveError: existing.moveError || null
   });
   const rootFolder = path.basename(savePath);
   upsertInfoFile(savePath, {
@@ -6255,6 +6819,21 @@ async function onTorrentDone({ torrent }) {
       infoUpdate.files[bestVideoPath].type || rootType;
   }
 
+  if (entry.moveToGdrive) {
+    entry.moveStatus = "moving";
+    entry.moveError = null;
+    scheduleSnapshotBroadcast();
+    const moveResult = await moveRootFolderToGdrive(rootFolder);
+    if (moveResult.ok) {
+      entry.moveStatus = "done";
+    } else {
+      entry.moveStatus = "error";
+      entry.moveError = moveResult.error || "GDrive taşıma hatası";
+      logRcloneMoveError(`torrent:${entry.infoHash}`, entry.moveError);
+    }
+    broadcastFileUpdate("downloads");
+  }
+
   scheduleSnapshotBroadcast();
 }
 
@@ -6295,6 +6874,12 @@ app.post("/api/transfer", requireAuth, upload.single("torrent"), (req, res) => {
     if (!source)
       return res.status(400).json({ error: "magnet veya .torrent gerekli" });
 
+    const rcloneSettings = loadRcloneSettings();
+    const moveToGdrive =
+      ["1", "true", "yes", "on"].includes(
+        String(req.body.moveToGdrive || "").toLowerCase()
+      ) || Boolean(rcloneSettings.autoMove);
+
     // Her torrent için ayrı klasör
     const savePath = path.join(DOWNLOAD_DIR, Date.now().toString());
     fs.mkdirSync(savePath, { recursive: true });
@@ -6307,13 +6892,41 @@ app.post("/api/transfer", requireAuth, upload.single("torrent"), (req, res) => {
     wireTorrent(torrent, {
       savePath,
       added,
-      respond: (payload) => res.json(payload)
+      respond: (payload) => res.json(payload),
+      moveToGdrive
     });
   } catch (err) {
     res.status(500).json({ error: err.message });
   }
 });
 
+// --- ☁️ Transfer için GDrive taşıma ayarı ---
+app.post("/api/transfer/:id/gdrive", requireAuth, (req, res) => {
+  const id = req.params.id;
+  const enabled = ["1", "true", "yes", "on"].includes(
+    String(req.body?.enabled || "").toLowerCase()
+  );
+  const torrentEntry = torrents.get(id);
+  if (torrentEntry) {
+    torrentEntry.moveToGdrive = enabled;
+    scheduleSnapshotBroadcast();
+    return res.json({ ok: true });
+  }
+  const ytJob = youtubeJobs.get(id);
+  if (ytJob) {
+    ytJob.moveToGdrive = enabled;
+    scheduleSnapshotBroadcast();
+    return res.json({ ok: true });
+  }
+  const mailJob = mailruJobs.get(id);
+  if (mailJob) {
+    mailJob.moveToGdrive = enabled;
+    scheduleSnapshotBroadcast();
+    return res.json({ ok: true });
+  }
+  return res.status(404).json({ ok: false, error: "Transfer bulunamadı" });
+});
+
 // --- Thumbnail endpoint ---
 app.get("/thumbnails/:path(*)", requireAuth, (req, res) => {
   const relThumb = req.params.path || "";
@@ -6643,12 +7256,20 @@ app.get("/media/:path(*)", requireAuth, (req, res) => {
     return res.status(400).send("Invalid path");
   }
 
-  const fullPath = path.join(DOWNLOAD_DIR, safeRel);
+  const fullPath = resolveStoragePath(safeRel);
 
-  if (!fs.existsSync(fullPath)) {
+  if (!fullPath || !fs.existsSync(fullPath)) {
     console.error("File not found:", fullPath);
     return res.status(404).send("File not found");
   }
+  if (MEDIA_DEBUG_LOG) {
+    const source = fullPath.startsWith(GDRIVE_ROOT)
+      ? "gdrive"
+      : fullPath.startsWith(DOWNLOAD_DIR)
+      ? "local"
+      : "unknown";
+    console.log("🎬 Media stream source:", { rel: safeRel, fullPath, source });
+  }
 
   const stat = fs.statSync(fullPath);
   const fileSize = stat.size;
@@ -7058,13 +7679,18 @@ app.get("/api/files", requireAuth, (req, res) => {
   };
 
   // --- 📁 Klasörleri dolaş ---
-  const walk = (dir) => {
-    let result = [];
+  const results = new Map();
+  const addResult = (entry, key) => {
+    if (results.has(key)) return;
+    results.set(key, entry);
+  };
+
+  const walk = (baseDir, dir) => {
     const list = fs.readdirSync(dir, { withFileTypes: true });
 
     for (const entry of list) {
       const full = path.join(dir, entry.name);
-      const rel = path.relative(DOWNLOAD_DIR, full);
+      const rel = path.relative(baseDir, full);
 
       // 🔥 Ignore kontrolü (hem dosya hem klasör için)
       if (isIgnored(entry.name) || isIgnored(rel)) continue;
@@ -7092,7 +7718,7 @@ app.get("/api/files", requireAuth, (req, res) => {
             ? torrentName
             : baseName;
 
-        result.push({
+        const record = {
           name: safeRel,
           displayName,
           size: 0,
@@ -7112,9 +7738,10 @@ app.get("/api/files", requireAuth, (req, res) => {
           movieMatch: null,
           seriesEpisode: null,
           thumbnail: null,
-        });
+        };
+        addResult(record, `d:${safeRel}`);
 
-        result = result.concat(walk(full));
+        walk(baseDir, full);
       } else {
         if (entry.name.toLowerCase() === INFO_FILENAME) continue;
 
@@ -7176,7 +7803,7 @@ app.get("/api/files", requireAuth, (req, res) => {
           !!info.primaryVideoPath && info.primaryVideoPath === relWithinRoot;
         const displayName = entry.name;
 
-        result.push({
+        const record = {
           name: safeRel,
           displayName,
           size,
@@ -7196,16 +7823,20 @@ app.get("/api/files", requireAuth, (req, res) => {
           primaryMediaInfo: info.primaryMediaInfo || null,
           movieMatch: isPrimaryVideo ? info.movieMatch || null : null,
           seriesEpisode: seriesEpisodeInfo
-        });
+        };
+        addResult(record, `f:${safeRel}`);
       }
     }
 
-    return result;
+    return null;
   };
 
   try {
-    const files = walk(DOWNLOAD_DIR);
-    res.json(files);
+    for (const base of getStorageRoots()) {
+      if (!fs.existsSync(base)) continue;
+      walk(base, base);
+    }
+    res.json(Array.from(results.values()));
   } catch (err) {
     console.error("📁 Files API error:", err);
     res.status(500).json({ error: err.message });
@@ -7739,16 +8370,15 @@ async function rebuildMovieMetadata({ clearCache = false, resetSeriesData = fals
 
   fs.mkdirSync(MOVIE_DATA_ROOT, { recursive: true });
 
-  const dirEntries = fs
-    .readdirSync(DOWNLOAD_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory());
+  const dirEntries = listStorageRootFolders();
 
   const processed = [];
 
   for (const dirent of dirEntries) {
-    const folder = sanitizeRelative(dirent.name);
+    const folder = sanitizeRelative(dirent.rootFolder || dirent.name);
     if (!folder) continue;
-    const rootDir = path.join(DOWNLOAD_DIR, folder);
+    const baseDir = dirent.baseDir || DOWNLOAD_DIR;
+    const rootDir = path.join(baseDir, folder);
     if (!fs.existsSync(rootDir)) continue;
 
     try {
@@ -7945,7 +8575,12 @@ app.post("/api/movies/rescan", requireAuth, async (req, res) => {
 app.post("/api/youtube/download", requireAuth, async (req, res) => {
   try {
     const rawUrl = req.body?.url;
-    const job = startYoutubeDownload(rawUrl);
+    const rcloneSettings = loadRcloneSettings();
+    const moveToGdrive =
+      ["1", "true", "yes", "on"].includes(
+        String(req.body?.moveToGdrive || "").toLowerCase()
+      ) || Boolean(rcloneSettings.autoMove);
+    const job = startYoutubeDownload(rawUrl, { moveToGdrive });
     if (!job) {
       return res
         .status(400)
@@ -7963,7 +8598,12 @@ app.post("/api/youtube/download", requireAuth, async (req, res) => {
 app.post("/api/mailru/download", requireAuth, async (req, res) => {
   try {
     const rawUrl = req.body?.url;
-    const job = await startMailRuDownload(rawUrl);
+    const rcloneSettings = loadRcloneSettings();
+    const moveToGdrive =
+      ["1", "true", "yes", "on"].includes(
+        String(req.body?.moveToGdrive || "").toLowerCase()
+      ) || Boolean(rcloneSettings.autoMove);
+    const job = await startMailRuDownload(rawUrl, { moveToGdrive });
     if (!job) {
       return res
         .status(400)
@@ -8117,6 +8757,175 @@ app.post("/api/youtube/settings", requireAuth, (req, res) => {
   }
 });
 
+// --- ☁️ Rclone ayarları ---
+app.get("/api/rclone/status", requireAuth, async (req, res) => {
+  const settings = loadRcloneSettings();
+  const mounted = isRcloneMounted(settings.mountDir);
+  res.json({
+    enabled: RCLONE_ENABLED,
+    mounted,
+    running: Boolean(rcloneProcess),
+    mountDir: settings.mountDir,
+    remoteName: settings.remoteName,
+    remotePath: settings.remotePath,
+    configPath: settings.configPath,
+    autoMove: settings.autoMove,
+    autoMount: settings.autoMount,
+    configExists: fs.existsSync(settings.configPath),
+    remoteConfigured: rcloneConfigHasRemote(settings.remoteName),
+    lastError: rcloneLastError || null
+  });
+});
+
+app.post("/api/rclone/settings", requireAuth, (req, res) => {
+  try {
+    const { autoMove, autoMount, remoteName, remotePath, mountDir } = req.body || {};
+    const next = saveRcloneSettings({
+      autoMove: Boolean(autoMove),
+      autoMount: Boolean(autoMount),
+      remoteName: remoteName || RCLONE_REMOTE_NAME,
+      remotePath: remotePath || RCLONE_REMOTE_PATH,
+      mountDir: mountDir || RCLONE_MOUNT_DIR,
+      configPath: RCLONE_CONFIG_PATH
+    });
+    res.json({ ok: true, settings: next });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err?.message || String(err) });
+  }
+});
+
+app.get("/api/rclone/auth-url", requireAuth, async (req, res) => {
+  const host = req.get("host") || "localhost";
+  const protocol = req.protocol || (req.secure ? "https" : "http");
+  const baseOrigin = `${protocol}://${host}`;
+  const result = await getRcloneAuthUrl(baseOrigin);
+  if (!result.ok) {
+    return res.status(400).json({ ok: false, error: result.error });
+  }
+  return res.json({ ok: true, url: result.url, sessionId: result.sessionId });
+});
+
+app.get("/api/rclone/auth/status/:session", requireAuth, (req, res) => {
+  const session = rcloneAuthSessions.get(req.params.session);
+  if (!session) {
+    return res.status(404).json({ ok: false, error: "Session bulunamadı." });
+  }
+  return res.json({
+    ok: true,
+    done: session.done,
+    error: session.error || null
+  });
+});
+
+app.all("/api/rclone/auth/forward/:session/*", async (req, res) => {
+  const session = rcloneAuthSessions.get(req.params.session);
+  if (!session || !session.port) {
+    return res.status(404).send("Auth session bulunamadı.");
+  }
+  const queryString = req.url.includes("?") ? req.url.split("?")[1] : "";
+  const extraPath = req.params[0] ? `/${req.params[0]}` : "";
+  const pathPart = extraPath || session.authPath || "/auth";
+  const targetUrl = `http://127.0.0.1:${session.port}${pathPart}${
+    queryString ? `?${queryString}` : ""
+  }`;
+  try {
+    const method = req.method || "GET";
+    const headers = { ...req.headers };
+    delete headers.host;
+    let body;
+    if (!["GET", "HEAD"].includes(method)) {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      body = Buffer.concat(chunks);
+    }
+    const resp = await fetch(targetUrl, {
+      method,
+      headers,
+      body
+    });
+    const respBody = await resp.text();
+    res.status(resp.status);
+    res.setHeader(
+      "Content-Type",
+      resp.headers.get("content-type") || "text/html"
+    );
+    return res.send(respBody);
+  } catch (err) {
+    return res.status(500).send("Auth proxy hatası.");
+  }
+});
+
+app.get("/api/rclone/auth/callback/:session", async (req, res) => {
+  const session = rcloneAuthSessions.get(req.params.session);
+  if (!session || !session.port) {
+    return res.status(404).send("Auth session bulunamadı.");
+  }
+  const targetUrl = `http://127.0.0.1:${session.port}/?${new URLSearchParams(
+    req.query
+  ).toString()}`;
+  try {
+    const resp = await fetch(targetUrl);
+    const body = await resp.text();
+    res.status(resp.status);
+    res.setHeader(
+      "Content-Type",
+      resp.headers.get("content-type") || "text/html"
+    );
+    return res.send(body);
+  } catch (err) {
+    return res.status(500).send("Auth proxy hatası.");
+  }
+});
+
+app.post("/api/rclone/token", requireAuth, (req, res) => {
+  try {
+    const { token, clientId, clientSecret, remoteName } = req.body || {};
+    const name = remoteName || loadRcloneSettings().remoteName || RCLONE_REMOTE_NAME;
+    const result = writeRcloneConfig({
+      remoteName: name,
+      token,
+      clientId,
+      clientSecret
+    });
+    if (!result.ok) {
+      return res.status(400).json({ ok: false, error: result.error });
+    }
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err?.message || String(err) });
+  }
+});
+
+app.post("/api/rclone/mount", requireAuth, (req, res) => {
+  const settings = loadRcloneSettings();
+  const result = startRcloneMount(settings);
+  if (!result.ok) {
+    return res.status(400).json({ ok: false, error: result.error });
+  }
+  return res.json({ ok: true, ...result });
+});
+
+app.post("/api/rclone/unmount", requireAuth, (req, res) => {
+  const result = stopRcloneMount();
+  if (!result.ok) {
+    return res.status(400).json({ ok: false, error: result.error });
+  }
+  return res.json({ ok: true, ...result });
+});
+
+app.post("/api/rclone/move", requireAuth, async (req, res) => {
+  const { path: relPath } = req.body || {};
+  if (!relPath) {
+    return res.status(400).json({ ok: false, error: "path gerekli" });
+  }
+  const result = await movePathToGdrive(relPath);
+  if (!result.ok) {
+    return res.status(400).json({ ok: false, error: result.error });
+  }
+  broadcastFileUpdate("downloads");
+  return res.json({ ok: true, ...result });
+});
+
 // --- 🎫 YouTube cookies yönetimi ---
 app.get("/api/youtube/cookies", requireAuth, (req, res) => {
   try {
@@ -8220,9 +9029,9 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
         if (!VIDEO_EXTS.includes(ext)) continue;
 
         const absVideo = normalizedRel
-          ? path.join(DOWNLOAD_DIR, rootFolder, normalizedRel)
+          ? resolveStoragePath(`${rootFolder}/${normalizedRel}`)
           : null;
-        if (!absVideo || !fs.existsSync(absVideo)) continue;
+        if (!absVideo) continue;
 
         infoEpisodeIndex.set(`${seasonNumber}-${episodeNumber}`, {
           relPath: normalizedRel,
@@ -8324,12 +9133,10 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
           if (!rawEpisode || typeof rawEpisode !== "object") continue;
           const relativeFile = (rawEpisode.file || "").replace(/\\/g, "/");
           if (relativeFile) {
-            const absEpisodePath = path.join(
-              DOWNLOAD_DIR,
-              rootFolder,
-              relativeFile
-            );
-            if (!fs.existsSync(absEpisodePath)) {
+          const absEpisodePath = resolveStoragePath(
+            `${rootFolder}/${relativeFile}`
+          );
+            if (!absEpisodePath) {
               delete rawEpisodes[episodeKey];
               dataChanged = true;
             }
@@ -8438,20 +9245,20 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
           if (normalizedEpisode.videoPath && !/^https?:\/\//i.test(normalizedEpisode.videoPath)) {
             const ext = path.extname(normalizedEpisode.videoPath).toLowerCase();
             if (!VIDEO_EXTS.includes(ext)) {
-              const absVideo = path.join(DOWNLOAD_DIR, normalizedEpisode.videoPath);
+              const absVideo = resolveStoragePath(normalizedEpisode.videoPath);
               if (
-                !fs.existsSync(absVideo) ||
-                !VIDEO_EXTS.includes(path.extname(absVideo).toLowerCase())
+                !absVideo ||
+                !VIDEO_EXTS.includes(path.extname(absVideo || "").toLowerCase())
               ) {
                 normalizedEpisode.videoPath = null;
               }
             }
             if (normalizedEpisode.videoPath) {
-              const absVideo = path.join(DOWNLOAD_DIR, normalizedEpisode.videoPath);
-              if (!fs.existsSync(absVideo)) {
+              const absVideo = resolveStoragePath(normalizedEpisode.videoPath);
+              if (!absVideo) {
                 normalizedEpisode.videoPath = null;
               }
-              if (fs.existsSync(absVideo)) {
+              if (absVideo) {
                 const stats = fs.statSync(absVideo);
                 normalizedEpisode.fileSize = Number(stats.size);
               }
@@ -8498,8 +9305,8 @@ app.get("/api/tvshows", requireAuth, (req, res) => {
                 if (/^https?:\/\//i.test(episode.videoPath)) return true;
                 const ext = path.extname(episode.videoPath).toLowerCase();
                 if (!VIDEO_EXTS.includes(ext)) return false;
-                const absVideo = path.join(DOWNLOAD_DIR, episode.videoPath);
-                return fs.existsSync(absVideo);
+                const absVideo = resolveStoragePath(episode.videoPath);
+                return !!absVideo;
               })
               .sort((a, b) => a.episodeNumber - b.episodeNumber);
             return {
@@ -8650,9 +9457,9 @@ function buildAnimeShows() {
         if (!rawEpisode || typeof rawEpisode !== "object") continue;
         const relativeFile = (rawEpisode.file || "").replace(/\\/g, "/");
         if (!relativeFile) continue;
-        const absEpisodePath = path.join(DOWNLOAD_DIR, relativeFile);
-        const controlPath = `${absEpisodePath}.aria2`;
-        const isComplete = fs.existsSync(absEpisodePath) && !fs.existsSync(controlPath);
+        const absEpisodePath = resolveStoragePath(relativeFile);
+        const controlPath = absEpisodePath ? `${absEpisodePath}.aria2` : null;
+        const isComplete = !!absEpisodePath && !fs.existsSync(controlPath);
         if (!isComplete) {
           delete rawEpisodes[episodeKey];
           dataChanged = true;
@@ -8703,9 +9510,9 @@ function buildAnimeShows() {
 
         const relativeFile = (normalizedEpisode.file || "").replace(/\\/g, "/");
         if (relativeFile) {
-          const absVideo = path.join(DOWNLOAD_DIR, relativeFile);
+          const absVideo = resolveStoragePath(relativeFile);
           const ext = path.extname(relativeFile).toLowerCase();
-          if (fs.existsSync(absVideo) && VIDEO_EXTS.includes(ext)) {
+          if (absVideo && VIDEO_EXTS.includes(ext)) {
             normalizedEpisode.videoPath = relativeFile;
             const stats = fs.statSync(absVideo);
             normalizedEpisode.fileSize = Number(stats.size);
@@ -8748,8 +9555,8 @@ function buildAnimeShows() {
               if (!episode?.videoPath) return false;
               const ext = path.extname(episode.videoPath).toLowerCase();
               if (!VIDEO_EXTS.includes(ext)) return false;
-              const absVideo = path.join(DOWNLOAD_DIR, episode.videoPath);
-              if (!fs.existsSync(absVideo)) return false;
+              const absVideo = resolveStoragePath(episode.videoPath);
+              if (!absVideo) return false;
               const controlPath = `${absVideo}.aria2`;
               return !fs.existsSync(controlPath);
             })
@@ -8809,32 +9616,35 @@ async function rebuildAnimeMetadata({ clearCache = false } = {}) {
   }
 
   let processed = 0;
-  let rootEntries = [];
-  try {
-    rootEntries = fs.readdirSync(DOWNLOAD_DIR, { withFileTypes: true });
-  } catch (err) {
-    console.warn(`⚠️ downloads kökü okunamadı: ${err.message}`);
-  }
+  for (const baseDir of getStorageRoots()) {
+    let rootEntries = [];
+    try {
+      rootEntries = fs.readdirSync(baseDir, { withFileTypes: true });
+    } catch (err) {
+      console.warn(`⚠️ root dizini okunamadı (${baseDir}): ${err.message}`);
+      continue;
+    }
 
-  for (const dirent of rootEntries) {
-    if (!dirent.isFile()) continue;
-    const safeName = sanitizeRelative(dirent.name);
-    if (!safeName || safeName.startsWith(".")) continue;
-    if (safeName.endsWith(".aria2")) continue;
-    const absPath = path.join(DOWNLOAD_DIR, safeName);
-    if (!fs.existsSync(absPath)) continue;
-    const mimeType = mime.lookup(absPath) || "";
-    if (!String(mimeType).startsWith("video/")) continue;
-    const seriesInfo = parseAnimeSeriesInfo(safeName);
-    if (!seriesInfo) continue;
-    const mediaInfo = await extractMediaInfo(absPath).catch(() => null);
-    await ensureSeriesData(
-      ANIME_ROOT_FOLDER,
-      safeName,
-      seriesInfo,
-      mediaInfo
-    );
-    processed += 1;
+    for (const dirent of rootEntries) {
+      if (!dirent.isFile()) continue;
+      const safeName = sanitizeRelative(dirent.name);
+      if (!safeName || safeName.startsWith(".")) continue;
+      if (safeName.endsWith(".aria2")) continue;
+      const absPath = path.join(baseDir, safeName);
+      if (!fs.existsSync(absPath)) continue;
+      const mimeType = mime.lookup(absPath) || "";
+      if (!String(mimeType).startsWith("video/")) continue;
+      const seriesInfo = parseAnimeSeriesInfo(safeName);
+      if (!seriesInfo) continue;
+      const mediaInfo = await extractMediaInfo(absPath).catch(() => null);
+      await ensureSeriesData(
+        ANIME_ROOT_FOLDER,
+        safeName,
+        seriesInfo,
+        mediaInfo
+      );
+      processed += 1;
+    }
   }
 
   const shows = buildAnimeShows();
@@ -8842,8 +9652,8 @@ async function rebuildAnimeMetadata({ clearCache = false } = {}) {
     for (const season of show.seasons || []) {
       for (const episode of season.episodes || []) {
         if (!episode?.videoPath) continue;
-        const absVideo = path.join(DOWNLOAD_DIR, episode.videoPath);
-        if (!fs.existsSync(absVideo)) continue;
+        const absVideo = resolveStoragePath(episode.videoPath);
+        if (!absVideo) continue;
         const seriesInfo = {
           title: show.title,
           searchTitle: show.title,
@@ -8904,12 +9714,10 @@ app.post("/api/anime/rescan", requireAuth, async (req, res) => {
 
 function collectMusicEntries() {
   const entries = [];
-  const dirEntries = fs
-    .readdirSync(DOWNLOAD_DIR, { withFileTypes: true })
-    .filter((dirent) => dirent.isDirectory());
+  const dirEntries = listStorageRootFolders();
 
   for (const dirent of dirEntries) {
-    const folder = sanitizeRelative(dirent.name);
+    const folder = sanitizeRelative(dirent.rootFolder || dirent.name);
     if (!folder) continue;
     // Klasörün tamamı çöpe taşınmışsa atla
     if (isPathTrashed(folder, "", true)) continue;
@@ -8932,6 +9740,8 @@ function collectMusicEntries() {
     if (isPathTrashed(folder, targetPath, false)) continue;
     const mediaType = fileMeta?.type || info.type || null;
     if (mediaType !== "music") continue;
+    const absMusic = resolveStoragePath(`${folder}/${targetPath}`);
+    if (!absMusic) continue;
 
     const metadataPath = path.join(YT_DATA_ROOT, folder, "metadata.json");
     let metadata = null;
@@ -9014,16 +9824,15 @@ async function rebuildTvMetadata({ clearCache = false } = {}) {
     tvdbEpisodeDetailCache.clear();
   }
 
-  const dirEntries = fs
-    .readdirSync(DOWNLOAD_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory());
+  const dirEntries = listStorageRootFolders();
 
   const processed = [];
 
   for (const dirent of dirEntries) {
-    const folder = sanitizeRelative(dirent.name);
+    const folder = sanitizeRelative(dirent.rootFolder || dirent.name);
     if (!folder) continue;
-    const rootDir = path.join(DOWNLOAD_DIR, folder);
+    const baseDir = dirent.baseDir || DOWNLOAD_DIR;
+    const rootDir = path.join(baseDir, folder);
     if (!fs.existsSync(rootDir)) continue;
 
     try {
@@ -9363,6 +10172,15 @@ if (WEBDAV_ENABLED) {
   console.log(`📁 WebDAV aktif: ${webdavBasePath}`);
 }
 
+// --- ☁️ Rclone auto mount ---
+const initialRcloneSettings = loadRcloneSettings();
+if (RCLONE_ENABLED && initialRcloneSettings.autoMount) {
+  const result = startRcloneMount(initialRcloneSettings);
+  if (!result.ok) {
+    console.warn(`⚠️ Rclone mount başlatılamadı: ${result.error}`);
+  }
+}
+
 // --- ✅ Client build (frontend) dosyalarını sun ---
 const publicDir = path.join(__dirname, "public");
 if (fs.existsSync(publicDir)) {