dsh-any-background 0.2.8 → 0.2.9

package/lib/index.js

@@ -27,10 +27,14 @@ 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 FONT_ROUTE = "/dsh-any-background/font";
+const FONT_UPLOAD_ROUTE = "/dsh-any-background/font/upload";
 const UPLOAD_TMP = "wallpaper.upload.tmp";
 const VIDEO_UPLOAD_TMP = "video.upload.tmp";
+const FONT_UPLOAD_TMP = "font.upload.tmp";
 const WALLPAPER_UPLOAD_MAX = 104857600;
 const VIDEO_UPLOAD_MAX = 2147483648;
+const FONT_UPLOAD_MAX = 104857600;
 const WALLPAPER_FETCH_MAX = 26214400;
 const WALLPAPER_FETCH_TIMEOUT = 2e4;
 const VIDEO_FETCH_MAX = 2147483648;
@@ -54,28 +58,100 @@ const VIDEO_CANDIDATES = [
 	"wallpaper.mkv",
 	"wallpaper.video"
 ];
+/** Font slot: one font owns the slot, named by format like the video slot. */
+function fontFileName(mime) {
+	switch (mime) {
+		case "font/woff2": return "font.woff2";
+		case "font/woff": return "font.woff";
+		case "font/otf": return "font.otf";
+		case "font/ttf": return "font.ttf";
+		default: return "font.ttf";
+	}
+}
+const FONT_CANDIDATES = [
+	"font.woff2",
+	"font.woff",
+	"font.otf",
+	"font.ttf"
+];
+/** Sniff a font's container format from its leading magic bytes (null when the
+*  bytes are not a recognized font — uploads are rejected rather than stored). */
+function sniffFontMime(buf) {
+	if (buf.length >= 4 && buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 50) return "font/woff2";
+	if (buf.length >= 4 && buf[0] === 119 && buf[1] === 79 && buf[2] === 70 && buf[3] === 70) return "font/woff";
+	if (buf.length >= 4 && buf[0] === 79 && buf[1] === 84 && buf[2] === 84 && buf[3] === 79) return "font/otf";
+	if (buf.length >= 4 && buf[0] === 0 && buf[1] === 1 && buf[2] === 0 && buf[3] === 0) return "font/ttf";
+	return null;
+}
 const DEFAULT_CONFIG = {
 	color: null,
 	opacities: {
-		bg: .85,
-		sidebar: .93,
-		card: 1,
-		input: 1
+		bg: .5,
+		sidebar: .5,
+		card: .5,
+		input: .5
 	},
 	blurs: {
-		bg: 0,
-		sidebar: 0,
-		card: 0,
-		settings: 0,
-		chat: 0,
-		trajectory: 0,
-		input: 0,
-		panel: 0,
-		produced: 0
+		bg: 30,
+		sidebar: 30,
+		card: 30,
+		settings: 30,
+		chat: 30,
+		trajectory: 30,
+		input: 30,
+		panel: 30,
+		produced: 30
 	},
-	settingsOpacity: 1,
+	strokes: {
+		bg: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		sidebar: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		card: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		settings: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		chat: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		trajectory: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		input: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		panel: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		},
+		produced: {
+			width: 0,
+			color: "auto",
+			customColor: "#808080"
+		}
+	},
+	settingsOpacity: .5,
 	wallpaperOpacity: 1,
