mcp-memory-bucket 0.12.3 → 0.12.5

package/dist/src/memory/repository.js

@@ -629,9 +629,11 @@ export class MemoryRepository {
         const existing = await this.get(folder, filename);
         if (!existing)
             throw new Error(`memory doc "${filename}" not found`);
-        // `paused` is local-cache-only and must never reach writeMarkdownFile — split it off of
-        // `existing` before spreading the rest into the frontmatter that gets written to disk.
-        const { paused: existingPaused, ...existingForFile } = existing;
+        // `paused` is local-cache-only and `body` is written separately as the markdown body, not
+        // frontmatter — both must be split off of `existing` before spreading the rest into
+        // `merged`, or they'd ride along into the MemoryFrontmatter written to disk (duplicating the
+        // body inside its own frontmatter as a `body:` key).
+        const { paused: existingPaused, body: _existingBody, ...existingForFile } = existing;
         const merged = {
             ...existingForFile,
             ...frontmatter,

package/dist/src/skills/repository.js

@@ -531,9 +531,11 @@ export class SkillRepository {
         const existing = await this.get(name, folder);
         if (!existing)
             throw new Error(`skill with name "${name}" not found`);
-        // `paused` is local-cache-only and must never reach writeMarkdownFile — split it off of
-        // `existing` before spreading the rest into the frontmatter that gets written to disk.
-        const { paused: existingPaused, ...existingForFile } = existing;
+        // `paused` is local-cache-only and `body` is written separately as the markdown body, not
+        // frontmatter — both must be split off of `existing` before spreading the rest into
+        // `merged`, or they'd ride along into the SkillFrontmatter written to disk (duplicating the
+        // body inside its own frontmatter as a `body:` key).
+        const { paused: existingPaused, body: _existingBody, ...existingForFile } = existing;
         // Builtin skills (e.g. memory-bucket-authoring) are the server's own always-present
         // documentation, not user content — deprecating them would hide guidance every session needs.
         const deprecated = this.isBuiltin(existing) ? existing.deprecated : frontmatter?.deprecated;
@@ -585,7 +587,9 @@ export class SkillRepository {
         const newFilePath = path.join(newDir, 'SKILL.md');
         // Rename changes the skill's id, so it becomes a fresh cache row — paused (local-only,
         // keyed by id) does not carry over, same as it wouldn't survive deleting the cache file.
-        const { paused: _existingPaused, ...existingForFile } = existing;
+        // `body` is split off too, for the same reason as in update() — it must not ride along into
+        // the SkillFrontmatter written to disk.
+        const { paused: _existingPaused, body: _existingBody, ...existingForFile } = existing;
         const merged = { ...existingForFile, name: newName };
         const fileContents = formatMarkdownFile(stripSourcePath(merged), existing.body);
         const remote = this.remoteFor(existing.folder);

package/dist/src/store/sync.js

@@ -182,8 +182,42 @@ export function upsertFile(db, spec, filePath) {
         .map((c) => `${c} = excluded.${c}`)
         .join(', ');
     const conflictTarget = scopedById ? 'folder, id' : 'source_path';
-    db.prepare(`INSERT INTO ${spec.table} (${cols.join(', ')}) VALUES (${placeholders})
-     ON CONFLICT(${conflictTarget}) DO UPDATE SET ${updateClause}`).run(...values);
+    const insert = () => db
+        .prepare(`INSERT INTO ${spec.table} (${cols.join(', ')}) VALUES (${placeholders})
+     ON CONFLICT(${conflictTarget}) DO UPDATE SET ${updateClause}`)
+        .run(...values);
+    try {
+        insert();
+    }
+    catch (err) {
+        // Belt-and-suspenders: the collision guards above are pre-checks against a fresh SELECT, and
+        // can still miss a stale row above (e.g. a source_path left over from before a folder/root
+        // rename, or a filesystem case-sensitivity mismatch between the path stored earlier and the
+        // one passed in now) — in which case the plain INSERT itself throws the raw SQLITE_CONSTRAINT
+        // error, which used to propagate straight out of upsertFile and abort the entire remote
+        // resync/poll tick for every OTHER file too (see the "initial remote skill resync failed"
+        // crash report this was added for). Self-heal instead: whatever row is squatting on this
+        // conflict target, evict it (same as a real delete would) and retry the insert once. If it
+        // still fails after that, log and skip this one file rather than taking the whole sync down.
+        if (err instanceof Error && 'code' in err && err.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+            const staleSourcePath = scopedById
+                ? db.prepare(`SELECT source_path FROM ${spec.table} WHERE folder = ? AND id = ?`).get(folder, id)?.source_path
+                : filePath;
+            if (staleSourcePath)
+                removeFile(db, spec.table, staleSourcePath);
+            try {
+                insert();
+                console.error(`[memory-bucket] recovered from a stale ${spec.table} row blocking ${filePath} (evicted ${staleSourcePath}) — re-indexed successfully`);
+            }
+            catch (retryErr) {
+                console.error(`[memory-bucket] SKIPPED indexing ${filePath}: unresolvable ${spec.table} conflict — ${retryErr.message}`);
+                return;
+            }
+        }
+        else {
+            throw err;
+        }
+    }
     // ref_folder scopes these two tables' delete-then-reinsert the same way the skills upsert above
     // does: two skills in different folders can now legitimately share an `id`, so ref_id alone is
     // no longer enough to identify "this file's" search_index/doc_dates rows without also clobbering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "type": "module",
   "description": "MCP server exposing skill_* (reusable coding patterns) and memory_* (point-in-time working context) tools over a markdown+frontmatter source, cached into SQLite at runtime.",
   "repository": {