@sparkelf/dsh-plugin-backup 0.1.0-rc.10

package/lib/index.js

@@ -0,0 +1,701 @@
+import { dirname, join } from "node:path";
+import Schema from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { once } from "node:events";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { Transform } from "node:stream";
+import { finished, pipeline } from "node:stream/promises";
+import { Zip, ZipDeflate, ZipPassThrough, strToU8 } from "fflate";
+import { open } from "yauzl";
+//#region lib/types/archive.js
+/**
+* User data backup core for the web settings Backup section. Export scans one
+* stable file plan, reads and compresses bounded chunks, and publishes source-
+* byte progress. Import validates before mutation, then writes bounded chunks
+* while publishing restored-byte progress.
+*/
+/** Manifest entry at the archive root; import validation uses it as the marker. */
+const BACKUP_MANIFEST_ENTRY = "backup-manifest.json";
+/** Runtime-generated harness-home directories that are not user configuration or data. */
+const GENERATED_DIRECTORIES = new Set(["profiles", "supervisor"]);
+/** File read and restore write size. */
+const BACKUP_CHUNK_BYTES = 64 * 1024;
+const EMPTY_BYTES = new Uint8Array(0);
+/**
+* Add one directory's portable entries to a stable export plan.
+* @param rootPath - backup root directory.
+* @param relativePath - current slash-separated path relative to the root.
+* @param entries - plan entries under construction.
+* @param signal - caller or response cancellation.
+* @returns the summed regular-file bytes below this directory.
+*/
+async function planDirectory(rootPath, relativePath, entries, signal) {
+	signal.throwIfAborted();
+	const children = await readdir(join(rootPath, relativePath), { withFileTypes: true });
+	let bytes = 0;
+	for (const child of children) {
+		signal.throwIfAborted();
+		const entryRelative = relativePath === "" ? child.name : relativePath + "/" + child.name;
+		if (relativePath === "" && (GENERATED_DIRECTORIES.has(child.name) || child.name === BACKUP_MANIFEST_ENTRY)) continue;
+		if (child.isDirectory()) {
+			entries.push({
+				kind: "directory",
+				relativePath: entryRelative
+			});
+			bytes += await planDirectory(rootPath, entryRelative, entries, signal);
+		} else if (child.isFile()) {
+			const { size } = await stat(join(rootPath, entryRelative));
+			entries.push({
+				kind: "file",
+				relativePath: entryRelative,
+				size
+			});
+			bytes += size;
+		}
+	}
+	return bytes;
+}
+/**
+* Build the stable file list and source-byte total used by one export.
+* @param dshHome - harness user data directory.
+* @param signal - caller or response cancellation.
+* @returns the planned entries, manifest bytes, and measurable byte total.
+*/
+async function planUserBackup(dshHome, signal) {
+	const manifest = strToU8(JSON.stringify({
+		app: "deepseek-harness",
+		kind: "user-data-backup",
+		version: 1,
+		exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2) + String.fromCharCode(10));
+	const entries = [];
+	return {
+		entries,
+		manifest,
+		totalBytes: await planDirectory(dshHome, "", entries, signal) + manifest.length
+	};
+}
+/**
+* Add one planned file without retaining its complete contents.
+* @param zip - streaming archive receiving the file.
+* @param rootPath - backup root directory.
+* @param entry - planned file and scan-time size.
+* @param waitForOutput - waits for archive output backpressure or failure.
+* @param signal - caller or response cancellation.
+* @param onBytes - publishes each source chunk after archive output accepts it.
+* @returns when the planned file bytes have reached the archive output.
+*/
+async function addFileToZip(zip, rootPath, entry, waitForOutput, signal, onBytes) {
+	const archiveFile = new ZipDeflate(entry.relativePath);
+	zip.add(archiveFile);
+	if (entry.size === 0) {
+		archiveFile.push(EMPTY_BYTES, true);
+		await waitForOutput();
+		return;
+	}
+	const source = createReadStream(join(rootPath, entry.relativePath), {
+		end: entry.size - 1,
+		highWaterMark: BACKUP_CHUNK_BYTES,
+		signal
+	});
+	let readBytes = 0;
+	for await (const chunk of source) {
+		signal.throwIfAborted();
+		archiveFile.push(chunk);
+		await waitForOutput();
+		readBytes += chunk.length;
+		await onBytes(chunk.length);
+	}
+	if (readBytes !== entry.size) throw new Error("backup source changed while reading: " + entry.relativePath);
+	archiveFile.push(EMPTY_BYTES, true);
+	await waitForOutput();
+}
+/**
+* Pack the harness home's user configuration and data into a zip archive,
+* publishing scan and source-byte compression progress. A failed export removes
+* its partial archive.
+* @param dshHome - harness user data directory (settings.yaml parent).
+* @param targetPath - absolute file path the archive is written to.
+* @param signal - caller or response cancellation.
+* @param report - ordered progress writer.
+* @returns the number of zip entries including the manifest marker.
+*/
+async function writeUserBackup(dshHome, targetPath, signal, report) {
+	await report({ phase: "scan" });
+	const plan = await planUserBackup(dshHome, signal);
+	let completedBytes = 0;
+	let lastPercent = -1;
+	const reportCompression = async () => {
+		const percent = Math.floor(completedBytes * 100 / plan.totalBytes);
+		if (percent === lastPercent) return;
+		lastPercent = percent;
+		await report({
+			phase: "compress",
+			completedBytes,
+			totalBytes: plan.totalBytes
+		});
+	};
+	await reportCompression();
+	let outputError;
+	const output = createWriteStream(targetPath, {
+		flags: "w",
+		signal
+	});
+	const outputSettled = finished(output).catch((error) => {
+		outputError = error instanceof Error ? error : new Error(String(error));
+	});
+	let pendingDrain;
+	output.on("error", (error) => {
+		outputError = error;
+	});
+	const zip = new Zip((error, data, final) => {
+		if (error !== null) {
+			outputError = error;
+			output.destroy(error);
+			return;
+		}
+		if (outputError !== void 0) return;
+		if (data.length > 0 && !output.write(data)) pendingDrain = once(output, "drain");
+		if (final) output.end();
+	});
+	const waitForOutput = async () => {
+		const drain = pendingDrain;
+		pendingDrain = void 0;
+		if (drain !== void 0) await drain;
+		if (outputError !== void 0) throw outputError;
+	};
+	let complete = false;
+	try {
+		for (const entry of plan.entries) {
+			signal.throwIfAborted();
+			if (entry.kind === "directory") {
+				const directory = new ZipPassThrough(entry.relativePath + "/");
+				zip.add(directory);
+				directory.push(EMPTY_BYTES, true);
+				await waitForOutput();
+			} else await addFileToZip(zip, dshHome, entry, waitForOutput, signal, async (bytes) => {
+				completedBytes += bytes;
+				await reportCompression();
+			});
+		}
+		const manifest = new ZipDeflate(BACKUP_MANIFEST_ENTRY);
+		zip.add(manifest);
+		manifest.push(plan.manifest, true);
+		await waitForOutput();
+		completedBytes += plan.manifest.length;
+		await reportCompression();
+		zip.end();
+		await outputSettled;
+		if (outputError !== void 0) throw outputError;
+		complete = true;
+		return { entries: plan.entries.length + 1 };
+	} finally {
+		if (!complete) {
+			zip.terminate();
+			output.destroy();
+			await outputSettled;
+			await rm(targetPath, { force: true });
+		}
+	}
+}
+function openArchive(path) {
+	return new Promise((resolveOpen, reject) => {
+		open(path, {
+			lazyEntries: true,
+			autoClose: false,
+			validateEntrySizes: true
+		}, (error, zip) => {
+			if (error !== null) reject(error);
+			else resolveOpen(zip);
+		});
+	});
+}
+function nextArchiveEntry(zip) {
+	return new Promise((resolveEntry, reject) => {
+		const settle = () => {
+			zip.off("entry", onEntry);
+			zip.off("end", onEnd);
+			zip.off("error", onError);
+		};
+		const onEntry = (entry) => {
+			settle();
+			resolveEntry(entry);
+		};
+		const onEnd = () => {
+			settle();
+			resolveEntry(void 0);
+		};
+		const onError = (error) => {
+			settle();
+			reject(error);
+		};
+		zip.once("entry", onEntry);
+		zip.once("end", onEnd);
+		zip.once("error", onError);
+		zip.readEntry();
+	});
+}
+function openEntryStream(zip, entry) {
+	return new Promise((resolveStream, reject) => {
+		zip.openReadStream(entry, (error, stream) => {
+			if (error !== null) reject(error);
+			else resolveStream(stream);
+		});
+	});
+}
+function requireSafeArchivePath(name) {
+	if (name.startsWith("/") || name.includes("\\") || /^[A-Za-z]:/u.test(name)) throw new Error("Backup archive contains an unsafe path: " + name);
+	const parts = name.split("/");
+	for (const [index, part] of parts.entries()) {
+		if (part === ".." || part === ".") throw new Error("Backup archive contains an unsafe path: " + name);
+		if (part === "" && index < parts.length - 1) throw new Error("Backup archive contains an unsafe path: " + name);
+	}
+}
+/**
+* Validate and extract one staged zip without retaining archive or entry bodies in memory.
+* @param archivePath - disk-staged raw upload.
+* @param stagingRoot - temporary extraction root outside the harness home.
+* @param maxExpandedBytes - aggregate expanded-byte limit shared with upload admission.
+* @param signal - response cancellation honored until DSH-home mutation begins.
+* @returns the validated staged entry plan.
+*/
+async function validateUserBackup(archivePath, stagingRoot, maxExpandedBytes, signal) {
+	const zip = await openArchive(archivePath);
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	let manifestSeen = false;
+	let expandedBytes = 0;
+	let totalBytes = 0;
+	try {
+		for (;;) {
+			signal.throwIfAborted();
+			const entry = await nextArchiveEntry(zip);
+			if (entry === void 0) break;
+			const name = entry.fileName;
+			requireSafeArchivePath(name);
+			if (names.has(name)) throw new Error("Backup archive contains a duplicate path: " + name);
+			names.add(name);
+			const directory = name.endsWith("/");
+			if (!Number.isSafeInteger(entry.uncompressedSize) || entry.uncompressedSize < 0 || expandedBytes + entry.uncompressedSize > maxExpandedBytes) throw new Error("Backup archive expanded data exceeds the configured limit");
+			expandedBytes += entry.uncompressedSize;
+			if (directory) {
+				await mkdir(join(stagingRoot, name), { recursive: true });
+				entries.push({
+					kind: "directory",
+					relativePath: name
+				});
+				continue;
+			}
+			const target = join(stagingRoot, name);
+			await mkdir(dirname(target), { recursive: true });
+			const source = await openEntryStream(zip, entry);
+			let written = 0;
+			await pipeline(source, new Transform({ transform(chunk, _encoding, callback) {
+				written += chunk.length;
+				callback(written > entry.uncompressedSize ? /* @__PURE__ */ new Error("Backup archive entry exceeded its declared size") : null, chunk);
+			} }), createWriteStream(target, { flags: "wx" }), { signal });
+			if (written !== entry.uncompressedSize) throw new Error("Backup archive entry size mismatch: " + name);
+			if (name === BACKUP_MANIFEST_ENTRY) manifestSeen = true;
+			else totalBytes += written;
+			entries.push({
+				kind: "file",
+				relativePath: name,
+				size: written
+			});
+		}
+	} finally {
+		zip.close();
+	}
+	if (!manifestSeen) throw new Error("Not a DeepSeek Harness user data backup: missing backup-manifest.json");
+	return {
+		stagingRoot,
+		entries,
+		count: entries.length,
+		totalBytes
+	};
+}
+/**
+* Write a validated staged archive over the harness home while publishing restored bytes.
+* Once file mutation begins the operation completes rather than honoring a late response
+* cancellation, so user data is not left half-written by closing a page.
+* @param validated - validateUserBackup result.
+* @param dshHome - harness user data directory.
+* @param report - ordered progress writer; a disconnected response may ignore updates.
+* @returns the restored entry count.
+*/
+async function restoreUserBackup(validated, dshHome, report) {
+	let completedBytes = 0;
+	let lastPercent = -1;
+	const reportRestore = async () => {
+		const percent = validated.totalBytes === 0 ? 100 : Math.floor(completedBytes * 100 / validated.totalBytes);
+		if (percent === lastPercent) return;
+		lastPercent = percent;
+		await report({
+			phase: "restore",
+			completedBytes,
+			totalBytes: validated.totalBytes
+		});
+	};
+	await reportRestore();
+	for (const entry of validated.entries) {
+		if (entry.relativePath === BACKUP_MANIFEST_ENTRY) continue;
+		const target = join(dshHome, entry.relativePath);
+		if (entry.kind === "directory") {
+			await mkdir(target, { recursive: true });
+			continue;
+		}
+		await mkdir(dirname(target), { recursive: true });
+		const progress = new Transform({ transform(chunk, _encoding, callback) {
+			completedBytes += chunk.length;
+			reportRestore().then(() => {
+				callback(null, chunk);
+			}, (error) => {
+				callback(error instanceof Error ? error : new Error(String(error)));
+			});
+		} });
+		await pipeline(createReadStream(join(validated.stagingRoot, entry.relativePath), { highWaterMark: BACKUP_CHUNK_BYTES }), progress, createWriteStream(target, { flags: "w" }));
+	}
+	await reportRestore();
+	return { entries: validated.count };
+}
+//#endregion
+//#region lib/types/routes.js
+/** Authenticated Host routes for streamed user-data Backup export and import. */
+const BACKUP_TOKEN_TTL_MS = 10 * 6e4;
+var BackupUploadTooLargeError = class extends Error {};
+/** Own one-use Host temp-file tokens and delete every file when its ownership ends. */
+var BackupTokenStore = class {
+	entries = /* @__PURE__ */ new Map();
+	mintDownload(path, size) {
+		this.sweep();
+		return this.mint({
+			kind: "download",
+			path,
+			size,
+			expiresAt: Date.now() + BACKUP_TOKEN_TTL_MS
+		});
+	}
+	mintUpload(path) {
+		this.sweep();
+		return this.mint({
+			kind: "upload",
+			path,
+			expiresAt: Date.now() + BACKUP_TOKEN_TTL_MS
+		});
+	}
+	peekDownload(token) {
+		const entry = this.peek(token);
+		return entry?.kind === "download" ? entry : void 0;
+	}
+	takeDownload(token) {
+		const entry = this.peekDownload(token);
+		if (entry !== void 0) this.take(token);
+		return entry;
+	}
+	takeUpload(token) {
+		const entry = this.peek(token);
+		if (entry?.kind !== "upload") return void 0;
+		this.take(token);
+		return entry;
+	}
+	async dispose() {
+		for (const entry of this.entries.values()) {
+			clearTimeout(entry.expiryTimer);
+			await removeTempDirectory(entry.path, "dispose");
+		}
+		this.entries.clear();
+	}
+	mint(entry) {
+		const token = randomUUID();
+		const owned = {
+			...entry,
+			expiryTimer: setTimeout(() => {
+				if (this.entries.get(token) !== owned) return;
+				this.entries.delete(token);
+				removeTempDirectory(owned.path, "expired");
+			}, BACKUP_TOKEN_TTL_MS)
+		};
+		this.entries.set(token, owned);
+		return token;
+	}
+	peek(token) {
+		const entry = this.entries.get(token);
+		if (entry === void 0) return void 0;
+		if (entry.expiresAt > Date.now()) return entry;
+		this.expire(token, entry);
+	}
+	take(token) {
+		const entry = this.entries.get(token);
+		if (entry === void 0) return void 0;
+		clearTimeout(entry.expiryTimer);
+		this.entries.delete(token);
+		return entry;
+	}
+	expire(token, entry) {
+		clearTimeout(entry.expiryTimer);
+		this.entries.delete(token);
+		removeTempDirectory(entry.path, "expired");
+	}
+	sweep() {
+		const now = Date.now();
+		for (const [token, entry] of this.entries) {
+			if (entry.expiresAt > now) continue;
+			this.expire(token, entry);
+		}
+	}
+};
+/** Log temp cleanup failure with the original stack while withholding the path. */
+async function removeTempDirectory(path, reason) {
+	try {
+		await rm(dirname(path), {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		console.error("[plus-backup] temp cleanup failed", { reason }, error);
+	}
+}
+/** Reject an unauthenticated route before reading any request body or query data. */
+function registerProtectedRoute(ctx, path, handler) {
+	const route = {
+		kind: "exact",
+		path,
+		handler: async (request, response) => {
+			const rejection = ctx.connection.requestRejection(request);
+			if (rejection !== void 0) {
+				response.writeHead(rejection);
+				response.end(rejection === 401 ? "unauthorized" : "forbidden");
+				return;
+			}
+			await handler(request, response);
+		}
+	};
+	ctx.effect(() => ctx.webServer.register(route), `plus-backup: ${path} route`);
+}
+function requireMethod(request, response, methods) {
+	if (request.method !== void 0 && methods.includes(request.method)) return true;
+	response.writeHead(405, { allow: methods.join(", ") });
+	response.end("method not allowed");
+	return false;
+}
+function tokenFromRequest(request) {
+	const token = new URL(request.url ?? "", "http://localhost").searchParams.get("token");
+	return token === null || token === "" ? void 0 : token;
+}
+async function writeProgressLine(response, line) {
+	if (response.destroyed) throw new Error("backup progress response closed");
+	if (!response.write(JSON.stringify(line) + String.fromCharCode(10))) await once(response, "drain");
+}
+function beginProgressResponse(response) {
+	const controller = new AbortController();
+	response.once("close", () => {
+		if (!response.writableEnded) controller.abort();
+	});
+	response.writeHead(200, {
+		"content-type": "application/x-ndjson; charset=utf-8",
+		"cache-control": "no-store",
+		"x-content-type-options": "nosniff"
+	});
+	response.flushHeaders();
+	return controller.signal;
+}
+function publicOperationError(error, operation) {
+	if (error instanceof Error && (error.message.includes("missing backup-manifest.json") || error.message.includes("unsafe path"))) return error.message;
+	return "backup " + operation + " failed";
+}
+/** Stream one upload to disk; both declared and observed bytes share this ingress limit owner. */
+async function stageUpload(request, response, tokens, maxUploadBytes) {
+	if (!requireMethod(request, response, ["POST"])) return;
+	const declared = Number(request.headers["content-length"] ?? "0");
+	if (Number.isFinite(declared) && declared > maxUploadBytes) {
+		response.writeHead(413);
+		response.end("backup upload too large");
+		return;
+	}
+	const path = join(await mkdtemp(join(tmpdir(), "dsh-backup-upload-")), "upload.zip");
+	let written = 0;
+	const limiter = new Transform({ transform(chunk, _encoding, callback) {
+		written += chunk.length;
+		callback(written > maxUploadBytes ? new BackupUploadTooLargeError() : null, chunk);
+	} });
+	try {
+		await pipeline(request, limiter, createWriteStream(path));
+		if (response.destroyed) {
+			await removeTempDirectory(path, "upload response closed");
+			return;
+		}
+		response.writeHead(200, { "content-type": "application/json" });
+		response.end(JSON.stringify({ token: tokens.mintUpload(path) }));
+	} catch (error) {
+		await removeTempDirectory(path, "upload failed");
+		if (request.destroyed || response.destroyed) return;
+		console.error("[plus-backup] upload failed", error);
+		response.writeHead(error instanceof BackupUploadTooLargeError ? 413 : 500);
+		response.end(error instanceof BackupUploadTooLargeError ? "backup upload too large" : "backup upload failed");
+	}
+}
+async function prepareExport(request, response, tokens, dshHome) {
+	if (!requireMethod(request, response, ["POST"])) return;
+	const signal = beginProgressResponse(response);
+	const path = join(await mkdtemp(join(tmpdir(), "dsh-backup-export-")), "backup.zip");
+	let tokenMinted = false;
+	try {
+		const { entries } = await writeUserBackup(dshHome, path, signal, (progress) => writeProgressLine(response, {
+			type: "progress",
+			progress
+		}));
+		const { size } = await stat(path);
+		const token = tokens.mintDownload(path, size);
+		tokenMinted = true;
+		await writeProgressLine(response, {
+			type: "export-ready",
+			downloadUrl: "/api/backup.export?token=" + token,
+			entries
+		});
+		response.end();
+	} catch (error) {
+		if (!tokenMinted) await removeTempDirectory(path, "export failed");
+		if (signal.aborted || response.destroyed) return;
+		console.error("[plus-backup] export failed", error);
+		await writeProgressLine(response, {
+			type: "error",
+			message: publicOperationError(error, "export")
+		});
+		response.end();
+	}
+}
+async function downloadExport(request, response, tokens) {
+	if (!requireMethod(request, response, ["GET", "HEAD"])) return;
+	const token = tokenFromRequest(request);
+	if (token === void 0) {
+		response.writeHead(400);
+		response.end("missing backup token");
+		return;
+	}
+	const entry = request.method === "HEAD" ? tokens.peekDownload(token) : tokens.takeDownload(token);
+	if (entry === void 0) {
+		response.writeHead(404);
+		response.end("unknown or expired backup token");
+		return;
+	}
+	response.writeHead(200, {
+		"content-type": "application/zip",
+		"content-disposition": "attachment; filename=\"deepseek-harness-backup.zip\"",
+		"content-length": String(entry.size)
+	});
+	if (request.method === "HEAD") {
+		response.end();
+		return;
+	}
+	try {
+		await pipeline(createReadStream(entry.path), response);
+	} catch (error) {
+		console.error("[plus-backup] download failed", error);
+		if (!response.destroyed) response.destroy(error instanceof Error ? error : new Error(String(error)));
+	} finally {
+		await removeTempDirectory(entry.path, "download settled");
+	}
+}
+/** Validate before mutation, then complete restore even when the browser closes mid-write. */
+async function importBackup(ctx, request, response, tokens, dshHome, maxExpandedBytes) {
+	if (!requireMethod(request, response, ["POST"])) return;
+	const token = tokenFromRequest(request);
+	if (token === void 0) {
+		response.writeHead(400);
+		response.end("missing backup upload token");
+		return;
+	}
+	const signal = beginProgressResponse(response);
+	const staged = tokens.takeUpload(token);
+	if (staged === void 0) {
+		await writeProgressLine(response, {
+			type: "error",
+			message: "unknown or expired backup upload token"
+		});
+		response.end();
+		return;
+	}
+	const lifecycle = { restoreStarted: false };
+	const report = async (progress) => {
+		if (progress.phase === "restore") lifecycle.restoreStarted = true;
+		if (lifecycle.restoreStarted && response.destroyed) return;
+		try {
+			await writeProgressLine(response, {
+				type: "progress",
+				progress
+			});
+		} catch (error) {
+			if (!lifecycle.restoreStarted) throw error;
+			console.error("[plus-backup] restore progress response failed", error);
+		}
+	};
+	try {
+		signal.throwIfAborted();
+		await report({ phase: "validate" });
+		const validated = await validateUserBackup(staged.path, join(dirname(staged.path), "validated"), maxExpandedBytes, signal);
+		signal.throwIfAborted();
+		const { entries } = await ctx.workspaceRegistry.withStorageRestore(async () => {
+			const restored = await restoreUserBackup(validated, dshHome, report);
+			await report({ phase: "reload" });
+			return restored;
+		});
+		if (response.destroyed) return;
+		await writeProgressLine(response, {
+			type: "import-complete",
+			entries
+		});
+		response.end();
+	} catch (error) {
+		if (!lifecycle.restoreStarted && (signal.aborted || response.destroyed)) return;
+		console.error("[plus-backup] import failed", error);
+		if (response.destroyed) return;
+		await writeProgressLine(response, {
+			type: "error",
+			message: publicOperationError(error, "import")
+		});
+		response.end();
+	} finally {
+		await removeTempDirectory(staged.path, "import settled");
+	}
+}
+/**
+* Register the complete authenticated Backup route set and its temp-file lifecycle.
+* @param ctx - Host services and the patched Workspace restore operation.
+* @param config - Upload resource policy.
+* @param dshHome - File-backed DSH home whose user data is archived.
+*/
+function registerBackupRoutes(ctx, config, dshHome) {
+	const tokens = new BackupTokenStore();
+	ctx.effect(() => () => tokens.dispose(), "plus-backup: temp files");
+	registerProtectedRoute(ctx, "/api/backup.upload", (request, response) => stageUpload(request, response, tokens, config.maxUploadBytes));
+	registerProtectedRoute(ctx, "/api/backup.export.prepare", (request, response) => prepareExport(request, response, tokens, dshHome));
+	registerProtectedRoute(ctx, "/api/backup.export", (request, response) => downloadExport(request, response, tokens));
+	registerProtectedRoute(ctx, "/api/backup.import", (request, response) => importBackup(ctx, request, response, tokens, dshHome, config.maxUploadBytes));
+}
+//#endregion
+//#region lib/types/index.js
+/** Full-stack Plus user-data Backup Host plugin. */
+const name = "plus-backup";
+const inject = [
+	"connection",
+	"webServer",
+	"settings",
+	"workspaceRegistry"
+];
+const DEFAULT_MAX_UPLOAD_BYTES = 2 * 1024 * 1024 * 1024;
+/** Validate Backup Host resource policy. */
+const Config = Schema.object({ maxUploadBytes: Schema.number().step(1).min(1).default(DEFAULT_MAX_UPLOAD_BYTES) });
+/**
+* Register authenticated archive routes against a file-backed DSH home.
+* @param ctx - Host services plus the temporary patched Workspace restore operation.
+* @param config - Upload resource policy resolved by Cordis.
+*/
+function apply(ctx, config = {}) {
+	const documentPath = ctx.settings.documentPath;
+	if (documentPath === void 0) throw new Error("plus-backup requires a file-backed settings provider");
+	registerBackupRoutes(ctx, { maxUploadBytes: config.maxUploadBytes ?? DEFAULT_MAX_UPLOAD_BYTES }, dirname(documentPath));
+}
+//#endregion
+export { Config, apply, inject, name };