dsh-any-background 0.1.8 → 0.2.1

package/lib/index.js

@@ -1,39 +1,63 @@
-import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { access, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createReadStream, createWriteStream } from "node:fs";
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 //#region src/index.ts
 /**
-* Node half of the dsh-any-background plugin: file-backed theme persistence.
+* Node half of dsh-any-background: file-backed theme persistence.
 *
-* The browser client cannot touch the filesystem, so this half owns the
-* `.dsh-any-background-data/` store under the DSH data home and exposes a
-* small RPC surface over the dedicated `/dsh-any-background` channel (never
-* the shared `/api`, so slash commands stay intact). The client reads the
-* persisted theme on boot and writes it back on every setting change.
+* Owns the `~/.dsh/.dsh-any-background-data/` store and exposes a small RPC
+* surface on the dedicated `/dsh-any-background` channel (never the shared
+* `/api`, so slash commands stay intact).
 *
-* Storage layout:
-*   ~/.dsh/.dsh-any-background-data/
-*     ├── theme-config.json   settings (color, opacities, blur, bg state)
-*     └── wallpaper.jpg       the chosen background image (deleted on remove)
-*
-* @module dsh-any-background
+*   theme-config.json   settings
+*   wallpaper.jpg       background image
+*   wallpaper.<ext>     background video, named by MIME (mp4/webm/ogv/mov/mkv);
+*                       played over HTTP route /dsh-any-background/video and
+*                       uploaded to /dsh-any-background/video/upload as raw
+*                       bytes — never base64 through the RPC channel.
 */
 const name = "dsh-any-background";
-const inject = ["connection"];
+const inject = ["connection", "webServer"];
 const DATA_DIR = ".dsh-any-background-data";
 const CONFIG_FILE = "theme-config.json";
 const WALLPAPER_FILE = "wallpaper.jpg";
+const VIDEO_ROUTE = "/dsh-any-background/video";
+const UPLOAD_ROUTE = "/dsh-any-background/video/upload";
+const UPLOAD_TMP = "wallpaper.upload.tmp";
+function videoFileName(mime) {
+	switch (mime) {
+		case "video/mp4": return "wallpaper.mp4";
+		case "video/webm": return "wallpaper.webm";
+		case "video/ogg": return "wallpaper.ogv";
+		case "video/quicktime": return "wallpaper.mov";
+		case "video/x-matroska": return "wallpaper.mkv";
+		default: return "wallpaper.video";
+	}
+}
+const VIDEO_CANDIDATES = [
+	"wallpaper.mp4",
+	"wallpaper.webm",
+	"wallpaper.ogv",
+	"wallpaper.mov",
+	"wallpaper.mkv",
+	"wallpaper.video"
+];
 const DEFAULT_CONFIG = {
 	color: null,
 	opacities: {
 		bg: .85,
 		sidebar: .93,
-		card: 1
+		card: 1,
+		input: 1
 	},
 	blurs: {
 		bg: 0,
 		sidebar: 0,
 		card: 0,
-		settings: 0
+		settings: 0,
+		chat: 0,
+		trajectory: 0,
+		input: 0
 	},
 	settingsOpacity: 1,
 	wallpaperOpacity: 1,
@@ -45,16 +69,73 @@ const DEFAULT_CONFIG = {
 		iw: 0,
 		ih: 0
 	},
+	videoBgState: {
+		zoom: 1,
+		x: 0,
+		y: 0,
+		iw: 0,
+		ih: 0
+	},
 	backgroundType: "image",
+	bgMode: "fit",
+	videoMime: null,
 	generatedBg: null,
-	regenerateOnReload: false
+	regenerateOnReload: false,
+	chatTextOpacity: 0,
+	trajectoryOpacity: 1
 };
 const dataDir = () => dshHomePath(DATA_DIR);
 const configPath = () => dshHomePath(DATA_DIR, CONFIG_FILE);
 const wallpaperPath = () => dshHomePath(DATA_DIR, WALLPAPER_FILE);
