dsh-any-background 0.2.5 → 0.2.6

package/lib/index.js

@@ -1,5 +1,6 @@
 import { access, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createReadStream, createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 //#region src/index.ts
 /**
@@ -24,9 +25,17 @@ const WALLPAPER_FILE = "wallpaper.jpg";
 const ROTATION_DIR = "rotation";
 const VIDEO_ROUTE = "/dsh-any-background/video";
 const UPLOAD_ROUTE = "/dsh-any-background/video/upload";
+const WALLPAPER_ROUTE = "/dsh-any-background/wallpaper";
+const WALLPAPER_UPLOAD_ROUTE = "/dsh-any-background/wallpaper/upload";
 const UPLOAD_TMP = "wallpaper.upload.tmp";
+const VIDEO_UPLOAD_TMP = "video.upload.tmp";
+const WALLPAPER_UPLOAD_MAX = 104857600;
+const VIDEO_UPLOAD_MAX = 2147483648;
 const WALLPAPER_FETCH_MAX = 26214400;
 const WALLPAPER_FETCH_TIMEOUT = 2e4;
+const VIDEO_FETCH_MAX = 2147483648;
+const VIDEO_FETCH_TIMEOUT = 6e4;
+const VIDEO_FETCH_IDLE_TIMEOUT = 6e4;
 function videoFileName(mime) {
 	switch (mime) {
 		case "video/mp4": return "wallpaper.mp4";
@@ -236,7 +245,8 @@ function normalizeGeneratedBg(p) {
 		preset: [
 			"aurora",
 			"nebula",
-			"noise"
+			"noise",
+			"starfield"
 		].includes(p.preset) ? p.preset : "aurora",
 		speed: clamp(p.speed, 0, 2, .3),
 		scale: clamp(p.scale, .3, 3, 1),
@@ -247,7 +257,10 @@ function normalizeGeneratedBg(p) {
 		preset: [
 			"dots",
 			"waves",
-			"poly"
+			"poly",
+			"rain",
+			"contour",
+			"meta"
 		].includes(p.preset) ? p.preset : "dots",
 		density: clamp(p.density, 0, 1, .5),
 		scale: clamp(p.scale, .3, 3, 1),
@@ -376,10 +389,12 @@ async function writeConfig(config) {
 		return false;
 	}
 }
-async function readWallpaper() {
+/** The wallpaper slot is served over HTTP (never shipped as base64 inside the
+*  read RPC): the browser decodes it natively through the same pipeline as any
+*  <img>, so boot only transfers a tiny URL instead of the whole image. */
+async function wallpaperServeUrl() {
 	try {
-		const buf = await readFile(wallpaperPath());
-		return `data:${sniffImageMime(buf)};base64,${buf.toString("base64")}`;
+		return (await stat(wallpaperPath())).size > 0 ? WALLPAPER_ROUTE : null;
 	} catch {
 		return null;
 	}
@@ -410,15 +425,16 @@ function sniffImageMime(buf) {
 	return "image/jpeg";
 }
 /** Download a wallpaper from a network URL and persist it into the local
-*  wallpaper.jpg slot (replacing whatever was stored), so type switches,
-*  export and import keep working through the existing data-URL path.
-*  null removes the wallpaper. Returns { ok, dataUrl?, error? }. */
+*  wallpaper.jpg slot (replacing whatever was stored), so type switches and
+*  rotation keep working through the single active slot. The response carries
+*  the serve URL, never the bytes. null removes the wallpaper.
+*  Returns { ok, wallpaperUrl?, error? }. */
 async function writeWallpaperFromUrl(url) {
 	if (url === null) {
 		const ok = await writeWallpaper(null);
 		return {
 			ok,
-			dataUrl: null,
+			wallpaperUrl: null,
 			error: ok ? void 0 : "remove failed"
 		};
 	}
@@ -480,13 +496,19 @@ async function writeWallpaperFromUrl(url) {
 			error: "read failed"
 		};
 	}
-	const dataUrl = `data:${sniffImageMime(buf)};base64,${buf.toString("base64")}`;
-	return await writeWallpaper(dataUrl) ? {
+	await ensureDir();
+	try {
+		await writeFile(wallpaperPath(), buf);
+	} catch (e) {
+		console.error("dsh-any-background: failed to write the downloaded wallpaper", e);
+		return {
+			ok: false,
+			error: "write failed"
+		};
+	}
+	return {
 		ok: true,
-		dataUrl
-	} : {
-		ok: false,
-		error: "write failed"
+		wallpaperUrl: WALLPAPER_ROUTE
 	};
 }
 const rotationDir = () => dshHomePath(DATA_DIR, ROTATION_DIR);
@@ -578,7 +600,8 @@ async function handleRotationRemove(payload) {
 	};
 }
 /** Activate a rotation item: copy its bytes over the active wallpaper slot and
-*  return the freshly sniffed data URL so the client can apply it live. */
+*  return the serve URL so the client applies it live (bytes never round-trip
+*  through the RPC response). */
 async function handleRotationSet(payload) {
 	const idx = payload?.index;
 	if (typeof idx !== "number" || !isFinite(idx)) return {
@@ -612,12 +635,155 @@ async function handleRotationSet(payload) {
 	}
 	return {
 		ok: true,
-		dataUrl: `data:${sniffImageMime(buf)};base64,${buf.toString("base64")}`
+		wallpaperUrl: WALLPAPER_ROUTE
 	};
 }
 async function videoUrl() {
 	return await findVideoFile() ? VIDEO_ROUTE : null;
 }
+/** Guess a video MIME from the URL's path extension (fallback for servers that
+*  send no precise Content-Type). */
+function videoMimeFromUrl(u) {
+	const p = u.pathname.toLowerCase();
+	if (/\.(mp4|m4v)$/.test(p)) return "video/mp4";
+	if (/\.webm$/.test(p)) return "video/webm";
+	if (/\.(ogg|ogv)$/.test(p)) return "video/ogg";
+	if (/\.(mov|qt)$/.test(p)) return "video/quicktime";
+	if (/\.(mkv|mk3d|mka)$/.test(p)) return "video/x-matroska";
+	return null;
+}
+/** Download a background video from a network URL and store it in the video
+*  slot (streamed to a temp file — never buffered whole), then record the MIME
+*  in the config so findVideoFile/serve resolve immediately. */
+async function writeVideoFromUrl(url) {
+	if (url === null) return {
+		ok: false,
+		error: "invalid url"
+	};
+	let u;
+	try {
+		u = new URL(url);
+	} catch {
+		return {
+			ok: false,
+			error: "invalid url"
+		};
+	}
+	if (u.protocol !== "http:" && u.protocol !== "https:") return {
+		ok: false,
+		error: "unsupported scheme"
+	};
+	let res;
+	try {
+		const ctl = new AbortController();
+		const timer = setTimeout(() => ctl.abort(), VIDEO_FETCH_TIMEOUT);
+		try {
+			res = await fetch(url, {
+				redirect: "follow",
+				signal: ctl.signal
+			});
+		} finally {
+			clearTimeout(timer);
+		}
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error && e.name === "AbortError" ? "timeout" : "network error"
+		};
+	}
+	if (!res.ok) return {
+		ok: false,
+		error: `http ${res.status}`
+	};
+	let mime = (res.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+	if (mime === "" || mime === "application/octet-stream" || mime === "binary/octet-stream") mime = videoMimeFromUrl(u) ?? "video/mp4";
+	if (!mime.startsWith("video/")) return {
+		ok: false,
+		error: "not a video"
+	};
+	const declared = Number(res.headers.get("content-length") ?? "");
+	if (Number.isFinite(declared) && declared > VIDEO_FETCH_MAX) return {
+		ok: false,
+		error: "too large"
+	};
+	await ensureDir();
+	const tmp = dshHomePath(DATA_DIR, "video.download.tmp");
+	const target = videoPathFor(mime);
+	try {
+		if (res.body === null) return {
+			ok: false,
+			error: "empty response"
+		};
+		const out = createWriteStream(tmp);
+		let received = 0;
+		let failed = false;
+		const fail = () => {
+			if (failed) return;
+			failed = true;
+			out.destroy();
+			rm(tmp, { force: true });
+		};
+		const nodeStream = Readable.fromWeb(res.body);
+		let idle = null;
+		const pokeIdle = () => {
+			if (idle) clearTimeout(idle);
+			idle = setTimeout(() => {
+				nodeStream.destroy();
+				fail();
+			}, VIDEO_FETCH_IDLE_TIMEOUT);
+		};
+		nodeStream.on("data", (chunk) => {
+			pokeIdle();
+			received += chunk.byteLength;
+			if (received > VIDEO_FETCH_MAX) {
+				nodeStream.destroy();
+				fail();
+			}
+		});
+		nodeStream.on("end", () => {
+			if (idle) clearTimeout(idle);
+			idle = null;
+		});
+		nodeStream.on("aborted", fail);
+		nodeStream.on("error", fail);
+		out.on("error", fail);
+		pokeIdle();
+		await new Promise((resolve, reject) => {
+			nodeStream.pipe(out);
+			out.on("finish", () => resolve());
+			out.on("close", () => {
+				if (failed) reject(/* @__PURE__ */ new Error("download failed"));
+			});
+			nodeStream.on("error", () => reject(/* @__PURE__ */ new Error("download failed")));
+		});
+		if (failed) return {
+			ok: false,
+			error: "read failed"
+		};
+		for (const name of VIDEO_CANDIDATES) {
+			const p = dshHomePath(DATA_DIR, name);
+			if (p !== target) await rm(p, { force: true });
+		}
+		await rm(target, { force: true });
+		await rename(tmp, target);
+		const cfg = await readConfig();
+		if (cfg.videoMime !== mime) {
+			cfg.videoMime = mime;
+			await writeConfig(cfg);
+		}
+		return {
+			ok: true,
+			mime
+		};
+	} catch (e) {
+		console.error("dsh-any-background: failed to download the background video", e);
+		rm(tmp, { force: true });
+		return {
+			ok: false,
+			error: e instanceof Error && e.message === "download failed" ? "read failed" : "write failed"
+		};
+	}
+}
 /** Persist a video from a data URL (null removes every variant); only used
 *  for removal and small legacy/import payloads. */
 async function writeVideo(dataUrl) {
@@ -735,9 +901,10 @@ async function handleVideoUpload(req, res) {
 	}
 	try {
 		await ensureDir();
-		const tmp = dshHomePath(DATA_DIR, UPLOAD_TMP);
+		const tmp = dshHomePath(DATA_DIR, VIDEO_UPLOAD_TMP);
 		const target = videoPathFor(mime);
 		const out = createWriteStream(tmp);
+		let received = 0;
 		let failed = false;
 		const fail = () => {
 			if (failed) return;
@@ -747,6 +914,13 @@ async function handleVideoUpload(req, res) {
 		};
 		req.on("aborted", fail);
 		req.on("error", fail);
+		req.on("data", (chunk) => {
+			received += chunk.byteLength;
+			if (received > VIDEO_UPLOAD_MAX) {
+				req.destroy();
+				fail();
+			}
+		});
 		out.on("error", () => {
 			fail();
 			try {
@@ -764,6 +938,11 @@ async function handleVideoUpload(req, res) {
 				}
 				await rm(target, { force: true });
 				await rename(tmp, target);
+				const cfg = await readConfig();
+				if (cfg.videoMime !== mime) {
+					cfg.videoMime = mime;
+					await writeConfig(cfg);
+				}
 				res.writeHead(200, { "Content-Type": "application/json" });
 				res.end(JSON.stringify({ ok: true }));
 			} catch (e) {
@@ -783,6 +962,131 @@ async function handleVideoUpload(req, res) {
 		} catch {}
 	}
 }
+/** Stream the stored wallpaper: sniffed MIME, no caching (uploads and rotation
+*  replace the file in place). */
+async function serveWallpaper(req, res) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "wallpaper route only serves GET/HEAD"
+		}));
+		return;
+	}
+	try {
+		const st = await stat(wallpaperPath());
+		if (st.size === 0) {
+			res.writeHead(404);
+			res.end();
+			return;
+		}
+		const mime = sniffImageMime(await new Promise((resolve, reject) => {
+			const chunks = [];
+			const s = createReadStream(wallpaperPath(), {
+				start: 0,
+				end: 15
+			});
+			s.on("data", (c) => chunks.push(c));
+			s.on("end", () => resolve(Buffer.concat(chunks)));
+			s.on("error", reject);
+		}));
+		res.writeHead(200, {
+			"Content-Type": mime,
+			"Content-Length": st.size,
+			"Cache-Control": "no-store"
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		createReadStream(wallpaperPath()).pipe(res);
+	} catch {
+		res.writeHead(404);
+		res.end("no wallpaper stored");
+	}
+}
+/** Accept a raw wallpaper upload (POST): pipe the body straight into the
+*  wallpaper slot — no base64 inflation, original pixels preserved. */
+async function handleWallpaperUpload(req, res) {
+	if (req.method !== "POST") {
+		res.writeHead(405);
+		res.end();
+		return;
+	}
+	if (!(typeof req.headers["content-type"] === "string" ? req.headers["content-type"] : "").split(";")[0].trim().startsWith("image/")) {
+		req.resume();
+		res.writeHead(415, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "unsupported media type, expected image/*"
+		}));
+		return;
+	}
+	try {
+		await ensureDir();
+		const tmp = dshHomePath(DATA_DIR, UPLOAD_TMP);
+		const out = createWriteStream(tmp);
+		let received = 0;
+		let failed = false;
+		const fail = () => {
+			if (failed) return;
+			failed = true;
+			out.destroy();
+			rm(tmp, { force: true });
+		};
+		req.on("aborted", fail);
+		req.on("error", fail);
+		out.on("error", () => {
+			fail();
+			try {
+				res.writeHead(500);
+				res.end();
+			} catch {}
+		});
+		req.on("data", (chunk) => {
+			received += chunk.byteLength;
+			if (received > WALLPAPER_UPLOAD_MAX) {
+				req.destroy();
+				fail();
+			}
+		});
+		req.pipe(out);
+		out.on("finish", async () => {
+			if (failed) return;
+			try {
+				if (received === 0) {
+					fail();
+					res.writeHead(400, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						ok: false,
+						error: "empty upload"
+					}));
+					return;
+				}
+				await rm(wallpaperPath(), { force: true });
+				await rename(tmp, wallpaperPath());
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					ok: true,
+					wallpaperUrl: WALLPAPER_ROUTE
+				}));
+			} catch (e) {
+				console.error("dsh-any-background: failed to finalize the wallpaper upload", e);
+				rm(tmp, { force: true });
+				try {
+					res.writeHead(500);
+					res.end();
+				} catch {}
+			}
+		});
+	} catch (e) {
+		console.error("dsh-any-background: failed to accept the wallpaper upload", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
 const NS = "dshAnyBackground";
 const RPC_CHANNEL = "/dsh-any-background";
 const RPC_BODY_MAX = 314572800;
@@ -841,7 +1145,7 @@ async function handleRpcMethod(endpoint, payload) {
 					ok: true,
 					value: {
 						config: await readConfig(),
-						wallpaper: await readWallpaper(),
+						wallpaperUrl: await wallpaperServeUrl(),
 						videoUrl: await videoUrl(),
 						rotated
 					}
@@ -863,6 +1167,10 @@ async function handleRpcMethod(endpoint, payload) {
 				ok: true,
 				value: await writeWallpaperFromUrl(payload?.url ?? null)
 			};
+			case "setVideoUrl": return {
+				ok: true,
+				value: await writeVideoFromUrl(payload?.url ?? null)
+			};
 			case "rotationAdd": return {
 				ok: true,
 				value: await handleRotationAdd(payload)
@@ -991,6 +1299,15 @@ function apply(ctx) {
 				}));
 			}
 		}), "dsh-any-background: rpc channel");
+		const fenceUpload = (handler) => (req, res) => {
+			const rejection = webCtx.connection.requestRejection(req);
+			if (rejection !== void 0) {
+				res.writeHead(rejection);
+				res.end(rejection === 401 ? "unauthorized" : "forbidden");
+				return;
+			}
+			handler(req, res);
+		};
 		webCtx.effect(() => webCtx.webServer.register({
 			kind: "prefix",
 			path: VIDEO_ROUTE,
@@ -999,8 +1316,18 @@ function apply(ctx) {
 		webCtx.effect(() => webCtx.webServer.register({
 			kind: "exact",
 			path: UPLOAD_ROUTE,
-			handler: handleVideoUpload
+			handler: fenceUpload(handleVideoUpload)
 		}), "dsh-any-background: upload route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "prefix",
+			path: WALLPAPER_ROUTE,
+			handler: serveWallpaper
+		}), "dsh-any-background: wallpaper route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "exact",
+			path: WALLPAPER_UPLOAD_ROUTE,
+			handler: fenceUpload(handleWallpaperUpload)
+		}), "dsh-any-background: wallpaper upload route");
 	});
 }
 //#endregion