engine-dj-mcp 0.11.2 → 0.11.3

package/README.md

@@ -1,5 +1,6 @@
 # engine-dj-mcp
 
+[![CI](https://github.com/Venut-Labs/engine-dj-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/Venut-Labs/engine-dj-mcp/actions/workflows/ci.yml)
 [![npm](https://img.shields.io/npm/v/engine-dj-mcp)](https://www.npmjs.com/package/engine-dj-mcp)
 [![licence](https://img.shields.io/npm/l/engine-dj-mcp)](./LICENSE)
 
@@ -58,7 +59,9 @@ the configuration you are reading:
 }
 ```
 
-**Requirements:** Node.js 22.13 or newer (for the unflagged `node:sqlite`;
+**Requirements:** Node.js 22.16 or newer (`node:sqlite` stopped needing a
+flag in 22.13, but the pre-write snapshot uses its `backup()`, added in
+22.16;
 there are no native dependencies), and an Engine DJ library at schema 3.0.0
 through 3.0.2 — Engine DJ 4.5 and 5.x.
 

package/dist/store/backup.d.ts

@@ -1,2 +1,26 @@
 import { type EngineError } from "../errors.js";
+/**
+ * The snapshots to delete, oldest first, from a directory listing.
+ *
+ * Two name shapes live here: the tagged `${uuid}-${tag}-${stamp}.db` written
+ * now, and the untagged `${uuid}-${stamp}.db` an earlier version wrote.
+ * Without the second, those sat outside every namespace and were never
+ * reclaimed -- up to KEEP full copies of a library, kept forever, on any
+ * upgrading user. Two libraries sharing a uuid is precisely why the tag
+ * exists, and an untagged file cannot say which of them it came from, so
+ * ageing them out under whichever library writes next is the only thing left
+ * to do with them.
+ *
+ * Ordering is by the stamp alone, never by the whole filename. Sorting the
+ * names as text compares a tag against a year at the same offset, and a tag
+ * is hex: `1e269292c523` sorts *before* `2026-...`, so a library whose path
+ * happens to hash to a tag starting 0 or 1 had its newest snapshot land at
+ * the head of the list and be deleted -- the file the caller had just been
+ * handed as its way back. Measured: it passed locally under the tag
+ * `cf11e2d00f88` and failed in CI under `1e269292c523`, same code.
+ *
+ * Untagged files sort before every tagged one regardless of stamp: they
+ * predate the tagged scheme, so they predate anything written since.
+ */
+export declare function evictable(names: string[], uuid: string, tag: string): string[];
 export declare function snapshotLibrary(mdbPath: string, uuid: string, baseDir: string): Promise<string | EngineError>;

package/dist/store/backup.js

@@ -33,7 +33,59 @@ function stamp() {
     const iso = new Date().toISOString().replace(/[:.]/g, "-");
     return `${iso}-${String(++counter).padStart(10, "0")}`;
 }
+/**
+ * The snapshots to delete, oldest first, from a directory listing.
+ *
+ * Two name shapes live here: the tagged `${uuid}-${tag}-${stamp}.db` written
+ * now, and the untagged `${uuid}-${stamp}.db` an earlier version wrote.
+ * Without the second, those sat outside every namespace and were never
+ * reclaimed -- up to KEEP full copies of a library, kept forever, on any
+ * upgrading user. Two libraries sharing a uuid is precisely why the tag
+ * exists, and an untagged file cannot say which of them it came from, so
+ * ageing them out under whichever library writes next is the only thing left
+ * to do with them.
+ *
+ * Ordering is by the stamp alone, never by the whole filename. Sorting the
+ * names as text compares a tag against a year at the same offset, and a tag
+ * is hex: `1e269292c523` sorts *before* `2026-...`, so a library whose path
+ * happens to hash to a tag starting 0 or 1 had its newest snapshot land at
+ * the head of the list and be deleted -- the file the caller had just been
+ * handed as its way back. Measured: it passed locally under the tag
+ * `cf11e2d00f88` and failed in CI under `1e269292c523`, same code.
+ *
+ * Untagged files sort before every tagged one regardless of stamp: they
+ * predate the tagged scheme, so they predate anything written since.
+ */
+export function evictable(names, uuid, tag) {
+    const tagged = `${uuid}-${tag}-`;
+    const legacy = new RegExp(`^${uuid}-(\\d{4}-.*)\\.db$`);
+    const mine = [];
+    for (const name of names) {
+        if (!name.endsWith(".db"))
+            continue;
+        if (name.startsWith(tagged)) {
+            mine.push({ name, old: false, stamp: name.slice(tagged.length, -3) });
+            continue;
+        }
+        const m = legacy.exec(name);
+        if (m)
+            mine.push({ name, old: true, stamp: m[1] });
+    }
+    mine.sort((a, b) => (a.old !== b.old ? (a.old ? -1 : 1) : a.stamp < b.stamp ? -1 : a.stamp > b.stamp ? 1 : 0));
+    return mine.slice(0, Math.max(0, mine.length - KEEP)).map((x) => x.name);
+}
 export async function snapshotLibrary(mdbPath, uuid, baseDir) {
+    // node:sqlite stopped needing a flag in 22.13, which is where this
+    // project's floor used to sit -- but backup() only arrived in 22.16. On
+    // 22.13 through 22.15 the read path works perfectly and this one throws
+    // "backup is not a function", which is what CI reported on its very first
+    // run against the declared floor. `engines` now says 22.16, and npm only
+    // enforces that under engine-strict, so the check is here too: a version
+    // number a user can act on beats a TypeError from inside a dependency.
+    if (typeof backup !== "function") {
+        return err("library_unreadable", `This Node cannot snapshot a library before writing to it: node:sqlite gained backup() in ` +
+            `22.16.0 and this is ${process.version}. Upgrade Node, or run without --allow-writes.`);
+    }
     let src;
     try {
         mkdirSync(baseDir, { recursive: true });
@@ -50,21 +102,8 @@ export async function snapshotLibrary(mdbPath, uuid, baseDir) {
         await backup(src, dest);
         src.close();
         src = undefined;
-        // Snapshots this library owns: the tagged shape above, plus the untagged
-        // `${uuid}-${stamp}.db` an earlier version wrote. Without the second,
-        // those sat outside every namespace and were never reclaimed -- up to
-        // KEEP full copies of a library, kept forever, on any upgrading user.
-        // They predate the tag and therefore predate everything written since,
-        // which is why folding them into one window evicts them first. Two
-        // libraries sharing a uuid is precisely why the tag exists, and an
-        // untagged file cannot say which of them it came from -- ageing them out
-        // under whichever library writes next is the only thing left to do.
-        const legacy = new RegExp(`^${uuid}-\\d{4}-`);
-        const mine = readdirSync(baseDir)
-            .filter((f) => f.endsWith(".db") && (f.startsWith(prefix) || legacy.test(f)))
-            .sort();
-        for (const old of mine.slice(0, Math.max(0, mine.length - KEEP))) {
-            rmSync(join(baseDir, old), { force: true });
+        for (const stale of evictable(readdirSync(baseDir), uuid, libraryTag(mdbPath))) {
+            rmSync(join(baseDir, stale), { force: true });
         }
         return dest;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engine-dj-mcp",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "MCP server for an Engine DJ library: search and audit it, read cues and beatgrids, and build playlists when you ask. Not affiliated with inMusic or Denon DJ.",
   "keywords": [
     "mcp",
@@ -27,7 +27,7 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=22.13.0"
+    "node": ">=22.16.0"
   },
   "bin": {
     "engine-dj-mcp": "dist/index.js"