wallpaper-engine-dsh 0.1.5 → 0.1.7

package/lib/index.js

@@ -6,17 +6,21 @@
  * All parsing/enumeration logic lives in the pure layer (lib/core.js); this
  * file only wires it into same-origin HTTP routes on `ctx.webServer`:
  *
- *   GET  /we-background/inventory[?refresh=1] → { installDir, wallpapers, playlists }
+ *   GET  /we-background/inventory[?refresh=1] → { installDir, total,
+ *         portableCount, wallpapers, playlists }
  *   GET  /we-background/media/<token>[/<sub-asset>…] → video / web HTML + assets
  *   GET  /we-background/preview/<token>             → preview image
  *
  * Security model
- *   - Tokens are 72-bit random values minted per inventory build (not
- *     reversible encodings of paths). Knowing a filesystem path grants
- *     nothing; only files enumerated into the inventory are reachable.
- *     Rebuilding the inventory re-mints every token, so stale URLs die.
+ *   - Tokens are 72-bit random values (not reversible encodings of paths).
+ *     Knowing a filesystem path grants nothing; only files enumerated into
+ *     the inventory are reachable. Tokens are stable per wallpaper across
+ *     TTL-triggered rebuilds (so an in-flight video stream is never killed
+ *     by a background refresh) and re-minted on an explicit ?refresh=1, so
+ *     deliberately stale URLs die.
  *   - Web-wallpaper sub-assets resolve strictly INSIDE their project
- *     directory (core.isInsideDir) — `..` traversal is answered 403.
+ *     directory (core.isInsideDir) — `..` and backslash traversal are
+ *     answered 403.
  *   - project.json-declared files must also be inside the project directory
  *     (core.readProject), so a hostile workshop item cannot point the server
  *     at arbitrary files.
@@ -26,6 +30,9 @@
  *   - Everything is loopback same-origin; `X-Content-Type-Options: nosniff`
  *     on every media response.
  *
+ * Async: discovery (reg.exe, vdf scan) and inventory builds run through
+ * fs/promises, so a rebuild never blocks the event loop mid-stream.
+ *
  * Lifecycle: every route registers through the plugin fiber and unwinds on
  * unload; the inventory cache and token map are dropped with it. The plugin
  * contributes no model-visible tool and no prompt text.
@@ -33,11 +40,9 @@
 
 import {
   createReadStream,
-  existsSync,
-  readFileSync,
-  statSync,
+  promises as fsp,
 } from 'node:fs';
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 
@@ -47,133 +52,197 @@ import * as core from './core.js';
 const BASE = '/we-background';
 /** Inventory is cached and rebuilt at most this often unless ?refresh=1. */
 const INVENTORY_TTL_MS = 30_000;
+/** Steam layout barely moves; re-discover at most this often on TTL builds. */
+const DISCOVERY_TTL_MS = 10 * 60_000;
+
+/** fs/promises-backed io for the pure layer (awaited there). */
+const asyncIo = {
+  existsSync: async (p) => { try { await fsp.access(p); return true; } catch { return false; } },
+  readFileSync: (p, encoding) => fsp.readFile(p, encoding),
+  readdirSync: (p) => fsp.readdir(p),
+  statSync: (p) => fsp.stat(p),
+};
 
 /** Steam root recorded by the Windows installer; null elsewhere/on failure. */
 function steamRegistryRoot() {
-  if (process.platform !== 'win32') return null;
-  try {
+  if (process.platform !== 'win32') return Promise.resolve(null);
+  return new Promise((resolvePromise) => {
     const reg = join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'reg.exe');
-    const out = execFileSync(
+    execFile(
       reg,
       ['query', 'HKCU\\Software\\Valve\\Steam', '/v', 'SteamPath'],
-      { encoding: 'utf8', windowsHide: true, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] },
+      { encoding: 'utf8', windowsHide: true, timeout: 5000 },
+      (err, stdout) => {
+        if (err) { resolvePromise(null); return; }
+        resolvePromise(core.steamPathFromRegQuery(stdout));
+      },
     );
-    return core.steamPathFromRegQuery(out);
-  } catch {
-    return null;
-  }
+  });
 }
 
 /** Full discovery pass: install dir + every library owning WE content. */
