wehub-resource-sync
470 lines
15 KiB
JavaScript
470 lines
15 KiB
JavaScript
import {
|
|
copyFileSync,
|
|
createReadStream,
|
|
createWriteStream,
|
|
existsSync,
|
|
mkdirSync,
|
|
readdirSync,
|
|
readFileSync,
|
|
statSync,
|
|
unlinkSync,
|
|
writeFileSync,
|
|
} from "node:fs";
|
|
import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
|
|
import { dirname, join, extname, basename } from "node:path";
|
|
import { Readable } from "node:stream";
|
|
import { pipeline } from "node:stream/promises";
|
|
import { resolveDataDir } from "../data-dir.mjs";
|
|
import { getBaseUrl, isServerUp } from "../api.mjs";
|
|
import { t } from "../i18n.mjs";
|
|
import { backupSqliteFile } from "../sqlite.mjs";
|
|
import { CLI_TOKEN_HEADER, getCliToken } from "../utils/cliToken.mjs";
|
|
|
|
function getBackupDir() {
|
|
return join(resolveDataDir(), "backups");
|
|
}
|
|
|
|
const FILES_TO_BACKUP = [
|
|
{ name: "storage.sqlite" },
|
|
{ name: "settings.json" },
|
|
{ name: "combos.json" },
|
|
{ name: "providers.json" },
|
|
];
|
|
|
|
export function registerBackup(program) {
|
|
const backup = program.command("backup").description(t("backup.description"));
|
|
|
|
backup
|
|
.command("create")
|
|
.description(t("backup.createDescription"))
|
|
.option("--name <name>", t("backup.nameOpt"))
|
|
.option("--cloud", t("backup.cloudOpt"))
|
|
.option("--encrypt", t("backup.encryptOpt"))
|
|
.option("--key-file <path>", t("backup.keyFileOpt"))
|
|
.option("--exclude <pattern>", t("backup.excludeOpt"), (v, prev = []) => [...prev, v], [])
|
|
.option("--retention <n>", t("backup.retentionOpt"), parseInt)
|
|
.action(async (opts) => {
|
|
const exitCode = await runBackupCommand(opts);
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
|
|
const auto = backup.command("auto").description(t("backup.auto.title"));
|
|
|
|
auto
|
|
.command("enable")
|
|
.description(t("backup.auto.enableDescription"))
|
|
.option("--cron <expr>", t("backup.auto.cronOpt"), "0 3 * * *")
|
|
.option("--cloud", t("backup.cloudOpt"))
|
|
.option("--encrypt", t("backup.encryptOpt"))
|
|
.option("--retention <n>", t("backup.retentionOpt"), parseInt)
|
|
.action(async (opts) => {
|
|
const exitCode = await runBackupAutoEnableCommand(opts);
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
|
|
auto
|
|
.command("disable")
|
|
.description(t("backup.auto.disableDescription"))
|
|
.action(async () => {
|
|
const exitCode = await runBackupAutoDisableCommand();
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
|
|
auto
|
|
.command("status")
|
|
.description(t("backup.auto.statusDescription"))
|
|
.action(async () => {
|
|
const exitCode = await runBackupAutoStatusCommand();
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
|
|
// Legacy: `omniroute backup` without subcommand still creates a backup
|
|
backup.action(async (opts) => {
|
|
const exitCode = await runBackupCommand(opts);
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
backup
|
|
.option("--name <name>", t("backup.nameOpt"))
|
|
.option("--cloud", t("backup.cloudOpt"))
|
|
.option("--encrypt", t("backup.encryptOpt"))
|
|
.option("--key-file <path>", t("backup.keyFileOpt"))
|
|
.option("--exclude <pattern>", t("backup.excludeOpt"), (v, prev = []) => [...prev, v], [])
|
|
.option("--retention <n>", t("backup.retentionOpt"), parseInt);
|
|
}
|
|
|
|
export function registerRestore(program) {
|
|
program
|
|
.command("restore [backupId]")
|
|
.description(t("backup.restoreDescription"))
|
|
.option("--list", "List available backups")
|
|
.option("--yes", "Skip confirmation")
|
|
.action(async (backupId, opts) => {
|
|
const exitCode = await runRestoreCommand(backupId, opts);
|
|
if (exitCode !== 0) process.exit(exitCode);
|
|
});
|
|
}
|
|
|
|
function matchesGlob(fileName, pattern) {
|
|
if (!pattern.includes("*")) return fileName === pattern;
|
|
const parts = pattern.split("*");
|
|
let pos = 0;
|
|
for (let i = 0; i < parts.length; i++) {
|
|
const part = parts[i];
|
|
if (!part) continue;
|
|
if (i === 0) {
|
|
if (!fileName.startsWith(part)) return false;
|
|
pos = part.length;
|
|
} else if (i === parts.length - 1) {
|
|
if (!fileName.endsWith(part)) return false;
|
|
if (fileName.length < pos + part.length) return false;
|
|
} else {
|
|
const idx = fileName.indexOf(part, pos);
|
|
if (idx === -1) return false;
|
|
pos = idx + part.length;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function shouldExclude(fileName, patterns) {
|
|
if (!patterns || patterns.length === 0) return false;
|
|
return patterns.some((p) => matchesGlob(fileName, p));
|
|
}
|
|
|
|
async function encryptFile(srcPath, destPath, passphrase) {
|
|
const salt = randomBytes(16);
|
|
const iv = randomBytes(12);
|
|
const key = scryptSync(passphrase, salt, 32);
|
|
const cipher = createCipheriv("aes-256-gcm", key, iv);
|
|
const tmpCipherPath = `${destPath}.ciphertext`;
|
|
await pipeline(createReadStream(srcPath), cipher, createWriteStream(tmpCipherPath));
|
|
const authTag = cipher.getAuthTag();
|
|
// Format: salt(16) + iv(12) + authTag(16) + ciphertext
|
|
const out = createWriteStream(destPath);
|
|
try {
|
|
await new Promise((resolve, reject) => {
|
|
out.write(Buffer.concat([salt, iv, authTag]), (err) => {
|
|
if (err) reject(err);
|
|
else resolve();
|
|
});
|
|
});
|
|
await pipeline(createReadStream(tmpCipherPath), out);
|
|
} finally {
|
|
try {
|
|
unlinkSync(tmpCipherPath);
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
async function promptPassphrase() {
|
|
const readline = await import("node:readline");
|
|
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
|
|
return new Promise((resolve) =>
|
|
rl.question(t("backup.passphrasePrompt"), (ans) => {
|
|
rl.close();
|
|
resolve(ans.trim());
|
|
})
|
|
);
|
|
}
|
|
|
|
async function pruneBackups(backupDir, retention) {
|
|
if (!retention || retention <= 0 || !existsSync(backupDir)) return;
|
|
try {
|
|
const dirs = readdirSync(backupDir)
|
|
.filter((f) => f.startsWith("omniroute-backup-"))
|
|
.sort()
|
|
.reverse();
|
|
for (const old of dirs.slice(retention)) {
|
|
const { rmSync } = await import("node:fs");
|
|
rmSync(join(backupDir, old), { recursive: true, force: true });
|
|
}
|
|
} catch {}
|
|
}
|
|
|
|
export async function runBackupCommand(opts = {}) {
|
|
const dataDir = resolveDataDir();
|
|
const backupDir = getBackupDir();
|
|
const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
|
|
const safeName = opts.name ? String(opts.name).replace(/[/\\]/g, "_") : null;
|
|
const backupName = safeName ? `omniroute-backup-${safeName}` : `omniroute-backup-${timestamp}`;
|
|
const backupPath = join(backupDir, backupName);
|
|
const excludePatterns = opts.exclude || [];
|
|
|
|
console.log(t("backup.creating"));
|
|
|
|
let passphrase = null;
|
|
if (opts.encrypt) {
|
|
if (opts.keyFile) {
|
|
passphrase = readFileSync(opts.keyFile, "utf8").trim();
|
|
} else {
|
|
passphrase = await promptPassphrase();
|
|
if (!passphrase) {
|
|
console.error(t("backup.noPassphrase"));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (!existsSync(backupDir)) mkdirSync(backupDir, { recursive: true });
|
|
|
|
let backedUp = 0;
|
|
let skipped = 0;
|
|
|
|
for (const file of FILES_TO_BACKUP) {
|
|
if (shouldExclude(file.name, excludePatterns)) {
|
|
skipped++;
|
|
continue;
|
|
}
|
|
const sourcePath = join(dataDir, file.name);
|
|
if (existsSync(sourcePath)) {
|
|
const destName = opts.encrypt ? `${file.name}.enc` : file.name;
|
|
const destPath = join(backupPath, destName);
|
|
mkdirSync(dirname(destPath), { recursive: true });
|
|
if (file.name.endsWith(".sqlite")) {
|
|
const tmpPath = destPath.replace(/\.enc$/, "");
|
|
await backupSqliteFile(sourcePath, tmpPath);
|
|
if (opts.encrypt) {
|
|
await encryptFile(tmpPath, destPath, passphrase);
|
|
unlinkSync(tmpPath);
|
|
}
|
|
} else if (opts.encrypt) {
|
|
await encryptFile(sourcePath, destPath, passphrase);
|
|
} else {
|
|
copyFileSync(sourcePath, destPath);
|
|
}
|
|
backedUp++;
|
|
} else {
|
|
skipped++;
|
|
}
|
|
}
|
|
|
|
if (backedUp > 0) {
|
|
const info = {
|
|
timestamp: new Date().toISOString(),
|
|
version: "omniroute-cli-v1",
|
|
encrypted: !!opts.encrypt,
|
|
files: FILES_TO_BACKUP.filter(
|
|
(f) => existsSync(join(dataDir, f.name)) && !shouldExclude(f.name, excludePatterns)
|
|
).map((f) => (opts.encrypt ? `${f.name}.enc` : f.name)),
|
|
};
|
|
writeFileSync(join(backupPath, "backup-info.json"), JSON.stringify(info, null, 2), "utf8");
|
|
|
|
if (opts.cloud) {
|
|
const cloudCode = await _uploadBackupToCloud(backupPath, info);
|
|
if (cloudCode !== 0) {
|
|
console.warn(t("backup.cloudFailed"));
|
|
}
|
|
}
|
|
|
|
if (opts.retention) {
|
|
await pruneBackups(backupDir, opts.retention);
|
|
}
|
|
|
|
console.log(t("backup.done", { path: backupPath }));
|
|
console.log(
|
|
`\x1b[2m ${backedUp} backed up, ${skipped} skipped${opts.encrypt ? " (encrypted)" : ""}\x1b[0m`
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
console.log(t("backup.noFiles"));
|
|
return 0;
|
|
} catch (err) {
|
|
console.error(t("backup.failed", { error: err instanceof Error ? err.message : String(err) }));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
async function _uploadBackupToCloud(backupPath, info) {
|
|
const serverUp = await isServerUp();
|
|
if (!serverUp) {
|
|
console.warn(t("common.serverOffline"));
|
|
return 1;
|
|
}
|
|
try {
|
|
const boundary = `omniroute-backup-${Date.now().toString(36)}-${randomBytes(8).toString("hex")}`;
|
|
const headers = new Headers({
|
|
accept: "application/json",
|
|
"content-type": `multipart/form-data; boundary=${boundary}`,
|
|
});
|
|
const apiKey = process.env.OMNIROUTE_API_KEY;
|
|
if (apiKey) headers.set("authorization", `Bearer ${apiKey}`);
|
|
const cliToken = process.env.OMNIROUTE_CLI_TOKEN ?? (await getCliToken());
|
|
if (cliToken) headers.set(CLI_TOKEN_HEADER, cliToken);
|
|
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), 30000);
|
|
const res = await fetch(`${getBaseUrl()}/api/db-backups/cloud`, {
|
|
method: "POST",
|
|
headers,
|
|
body: Readable.from(createBackupMultipartStream(backupPath, info, boundary)),
|
|
duplex: "half",
|
|
signal: controller.signal,
|
|
}).finally(() => clearTimeout(timeout));
|
|
if (res.ok) {
|
|
const data = await res.json();
|
|
console.log(t("backup.cloudUploaded", { url: data.url || "(stored)" }));
|
|
return 0;
|
|
}
|
|
return 1;
|
|
} catch {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
async function* createBackupMultipartStream(backupPath, info, boundary) {
|
|
const encoder = new TextEncoder();
|
|
const encode = (value) => encoder.encode(value);
|
|
yield encode(
|
|
`--${boundary}\r\nContent-Disposition: form-data; name="info"\r\nContent-Type: application/json\r\n\r\n${JSON.stringify(info)}\r\n`
|
|
);
|
|
for (const fname of readdirSync(backupPath)) {
|
|
const fullPath = join(backupPath, fname);
|
|
const stat = statSync(fullPath);
|
|
if (!stat.isFile()) continue;
|
|
const safeName = fname.replace(/["\r\n]/g, "_");
|
|
yield encode(
|
|
`--${boundary}\r\nContent-Disposition: form-data; name="files"; filename="${safeName}"\r\nContent-Type: application/octet-stream\r\n\r\n`
|
|
);
|
|
yield* createReadStream(fullPath);
|
|
yield encode("\r\n");
|
|
}
|
|
yield encode(`--${boundary}--\r\n`);
|
|
}
|
|
|
|
function getSchedulePath() {
|
|
return join(resolveDataDir(), "backup-schedule.json");
|
|
}
|
|
|
|
export async function runBackupAutoEnableCommand(opts = {}) {
|
|
const schedulePath = getSchedulePath();
|
|
const schedule = {
|
|
enabled: true,
|
|
cron: opts.cron || "0 3 * * *",
|
|
cloud: !!opts.cloud,
|
|
encrypt: !!opts.encrypt,
|
|
retention: opts.retention || null,
|
|
updatedAt: new Date().toISOString(),
|
|
};
|
|
mkdirSync(dirname(schedulePath), { recursive: true });
|
|
writeFileSync(schedulePath, JSON.stringify(schedule, null, 2), "utf8");
|
|
console.log(t("backup.auto.enabled", { cron: schedule.cron }));
|
|
console.log(t("backup.auto.hint"));
|
|
return 0;
|
|
}
|
|
|
|
export async function runBackupAutoDisableCommand() {
|
|
const schedulePath = getSchedulePath();
|
|
if (existsSync(schedulePath)) {
|
|
const schedule = JSON.parse(readFileSync(schedulePath, "utf8"));
|
|
schedule.enabled = false;
|
|
schedule.updatedAt = new Date().toISOString();
|
|
writeFileSync(schedulePath, JSON.stringify(schedule, null, 2), "utf8");
|
|
}
|
|
console.log(t("backup.auto.disabled"));
|
|
return 0;
|
|
}
|
|
|
|
export async function runBackupAutoStatusCommand() {
|
|
const schedulePath = getSchedulePath();
|
|
if (!existsSync(schedulePath)) {
|
|
console.log(t("backup.auto.notConfigured"));
|
|
return 0;
|
|
}
|
|
const schedule = JSON.parse(readFileSync(schedulePath, "utf8"));
|
|
const statusLabel = schedule.enabled ? "\x1b[32m● enabled\x1b[0m" : "\x1b[31m○ disabled\x1b[0m";
|
|
console.log(`${t("backup.auto.title")}: ${statusLabel}`);
|
|
console.log(` cron: ${schedule.cron}`);
|
|
console.log(` cloud: ${schedule.cloud ? "yes" : "no"}`);
|
|
console.log(` encrypt: ${schedule.encrypt ? "yes" : "no"}`);
|
|
console.log(` retention: ${schedule.retention ?? "unlimited"}`);
|
|
return 0;
|
|
}
|
|
|
|
export async function runRestoreCommand(backupId, opts = {}) {
|
|
const backupDir = getBackupDir();
|
|
|
|
if (opts.list || !backupId) {
|
|
console.log(`\n\x1b[1m\x1b[36m${t("backup.listTitle")}\x1b[0m\n`);
|
|
if (!existsSync(backupDir)) {
|
|
console.log(t("backup.noBackups"));
|
|
return 0;
|
|
}
|
|
|
|
try {
|
|
const dirs = readdirSync(backupDir)
|
|
.filter((f) => f.startsWith("omniroute-backup-"))
|
|
.sort()
|
|
.reverse();
|
|
|
|
if (dirs.length === 0) {
|
|
console.log(t("backup.noBackups"));
|
|
return 0;
|
|
}
|
|
|
|
for (const dir of dirs) {
|
|
const infoPath = join(backupDir, dir, "backup-info.json");
|
|
if (existsSync(infoPath)) {
|
|
const info = JSON.parse(readFileSync(infoPath, "utf8"));
|
|
const id = dir.replace("omniroute-backup-", "");
|
|
const dateStr = new Date(info.timestamp).toLocaleString();
|
|
console.log(` ${id}`);
|
|
console.log(`\x1b[2m ${dateStr} — ${info.files?.length || 0} files\x1b[0m`);
|
|
} else {
|
|
console.log(`\x1b[2m ${dir.replace("omniroute-backup-", "")}\x1b[0m`);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error(
|
|
t("common.error", { message: err instanceof Error ? err.message : String(err) })
|
|
);
|
|
return 1;
|
|
}
|
|
|
|
if (!backupId) console.log("\nUsage: omniroute restore <backup-id>");
|
|
return 0;
|
|
}
|
|
|
|
const safeBackupId = String(backupId).replace(/[/\\]/g, "_");
|
|
const backupPath = join(backupDir, `omniroute-backup-${safeBackupId}`);
|
|
if (!existsSync(backupPath)) {
|
|
console.error(t("backup.notFound", { name: backupId }));
|
|
return 1;
|
|
}
|
|
|
|
const infoPath = join(backupPath, "backup-info.json");
|
|
const ts = existsSync(infoPath) ? JSON.parse(readFileSync(infoPath, "utf8")).timestamp : backupId;
|
|
|
|
if (!opts.yes) {
|
|
const readline = await import("node:readline");
|
|
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
|
|
const answer = await new Promise((resolve) =>
|
|
rl.question(t("backup.confirmRestore", { ts }) + " [y/N] ", resolve)
|
|
);
|
|
rl.close();
|
|
if (!/^y(es)?$/i.test(answer)) {
|
|
console.log(t("common.cancelled"));
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
console.log(t("backup.restoring", { path: backupPath }));
|
|
|
|
const dataDir = resolveDataDir();
|
|
try {
|
|
for (const file of FILES_TO_BACKUP) {
|
|
const sourcePath = join(backupPath, file.name);
|
|
if (existsSync(sourcePath)) {
|
|
copyFileSync(sourcePath, join(dataDir, file.name));
|
|
console.log(`\x1b[2m Restored: ${file.name}\x1b[0m`);
|
|
}
|
|
}
|
|
console.log(t("backup.restored"));
|
|
return 0;
|
|
} catch (err) {
|
|
console.error(t("common.error", { message: err instanceof Error ? err.message : String(err) }));
|
|
return 1;
|
|
}
|
|
}
|