+const videoPathFor = (mime) => dshHomePath(DATA_DIR, videoFileName(mime));
+const exists = async (p) => {
+	try {
+		await access(p);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Locate the stored video: the recorded MIME decides the expected name; a
+*  legacy extensionless wallpaper.video is renamed on first access. */
+async function findVideoFile() {
+	const cfg = await readConfig();
+	const expected = videoPathFor(cfg.videoMime);
+	if (await exists(expected)) return {
+		path: expected,
+		mime: cfg.videoMime
+	};
+	for (const name of VIDEO_CANDIDATES) {
+		const p = dshHomePath(DATA_DIR, name);
+		if (!await exists(p)) continue;
+		if (cfg.videoMime !== null && name !== videoFileName(cfg.videoMime)) try {
+			await rename(p, expected);
+			return {
+				path: expected,
+				mime: cfg.videoMime
+			};
+		} catch {
+			return null;
+		}
+		return {
+			path: p,
+			mime: cfg.videoMime
+		};
+	}
+	return null;
+}
 function clamp(n, lo, hi, def) {
 	return typeof n === "number" && isFinite(n) ? Math.min(hi, Math.max(lo, n)) : def;
 }
+function normalizeBgState(s) {
+	return {
+		zoom: clamp(s.zoom, .1, 10, 1),
+		x: typeof s.x === "number" && isFinite(s.x) ? s.x : 0,
+		y: typeof s.y === "number" && isFinite(s.y) ? s.y : 0,
+		iw: typeof s.iw === "number" && s.iw > 0 ? s.iw : 0,
+		ih: typeof s.ih === "number" && s.ih > 0 ? s.ih : 0
+	};
+}
 /** Coerce an unknown persisted value into a valid ThemeConfig, falling back per-field. */
 function normalizeConfig(raw) {
 	const r = raw ?? {};
@@ -64,44 +145,56 @@ function normalizeConfig(raw) {
 		clamp(c[1], 0, 1, .55),
 		clamp(c[2], 0, 1, .25)
 	] : null;
-	const bg = r.bgState ?? {};
 	const bgType = [
 		"image",
+		"video",
 		"mesh",
 		"shader",
 		"pattern"
 	].includes(r.backgroundType) ? r.backgroundType : DEFAULT_CONFIG.backgroundType;
+	const bgMode = [
+		"fit",
+		"fill",
+		"stretch",
+		"tile",
+		"center"
+	].includes(r.bgMode) ? r.bgMode : DEFAULT_CONFIG.bgMode;
 	const gen = r.generatedBg && typeof r.generatedBg === "object" ? r.generatedBg : null;
 	const generatedBg = gen && gen.type === bgType ? normalizeGeneratedBg(r.generatedBg) : null;
 	const legacy = typeof r.opacity === "number" ? r.opacity : null;
 	const ops = r.opacities ?? {};
 	const bl = r.blurs ?? {};
+	const blurs = {};
+	for (const k of [
+		"bg",
+		"sidebar",
+		"card",
+		"settings",
+		"chat",
+		"trajectory",
+		"input"
+	]) blurs[k] = clamp(bl[k], 0, 60, DEFAULT_CONFIG.blurs[k]);
 	return {
 		color,
 		opacities: {
 			bg: clamp(ops.bg, 0, 1, legacy ?? DEFAULT_CONFIG.opacities.bg),
 			sidebar: clamp(ops.sidebar, 0, 1, legacy !== null ? Math.min(1, legacy + .08) : DEFAULT_CONFIG.opacities.sidebar),
-			card: clamp(ops.card, 0, 1, DEFAULT_CONFIG.opacities.card)
-		},
-		blurs: {
-			bg: clamp(bl.bg, 0, 60, DEFAULT_CONFIG.blurs.bg),
-			sidebar: clamp(bl.sidebar, 0, 60, DEFAULT_CONFIG.blurs.sidebar),
-			card: clamp(bl.card, 0, 60, DEFAULT_CONFIG.blurs.card),
-			settings: clamp(bl.settings, 0, 60, DEFAULT_CONFIG.blurs.settings)
+			card: clamp(ops.card, 0, 1, DEFAULT_CONFIG.opacities.card),
+			input: clamp(ops.input, 0, 1, DEFAULT_CONFIG.opacities.input)
 		},
+		blurs,
 		settingsOpacity: clamp(r.settingsOpacity, 0, 1, DEFAULT_CONFIG.settingsOpacity),
 		wallpaperOpacity: clamp(r.wallpaperOpacity, 0, 1, DEFAULT_CONFIG.wallpaperOpacity),
 		blur: clamp(r.blur, 0, 60, DEFAULT_CONFIG.blur),
-		bgState: {
-			zoom: clamp(bg.zoom, .1, 10, 1),
-			x: typeof bg.x === "number" && isFinite(bg.x) ? bg.x : 0,
-			y: typeof bg.y === "number" && isFinite(bg.y) ? bg.y : 0,
-			iw: typeof bg.iw === "number" && bg.iw > 0 ? bg.iw : 0,
-			ih: typeof bg.ih === "number" && bg.ih > 0 ? bg.ih : 0
-		},
+		bgState: normalizeBgState(r.bgState ?? {}),
+		videoBgState: normalizeBgState(r.videoBgState ?? {}),
 		backgroundType: bgType,
+		bgMode,
+		videoMime: typeof r.videoMime === "string" ? r.videoMime : null,
 		generatedBg,
-		regenerateOnReload: typeof r.regenerateOnReload === "boolean" ? r.regenerateOnReload : DEFAULT_CONFIG.regenerateOnReload
+		regenerateOnReload: typeof r.regenerateOnReload === "boolean" ? r.regenerateOnReload : DEFAULT_CONFIG.regenerateOnReload,
+		chatTextOpacity: clamp(r.chatTextOpacity, 0, 1, DEFAULT_CONFIG.chatTextOpacity),
+		trajectoryOpacity: clamp(r.trajectoryOpacity, 0, 1, DEFAULT_CONFIG.trajectoryOpacity)
 	};
 }
 function normalizeGeneratedBg(p) {
@@ -144,16 +237,10 @@ async function ensureDir() {
 }
 async function readConfig() {
 	await ensureDir();
-	try {
-		await access(configPath());
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
 	try {
 		const raw = await readFile(configPath(), "utf8");
 		return normalizeConfig(JSON.parse(raw));
-	} catch (e) {
-		console.warn(`dsh-any-background: cannot read "${CONFIG_FILE}", using defaults`, e);
+	} catch {
 		return { ...DEFAULT_CONFIG };
 	}
 }
@@ -167,7 +254,6 @@ async function writeConfig(config) {
 		return false;
 	}
 }
-/** Read the wallpaper file and return it as a JPEG data URL (null when absent). */
 async function readWallpaper() {
 	try {
 		return `data:image/jpeg;base64,${(await readFile(wallpaperPath())).toString("base64")}`;
@@ -175,11 +261,7 @@ async function readWallpaper() {
 		return null;
 	}
 }
-/**
-* Persist a wallpaper. Passing null removes the stored file; otherwise the
-* data URL is decoded and written to wallpaper.jpg. Returns false (and keeps
-* the previous file) when the payload is invalid or the write fails.
-*/
+/** Persist a wallpaper (null removes it); false keeps the previous file. */
 async function writeWallpaper(dataUrl) {
 	await ensureDir();
 	try {
@@ -196,6 +278,174 @@ async function writeWallpaper(dataUrl) {
 		return false;
 	}
 }
+async function videoUrl() {
+	return await findVideoFile() ? VIDEO_ROUTE : null;
+}
+/** Persist a video from a data URL (null removes every variant); only used
+*  for removal and small legacy/import payloads. */
+async function writeVideo(dataUrl) {
+	await ensureDir();
+	try {
+		if (dataUrl === null) {
+			for (const name of VIDEO_CANDIDATES) await rm(dshHomePath(DATA_DIR, name), { force: true });
+			return true;
+		}
+		const m = /^data:(video\/[a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(dataUrl);
+		if (!m) return false;
+		const target = videoPathFor(m[1]);
+		for (const name of VIDEO_CANDIDATES) {
+			const p = dshHomePath(DATA_DIR, name);
+			if (p !== target) await rm(p, { force: true });
+		}
+		await writeFile(target, Buffer.from(m[2], "base64"));
+		return true;
+	} catch (e) {
+		console.error("dsh-any-background: failed to write the background video", e);
+		return false;
+	}
+}
+/** Stream the stored video: correct MIME, no caching, Range answers so the
+*  browser can seek (snapshot capture does). */
+async function serveVideo(req, res) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "video route only serves GET/HEAD; uploads need the plugin upload route — restart the web server to load it"
+		}));
+		return;
+	}
+	try {
+		const found = await findVideoFile();
+		if (found === null) {
+			res.writeHead(404);
+			res.end("no background video stored");
+			return;
+		}
+		const st = await stat(found.path);
+		const baseHeaders = {
+			"Content-Type": found.mime ?? "application/octet-stream",
+			"Accept-Ranges": "bytes",
+			"Cache-Control": "no-store"
+		};
+		const range = typeof req.headers.range === "string" ? req.headers.range.trim() : "";
+		const m = /^bytes=(\d*)-(\d*)$/.exec(range);
+		if (m !== null && (m[1] !== "" || m[2] !== "")) {
+			let start;
+			let end;
+			if (m[1] === "") {
+				const suffix = parseInt(m[2], 10);
+				start = Math.max(0, st.size - suffix);
+				end = st.size - 1;
+			} else {
+				start = parseInt(m[1], 10);
+				end = m[2] !== "" ? Math.min(parseInt(m[2], 10), st.size - 1) : st.size - 1;
+			}
+			if (start >= st.size || start > end) {
+				res.writeHead(416, { "Content-Range": `bytes */${st.size}` });
+				res.end();
+				return;
+			}
+			res.writeHead(206, {
+				...baseHeaders,
+				"Content-Range": `bytes ${start}-${end}/${st.size}`,
+				"Content-Length": end - start + 1
+			});
+			if (req.method === "HEAD") {
+				res.end();
+				return;
+			}
+			createReadStream(found.path, {
+				start,
+				end
+			}).pipe(res);
+			return;
+		}
+		res.writeHead(200, {
+			...baseHeaders,
+			"Content-Length": st.size
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		createReadStream(found.path).pipe(res);
+	} catch (e) {
+		console.error("dsh-any-background: failed to serve the background video", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
+/** Accept a raw video upload (POST): pipe the body into a temp file, then
+*  rename it into the MIME-derived slot. Aborted transfers clean up. */
+async function handleVideoUpload(req, res) {
+	if (req.method !== "POST") {
+		res.writeHead(405);
+		res.end();
+		return;
+	}
+	const mime = (typeof req.headers["content-type"] === "string" ? req.headers["content-type"] : "").split(";")[0].trim();
+	if (!mime.startsWith("video/")) {
+		req.resume();
+		res.writeHead(415, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "unsupported media type, expected video/*"
+		}));
+		return;
+	}
+	try {
+		await ensureDir();
+		const tmp = dshHomePath(DATA_DIR, UPLOAD_TMP);
+		const target = videoPathFor(mime);
+		const out = createWriteStream(tmp);
+		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.pipe(out);
+		out.on("finish", async () => {
+			if (failed) return;
+			try {
+				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);
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ ok: true }));
+			} catch (e) {
+				console.error("dsh-any-background: failed to finalize the uploaded video", e);
+				rm(tmp, { force: true });
+				try {
+					res.writeHead(500);
+					res.end();
+				} catch {}
+			}
+		});
+	} catch (e) {
+		console.error("dsh-any-background: failed to accept the video upload", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
 const NS = "dshAnyBackground";
 function apply(ctx) {
 	const dispose = ctx.connection.rpc.handle("/dsh-any-background", async (ep, payload) => {
@@ -206,7 +456,8 @@ function apply(ctx) {
 					ok: true,
 					value: {
 						config: await readConfig(),
-						wallpaper: await readWallpaper()
+						wallpaper: await readWallpaper(),
+						videoUrl: await videoUrl()
 					}
 				};
 				case "writeConfig": return {
@@ -217,6 +468,10 @@ function apply(ctx) {
 					ok: true,
 					value: await writeWallpaper(payload?.dataUrl ?? null)
 				};
+				case "setVideo": return {
+					ok: true,
+					value: await writeVideo(payload?.dataUrl ?? null)
+				};
 				default: return {
 					ok: false,
 					error: {
@@ -237,7 +492,19 @@ function apply(ctx) {
 			};
 		}
 	}, { authority: "trusted-host" });
+	const disposeRoute = ctx.webServer.register({
+		kind: "prefix",
+		path: VIDEO_ROUTE,
+		handler: serveVideo
+	});
+	const disposeUpload = ctx.webServer.register({
+		kind: "exact",
+		path: UPLOAD_ROUTE,
+		handler: handleVideoUpload
+	});
 	ctx.on("dispose", () => {
+		disposeRoute();
+		disposeUpload();
 		dispose();
 	});
 }

package/lib/invariant.js

@@ -1,19 +1,8 @@
 //#region src/invariant.ts
 const PACKAGE_NAME = "dsh-any-background";
-/** Cordis companion plugin name. */
 const name = "dsh-any-background-invariant";
-/** Service required before the companion can reserve package ownership. */
 const inject = ["invariants"];
-/**
-* No runtime invariant: the plugin registers a theme definition through the
-* existing ThemeRuntime service and emits no cross-plugin mutable state.
-*/
 const install = () => {};
-/**
-* Register this package's invariant companion.
-* @param ctx - Cordis context carrying the invariant service.
-* @returns the installed registration's disposer after setup succeeds.
-*/
 const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
 //#endregion
 export { apply, inject, name };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-any-background",
-  "version": "0.1.8",
+  "version": "0.2.1",
   "description": "Appearance plugin for DeepSeek Harness: custom theme color (PS-style color wheel), background wallpaper with opacity/blur controls, and separate main/settings interface opacity.",
   "keywords": [
     "deepseek-harness",
@@ -50,16 +50,17 @@
     "watch": "tsdown --watch",
     "typecheck": "tsc -p tsconfig.json"
   },
+  "dependencies": {
+    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6"
+  },
   "devDependencies": {
     "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6",
     "@types/node": "^26.2.0",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
     "tsdown": "^0.22.2",
-    "typescript": "^7.0.2"
-  },
-  "dependencies": {
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6"
+    "typescript": "^7.0.2",
+    "unrun": "^0.3.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
@@ -102,5 +103,6 @@
       ],
       "immediately": true
     }
-  }
+  },
+  "packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be"
 }