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)) {