Spaces:
Sleeping
Sleeping
| import { uploadFile, downloadFile, listFiles, createRepo, deleteFile } from "@huggingface/hub"; | |
| import { doc, getDoc, setDoc } from "firebase/firestore"; | |
| import { db } from "./firebase-config.js"; | |
| import fs from "fs"; | |
| import path from "path"; | |
| import AdmZip from "adm-zip"; | |
| // ─── Config ─────────────────────────────────────────────────────────────────── | |
| const HF_OWNER = process.env.SPACE_AUTHOR_NAME || "techedstudios"; | |
| const MAX_BACKUPS = 5; // Keep last 5 backups (unlimited space on HF!) | |
| function getHFToken() { | |
| return process.env.HF_TOKEN; | |
| } | |
| function getRepoId(serverId) { | |
| const sanitizedId = serverId | |
| .replace(/\./g, '-') | |
| .replace(/[^a-zA-Z0-9-_\.]/g, '-') | |
| .replace(/-+/g, '-') | |
| .replace(/^-+|-+$/g, ''); | |
| return `${HF_OWNER}/mc-server-data-${sanitizedId}`.toLowerCase(); | |
| } | |
| // ─── Ensure HF Dataset exists ───────────────────────────────────────────────── | |
| async function ensureDataset(serverId, onLog) { | |
| const repoId = getRepoId(serverId); | |
| const token = getHFToken(); | |
| try { | |
| await createRepo({ | |
| repo: { type: "dataset", name: repoId }, | |
| accessToken: token, | |
| private: false, | |
| }); | |
| onLog(serverId, `[HF] Created public dataset: ${repoId}`); | |
| } catch (e) { | |
| // 409 = already exists, that's fine | |
| if (!e.message?.includes("409") && !e.message?.includes("already")) { | |
| onLog(serverId, `[HF] Dataset already exists or note: ${e.message}`); | |
| } | |
| } | |
| return repoId; | |
| } | |
| // ─── Compress directory to Buffer (skips heavy/temp files) ─────────────────── | |
| function compressDirectoryToBuffer(sourceDir, skipExtra = []) { | |
| const zip = new AdmZip(); | |
| const skipNames = new Set(["playit", "playit.exe", "downloads", ".git", "tmp", "node_modules", "logs", "cache", "libraries", ".paper-remapped", "versions", ...skipExtra]); | |
| function addDir(dirPath, zipPath) { | |
| const entries = fs.readdirSync(dirPath); | |
| for (const entry of entries) { | |
| if (skipNames.has(entry)) continue; | |
| const fullPath = path.join(dirPath, entry); | |
| const stat = fs.statSync(fullPath); | |
| if (stat.isDirectory()) { | |
| addDir(fullPath, path.join(zipPath, entry)); | |
| } else { | |
| if (stat.size > 200 * 1024 * 1024) continue; | |
| const content = fs.readFileSync(fullPath); | |
| zip.addFile(path.join(zipPath, entry).replace(/\\/g, "/"), content); | |
| } | |
| } | |
| } | |
| addDir(sourceDir, ""); | |
| return zip.toBuffer(); | |
| } | |
| // ─── Compress only the plugins folder to Buffer ─────────────────────────────── | |
| function compressPluginsFolderToBuffer(serverPath) { | |
| const zip = new AdmZip(); | |
| const pluginsDir = path.join(serverPath, 'plugins'); | |
| const modsDir = path.join(serverPath, 'mods'); | |
| function addDir(dirPath, zipPrefix) { | |
| if (!fs.existsSync(dirPath)) return; | |
| const entries = fs.readdirSync(dirPath); | |
| for (const entry of entries) { | |
| const fullPath = path.join(dirPath, entry); | |
| try { | |
| const stat = fs.statSync(fullPath); | |
| if (stat.isDirectory()) { | |
| addDir(fullPath, `${zipPrefix}/${entry}`); | |
| } else { | |
| if (stat.size > 150 * 1024 * 1024) continue; // skip files >150MB | |
| const content = fs.readFileSync(fullPath); | |
| zip.addFile(`${zipPrefix}/${entry}`, content); | |
| } | |
| } catch(e) {} | |
| } | |
| } | |
| addDir(pluginsDir, 'plugins'); | |
| addDir(modsDir, 'mods'); | |
| return zip.toBuffer(); | |
| } | |
| // ─── Decompress Buffer to directory (overwrite=true) ───────────────────────── | |
| function decompressBufferToDir(buffer, targetDir) { | |
| if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true }); | |
| const zip = new AdmZip(buffer); | |
| zip.extractAllTo(targetDir, true); | |
| } | |
| // ─── Upload a Buffer to HF Dataset as a file ────────────────────────────────── | |
| async function uploadBufferToHF(repoId, token, hfPath, buffer, commitMessage) { | |
| const blob = new Blob([buffer]); | |
| await uploadFile({ | |
| repo: { type: "dataset", name: repoId }, | |
| accessToken: token, | |
| file: { | |
| path: hfPath, | |
| content: blob, | |
| }, | |
| commitTitle: commitMessage, | |
| }); | |
| } | |
| // ─── Download a file from HF Dataset as Buffer (Bypasses CDN Cache) ─────────── | |
| async function downloadBufferFromHF(repoId, token, hfPath) { | |
| // Use raw fetch to bypass CDN caching with a cache-busting query parameter | |
| const url = `https://huggingface.co/datasets/${repoId}/resolve/main/${hfPath}?t=${Date.now()}`; | |
| const response = await fetch(url, { | |
| headers: { Authorization: `Bearer ${token}` } | |
| }); | |
| if (!response.ok) throw new Error(`File not found or failed to fetch ${hfPath} in ${repoId}`); | |
| const arrayBuffer = await response.arrayBuffer(); | |
| return Buffer.from(arrayBuffer); | |
| } | |
| // ─── List backup timestamps from HF Dataset ─────────────────────────────────── | |
| async function listBackupTimestamps(repoId, token) { | |
| const timestamps = []; | |
| try { | |
| for await (const entry of listFiles({ | |
| repo: { type: "dataset", name: repoId }, | |
| path: "backups", | |
| accessToken: token, | |
| })) { | |
| // Each backup is stored as backups/{timestamp}.zip | |
| if (entry.type === "file" && entry.path.endsWith(".zip")) { | |
| const name = path.basename(entry.path, ".zip"); | |
| const ts = parseInt(name); | |
| if (!isNaN(ts)) timestamps.push(ts); | |
| } | |
| } | |
| } catch (e) { | |
| // backups/ folder may not exist yet | |
| } | |
| return timestamps | |
| .filter(ts => ts < Date.now() + 86400000) // Ignore impossible future dates (e.g. 2286 bug) | |
| .sort((a, b) => a - b); // ascending (oldest first) | |
| } | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| // PUBLIC: Backup server to HuggingFace Dataset | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| export async function backupServer(serverId, serverPath, onLog, serverData) { | |
| if (!fs.existsSync(serverPath) || fs.readdirSync(serverPath).length === 0) { | |
| onLog(serverId, `[BACKUP] Server path empty or missing. Skipping backup.`); | |
| return false; | |
| } | |
| try { | |
| const token = getHFToken(); | |
| const repoId = await ensureDataset(serverId, onLog); | |
| onLog(serverId, `[BACKUP] Compressing server files...`); | |
| const zipBuffer = compressDirectoryToBuffer(serverPath); | |
| const sizeMB = (zipBuffer.length / (1024 * 1024)).toFixed(2); | |
| onLog(serverId, `[BACKUP] Compression complete. Size: ${sizeMB} MB`); | |
| const timestamp = Date.now(); | |
| const hfPath = `backups/${timestamp}.zip`; | |
| onLog(serverId, `[BACKUP] Uploading to HuggingFace Dataset (${repoId})...`); | |
| await uploadBufferToHF(repoId, token, hfPath, zipBuffer, `Backup at ${new Date(timestamp).toISOString()}`); | |
| onLog(serverId, `[BACKUP] ✅ Upload complete → hf://datasets/${repoId}/${hfPath}`); | |
| // ── Always save a dedicated plugins-backup.zip (so plugins survive restores) ── | |
| try { | |
| const pluginsZip = compressPluginsFolderToBuffer(serverPath); | |
| await uploadBufferToHF(repoId, token, 'plugins-backup.zip', pluginsZip, `Plugin backup at ${new Date(timestamp).toISOString()}`); | |
| onLog(serverId, `[BACKUP] 🔌 Plugins backup saved separately (plugins-backup.zip).`); | |
| } catch(e) { | |
| onLog(serverId, `[BACKUP] Warning: Plugins backup failed: ${e.message}`); | |
| } | |
| // Upload metadata.json to the root of the dataset so autoRecoverServers can read it later | |
| if (serverData) { | |
| try { | |
| const metaBuffer = Buffer.from(JSON.stringify(serverData, null, 2), 'utf-8'); | |
| await uploadBufferToHF(repoId, token, 'metadata.json', metaBuffer, `Update server metadata`); | |
| onLog(serverId, `[BACKUP] Server metadata (RAM, version, etc) saved to Dataset.`); | |
| } catch (e) { | |
| onLog(serverId, `[BACKUP] Warning: Failed to save metadata.json to Dataset: ${e.message}`); | |
| } | |
| } | |
| // Sync backup metadata to Firestore (just timestamps, tiny text data) | |
| try { | |
| const metaRef = doc(db, `backupMeta/${serverId}`); | |
| const existing = (await getDoc(metaRef)).data() || {}; | |
| const allTimestamps = [...(existing.timestamps || []), timestamp].sort((a, b) => a - b); | |
| await setDoc(metaRef, { timestamps: allTimestamps, lastBackup: new Date(timestamp).toISOString() }); | |
| } catch (e) { | |
| onLog(serverId, `[BACKUP] Note: Firestore metadata sync failed: ${e.message}`); | |
| } | |
| // Prune old backups on HF (keep latest MAX_BACKUPS) | |
| try { | |
| const allTs = await listBackupTimestamps(repoId, token); | |
| if (allTs.length > MAX_BACKUPS) { | |
| const toDelete = allTs.slice(0, allTs.length - MAX_BACKUPS); | |
| for (const ts of toDelete) { | |
| onLog(serverId, `[BACKUP] Pruning old backup: ${ts}.zip`); | |
| await deleteFile({ | |
| repo: { type: "dataset", name: repoId }, | |
| path: `backups/${ts}.zip`, | |
| accessToken: token, | |
| commitTitle: `Prune old backup ${ts}`, | |
| }); | |
| } | |
| onLog(serverId, `[BACKUP] Pruned ${toDelete.length} old backup(s).`); | |
| } | |
| } catch (pruneErr) { | |
| onLog(serverId, `[BACKUP] Warning: Pruning failed: ${pruneErr.message}`); | |
| } | |
| return true; | |
| } catch (err) { | |
| onLog(serverId, `[BACKUP] ERROR: ${err.message}`); | |
| console.error(err); | |
| return false; | |
| } | |
| } | |
| // PUBLIC: Backup ONLY plugins to HF immediately (called after plugin install) | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| export async function backupPluginsOnly(serverId, serverPath, onLog) { | |
| try { | |
| const token = getHFToken(); | |
| const repoId = await ensureDataset(serverId, onLog); | |
| const pluginsZip = compressPluginsFolderToBuffer(serverPath); | |
| await uploadBufferToHF(repoId, token, 'plugins-backup.zip', pluginsZip, `Plugin install backup`); | |
| onLog(serverId, `[BACKUP] 🔌 Plugin saved to cloud (plugins-backup.zip updated).`); | |
| return true; | |
| } catch(e) { | |
| onLog(serverId, `[BACKUP] ⚠️ Plugin cloud save failed: ${e.message}`); | |
| return false; | |
| } | |
| } | |
| // PUBLIC: Backup ONLY configs (ops, whitelist) to HF immediately | |
| export async function backupConfigsOnly(serverId, serverPath, onLog) { | |
| try { | |
| const token = getHFToken(); | |
| const repoId = getRepoId(serverId); | |
| // Create an in-memory zip containing only config files | |
| const AdmZip = (await import('adm-zip')).default; | |
| const zip = new AdmZip(); | |
| let added = false; | |
| const configsToSave = ['ops.json', 'whitelist.json', 'banned-players.json', 'banned-ips.json', 'server.properties']; | |
| for (const file of configsToSave) { | |
| const p = path.join(serverPath, file); | |
| if (fs.existsSync(p)) { | |
| zip.addLocalFile(p); | |
| added = true; | |
| } | |
| } | |
| if (added) { | |
| const zipBuffer = zip.toBuffer(); | |
| await uploadBufferToHF(repoId, token, 'configs-backup.zip', zipBuffer, `Real-time configs auto-save`); | |
| onLog(serverId, `[BACKUP] 💾 Real-time config auto-save triggered (ops/whitelist saved to cloud).`); | |
| } | |
| } catch (e) { | |
| onLog(serverId, `[BACKUP] ⚠️ Config auto-save failed: ${e.message}`); | |
| } | |
| } | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| // PUBLIC: Restore server from HuggingFace Dataset | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| export async function restoreServer(serverId, serverPath, onLog) { | |
| try { | |
| const token = getHFToken(); | |
| const repoId = getRepoId(serverId); | |
| onLog(serverId, `[RESTORE] Checking Firestore & HuggingFace Dataset for backups...`); | |
| let allTs = []; | |
| try { | |
| const metaSnap = await getDoc(doc(db, 'backupMeta', serverId)); | |
| if (metaSnap.exists() && metaSnap.data().timestamps) { | |
| allTs = metaSnap.data().timestamps; | |
| } | |
| } catch(e) {} | |
| // Fallback to Hugging Face API if Firestore is empty | |
| if (allTs.length === 0) { | |
| allTs = await listBackupTimestamps(repoId, token); | |
| } else { | |
| allTs = allTs.filter(ts => ts < Date.now() + 86400000).sort((a, b) => a - b); | |
| } | |
| if (allTs.length === 0) { | |
| onLog(serverId, `[RESTORE] No backups found on HuggingFace. Starting fresh.`); | |
| return false; | |
| } | |
| const latestTs = allTs[allTs.length - 1]; | |
| const hfPath = `backups/${latestTs}.zip`; | |
| onLog(serverId, `[RESTORE] Found ${allTs.length} backup(s). Restoring latest: ${new Date(latestTs).toLocaleString()}`); | |
| // ── Step 1: Download + extract main world backup ────────────────────────── | |
| onLog(serverId, `[RESTORE] Downloading world backup from HuggingFace...`); | |
| const zipBuffer = await downloadBufferFromHF(repoId, token, hfPath); | |
| const sizeMB = (zipBuffer.length / (1024 * 1024)).toFixed(2); | |
| onLog(serverId, `[RESTORE] Download complete (${sizeMB} MB). Extracting...`); | |
| decompressBufferToDir(zipBuffer, serverPath); | |
| onLog(serverId, `[RESTORE] ✅ World backup extracted.`); | |
| // ── Step 2: ALWAYS restore dedicated plugins-backup.zip on top ─────────── | |
| // plugins-backup.zip is the single source of truth — updated on every install | |
| try { | |
| onLog(serverId, `[RESTORE] 🔌 Restoring plugins from dedicated plugins backup...`); | |
| const pluginsZip = await downloadBufferFromHF(repoId, token, 'plugins-backup.zip'); | |
| decompressBufferToDir(pluginsZip, serverPath); | |
| onLog(serverId, `[RESTORE] ✅ Plugins restored from plugins-backup.zip`); | |
| } catch(e) { | |
| onLog(serverId, `[RESTORE] ℹ️ No dedicated plugins backup found yet. Using plugins from world backup.`); | |
| } | |
| // ── Step 3: Restore real-time configs if they exist ─────────── | |
| try { | |
| const configsZip = await downloadBufferFromHF(repoId, token, 'configs-backup.zip'); | |
| decompressBufferToDir(configsZip, serverPath); | |
| onLog(serverId, `[RESTORE] 💾 Real-time configs (ops, whitelist) restored successfully.`); | |
| } catch(e) { | |
| // It's okay if this doesn't exist yet | |
| } | |
| onLog(serverId, `[RESTORE] ✅ Server files restored from HuggingFace backup.`); | |
| return true; | |
| } catch (err) { | |
| onLog(serverId, `[RESTORE] ERROR: ${err.message}`); | |
| console.error(err); | |
| return false; | |
| } | |
| } | |