beauticode-dsh 1.0.3 → 1.0.4

package/cli.js

@@ -78,19 +78,66 @@ function packageInsert() {
   ].join("\n");
 }
 
-function hasBridge(text) {
-  return new RegExp(`^\\s*-\\s*id:\\s*${bridgeId}\\s*$`, "m").test(text);
-}
-
-function stripBridge(text) {
-  const patterns = [
-    /(?:^|\r?\n)# beauticode-bridge \(installer\)\r?\n- insert:\r?\n(?:[ \t]+.*\r?\n)*/g,
-    /(?:^|\r?\n)- insert:\r?\n(?:[ \t]+.*\r?\n)*?[ \t]+-\s*id:\s*beauticode-bridge\r?\n(?:[ \t]+.*\r?\n)*/g,
-  ];
-  let next = text;
-  for (const pattern of patterns) next = next.replace(pattern, "\n");
-  return next;
-}
+function hasBridge(text) {
+  return new RegExp(`^\\s*-\\s*id:\\s*${bridgeId}\\s*$`, "m").test(text);
+}
+
+function stripBridge(text) {
+  const lines = text.split(/\r?\n/);
+  const removed = new Array(lines.length).fill(false);
+  const indentOf = (line) => line.match(/^[ \t]*/)?.[0].length ?? 0;
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const insert = lines[i].match(/^([ \t]*)-\s*insert:\s*(?:#.*)?$/);
+    if (!insert) continue;
+    const insertIndent = insert[1].length;
+    let blockEnd = i + 1;
+    while (blockEnd < lines.length) {
+      const line = lines[blockEnd];
+      if (line.trim() && indentOf(line) <= insertIndent) break;
+      blockEnd += 1;
+    }
+
+    let foundBridge = false;
+    for (let j = i + 1; j < blockEnd; ) {
+      const bridge = lines[j].match(
+        /^([ \t]*)-\s*id:\s*beauticode-bridge\s*(?:#.*)?$/,
+      );
+      if (!bridge || bridge[1].length <= insertIndent) {
+        j += 1;
+        continue;
+      }
+      foundBridge = true;
+      const itemIndent = bridge[1].length;
+      let itemEnd = j + 1;
+      while (itemEnd < blockEnd) {
+        const line = lines[itemEnd];
+        if (line.trim() && indentOf(line) <= itemIndent) break;
+        itemEnd += 1;
+      }
+      for (let k = j; k < itemEnd; k += 1) removed[k] = true;
+      j = itemEnd;
+    }
+
+    if (!foundBridge) continue;
+    const marker = `${insert[1]}# beauticode-bridge (installer)`;
+    if (i > 0 && lines[i - 1].trimEnd() === marker) removed[i - 1] = true;
+    const hasSibling = lines
+      .slice(i + 1, blockEnd)
+      .some(
+        (line, offset) =>
+          !removed[i + 1 + offset] &&
+          line.trim() !== "" &&
+          !line.trimStart().startsWith("#"),
+      );
+    if (!hasSibling) {
+      for (let k = i; k < blockEnd; k += 1) removed[k] = true;
+    }
+    i = blockEnd - 1;
+  }
+
+  return lines.filter((_, index) => !removed[index]).join("\n");
+}
 
 function overlayPayload(text) {
   return text
@@ -196,6 +243,83 @@ async function ensureEngine(dest) {
   await stageEngineInto(dest);
 }
 
+function pluginLinkPath(webProfile) {
+  return path.join(webProfile, "node_modules", pluginName);
+}
+
+function legacyPluginLinkPath(webProfile) {
+  return path.join(webProfile, "node_modules", "@beauticode", "dsh-plugin");
+}
+
+function linkSpecFor(pluginHome) {
+  return `link:${path.resolve(pluginHome).replaceAll("\\", "/")}`;
+}
+
+async function sameLinkTarget(link, dest) {
+  try {
+    const stat = await fsp.lstat(link);
+    if (stat.isSymbolicLink()) {
+      const target = await fsp.readlink(link);
+      return path.resolve(path.dirname(link), target) === path.resolve(dest);
+    }
+    if (stat.isDirectory()) {
+      return path.resolve(link) === path.resolve(dest);
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+
+async function linkPluginIntoProfile(webProfile, dest) {
+  const link = pluginLinkPath(webProfile);
+  const legacy = legacyPluginLinkPath(webProfile);
+  if (fs.existsSync(legacy)) {
+    await fsp.rm(legacy, { recursive: true, force: true });
+  }
+  await fsp.mkdir(path.dirname(link), { recursive: true });
+  if (fs.existsSync(link)) {
+    if (await sameLinkTarget(link, dest)) return;
+    await fsp.rm(link, { recursive: true, force: true });
+  }
+  const type = process.platform === "win32" ? "junction" : "dir";
+  await fsp.symlink(path.resolve(dest), link, type);
+}
+
+async function ensureWebPackageDep(webPackage, pluginHome) {
+  const raw = await fsp.readFile(webPackage, "utf8");
+  const json = JSON.parse(raw);
+  if (!json.dependencies || typeof json.dependencies !== "object" || Array.isArray(json.dependencies)) {
+    json.dependencies = {};
+  }
+  const spec = linkSpecFor(pluginHome);
+  const hadLegacy = Object.prototype.hasOwnProperty.call(
+    json.dependencies,
+    "@beauticode/dsh-plugin",
+  );
+  delete json.dependencies["@beauticode/dsh-plugin"];
+  const current = json.dependencies[pluginName];
+  if (current === spec && !hadLegacy) return;
+  json.dependencies[pluginName] = spec;
+  await fsp.writeFile(webPackage, `${JSON.stringify(json, null, 2)}\n`, "utf8");
+}
+
+async function removeWebPackageDep(webPackage) {
+  if (!fs.existsSync(webPackage)) return false;
+  const json = JSON.parse(await fsp.readFile(webPackage, "utf8"));
+  if (!json.dependencies || typeof json.dependencies !== "object") return false;
+  let changed = false;
+  for (const name of [pluginName, "@beauticode/dsh-plugin"]) {
+    if (Object.prototype.hasOwnProperty.call(json.dependencies, name)) {
+      delete json.dependencies[name];
+      changed = true;
+    }
+  }
+  if (!changed) return false;
+  await fsp.writeFile(webPackage, `${JSON.stringify(json, null, 2)}\n`, "utf8");
+  return true;
+}
+
 async function install(opts) {
   const dest = path.resolve(opts.pluginHome);
   const dshHome = path.resolve(opts.dshHome);
@@ -213,7 +337,9 @@ async function install(opts) {
   }
 
   if (fs.existsSync(webPackage)) {
-    await writePatch(webPatch, fileUriInsert(toFileUri(indexFile)));
+    await linkPluginIntoProfile(webProfile, dest);
+    await ensureWebPackageDep(webPackage, dest);
+    await writePatch(webPatch, packageInsert());
     if (fs.existsSync(homePatch)) {
       const homeRaw = await fsp.readFile(homePatch, "utf8");
       if (hasBridge(homeRaw)) await removePatch(homePatch);
@@ -234,13 +360,23 @@ async function install(opts) {
 
 async function uninstall(opts) {
   const dshHome = path.resolve(opts.dshHome);
+  const webProfile = path.join(dshHome, "profiles", "web");
   const removed = [];
-  if (await removePatch(path.join(dshHome, "profiles", "web", "cordis.patch.yml"))) {
+  if (await removePatch(path.join(webProfile, "cordis.patch.yml"))) {
     removed.push("web patch");
   }
   if (await removePatch(path.join(dshHome, "cordis.patch.yml"))) {
     removed.push("home patch");
   }
+  if (await removeWebPackageDep(path.join(webProfile, "package.json"))) {
+    removed.push("web package.json");
+  }
+  for (const link of [pluginLinkPath(webProfile), legacyPluginLinkPath(webProfile)]) {
+    if (fs.existsSync(link)) {
+      await fsp.rm(link, { recursive: true, force: true });
+      removed.push(link);
+    }
+  }
   const dest = path.resolve(opts.pluginHome);
   if (fs.existsSync(dest)) {
     await fsp.rm(dest, { recursive: true, force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beauticode-dsh",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Cordis plugin: image/video backgrounds for DeepSeek Harness web.",
   "type": "module",
   "main": "./index.mjs",

package/vendor/adapter-dsh/session.js

@@ -181,7 +181,11 @@ export class DshSession {
                 }
             }
             if (manifest.background) {
-                stagedImage = await this.media.stage(path.join(this.store.paths.activeDir, manifest.background.image));
+                const runtimeImagePath = await this.store.prepareRuntimeImage(manifest);
+                if (!runtimeImagePath) {
+                    throw new Error("DSH image reapply requires a detached runtime copy.");
+                }
+                stagedImage = await this.media.stage(runtimeImagePath);
                 if (manifest.background.type === "video" && manifest.background.video) {
                     const runtimeVideoPath = await this.store.prepareRuntimeVideo(manifest);
                     if (!runtimeVideoPath) {

package/vendor/core/apply-transaction.js

@@ -103,7 +103,7 @@ export class ApplyTransaction {
                 }
             }
             await this.media.commit(staged);
-            await this.store.pruneRuntimeMedia(runtimeVideoPath);
+            await this.store.pruneRuntimeMedia(runtimeKeepPaths(staged, runtimeVideoPath));
             staged = null;
             if (snapshot) {
                 await this.store.clearSnapshot(snapshot);
@@ -141,13 +141,15 @@ export class ApplyTransaction {
         if (!manifest.background) {
             return { image: null, video: null };
         }
-        const imagePath = path.join(this.store.paths.activeDir, manifest.background.image);
-        const image = await this.media.stage(imagePath);
+        // Serve stills and videos from runtime-media copies so Windows can rotate
+        // `active/` while the previous generation is still being read.
+        const runtimeImagePath = await this.store.prepareRuntimeImage(manifest);
+        if (!runtimeImagePath) {
+            throw new Error("Image media staging requires a detached runtime copy.");
+        }
+        const image = await this.media.stage(runtimeImagePath);
         let video = null;
         if (manifest.background.type === "video" && manifest.background.video) {
-            // DSH streams this handle for the lifetime of the active <video>. On
-            // Windows, serving active/background.mp4 directly keeps the active
-            // directory open and the next atomic directory swap fails with EPERM.
             const runtimeVideoPath = await this.store.prepareRuntimeVideo(manifest);
             if (!runtimeVideoPath) {
                 throw new Error("Video media staging requires a detached runtime copy.");
@@ -188,7 +190,7 @@ export class ApplyTransaction {
                 }
             }
             await this.media.commit(restoredMedia);
-            await this.store.pruneRuntimeMedia(runtimeVideoPath);
+            await this.store.pruneRuntimeMedia(runtimeKeepPaths(restoredMedia, runtimeVideoPath));
             restoredMedia = null;
             await this.store.clearSnapshot(snapshot);
         }
@@ -197,6 +199,16 @@ export class ApplyTransaction {
         }
     }
 }
+function runtimeKeepPaths(staged, extra) {
+    const keep = [];
+    if (staged?.image?.filePath)
+        keep.push(staged.image.filePath);
+    if (staged?.video?.filePath)
+        keep.push(staged.video.filePath);
+    if (extra)
+        keep.push(extra);
+    return keep;
+}
 export async function buildHostApplyPayload(store, manifest, staged, cssText, videoStartAt) {
     if (!manifest.background) {
         return {

package/vendor/core/background-store.js

@@ -56,7 +56,7 @@ export class BackgroundStore {
     maxSavedBytes;
     bundledThemes;
     #runtimeSessionName = `session-${process.pid}-${crypto.randomUUID()}`;
-    #runtimeVideoCache = new Map();
+    #runtimeMediaCache = new Map();
     #writeChain = Promise.resolve();
     #writeContext = new AsyncLocalStorage();
     constructor(opts = {}) {
@@ -242,6 +242,24 @@ export class BackgroundStore {
         this.#writeChain = run.then(() => undefined, () => undefined);
         return run;
     }
+    /**
+     * Copy the active still to a renderer-only path outside `active`.
+     *
+     * Serving `active/poster.png` keeps that directory open on Windows, so the
+     * next atomic active-directory rotation fails with EPERM. The detached copy
+     * matches the video runtime path.
+     */
+    async prepareRuntimeImage(manifest) {
+        if (!manifest.background?.image)
+            return null;
+        return this.#prepareRuntimeMedia({
+            generation: manifest.generation,
+            kind: "image",
+            sourceName: manifest.background.image,
+            ext: path.extname(manifest.background.image) || ".png",
+            validate: (filePath) => validateImageFile(filePath),
+        });
+    }
     /**
      * Copy the active video to a renderer-only path outside `active`.
      *
@@ -251,57 +269,73 @@ export class BackgroundStore {
      * renderer lifetime independent from the disk transaction.
      */
     async prepareRuntimeVideo(manifest) {
+        if (manifest.background?.type !== "video" ||
+            !manifest.background.video) {
+            return null;
+        }
+        return this.#prepareRuntimeMedia({
+            generation: manifest.generation,
+            kind: "video",
+            sourceName: manifest.background.video,
+            ext: ".mp4",
+            validate: (filePath) => validateVideoFile(filePath),
+        });
+    }
+    async #prepareRuntimeMedia(opts) {
         return this.#withWriteLock(async () => {
-            if (manifest.background?.type !== "video" ||
-                !manifest.background.video) {
-                return null;
-            }
             await this.init();
-            const cached = this.#runtimeVideoCache.get(manifest.generation);
+            const cacheKey = `${opts.kind}:${opts.generation}`;
+            const cached = this.#runtimeMediaCache.get(cacheKey);
             if (cached) {
                 try {
-                    await validateVideoFile(cached);
+                    await opts.validate(cached);
                     return cached;
                 }
                 catch {
-                    this.#runtimeVideoCache.delete(manifest.generation);
+                    this.#runtimeMediaCache.delete(cacheKey);
                 }
             }
-            const source = path.join(this.paths.activeDir, manifest.background.video);
-            const validated = await validateVideoFile(source);
-            const sessionDir = path.join(this.paths.runtimeMediaDir, this.#runtimeSessionName);
-            if (!isPathInsideRoot(this.paths.runtimeMediaDir, sessionDir)) {
-                throw new MediaValidationError("Runtime media path escaped runtime-media root.");
-            }
-            const runtimeRootStat = await fs.lstat(this.paths.runtimeMediaDir);
-            if (!runtimeRootStat.isDirectory() ||
-                runtimeRootStat.isSymbolicLink()) {
-                throw new MediaValidationError("Runtime media root must be a real directory.");
-            }
-            await fs.mkdir(sessionDir, { recursive: true });
-            const sessionStat = await fs.lstat(sessionDir);
-            if (!sessionStat.isDirectory() || sessionStat.isSymbolicLink()) {
-                throw new MediaValidationError("Runtime media session must be a real directory.");
-            }
-            const [realRuntimeRoot, realSessionDir] = await Promise.all([
-                fs.realpath(this.paths.runtimeMediaDir),
-                fs.realpath(sessionDir),
-            ]);
-            if (!isPathInsideRoot(realRuntimeRoot, realSessionDir)) {
-                throw new MediaValidationError("Runtime media session escaped runtime-media root.");
-            }
-            const destination = path.join(sessionDir, `video-${manifest.generation}-${validated.identity.slice(0, 16)}.mp4`);
+            const source = path.join(this.paths.activeDir, opts.sourceName);
+            const validated = await opts.validate(source);
+            const sessionDir = await this.#ensureRuntimeSessionDir();
+            const safeExt = opts.ext.toLowerCase().startsWith(".")
+                ? opts.ext.toLowerCase()
+                : `.${opts.ext}`;
+            const destination = path.join(sessionDir, `${opts.kind}-${opts.generation}-${validated.identity.slice(0, 16)}${safeExt}`);
             await copyFileAtomic(validated.filePath, destination);
-            const copied = await validateVideoFile(destination);
+            const copied = await opts.validate(destination);
             if (copied.identity !== validated.identity) {
                 await fs.rm(destination, { force: true }).catch(() => { });
-                throw new MediaValidationError("Runtime video copy failed its identity check.");
+                throw new MediaValidationError(`Runtime ${opts.kind} copy failed its identity check.`);
             }
-            this.#runtimeVideoCache.set(manifest.generation, destination);
-            await this.#pruneRuntimeMediaUnlocked(destination);
+            this.#runtimeMediaCache.set(cacheKey, destination);
+            await this.#pruneRuntimeMediaUnlocked([...this.#runtimeMediaCache.values()]);
             return destination;
         });
     }
+    async #ensureRuntimeSessionDir() {
+        const sessionDir = path.join(this.paths.runtimeMediaDir, this.#runtimeSessionName);
+        if (!isPathInsideRoot(this.paths.runtimeMediaDir, sessionDir)) {
+            throw new MediaValidationError("Runtime media path escaped runtime-media root.");
+        }
+        const runtimeRootStat = await fs.lstat(this.paths.runtimeMediaDir);
+        if (!runtimeRootStat.isDirectory() || runtimeRootStat.isSymbolicLink()) {
+            throw new MediaValidationError("Runtime media root must be a real directory.");
+        }
+        await fs.mkdir(sessionDir, { recursive: true });
+        const sessionStat = await fs.lstat(sessionDir);
+        if (!sessionStat.isDirectory() || sessionStat.isSymbolicLink()) {
+            throw new MediaValidationError("Runtime media session must be a real directory.");
+        }
+        const [realRuntimeRoot, realSessionDir] = await Promise.all([
+            fs.realpath(this.paths.runtimeMediaDir),
+            fs.realpath(sessionDir),
+        ]);
+        if (!isPathInsideRoot(realRuntimeRoot, realSessionDir)) {
+            throw new MediaValidationError("Runtime media session escaped runtime-media root.");
+        }
+        return sessionDir;
+    }
     /**
      * Best-effort cleanup. Locked stale files are retained and retried on the
      * next apply/start instead of turning successful theme switching into an
@@ -310,14 +344,15 @@ export class BackgroundStore {
     async pruneRuntimeMedia(keepPath = null) {
         await this.#withWriteLock(async () => {
             await this.init();
-            await this.#pruneRuntimeMediaUnlocked(keepPath);
+            const keep = (Array.isArray(keepPath) ? keepPath : [keepPath]).filter((value) => typeof value === "string" && value.length > 0);
+            await this.#pruneRuntimeMediaUnlocked(keep);
         });
     }
-    async #pruneRuntimeMediaUnlocked(keepPath) {
+    async #pruneRuntimeMediaUnlocked(keepPaths) {
         const runtimeRoot = path.resolve(this.paths.runtimeMediaDir);
-        const keep = keepPath && isPathInsideRoot(runtimeRoot, keepPath)
-            ? path.resolve(keepPath)
-            : null;
+        const keep = new Set(keepPaths
+            .filter((value) => isPathInsideRoot(runtimeRoot, value))
+            .map((value) => path.resolve(value)));
         let sessions;
         try {
             sessions = await fs.readdir(runtimeRoot);
@@ -331,7 +366,8 @@ export class BackgroundStore {
             const sessionDir = path.join(runtimeRoot, name);
             if (!isPathInsideRoot(runtimeRoot, sessionDir))
                 continue;
-            if (!keep || !isPathInsideRoot(sessionDir, keep)) {
+            const keepInSession = [...keep].some((file) => isPathInsideRoot(sessionDir, file));
+            if (!keepInSession) {
                 await rmrf(sessionDir).catch(() => { });
                 continue;
             }
@@ -344,15 +380,15 @@ export class BackgroundStore {
             }
             for (const file of files) {
                 const candidate = path.resolve(sessionDir, file);
-                if (candidate === keep || !isPathInsideRoot(sessionDir, candidate)) {
+                if (keep.has(candidate) || !isPathInsideRoot(sessionDir, candidate)) {
                     continue;
                 }
                 await fs.rm(candidate, { recursive: true, force: true }).catch(() => { });
             }
         }
-        for (const [generation, cached] of this.#runtimeVideoCache) {
-            if (path.resolve(cached) !== keep) {
-                this.#runtimeVideoCache.delete(generation);
+        for (const [key, cached] of this.#runtimeMediaCache) {
+            if (!keep.has(path.resolve(cached))) {
+                this.#runtimeMediaCache.delete(key);
             }
         }
     }

package/vendor/core/media-server.js

@@ -36,6 +36,27 @@ function parseRange(value, size) {
 function makeToken() {
     return randomUUID().replaceAll("-", "");
 }
+function pipeOpenedFile(handle, response, range) {
+    const stream = handle.createReadStream({
+        start: range.start,
+        ...(range.end != null ? { end: range.end } : {}),
+        autoClose: false,
+    });
+    let closed = false;
+    const closeHandle = () => {
+        if (closed)
+            return;
+        closed = true;
+        void handle.close().catch(() => { });
+    };
+    stream.on("error", () => {
+        closeHandle();
+        response.destroy();
+    });
+    stream.on("close", closeHandle);
+    response.on("close", closeHandle);
+    stream.pipe(response);
+}
 async function hashOpenedFile(handle, size) {
     const hash = createHash("sha256");
     const chunk = Buffer.allocUnsafe(1024 * 1024);
@@ -401,11 +422,8 @@ export class LoopbackMediaHub {
                     opened = null;
                     return;
                 }
-                const stream = opened.createReadStream({ start: 0, autoClose: true });
+                pipeOpenedFile(opened, response, { start: 0 });
                 opened = null;
-                stream
-                    .on("error", () => response.destroy())
-                    .pipe(response);
                 return;
             }
             headers["Content-Range"] =
@@ -418,15 +436,11 @@ export class LoopbackMediaHub {
                 opened = null;
                 return;
             }
-            const stream = opened.createReadStream({
+            pipeOpenedFile(opened, response, {
                 start: range.start,
                 end: range.end,
-                autoClose: true,
             });
             opened = null;
-            stream
-                .on("error", () => response.destroy())
-                .pipe(response);
         }
         catch {
             await opened?.close().catch(() => { });