mcp-memory-bucket 0.10.2 → 0.10.3

package/dist/src/attachments/repository.js

@@ -23,10 +23,34 @@ export class AttachmentRepository {
             await this.skillRepo.update(docIdOrName, { attachments });
         }
     }
+    /**
+     * Pushes an attachment's binary content to folderfoo if the doc lives in a remote folder —
+     * no-op for a local folder (both repos' pushAttachmentIfNeeded already guard on that). Callers
+     * must roll back their own local file write if this throws, same as skill/memory create() rolls
+     * back its own file on a failed remote push.
+     */
+    async pushAttachmentToRemoteIfNeeded(kind, folder, filePath, mimeType) {
+        if (kind === 'memory') {
+            await this.memoryRepo.pushAttachmentIfNeeded(folder, filePath, mimeType);
+        }
+        else {
+            await this.skillRepo.pushAttachmentIfNeeded(folder, filePath, mimeType);
+        }
+    }
     async add(kind, docIdOrName, filename, data) {
         const doc = await this.getDoc(kind, docIdOrName);
         const dir = attachmentsDirFor(doc.source_path, kind);
         const entry = writeAttachmentFile(dir, filename, data);
+        try {
+            await this.pushAttachmentToRemoteIfNeeded(kind, doc.folder, path.join(dir, entry.filename), entry.mime_type);
+        }
+        catch (err) {
+            // Mirrors create()'s rollback: remote push failed after the local mirror file was already
+            // written — remove the orphaned local file rather than leaving it registered as if it were
+            // already synced remotely.
+            fs.rmSync(path.join(dir, entry.filename), { force: true });
+            throw err;
+        }
         const existing = doc.attachments ?? [];
         await this.saveAttachmentsList(kind, docIdOrName, [...existing, entry]);
         return entry;
@@ -44,6 +68,7 @@ export class AttachmentRepository {
         const safePath = resolveWithinBase(dir, undefined, filename);
         fs.rmSync(safePath, { force: true });
         const written = writeAttachmentFile(dir, filename, data);
+        await this.pushAttachmentToRemoteIfNeeded(kind, doc.folder, path.join(dir, written.filename), written.mime_type);
         // Full replace: preserve position, overwrite metadata for this filename entry.
         const next = (doc.attachments ?? []).map((a) => (a.filename === filename ? written : a));
         await this.saveAttachmentsList(kind, docIdOrName, next);
@@ -54,6 +79,10 @@ export class AttachmentRepository {
         const dir = attachmentsDirFor(doc.source_path, kind);
         const safePath = resolveWithinBase(dir, undefined, filename);
         fs.rmSync(safePath, { force: true });
+        // Does NOT delete the corresponding file on folderfoo — there is no delete endpoint in
+        // folderfoo-client.ts, matching the same already-flagged gap on skill/memory doc rename/delete
+        // (see SkillRepository.rename()/remove() doc comments). A removed attachment leaves a stale
+        // copy on the remote source until folderfoo itself gains a delete API.
         const next = (doc.attachments ?? []).filter((a) => a.filename !== filename);
         await this.saveAttachmentsList(kind, docIdOrName, next);
         if (listAttachmentFiles(dir).length === 0) {

package/dist/src/memory/repository.js

@@ -11,7 +11,7 @@ import { applyBodyEdits } from '../shared/body-edits.js';
 import { attachmentsDirFor } from '../attachments/storage.js';
 import { rebaseFolderPath } from '../config.js';
 import { normalizeKey } from '../types.js';
-import { readFile as readRemoteFile, writeFile as writeRemoteFile, joinRemoteFolderPath, assertRemoteFolderExists } from '../remote/folderfoo-client.js';
+import { readFile as readRemoteFile, writeFile as writeRemoteFile, writeBinaryFile as writeRemoteBinaryFile, joinRemoteFolderPath, assertRemoteFolderExists } from '../remote/folderfoo-client.js';
 import { isFolderVisible } from '../remote/identity.js';
 /** Uppercases and strips everything but letters/digits — used to compare keys that differ only in
  * punctuation/whitespace formatting (e.g. `RMXS-15` and `RMXS15` strip to the same `RMXS15`). */
@@ -73,6 +73,24 @@ export class MemoryRepository {
         const identity = this.identity.current();
         return this.remoteFolders.filter((f) => !isFolderVisible(f, identity)).map((f) => f.name);
     }
+    /**
+     * Pushes one attachment file's raw binary content to folderfoo, if `folderName` resolves to a
+     * remote source — the attachment counterpart to create()/update()'s inline remote-write blocks.
+     * Pushed under the attachment's own actual filename (unlike the doc's own .md file, which is
+     * pushed under its id with the .md suffix stripped). No-op for a local folder. Called by
+     * AttachmentRepository after it writes an attachment to the local mirror — callers must roll
+     * back the local write on a thrown error here, exactly like create() already rolls back its own
+     * .md file on a failed push.
+     */
+    async pushAttachmentIfNeeded(folderName, attachmentFilePath, mimeType) {
+        const remote = this.remoteFor(folderName);
+        if (!remote || !this.credentialsBaseDir)
+            return;
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName);
+        const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(attachmentFilePath)));
+        const data = fs.readFileSync(attachmentFilePath);
+        await writeRemoteBinaryFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), data, mimeType);
+    }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;