-function discover() {
+async function discover() {
   const probes = core.steamProbeDirs();
-  const registryRoot = steamRegistryRoot();
+  const registryRoot = await steamRegistryRoot();
   const searchRoots = registryRoot ? [registryRoot, ...probes] : probes;
   const vdfLibraries = [];
   for (const root of searchRoots) {
     const vdf = join(root, 'steamapps', 'libraryfolders.vdf');
-    if (!existsSync(vdf)) continue;
+    if (!await asyncIo.existsSync(vdf)) continue;
     try {
-      vdfLibraries.push(...core.librariesFromVdfText(readFileSync(vdf, 'utf8')));
+      vdfLibraries.push(...core.librariesFromVdfText(await asyncIo.readFileSync(vdf, 'utf8')));
     } catch { /* unreadable vdf → skip this root */ }
   }
-  const installDir = core.findInstallDir(
+  const installDir = await core.findInstallDir(
     core.installDirCandidates({ registryRoot, libraryRoots: vdfLibraries }),
+    asyncIo,
   );
-  const libraryRoots = core.workshopLibraryRoots(searchRoots, vdfLibraries);
+  const libraryRoots = await core.workshopLibraryRoots(searchRoots, vdfLibraries, asyncIo);
   return { installDir, libraryRoots };
 }
 
-export const inject = ['webServer'];
-
-export function apply(ctx) {
-  const webServer = ctx.webServer;
-  if (!webServer || typeof webServer.register !== 'function') {
-    return () => {}; // defensive: inject guarantees the service in practice
-  }
+/**
+ * Register all routes on a webServer-like registry and return a disposer.
+ * Extracted from apply() so integration tests can drive the HTTP surface
+ * against a fixture discovery without a live Steam install.
+ *
+ * @param {{ register(route: { kind: 'exact'|'prefix', path: string, handler: Function }): () => void }} webServer
+ * @param {{ discover?: () => Promise<{ installDir: string|null, libraryRoots: string[] }>, inventoryTtlMs?: number, discoveryTtlMs?: number }} [opts]
+ */
+export function createRouteRegistrar(webServer, opts = {}) {
+  const discoverFn = opts.discover || discover;
+  const inventoryTtlMs = opts.inventoryTtlMs ?? INVENTORY_TTL_MS;
+  const discoveryTtlMs = opts.discoveryTtlMs ?? DISCOVERY_TTL_MS;
 
   // ── Token registry ──────────────────────────────────────────────────────
-  // token → { abs, rootDir|null }. rootDir is set for renderable projects so
-  // web wallpapers can fetch their bundled sub-assets (contained, see below).
+  // token → { abs, rootDir|null }. rootDir is set for renderable web projects
+  // so their bundled sub-assets can be fetched (contained, see below).
+  // Tokens are keyed per wallpaper asset (`<id>:media` / `<id>:preview`):
+  // TTL rebuilds REUSE the token for an unchanged asset (in-flight streams
+  // survive), prune assets that vanished, and only an explicit ?refresh=1
+  // re-mints everything.
   const tokens = new Map();
+  const tokenByKey = new Map();
   const mint = (entry) => {
+    const key = entry && entry.key;
+    if (key && tokenByKey.has(key)) return tokenByKey.get(key);
     const token = randomBytes(9).toString('base64url'); // 72 bits, url-safe
     tokens.set(token, entry);
+    if (key) tokenByKey.set(key, token);
     return token;
   };
+  const remintAll = () => { tokens.clear(); tokenByKey.clear(); };
+  const pruneTokens = (payload) => {
+    const live = new Set();
+    for (const w of payload.wallpapers) {
+      for (const url of [w.media, w.preview]) {
+        if (!url) continue;
+        const token = url.slice(url.lastIndexOf('/') + 1);
+        live.add(token);
+      }
+    }
+    for (const token of [...tokens.keys()]) {
+      if (!live.has(token)) {
+        const entry = tokens.get(token);
+        tokens.delete(token);
+        if (entry && entry.key && tokenByKey.get(entry.key) === token) {
+          tokenByKey.delete(entry.key);
+        }
+      }
+    }
+  };
 
   // ── Inventory (cached) ──────────────────────────────────────────────────
   let cache = null; // { at: number, payload: object }
+  let discoveryCache = null; // { at: number, value: object }
+  let building = null; // in-flight build promise (request coalescing)
 
-  // Discovery is expensive (reg.exe + vdf scan) and the install layout barely
-  // changes — resolve it ONCE and reuse across builds; only an explicit
-  // refresh (or TTL expiry on the first build) forces a re-discovery.
-  let discoveryCache = null;
-  function getDiscovery(force) {
-    if (!force && discoveryCache) return discoveryCache;
-    discoveryCache = discover();
-    return discoveryCache;
+  async function getDiscovery(force) {
+    const fresh = discoveryCache && Date.now() - discoveryCache.at < discoveryTtlMs;
+    if (!force && fresh) return discoveryCache.value;
+    const value = await discoverFn();
+    discoveryCache = { at: Date.now(), value };
+    return value;
   }
 
-  function buildInventory(force) {
-    tokens.clear(); // re-mint: tokens from older builds stop resolving
-    return core.buildInventoryFrom(getDiscovery(force), { mint });
+  async function buildInventory(force) {
+    if (force) remintAll(); // explicit refresh: stale URLs die on purpose
+    const payload = await core.buildInventoryFrom(await getDiscovery(force), {
+      ...asyncIo,
+      mint,
+      base: BASE,
+    });
+    pruneTokens(payload);
+    return payload;
   }
 
   function getInventory(force) {
-    if (!force && cache && Date.now() - cache.at < INVENTORY_TTL_MS) return cache.payload;
-    const payload = buildInventory(force);
-    cache = { at: Date.now(), payload };
-    return payload;
+    if (!force && cache && Date.now() - cache.at < inventoryTtlMs) {
+      return Promise.resolve(cache.payload);
+    }
+    // Coalesce concurrent builds (double-clicked 刷新, parallel clients).
+    if (building) return building;
+    building = buildInventory(force)
+      .then((payload) => { cache = { at: Date.now(), payload }; return payload; })
+      .finally(() => { building = null; });
+    return building;
   }
 
   // ── Response helpers ────────────────────────────────────────────────────
-  function sendJson(res, status, body) {
+  function sendJson(req, res, status, body) {
+    const text = JSON.stringify(body);
     res.statusCode = status;
     res.setHeader('Content-Type', 'application/json; charset=utf-8');
     res.setHeader('Cache-Control', 'no-store');
-    res.end(JSON.stringify(body));
+    res.setHeader('Content-Length', String(Buffer.byteLength(text)));
+    res.end(req.method === 'HEAD' ? undefined : text);
   }
 
   /** Stream one file with Range support (video seeking) and HEAD handling. */
   function serveFile(absPath, req, res) {
-    let st;
-    try { st = statSync(absPath); } catch { st = null; }
-    if (!st || !st.isFile()) {
-      res.statusCode = 404;
-      res.end('not found');
-      return;
-    }
-    res.setHeader('Content-Type', core.mimeFor(absPath));
-    res.setHeader('Accept-Ranges', 'bytes');
-    res.setHeader('Cache-Control', 'no-store');
-    res.setHeader('X-Content-Type-Options', 'nosniff');
+    fsp.stat(absPath).then((st) => {
+      if (!st.isFile()) {
+        res.statusCode = 404;
+        res.setHeader('Content-Length', '0');
+        res.end();
+        return;
+      }
+      res.setHeader('Content-Type', core.mimeFor(absPath));
+      res.setHeader('Accept-Ranges', 'bytes');
+      res.setHeader('Cache-Control', 'no-store');
+      res.setHeader('X-Content-Type-Options', 'nosniff');
 
-    const range = core.parseRangeHeader(req.headers.range, st.size);
-    if (range && range.error) {
-      res.statusCode = 416;
-      res.setHeader('Content-Range', `bytes */${st.size}`);
-      res.end();
-      return;
-    }
-    const head = req.method === 'HEAD';
-    if (range) {
-      res.statusCode = 206;
-      res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${st.size}`);
-      res.setHeader('Content-Length', String(range.end - range.start + 1));
-    } else {
-      res.setHeader('Content-Length', String(st.size));
-    }
-    if (head) { res.end(); return; }
+      const range = core.parseRangeHeader(req.headers.range, st.size);
+      if (range && range.error) {
+        res.statusCode = 416;
+        res.setHeader('Content-Range', `bytes */${st.size}`);
+        res.setHeader('Content-Length', '0');
+        res.end();
+        return;
+      }
+      const head = req.method === 'HEAD';
+      if (range) {
+        res.statusCode = 206;
+        res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${st.size}`);
+        res.setHeader('Content-Length', String(range.end - range.start + 1));
+      } else {
+        res.setHeader('Content-Length', String(st.size));
+      }
+      if (head) { res.end(); return; }
 
-    const stream = range
-      ? createReadStream(absPath, { start: range.start, end: range.end })
-      : createReadStream(absPath);
-    stream.on('error', () => {
-      if (!res.headersSent) res.statusCode = 500;
+      const stream = range
+        ? createReadStream(absPath, { start: range.start, end: range.end })
+        : createReadStream(absPath);
+      // The file can vanish between stat and open; ending normally would
+      // leave the already-announced Content-Length unsatisfied and the
+      // client hanging — destroy the response instead.
+      stream.on('error', () => { res.destroy(); });
+      stream.pipe(res);
+    }).catch(() => {
+      res.statusCode = 404;
+      res.setHeader('Content-Length', '0');
       res.end();
     });
-    stream.pipe(res);
   }
 
   // ── Routes ──────────────────────────────────────────────────────────────
@@ -184,20 +253,15 @@ export function apply(ctx) {
     path: `${BASE}/inventory`,
     handler: (req, res) => {
       if (req.method !== 'GET' && req.method !== 'HEAD') {
-        sendJson(res, 405, { error: 'method not allowed' });
+        sendJson(req, res, 405, { error: 'method not allowed' });
         return;
       }
-      try {
-        const url = new URL(req.url || '/', 'http://x');
-        const payload = JSON.stringify(getInventory(url.searchParams.get('refresh') === '1'));
-        res.statusCode = 200;
-        res.setHeader('Content-Type', 'application/json; charset=utf-8');
-        res.setHeader('Cache-Control', 'no-store');
-        res.setHeader('Content-Length', String(Buffer.byteLength(payload)));
-        res.end(req.method === 'HEAD' ? undefined : payload);
-      } catch (err) {
-        sendJson(res, 500, { error: String(err && err.message ? err.message : err) });
-      }
+      const url = new URL(req.url || '/', 'http://x');
+      getInventory(url.searchParams.get('refresh') === '1')
+        .then((payload) => sendJson(req, res, 200, payload))
+        .catch((err) => {
+          sendJson(req, res, 500, { error: String(err && err.message ? err.message : err) });
+        });
     },
   }));
 
@@ -208,14 +272,14 @@ export function apply(ctx) {
       path: `${BASE}/${seg}`,
       handler: (req, res) => {
         if (req.method !== 'GET' && req.method !== 'HEAD') {
-          sendJson(res, 405, { error: 'method not allowed' });
+          sendJson(req, res, 405, { error: 'method not allowed' });
           return;
         }
         let pathname;
         try {
           pathname = new URL(req.url || '/', 'http://x').pathname;
         } catch {
-          sendJson(res, 400, { error: 'bad request' });
+          sendJson(req, res, 400, { error: 'bad request' });
           return;
         }
         const rest = pathname.slice(prefix.length); // "<token>" | "<token>/<rel…>"
@@ -223,14 +287,14 @@ export function apply(ctx) {
         const rawToken = slash < 0 ? rest : rest.slice(0, slash);
         let token;
         try { token = decodeURIComponent(rawToken); } catch {
-          sendJson(res, 400, { error: 'bad token' });
+          sendJson(req, res, 400, { error: 'bad token' });
           return;
         }
         const entry = tokens.get(token);
         if (!entry) {
           res.statusCode = 404;
-          if (req.method === 'HEAD') res.end();
-          else res.end('not found');
+          res.setHeader('Content-Length', '0');
+          res.end();
           return;
         }
         let abs = entry.abs;
@@ -238,22 +302,25 @@ export function apply(ctx) {
           // Sub-asset of a bundled web wallpaper: must stay inside its dir.
           if (seg !== 'media' || !entry.rootDir) {
             res.statusCode = 404;
-            if (req.method === 'HEAD') res.end();
-            else res.end('not found');
+            res.setHeader('Content-Length', '0');
+            res.end();
             return;
           }
           let rel;
           try { rel = decodeURIComponent(rest.slice(slash + 1)); } catch {
-            sendJson(res, 400, { error: 'bad path' });
+            sendJson(req, res, 400, { error: 'bad path' });
             return;
           }
-          if (!rel || rel.split('/').some((part) => part === '..' || part === '')) {
-            sendJson(res, 403, { error: 'forbidden' });
+          // Backslash parts are never legitimate in a URL path here; on win32
+          // `..\evil` would slip past a `/`-only split (the isInsideDir
+          // backstop still catches it — this is defense in depth).
+          if (!rel || rel.split('/').some((part) => part === '..' || part === '' || part.includes('\\'))) {
+            sendJson(req, res, 403, { error: 'forbidden' });
             return;
           }
           abs = join(entry.rootDir, ...rel.split('/'));
           if (!core.isInsideDir(entry.rootDir, abs)) {
-            sendJson(res, 403, { error: 'forbidden' });
+            sendJson(req, res, 403, { error: 'forbidden' });
             return;
           }
         }
@@ -262,17 +329,24 @@ export function apply(ctx) {
     }));
   }
 
-  // Warm the discovery cache now (reg.exe + vdf scan) so the first inventory
-  // request answers immediately instead of paying the discovery cost inline.
-  try { getDiscovery(false); } catch { /* non-fatal: inventory will 500 with reason */ }
+  // Warm the discovery cache now (async, off the request path) so the first
+  // inventory request answers quickly.
+  getDiscovery(false).catch(() => { /* non-fatal: inventory will 500 with reason */ });
 
   return () => {
     for (const d of disposers) { try { d(); } catch { /* ignore */ } }
     disposers.length = 0;
-    tokens.clear();
+    remintAll();
     cache = null;
     discoveryCache = null;
   };
 }
 
+export const inject = ['webServer'];
+
+export function apply(ctx) {
+  // inject guarantees the service is present before apply runs.
+  return createRouteRegistrar(ctx.webServer);
+}
+
 export default { inject, apply };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "wallpaper-engine-dsh",
-  "version": "0.1.5",
-  "description": "Wallpaper Engine Video/Web wallpapers as the DSH web GUI background — discovery, sandboxed rendering, rotation lists, liquid-glass tuning.",
+  "version": "0.1.7",
+  "description": "Wallpaper Engine library as the DSH web GUI background — video/web/still wallpapers, rotation lists, search, resource monitor, bilingual UI.",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -9,10 +9,14 @@
     "type": "git",
     "url": "git+https://github.com/Weilv-D/wallpaper-engine-dsh.git"
   },
+  "bugs": "https://github.com/Weilv-D/wallpaper-engine-dsh/issues",
+  "homepage": "https://github.com/Weilv-D/wallpaper-engine-dsh#readme",
   "keywords": [
     "dsh",
     "dsh-plugin",
+    "deepseek",
     "deepseek-harness",
+    "cordis",
     "wallpaper",
     "wallpaper-engine",
     "background",
@@ -59,7 +63,7 @@
   "scripts": {
     "build": "node scripts/build-client.mjs",
     "verify": "node scripts/verify-client.mjs",
-    "test": "node --test test/core.test.mjs",
+    "test": "node --test test/core.test.mjs test/host.test.mjs",
     "prepare": "node scripts/prepare.mjs",
     "prepublishOnly": "npm run test && npm run build && npm run verify",
     "release": "npm version patch -m \"chore: release v%s\" && git push --follow-tags",