mcp-memory-bucket 0.7.4 → 0.8.0

package/dist/src/web/routes.js

@@ -3,12 +3,15 @@ import os from 'node:os';
 import path from 'node:path';
 import express from 'express';
 import matter from 'gray-matter';
-import { saveFolder, removeFolder as removeFolderFromConfig, sanitizeFolderName } from '../config.js';
+import { saveFolder, saveRemoteFolder, removeFolder as removeFolderFromConfig, sanitizeFolderName, mirrorDirFor } from '../config.js';
 import { stripKey } from '../memory/repository.js';
 import { initialScan } from '../store/sync.js';
 import { sanitizeFtsQuery } from '../store/search.js';
 import { resolveWithinBase } from '../store/safe-path.js';
 import { attachmentsDirFor, guessMimeType } from '../attachments/storage.js';
+import { listFolders as listFolderfooFolders } from '../remote/folderfoo-client.js';
+import { setCredential } from '../remote/credentials.js';
+import { pollOne } from '../remote/remote-sync.js';
 function asArray(v) {
     if (v === undefined)
         return [];
@@ -268,10 +271,17 @@ function buildHealth(db) {
         .map((m) => m.id);
     return { danglingExtends, danglingRelatedTo, emptyTriggerPhrases, staleActiveMemoryDocs };
 }
-export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec) {
+export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec, remotePollers) {
     const router = express.Router();
-    router.post('/api/rebuild-cache', (_req, res) => {
+    // Resyncs every remote source FIRST (force: true - always does real work,
+    // including reconcileDeletions, regardless of the watermark check), so a
+    // deletion made on folderfoo shows up here even if the poller's next
+    // regular tick hasn't fired yet. Without this, the wipe-and-rescan below
+    // is LOCAL-ONLY - it would silently resurrect a file that was deleted on
+    // folderfoo but whose stale mirror copy hadn't been reconciled away yet.
+    router.post('/api/rebuild-cache', async (_req, res) => {
         try {
+            await Promise.all([remotePollers?.skill?.resyncAll(), remotePollers?.memory?.resyncAll()]);
             db.exec(`DELETE FROM skills; DELETE FROM memory_docs; DELETE FROM search_index; DELETE FROM doc_dates;`);
             initialScan(db, skillSpec);
             initialScan(db, memorySpec);
@@ -399,7 +409,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             }
         });
     });
-    router.patch('/api/entries/:table/:id/deprecated', (req, res) => {
+    router.patch('/api/entries/:table/:id/deprecated', async (req, res) => {
         const { table, id } = req.params;
         const { deprecated } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -416,16 +426,16 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
         }
         try {
             if (table === 'skills')
-                skillRepo.update(id, { deprecated });
+                await skillRepo.update(id, { deprecated });
             else
-                memoryRepo.update(id, { deprecated });
+                await memoryRepo.update(id, { deprecated });
             res.json({ id, deprecated });
         }
         catch (err) {
             res.status(404).json({ error: err.message });
         }
     });
-    router.post('/api/entries/:table/bulk/deprecated', (req, res) => {
+    router.post('/api/entries/:table/bulk/deprecated', async (req, res) => {
         const { table } = req.params;
         const { ids, deprecated } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -436,7 +446,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: 'body must be { ids: string[], deprecated: boolean }' });
             return;
         }
-        const results = table === 'skills' ? skillRepo.bulkUpdate(ids, { deprecated }) : memoryRepo.bulkUpdate(ids, { deprecated });
+        const results = table === 'skills' ? await skillRepo.bulkUpdate(ids, { deprecated }) : await memoryRepo.bulkUpdate(ids, { deprecated });
         res.json({ results });
     });
     // General frontmatter edit — covers both "edit an existing doc's fields" and "add frontmatter
@@ -444,7 +454,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     // "add" is just this same call supplying real values). Memory `key` is editable here (update()
     // normalizes it). Skill `name` is not — SkillRepository.update() rejects it outright since
     // renaming requires a real folder move (see the rename route below).
-    router.patch('/api/entries/:table/:id', (req, res) => {
+    router.patch('/api/entries/:table/:id', async (req, res) => {
         const { table, id } = req.params;
         const { frontmatter } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -464,14 +474,14 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             return;
         }
         try {
-            const updated = table === 'skills' ? skillRepo.update(id, frontmatter) : memoryRepo.update(id, frontmatter);
+            const updated = table === 'skills' ? await skillRepo.update(id, frontmatter) : await memoryRepo.update(id, frontmatter);
             res.json(updated);
         }
         catch (err) {
             res.status(404).json({ error: err.message });
         }
     });
-    router.post('/api/entries/skills/:name/rename', (req, res) => {
+    router.post('/api/entries/skills/:name/rename', async (req, res) => {
         const { name } = req.params;
         const { new_name } = req.body;
         if (!name) {
@@ -483,7 +493,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             return;
         }
         try {
-            const renamed = skillRepo.rename(name, new_name);
+            const renamed = await skillRepo.rename(name, new_name);
             res.json(renamed);
         }
         catch (err) {
@@ -492,14 +502,14 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     });
     // Memory docs only — skill frontmatter (name/description) is required by the agentskills.io
     // spec, so stripping it would produce a non-conformant SKILL.md no compliant agent can load.
-    router.delete('/api/entries/memory_docs/:id/frontmatter', (req, res) => {
+    router.delete('/api/entries/memory_docs/:id/frontmatter', async (req, res) => {
         const { id } = req.params;
         if (!id) {
             res.status(400).json({ error: 'id is required' });
             return;
         }
         try {
-            memoryRepo.stripFrontmatter(id);
+            await memoryRepo.stripFrontmatter(id);
             res.json({ id, frontmatterRemoved: true });
         }
         catch (err) {
@@ -508,7 +518,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     });
     // `paused` is a local-only cache toggle (see SkillRepository/MemoryRepository#setPaused) — it
     // never touches the source file, so this goes through setPaused, not update()/bulkUpdate().
-    router.patch('/api/entries/:table/:id/paused', (req, res) => {
+    router.patch('/api/entries/:table/:id/paused', async (req, res) => {
         const { table, id } = req.params;
         const { paused } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -523,14 +533,14 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: 'body must be { paused: boolean }' });
             return;
         }
-        const [result] = table === 'skills' ? skillRepo.setPaused([id], paused) : memoryRepo.setPaused([id], paused);
+        const [result] = table === 'skills' ? await skillRepo.setPaused([id], paused) : await memoryRepo.setPaused([id], paused);
         if (!result?.ok) {
             res.status(404).json({ error: result?.error ?? 'not found' });
             return;
         }
         res.json({ id, paused });
     });
-    router.post('/api/entries/:table/bulk/paused', (req, res) => {
+    router.post('/api/entries/:table/bulk/paused', async (req, res) => {
         const { table } = req.params;
         const { ids, paused } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -541,10 +551,10 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: 'body must be { ids: string[], paused: boolean }' });
             return;
         }
-        const results = table === 'skills' ? skillRepo.setPaused(ids, paused) : memoryRepo.setPaused(ids, paused);
+        const results = table === 'skills' ? await skillRepo.setPaused(ids, paused) : await memoryRepo.setPaused(ids, paused);
         res.json({ results });
     });
-    router.delete('/api/entries/:table/:id', (req, res) => {
+    router.delete('/api/entries/:table/:id', async (req, res) => {
         const { table, id } = req.params;
         if (table !== 'skills' && table !== 'memory_docs') {
             res.status(400).json({ error: 'table must be "skills" or "memory_docs"' });
@@ -556,16 +566,16 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
         }
         try {
             if (table === 'skills')
-                skillRepo.delete(id);
+                await skillRepo.delete(id);
             else
-                memoryRepo.delete(id);
+                await memoryRepo.delete(id);
             res.json({ deleted: id });
         }
         catch (err) {
             res.status(404).json({ error: err.message });
         }
     });
-    router.post('/api/entries/:table/bulk/delete', (req, res) => {
+    router.post('/api/entries/:table/bulk/delete', async (req, res) => {
         const { table } = req.params;
         const { ids } = req.body;
         if (table !== 'skills' && table !== 'memory_docs') {
@@ -576,7 +586,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: 'body must be { ids: string[] }' });
             return;
         }
-        const results = table === 'skills' ? skillRepo.bulkDelete(ids) : memoryRepo.bulkDelete(ids);
+        const results = table === 'skills' ? await skillRepo.bulkDelete(ids) : await memoryRepo.bulkDelete(ids);
         res.json({ results });
     });
     router.get('/api/facets', (req, res) => {
@@ -594,10 +604,80 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     router.get('/api/health', (_req, res) => {
         res.json(buildHealth(db));
     });
+    // Tells the client which folderfoo deployment (if any) to point the
+    // "Connect folderfoo" flow and the page-level login widget at — see
+    // config.ts's FolderfooMode doc comment for why this can't be inferred
+    // from window.location.hostname the way mindfoo/bulletino/avotuner do.
+    router.get('/api/config', (_req, res) => {
+        res.json({ folderfooMode: config.folderfooMode, folderfooHost: config.folderfooHost });
+    });
     router.get('/api/folders', (_req, res) => {
         res.json({
-            skill: skillRepo.listFolders().map((f) => ({ ...f, kind: 'skill' })),
-            memory: memoryRepo.listFolders().map((f) => ({ ...f, kind: 'memory' })),
+            skill: skillRepo.listFoldersWithRemoteInfo().map((f) => ({ ...f, kind: 'skill' })),
+            memory: memoryRepo.listFoldersWithRemoteInfo().map((f) => ({ ...f, kind: 'memory' })),
+        });
+    });
+    // Resolves a file opened via folderfoo's own File Open dialog
+    // (<folderfoo-profile-circle>'s "folderfoo-file-open" event) back to a
+    // memory-bucket doc, so the web UI can select it in the right panel —
+    // and, since that panel's edits already push through to folderfoo for
+    // any doc whose folder resolves to a remote source (see PATCH
+    // /api/entries/:table/:id), frontmatter changes made there persist to
+    // the cloud automatically once the right doc is open, no separate wiring
+    // needed for that half.
+    //
+    // Only works when the opened file's (server, tenantId, folderPath) falls
+    // under a folder ALREADY connected as a remote source here — folderfoo's
+    // File Open dialog browses the user's whole folderfoo tree, not just
+    // connected folders, so a miss (file from an unconnected folder) is a
+    // real, expected case the client surfaces as a clear message, not
+    // silently swallowed.
+    router.post('/api/folderfoo/resolve-open', (req, res) => {
+        const { server, tenantId, folderPath, name } = req.body;
+        if (!server || !tenantId || !name) {
+            res.status(400).json({ error: 'server, tenantId, and name are required' });
+            return;
+        }
+        const openedFolderPath = folderPath || '';
+        for (const [table, repo] of [
+            ['skills', skillRepo],
+            ['memory_docs', memoryRepo],
+        ]) {
+            for (const remote of repo.listRemoteFolders()) {
+                if (remote.server !== server || remote.tenantId !== tenantId)
+                    continue;
+                // The opened file's folder must be remote.folderPath itself, or nested inside it.
+                const sourceFolder = remote.folderPath;
+                let withinFolder;
+                if (openedFolderPath === sourceFolder) {
+                    withinFolder = '';
+                }
+                else if (sourceFolder === '') {
+                    withinFolder = openedFolderPath;
+                }
+                else if (openedFolderPath.startsWith(`${sourceFolder}/`)) {
+                    withinFolder = openedFolderPath.slice(sourceFolder.length + 1);
+                }
+                else {
+                    continue; // not under this source
+                }
+                const sourcePath = table === 'skills'
+                    ? path.join(remote.mirrorDir, withinFolder, name, 'SKILL.md')
+                    : path.join(remote.mirrorDir, withinFolder, `${name}.md`);
+                const row = db.prepare(`SELECT id FROM ${table} WHERE source_path = ?`).get(sourcePath);
+                if (row) {
+                    res.json({ table, id: row.id });
+                    return;
+                }
+                // Matched the connected source but no cache row yet (e.g. the
+                // poller hasn't picked it up since it was just created elsewhere) —
+                // a different, more specific miss than "not connected at all".
+                res.status(404).json({ error: `matched remote source "${remote.name}", but no cached doc found yet for this file — try Resync` });
+                return;
+            }
+        }
+        res.status(404).json({
+            error: `this file's folder isn't connected in memory-bucket yet — add it as a remote source first`,
         });
     });
     router.post('/api/folders', (req, res) => {
@@ -629,6 +709,121 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(409).json({ error: err.message });
         }
     });
+    // Persists a folderfoo JWT the browser already obtained (see
+    // credentials.ts — keyed by server URL, so every remote source pointing
+    // at the same folderfoo deployment shares this one login). The actual
+    // login UI is folderfoo's own <folderfoo-profile-circle> widget,
+    // dynamically imported into the client page exactly like every other
+    // folderfoo-consuming app (bulletino, mindfoo) — that widget stores its
+    // token in THIS page's localStorage (browser-only), so the client reads
+    // it back out and POSTs it here to also persist it server-side, where
+    // the Node process (poller, live reads/writes) actually needs it. This
+    // avoids a second username/password prompt: one login, reused for both
+    // the browser tab and the backend.
+    router.post('/api/folderfoo/login', async (req, res) => {
+        const { server, token } = req.body;
+        if (!server || !token) {
+            res.status(400).json({ error: 'server and token are required' });
+            return;
+        }
+        setCredential(config.baseDir, server, token);
+        res.json({ connected: true, server });
+    });
+    // Lists the caller's own folderfoo folders for the "connect a folder"
+    // picker, once already logged in to `server` (via the route above).
+    router.get('/api/folderfoo/folders', async (req, res) => {
+        const server = req.query.server;
+        const tenantId = req.query.tenantId;
+        if (!server || !tenantId) {
+            res.status(400).json({ error: 'server and tenantId query params are required' });
+            return;
+        }
+        try {
+            const folders = await listFolderfooFolders(server, config.baseDir, tenantId);
+            res.json(folders);
+        }
+        catch (err) {
+            res.status(401).json({ error: err.message });
+        }
+    });
+    // Registers a REMOTE (folderfoo) source — the connect-a-folder counterpart
+    // to POST /api/folders above, which only ever handles local filesystem
+    // paths. Creates the local mirror directory, registers it with the
+    // repository (so it starts watching/scanning like any local folder), then
+    // immediately triggers one poll so content shows up without waiting for
+    // the first interval tick.
+    router.post('/api/remote-folders', async (req, res) => {
+        const { kind, name, server, tenantId, folderPath } = req.body;
+        if (kind !== 'skill' && kind !== 'memory') {
+            res.status(400).json({ error: 'kind must be "skill" or "memory"' });
+            return;
+        }
+        if (!server || !tenantId || folderPath === undefined) {
+            res.status(400).json({ error: 'server, tenantId, and folderPath are required' });
+            return;
+        }
+        const folderName = sanitizeFolderName(name || folderPath.split('/').filter(Boolean).pop() || tenantId);
+        if (!folderName) {
+            res.status(400).json({ error: 'could not derive a valid folder name — provide one explicitly' });
+            return;
+        }
+        const repo = kind === 'skill' ? skillRepo : memoryRepo;
+        const spec = kind === 'skill' ? skillSpec : memorySpec;
+        const mirrorDir = mirrorDirFor(config.baseDir, folderName);
+        const remote = { name: folderName, server, tenantId, folderPath, mirrorDir };
+        try {
+            repo.registerRemoteFolder(remote);
+            saveRemoteFolder(config, kind, { name: folderName, server, tenantId, folderPath });
+            await pollOne(db, spec, remote, config.baseDir);
+            res.json({ name: folderName, server, tenantId, folderPath, kind });
+        }
+        catch (err) {
+            res.status(409).json({ error: err.message });
+        }
+    });
+    // Triggers one immediate out-of-cycle poll for a single remote source —
+    // backs the web UI's per-source "resync now" action, so a user who just
+    // saved something remotely doesn't have to wait out the fixed poll
+    // interval to see it reflected locally.
+    router.post('/api/remote-folders/:kind/:name/resync', async (req, res) => {
+        const { kind, name } = req.params;
+        if (kind !== 'skill' && kind !== 'memory') {
+            res.status(400).json({ error: 'kind must be "skill" or "memory"' });
+            return;
+        }
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        const handle = kind === 'skill' ? remotePollers?.skill : remotePollers?.memory;
+        if (!handle) {
+            res.status(404).json({ error: `no remote ${kind} sources configured` });
+            return;
+        }
+        try {
+            await handle.resyncNow(name);
+            res.json({ resynced: name, kind });
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
+    // Lightweight "check every remote source for changes right now" — unlike
+    // rebuild-cache (which wipes the WHOLE local cache and re-scans
+    // everything, including local-only folders), this only force-resyncs the
+    // remote sources' own incremental pull+reconcile, so it's cheap enough to
+    // call on every tab focus without the user needing to hit rebuild-cache
+    // by hand just to see a remote change (e.g. a deletion) sooner than the
+    // fixed poll interval.
+    router.post('/api/remote-folders/resync-all', async (_req, res) => {
+        try {
+            await Promise.all([remotePollers?.skill?.resyncAll(), remotePollers?.memory?.resyncAll()]);
+            res.json({ resynced: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     router.delete('/api/folders/:kind/:name', (req, res) => {
         const { kind, name } = req.params;
         if (kind !== 'skill' && kind !== 'memory') {

package/package.json

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