package/dist/src/remote/folderfoo-client.js

@@ -172,3 +172,25 @@ export async function writeFile(server, baseDir, tenantId, folderPath, name, con
         body: content,
     }), async () => undefined);
 }
+/**
+ * Writes one file's raw BINARY content via POST /save/:filename — the attachment-file counterpart
+ * to writeFile's markdown-string upload. Same endpoint, same auth/retry wrapper, just a Buffer body
+ * and the attachment's own mime type instead of a fixed text/markdown content-type.
+ *
+ * NOT YET LIVE-VERIFIED against folderfoo: memory doc ids are deliberately stripped of hyphens
+ * before ever reaching writeFile's `name` param, per a confirmed-in-production finding that
+ * folderfoo's save endpoint silently drops non-[0-9a-zA-Z_] characters from the final filename
+ * segment. Attachment filenames routinely contain dots and hyphens (e.g. "entity.java.hbs") that
+ * this same stripping would mangle if it applies uniformly here too. This function intentionally
+ * does NOT pre-sanitize the name (unlike memory ids) because that behavior hasn't been confirmed
+ * for this endpoint/content-type combination from this client alone — verify with a real round-trip
+ * (attach a dotted/hyphenated filename to a doc in a remote folder, then check the folderfoo UI
+ * shows it unmangled) before relying on this for anything beyond best-effort.
+ */
+export async function writeBinaryFile(server, baseDir, tenantId, folderPath, name, data, mimeType) {
+    await withAuth(server, baseDir, (jwt) => fetch(`${server}/save/${filenameParam(folderPath, name)}`, {
+        method: 'POST',
+        headers: { authorization: `Bearer ${jwt}`, 'x-tenant-id': tenantId, 'content-type': mimeType },
+        body: data,
+    }), async () => undefined);
+}

package/dist/src/skills/repository.js

@@ -8,7 +8,7 @@ import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSp
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
 import { applyBodyEdits } from '../shared/body-edits.js';
 import { rebaseFolderPath } from '../config.js';
-import { readFile as readRemoteFile, writeFile as writeRemoteFile, joinRemoteFolderPath, assertRemoteFolderExists } from '../remote/folderfoo-client.js';
+import { readFile as readRemoteFile, writeFile as writeRemoteFile, writeBinaryFile as writeRemoteBinaryFile, joinRemoteFolderPath, assertRemoteFolderExists } from '../remote/folderfoo-client.js';
 import { isFolderVisible } from '../remote/identity.js';
 function rowToDoc(row) {
     return {
@@ -81,6 +81,24 @@ export class SkillRepository {
         const fileContents = fs.readFileSync(filePath, 'utf-8');
         await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, 'SKILL', fileContents);
     }
+    /**
+     * Pushes one attachment file's raw binary content to folderfoo, if `folderName` resolves to a
+     * remote source — the attachment counterpart to pushToRemoteIfNeeded. Unlike SKILL.md (always
+     * pushed under the fixed name 'SKILL'), an attachment is pushed under its own actual filename,
+     * since folderfoo needs to store each attachment as a distinct file. No-op for a local folder,
+     * same as pushToRemoteIfNeeded. Called by AttachmentRepository after it writes an attachment to
+     * the local mirror — callers must roll back the local write on a thrown error here, exactly like
+     * create()/update() already roll back SKILL.md on a failed push.
+     */
+    async pushAttachmentIfNeeded(folderName, attachmentFilePath, mimeType) {
+        const remote = this.remoteFor(folderName);
+        if (!remote || !this.credentialsBaseDir)
+            return;
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName);
+        const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(attachmentFilePath)));
+        const data = fs.readFileSync(attachmentFilePath);
+        await writeRemoteBinaryFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), data, mimeType);
+    }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "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": {