-	blur: 0,
+	blur: 30,
 	bgState: {
 		zoom: 1,
 		x: 0,
@@ -93,12 +169,14 @@ const DEFAULT_CONFIG = {
 	backgroundType: "image",
 	bgMode: "fit",
 	videoMime: null,
+	fontMime: null,
+	fontEnabled: true,
 	generatedBg: null,
 	regenerateOnReload: false,
-	chatTextOpacity: 0,
-	trajectoryOpacity: 1,
-	panelOpacity: 1,
-	producedOpacity: 1,
+	chatTextOpacity: .5,
+	trajectoryOpacity: .5,
+	panelOpacity: .5,
+	producedOpacity: .5,
 	profiles: [],
 	rotation: {
 		enabled: false,
@@ -123,6 +201,7 @@ 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 fontPathFor = (mime) => dshHomePath(DATA_DIR, fontFileName(mime));
 const exists = async (p) => {
 	try {
 		await access(p);
@@ -162,6 +241,43 @@ async function findVideoFile() {
 function clamp(n, lo, hi, def) {
 	return typeof n === "number" && isFinite(n) ? Math.min(hi, Math.max(lo, n)) : def;
 }
+/** Locate the stored font: the recorded MIME decides the expected name; stray
+*  files from a lost config write are adopted via rename (mirrors the video
+*  slot's recovery). */
+async function findFontFile() {
+	const mime = (await readConfig()).fontMime ?? "font/ttf";
+	const expected = fontPathFor(mime);
+	if (await exists(expected)) return {
+		path: expected,
+		mime
+	};
+	for (const name of FONT_CANDIDATES) {
+		const p = dshHomePath(DATA_DIR, name);
+		if (!await exists(p)) continue;
+		const foundMime = mimeForFontFile(name);
+		try {
+			await rename(p, expected);
+			return {
+				path: expected,
+				mime: foundMime
+			};
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+function mimeForFontFile(name) {
+	switch (name) {
+		case "font.woff2": return "font/woff2";
+		case "font.woff": return "font/woff";
+		case "font.otf": return "font/otf";
+		default: return "font/ttf";
+	}
+}
+async function fontUrl() {
+	return await findFontFile() ? FONT_ROUTE : null;
+}
 function normalizeBgState(s) {
 	return {
 		zoom: clamp(s.zoom, .1, 10, 1),
@@ -172,6 +288,40 @@ function normalizeBgState(s) {
 	};
 }
 /** Coerce an unknown persisted value into a valid ThemeConfig, falling back per-field. */
+const STROKE_GROUPS = [
+	"bg",
+	"sidebar",
+	"card",
+	"settings",
+	"chat",
+	"trajectory",
+	"input",
+	"panel",
+	"produced"
+];
+const STROKE_COLOR_KEYS = [
+	"auto",
+	"gray",
+	"black",
+	"white",
+	"theme",
+	"custom"
+];
+const HEX_RE = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+function normalizeStroke(raw) {
+	const s = raw ?? {};
+	return {
+		width: clamp(s.width, 0, 4, 0),
+		color: STROKE_COLOR_KEYS.includes(s.color) ? s.color : "auto",
+		customColor: typeof s.customColor === "string" && HEX_RE.test(s.customColor) ? s.customColor : "#808080"
+	};
+}
+function normalizeStrokes(raw) {
+	const s = raw ?? {};
+	const out = {};
+	for (const k of STROKE_GROUPS) out[k] = normalizeStroke(s[k]);
+	return out;
+}
 function normalizeConfig(raw) {
 	const r = raw ?? {};
 	const c = r.color;
@@ -220,6 +370,7 @@ function normalizeConfig(raw) {
 			input: clamp(ops.input, 0, 1, DEFAULT_CONFIG.opacities.input)
 		},
 		blurs,
+		strokes: normalizeStrokes(r.strokes),
 		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),
@@ -228,6 +379,8 @@ function normalizeConfig(raw) {
 		backgroundType: bgType,
 		bgMode,
 		videoMime: typeof r.videoMime === "string" ? r.videoMime : null,
+		fontMime: typeof r.fontMime === "string" ? r.fontMime : null,
+		fontEnabled: typeof r.fontEnabled === "boolean" ? r.fontEnabled : DEFAULT_CONFIG.fontEnabled,
 		generatedBg,
 		regenerateOnReload: typeof r.regenerateOnReload === "boolean" ? r.regenerateOnReload : DEFAULT_CONFIG.regenerateOnReload,
 		chatTextOpacity: clamp(r.chatTextOpacity, 0, 1, DEFAULT_CONFIG.chatTextOpacity),
@@ -311,6 +464,7 @@ function normalizeProfileAppearance(raw) {
 			input: clamp(ops.input, 0, 1, DEFAULT_CONFIG.opacities.input)
 		},
 		blurs,
+		strokes: normalizeStrokes(a.strokes),
 		settingsOpacity: clamp(a.settingsOpacity, 0, 1, DEFAULT_CONFIG.settingsOpacity),
 		wallpaperOpacity: clamp(a.wallpaperOpacity, 0, 1, DEFAULT_CONFIG.wallpaperOpacity),
 		blur: clamp(a.blur, 0, 60, DEFAULT_CONFIG.blur),
@@ -406,7 +560,11 @@ function warnUnknownConfigKeys(raw, normalized) {
 		if (known.has(key) || LEGACY_CONFIG_KEYS.has(key)) continue;
 		warn(key);
 	}
-	for (const group of ["blurs", "opacities"]) {
+	for (const group of [
+		"blurs",
+		"opacities",
+		"strokes"
+	]) {
 		const got = r[group];
 		if (got === null || typeof got !== "object") continue;
 		const have = new Set(Object.keys(normalized[group]));
@@ -1123,6 +1281,164 @@ async function handleWallpaperUpload(req, res) {
 		} catch {}
 	}
 }
+/** Stream the stored custom font: sniffed MIME, no caching (uploads replace
+*  the file in place). Fonts need no Range support — the browser fetches once. */
+async function serveFont(req, res) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "font route only serves GET/HEAD"
+		}));
+		return;
+	}
+	try {
+		const found = await findFontFile();
+		if (found === null) {
+			res.writeHead(404);
+			res.end("no custom font stored");
+			return;
+		}
+		const st = await stat(found.path);
+		res.writeHead(200, {
+			"Content-Type": found.mime,
+			"Content-Length": st.size,
+			"Cache-Control": "no-store"
+		});
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		createReadStream(found.path).pipe(res);
+	} catch (e) {
+		console.error("dsh-any-background: failed to serve the custom font", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
+/** Accept a raw font upload (POST): pipe the body into a temp file, sniff the
+*  container format from its magic bytes (rejecting anything that is not a
+*  recognizable font), then rename it into the format-derived slot and record
+*  the MIME in the config so serve/find resolve immediately. */
+async function handleFontUpload(req, res) {
+	if (req.method !== "POST") {
+		res.writeHead(405);
+		res.end();
+		return;
+	}
+	try {
+		await ensureDir();
+		const tmp = dshHomePath(DATA_DIR, FONT_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 > FONT_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;
+				}
+				const mime = sniffFontMime(await new Promise((resolve, reject) => {
+					const chunks = [];
+					const s = createReadStream(tmp, {
+						start: 0,
+						end: 15
+					});
+					s.on("data", (c) => chunks.push(c));
+					s.on("end", () => resolve(Buffer.concat(chunks)));
+					s.on("error", reject);
+				}));
+				if (mime === null) {
+					fail();
+					res.writeHead(415, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						ok: false,
+						error: "not a font (expected ttf/otf/woff/woff2)"
+					}));
+					return;
+				}
+				const target = fontPathFor(mime);
+				for (const name of FONT_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.fontMime !== mime) {
+					cfg.fontMime = mime;
+					await writeConfig(cfg);
+				}
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					ok: true,
+					fontUrl: FONT_ROUTE,
+					mime
+				}));
+			} catch (e) {
+				console.error("dsh-any-background: failed to finalize the font upload", e);
+				rm(tmp, { force: true });
+				try {
+					res.writeHead(500);
+					res.end();
+				} catch {}
+			}
+		});
+	} catch (e) {
+		console.error("dsh-any-background: failed to accept the font upload", e);
+		try {
+			res.writeHead(500);
+			res.end();
+		} catch {}
+	}
+}
+/** Remove every stored font variant and clear the recorded MIME. */
+async function removeFontFile() {
+	try {
+		for (const name of FONT_CANDIDATES) await rm(dshHomePath(DATA_DIR, name), { force: true });
+		await rm(dshHomePath(DATA_DIR, FONT_UPLOAD_TMP), { force: true });
+		const cfg = await readConfig();
+		if (cfg.fontMime !== null) {
+			cfg.fontMime = null;
+			await writeConfig(cfg);
+		}
+		return true;
+	} catch (e) {
+		console.error("dsh-any-background: failed to remove the custom font", e);
+		return false;
+	}
+}
 const NS = "dshAnyBackground";
 const RPC_CHANNEL = "/dsh-any-background";
 const RPC_BODY_MAX = 314572800;
@@ -1177,13 +1493,18 @@ async function handleRpcMethod(endpoint, payload) {
 		switch (method) {
 			case "read": {
 				const rotated = await advanceRotationIfDue();
+				const config = await readConfig();
+				const firstRun = !await exists(configPath());
+				if (firstRun) await writeConfig(config);
 				return {
 					ok: true,
 					value: {
-						config: await readConfig(),
+						config,
 						wallpaperUrl: await wallpaperServeUrl(),
 						videoUrl: await videoUrl(),
-						rotated
+						fontUrl: await fontUrl(),
+						rotated,
+						firstRun
 					}
 				};
 			}
@@ -1219,6 +1540,10 @@ async function handleRpcMethod(endpoint, payload) {
 				ok: true,
 				value: await handleRotationSet(payload)
 			};
+			case "removeFont": return {
+				ok: true,
+				value: await removeFontFile()
+			};
 			default: return {
 				ok: false,
 				error: {
@@ -1364,7 +1689,17 @@ function apply(ctx) {
 			path: WALLPAPER_UPLOAD_ROUTE,
 			handler: fenceUpload(handleWallpaperUpload)
 		}), "dsh-any-background: wallpaper upload route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "prefix",
+			path: FONT_ROUTE,
+			handler: serveFont
+		}), "dsh-any-background: font route");
+		webCtx.effect(() => webCtx.webServer.register({
+			kind: "exact",
+			path: FONT_UPLOAD_ROUTE,
+			handler: fenceUpload(handleFontUpload)
+		}), "dsh-any-background: font upload route");
 	});
 }
 //#endregion
-export { apply, inject, name };
+export { DEFAULT_CONFIG, apply, inject, name };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-any-background",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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",
@@ -103,6 +103,7 @@
   },
   "dsh": {
     "compatibility": {
+      "dsh": "0.1.5-rc.2",
       "dshReleases": {
         "0.1.5-rc.2": "compatible"
       }