mcp-memory-bucket 0.8.1 → 0.8.2

package/dist/client/index.html

@@ -33,7 +33,7 @@
       z-index: 2147483000;
     }
   </style>
-  <script type="module" crossorigin src="/assets/index-Y4C-4HnN.js"></script>
+  <script type="module" crossorigin src="/assets/index-_w_b_MQl.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/config.js

@@ -5,9 +5,18 @@ const FOLDERFOO_CLOUD_HOST = 'https://files.cuul.cc';
 function isRemoteEntry(entry) {
     return typeof entry === 'object' && 'remote' in entry;
 }
-/** Local mirror directory a remote source's content is synced into - see the RemoteFolder doc comment above. */
-export function mirrorDirFor(baseDir, name) {
-    return path.join(baseDir, '.memory-bucket-remote-cache', sanitizeFolderName(name));
+/**
+ * Local mirror directory a remote source's content is synced into - see the
+ * RemoteFolder doc comment above. Nested under a {mode}_{username} segment
+ * so mirrors from different folderfoo deployments/logins never collide or
+ * get mistaken for one another (see identity.ts) - a mirror connected while
+ * logged into "dev" as "anatoli" lands at
+ * .memory-bucket-remote-cache/dev_anatoli/<name>/, distinct from the same
+ * folder name connected under "cloud" or a different username.
+ */
+export function mirrorDirFor(baseDir, mode, username, name) {
+    const identitySegment = sanitizeFolderName(`${mode}_${username}`);
+    return path.join(baseDir, '.memory-bucket-remote-cache', identitySegment, sanitizeFolderName(name));
 }
 function memoryDirFlag(argv) {
     const idx = argv.indexOf('--memory-dir');
@@ -55,7 +64,7 @@ function resolveFolders(entries, baseDir) {
             return { name: nameFromPath(entry), path: path.resolve(baseDir, entry) };
         }
         if (isRemoteEntry(entry)) {
-            const mirrorDir = mirrorDirFor(baseDir, entry.name);
+            const mirrorDir = mirrorDirFor(baseDir, entry.remote.mode, entry.remote.username, entry.name);
             remoteFolders.push({ name: entry.name, ...entry.remote, mirrorDir });
             return { name: entry.name, path: mirrorDir };
         }
@@ -130,7 +139,16 @@ export function saveRemoteFolder(config, kind, entry) {
         ...current,
         [key]: [
             ...existing,
-            { name: entry.name, remote: { server: entry.server, tenantId: entry.tenantId, folderPath: entry.folderPath } },
+            {
+                name: entry.name,
+                remote: {
+                    server: entry.server,
+                    tenantId: entry.tenantId,
+                    folderPath: entry.folderPath,
+                    mode: entry.mode,
+                    username: entry.username,
+                },
+            },
         ],
     };
     fs.writeFileSync(config.configPath, JSON.stringify(next, null, 2) + '\n');

package/dist/src/memory/repository.js

@@ -11,6 +11,7 @@ import { applyBodyEdits } from '../shared/body-edits.js';
 import { attachmentsDirFor } from '../attachments/storage.js';
 import { normalizeKey } from '../types.js';
 import { readFile as readRemoteFile, writeFile as writeRemoteFile, joinRemoteFolderPath } 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`). */
 export function stripKey(s) {
@@ -40,19 +41,37 @@ export class MemoryRepository {
     folders;
     remoteFolders;
     credentialsBaseDir;
+    identity;
     syncSpec;
     watcher;
-    constructor(db, folders, remoteFolders = [], credentialsBaseDir) {
+    constructor(db, folders, remoteFolders = [], credentialsBaseDir, identity) {
         this.db = db;
         this.folders = folders;
         this.remoteFolders = remoteFolders;
         this.credentialsBaseDir = credentialsBaseDir;
+        this.identity = identity;
         this.syncSpec = memorySyncSpec(folders);
     }
     /** The RemoteFolder a NamedFolder name resolves to, or undefined for a local (non-remote) folder. */
     remoteFor(folderName) {
         return this.remoteFolders.find((f) => f.name === folderName);
     }
+    /** Whether `folderName` should be visible right now — always true for local folders; for a remote folder, only when it matches the current login (see identity.ts). No identity tracker configured means folderfoo integration is off entirely, so nothing remote is ever visible. */
+    isFolderNameVisible(folderName) {
+        const remote = this.remoteFor(folderName);
+        if (!remote)
+            return true;
+        if (!this.identity)
+            return false;
+        return isFolderVisible(remote, this.identity.current());
+    }
+    /** Names of every remote folder NOT matching the current identity — used to exclude their rows from list/search SQL. */
+    hiddenFolderNames() {
+        if (!this.identity)
+            return this.remoteFolders.map((f) => f.name);
+        const identity = this.identity.current();
+        return this.remoteFolders.filter((f) => !isFolderVisible(f, identity)).map((f) => f.name);
+    }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;
@@ -64,9 +83,9 @@ export class MemoryRepository {
     listRemoteFolders() {
         return [...this.remoteFolders];
     }
-    /** Same as listFolders(), but tags each entry with whether it's a remote (folderfoo) source — for the web UI's folder list, e.g. to render remote folders in a distinct color. */
+    /** Same as listFolders(), but tags each entry with whether it's a remote (folderfoo) source — for the web UI's folder list, e.g. to render remote folders in a distinct color. Excludes remote folders that don't match the current login (see identity.ts). */
     listFoldersWithRemoteInfo() {
-        return this.folders.map((f) => ({ ...f, remote: !!this.remoteFor(f.name) }));
+        return this.folders.filter((f) => this.isFolderNameVisible(f.name)).map((f) => ({ ...f, remote: !!this.remoteFor(f.name) }));
     }
     resolveFolder(folderName) {
         if (folderName) {
@@ -134,6 +153,11 @@ export class MemoryRepository {
         if (!opts.includePaused) {
             conditions.push('paused = 0');
         }
+        const hidden = this.hiddenFolderNames();
+        if (hidden.length > 0) {
+            conditions.push(`folder NOT IN (${hidden.map(() => '?').join(', ')})`);
+            params.push(...hidden);
+        }
         const rows = this.db
             .prepare(`SELECT * FROM memory_docs WHERE ${conditions.join(' AND ')}`)
             .all(...params);
@@ -168,6 +192,11 @@ export class MemoryRepository {
         if (!includePaused) {
             conditions.push('m.paused = 0');
         }
+        const hidden = this.hiddenFolderNames();
+        if (hidden.length > 0) {
+            conditions.push(`m.folder NOT IN (${hidden.map(() => '?').join(', ')})`);
+            params.push(...hidden);
+        }
         params.push(limit, offset);
         try {
             const rows = this.db
@@ -198,6 +227,8 @@ export class MemoryRepository {
         if (!row)
             return null;
         const doc = rowToDoc(row);
+        if (!this.isFolderNameVisible(doc.folder))
+            return null;
         const remote = this.remoteFor(doc.folder);
         if (!remote || !this.credentialsBaseDir)
             return doc;

package/dist/src/remote/identity.js

@@ -0,0 +1,67 @@
+/**
+ * Decodes the `username` claim out of a folderfoo JWT's payload — no
+ * signature verification, since this only reads a claim from a token the
+ * server already trusts enough to use against folderfoo itself (see
+ * credentials.ts). folderfoo's signToken() payload shape is
+ * {username, fullname, origIat, iat, exp} (folderfoo's own server.js) — no
+ * sub/id/email/tenantId claim exists, so username is the stable identity key.
+ */
+export function decodeUsername(jwt) {
+    const payloadSegment = jwt.split('.')[1];
+    if (!payloadSegment)
+        throw new Error('malformed folderfoo token: missing payload segment');
+    const payload = JSON.parse(Buffer.from(payloadSegment, 'base64').toString('utf-8'));
+    if (!payload.username)
+        throw new Error('malformed folderfoo token: missing username claim');
+    return payload.username;
+}
+/**
+ * Process-wide "who's currently logged in" tracker. `mode` is fixed for the
+ * process's lifetime (only changes via a restart with a different
+ * --folderfoo-mode flag, per the settled design) - only `username` is
+ * mutable, driven by the browser's login/logout signals via
+ * /api/folderfoo/login and /api/folderfoo/logout. There is no per-tab or
+ * per-MCP-client identity: multiple browser tabs and MCP clients share this
+ * one process-wide value, and the most recent login anywhere wins for all of
+ * them (settled design decision — not a per-connection scope).
+ */
+export class IdentityTracker {
+    mode;
+    username = null;
+    listeners = new Set();
+    constructor(mode) {
+        this.mode = mode;
+    }
+    current() {
+        return { mode: this.mode, username: this.username };
+    }
+    setUsername(username) {
+        if (this.username === username)
+            return;
+        this.username = username;
+        this.emit();
+    }
+    clearUsername() {
+        if (this.username === null)
+            return;
+        this.username = null;
+        this.emit();
+    }
+    onIdentityChange(cb) {
+        this.listeners.add(cb);
+        return () => this.listeners.delete(cb);
+    }
+    emit() {
+        const identity = this.current();
+        for (const cb of this.listeners)
+            cb(identity);
+    }
+}
+/** True when `folder` was connected under the identity currently logged in. */
+export function matchesCurrentIdentity(folder, identity) {
+    return identity.username !== null && folder.mode === identity.mode && folder.username === identity.username;
+}
+/** Local (non-remote) folders are always visible; a remote folder only when it matches the current identity. */
+export function isFolderVisible(remote, identity) {
+    return remote === undefined || matchesCurrentIdentity(remote, identity);
+}

package/dist/src/server.js

@@ -20,6 +20,7 @@ import { registerUiTool } from './web/ui-tool.js';
 import { registerMemoryChannelTools } from './channels/tools.js';
 import { startChannelSweep } from './channels/store.js';
 import { startRemotePolling } from './remote/remote-sync.js';
+import { IdentityTracker } from './remote/identity.js';
 // server.ts is rebuilt from `buildMcpServer()` on every /mcp request (see below),
 // so tool schemas (which conditionally include `folder` based on folder count) always
 // reflect the current folders — no restart needed after an add/remove-folder call.
@@ -36,14 +37,15 @@ const builtinSkillsDir = path.join(__dirname, 'skills', 'builtin');
 const PORT = process.env.PORT ? Number(process.env.PORT) : 8767;
 const config = loadConfig();
 const db = openCache(config.cacheDbPath);
+const identity = new IdentityTracker(config.folderfooMode);
 const skillSpec = skillSyncSpec([{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders]);
 const memorySpec = memorySyncSpec(config.memoryFolders);
 initialScan(db, skillSpec);
 initialScan(db, memorySpec);
 const skillWatcher = watchSources(db, skillSpec);
 const memoryWatcher = watchSources(db, memorySpec);
-const skillRepo = new SkillRepository(db, [{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders], config.remoteSkillFolders, config.baseDir);
-const memoryRepo = new MemoryRepository(db, config.memoryFolders, config.remoteMemoryFolders, config.baseDir);
+const skillRepo = new SkillRepository(db, [{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders], config.remoteSkillFolders, config.baseDir, identity);
+const memoryRepo = new MemoryRepository(db, config.memoryFolders, config.remoteMemoryFolders, config.baseDir, identity);
 skillRepo.setWatcher(skillWatcher);
 memoryRepo.setWatcher(memoryWatcher);
 const attachmentRepo = new AttachmentRepository(memoryRepo, skillRepo);
@@ -77,7 +79,7 @@ function buildMcpServer() {
 startChannelSweep((name) => console.error(`[memory-bucket] sweeping idle memory channel: ${name}`));
 const app = express();
 app.use(express.json());
-app.use(buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec, { skill: remoteSkillPoller, memory: remoteMemoryPoller }));
+app.use(buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec, identity, { skill: remoteSkillPoller, memory: remoteMemoryPoller }));
 app.use(express.static(path.join(packageRoot, 'dist', 'client')));
 app.post('/mcp', async (req, res) => {
     const server = buildMcpServer();

package/dist/src/skills/repository.js

@@ -8,6 +8,7 @@ import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSp
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
 import { applyBodyEdits } from '../shared/body-edits.js';
 import { readFile as readRemoteFile, writeFile as writeRemoteFile, joinRemoteFolderPath } from '../remote/folderfoo-client.js';
+import { isFolderVisible } from '../remote/identity.js';
 function rowToDoc(row) {
     return {
         name: row.id,
@@ -29,20 +30,38 @@ export class SkillRepository {
     folders;
     remoteFolders;
     credentialsBaseDir;
+    identity;
     syncSpec;
     watcher;
     /** `folders[0]` is always the builtin skills dir — never exposed for create()/removal. */
-    constructor(db, folders, remoteFolders = [], credentialsBaseDir) {
+    constructor(db, folders, remoteFolders = [], credentialsBaseDir, identity) {
         this.db = db;
         this.folders = folders;
         this.remoteFolders = remoteFolders;
         this.credentialsBaseDir = credentialsBaseDir;
+        this.identity = identity;
         this.syncSpec = skillSyncSpec(folders);
     }
     /** The RemoteFolder a NamedFolder name resolves to, or undefined for a local (non-remote) folder. */
     remoteFor(folderName) {
         return this.remoteFolders.find((f) => f.name === folderName);
     }
+    /** Whether `folderName` should be visible right now — always true for local folders; for a remote folder, only when it matches the current login (see identity.ts). No identity tracker configured means folderfoo integration is off entirely, so nothing remote is ever visible. */
+    isFolderNameVisible(folderName) {
+        const remote = this.remoteFor(folderName);
+        if (!remote)
+            return true;
+        if (!this.identity)
+            return false;
+        return isFolderVisible(remote, this.identity.current());
+    }
+    /** Names of every remote folder NOT matching the current identity — used to exclude their rows from list/search SQL. */
+    hiddenFolderNames() {
+        if (!this.identity)
+            return this.remoteFolders.map((f) => f.name);
+        const identity = this.identity.current();
+        return this.remoteFolders.filter((f) => !isFolderVisible(f, identity)).map((f) => f.name);
+    }
     /** Pushes the just-written SKILL.md at filePath to folderfoo, if targetFolderName resolves to a remote source. No-op for a local folder. See get()'s comment on the folderPath/name split for a skill's directory-per-skill layout. */
     async pushToRemoteIfNeeded(targetFolderName, filePath) {
         const remote = this.remoteFor(targetFolderName);
@@ -64,9 +83,11 @@ export class SkillRepository {
     listRemoteFolders() {
         return [...this.remoteFolders];
     }
-    /** Same as listFolders(), but tags each entry with whether it's a remote (folderfoo) source — for the web UI's folder list, e.g. to render remote folders in a distinct color. */
+    /** Same as listFolders(), but tags each entry with whether it's a remote (folderfoo) source — for the web UI's folder list, e.g. to render remote folders in a distinct color. Excludes remote folders that don't match the current login (see identity.ts). */
     listFoldersWithRemoteInfo() {
-        return this.listFolders().map((f) => ({ ...f, remote: !!this.remoteFor(f.name) }));
+        return this.listFolders()
+            .filter((f) => this.isFolderNameVisible(f.name))
+            .map((f) => ({ ...f, remote: !!this.remoteFor(f.name) }));
     }
     resolveFolder(folderName) {
         const userFolders = this.listFolders();
@@ -131,6 +152,11 @@ export class SkillRepository {
         if (!opts.includePaused) {
             conditions.push('paused = 0');
         }
+        const hidden = this.hiddenFolderNames();
+        if (hidden.length > 0) {
+            conditions.push(`folder NOT IN (${hidden.map(() => '?').join(', ')})`);
+            params.push(...hidden);
+        }
         const where = conditions.length ? ` WHERE ${conditions.join(' AND ')}` : '';
         const rows = this.db
             .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, folder, paused FROM skills${where}`)
@@ -182,6 +208,11 @@ export class SkillRepository {
         if (!includePaused) {
             conditions.push('s.paused = 0');
         }
+        const hidden = this.hiddenFolderNames();
+        if (hidden.length > 0) {
+            conditions.push(`s.folder NOT IN (${hidden.map(() => '?').join(', ')})`);
+            params.push(...hidden);
+        }
         params.push(limit, offset);
         try {
             const rows = this.db
@@ -211,6 +242,8 @@ export class SkillRepository {
         if (!row)
             return null;
         const doc = rowToDoc(row);
+        if (!this.isFolderNameVisible(doc.folder))
+            return null;
         const remote = this.remoteFor(doc.folder);
         if (!remote || !this.credentialsBaseDir)
             return doc;

package/dist/src/web/routes.js

@@ -12,6 +12,7 @@ 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';
+import { decodeUsername } from '../remote/identity.js';
 import { getChannel, listChannels } from '../channels/store.js';
 function asArray(v) {
     if (v === undefined)
@@ -272,7 +273,7 @@ function buildHealth(db) {
         .map((m) => m.id);
     return { danglingExtends, danglingRelatedTo, emptyTriggerPhrases, staleActiveMemoryDocs };
 }
-export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec, remotePollers) {
+export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, memorySpec, identity, remotePollers) {
     const router = express.Router();
     // Resyncs every remote source FIRST (force: true - always does real work,
     // including reconcileDeletions, regardless of the watermark check), so a
@@ -742,8 +743,40 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             return;
         }
         setCredential(config.baseDir, server, token);
+        // Updates the process-wide current identity (see identity.ts) - the most
+        // recent login from ANY browser tab becomes "current" for the whole
+        // process, including MCP tool calls. Logging in doesn't itself change
+        // which entries are stamped with this identity (that only happens at
+        // connect-time, see /api/remote-folders below) - it just changes which
+        // already-stamped entries become visible.
+        identity.setUsername(decodeUsername(token));
         res.json({ connected: true, server });
     });
+    // Signals that the browser's folderfoo login session just ended (the page
+    // detects folderfoo's own auth-change event going to logged-out) - clears
+    // the process-wide current identity, which hides every remote folder
+    // (everywhere: web UI and MCP tool results alike) until a new login
+    // stamps a fresh identity via the route above. No server/token body: this
+    // is "the browser lost its session," not scoped to one server.
+    router.post('/api/folderfoo/logout', (_req, res) => {
+        identity.clearUsername();
+        res.json({ connected: false });
+    });
+    // Server-sent-events stream of the current identity, so an open browser
+    // tab's folder list updates the instant a login/logout happens anywhere
+    // (this tab or another one) - no polling, no page reload. Sends the
+    // current value immediately on connect, then again on every change.
+    router.get('/api/folderfoo/identity-stream', (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        });
+        const send = (current) => res.write(`data: ${JSON.stringify(current)}\n\n`);
+        send(identity.current());
+        const unsubscribe = identity.onIdentityChange(send);
+        req.on('close', unsubscribe);
+    });
     // 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) => {
@@ -782,13 +815,21 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: 'could not derive a valid folder name — provide one explicitly' });
             return;
         }
+        // A folder can only be connected while logged in — the identity it's
+        // stamped with (see identity.ts) is exactly the one that just made the
+        // "connect a folder" picker possible in the first place.
+        const current = identity.current();
+        if (!current.username) {
+            res.status(401).json({ error: 'not logged in to folderfoo' });
+            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 };
+        const mirrorDir = mirrorDirFor(config.baseDir, current.mode, current.username, folderName);
+        const remote = { name: folderName, server, tenantId, folderPath, mirrorDir, mode: current.mode, username: current.username };
         try {
             repo.registerRemoteFolder(remote);
-            saveRemoteFolder(config, kind, { name: folderName, server, tenantId, folderPath });
+            saveRemoteFolder(config, kind, { name: folderName, server, tenantId, folderPath, mode: current.mode, username: current.username });
             await pollOne(db, spec, remote, config.baseDir);
             res.json({ name: folderName, server, tenantId, folderPath, kind });
         }

package/package.json

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