mcp-memory-bucket 0.10.12 → 0.10.13

package/dist/src/skills/repository.js

@@ -83,9 +83,9 @@ export class SkillRepository {
         const remote = this.remoteFor(targetFolderName);
         if (!remote || !this.credentialsBaseDir)
             return;
-        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, targetFolderName);
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, targetFolderName, remote.owner);
         const skillDirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(filePath)));
-        await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, 'SKILL', fileContents);
+        await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, 'SKILL', fileContents, remote.owner);
     }
     /**
      * Pushes one attachment's raw binary content to folderfoo, if `folderName` resolves to a remote
@@ -100,9 +100,9 @@ export class SkillRepository {
         const remote = this.remoteFor(folderName);
         if (!remote || !this.credentialsBaseDir)
             return;
-        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName);
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName, remote.owner);
         const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(attachmentFilePath)));
-        await writeRemoteBinaryFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), data, mimeType);
+        await writeRemoteBinaryFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), data, mimeType, remote.owner);
     }
     /**
      * Trashes one attachment's remote copy on folderfoo, if `folderName` resolves to a remote source
@@ -115,9 +115,9 @@ export class SkillRepository {
         const remote = this.remoteFor(folderName);
         if (!remote || !this.credentialsBaseDir)
             return;
-        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName);
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName, remote.owner);
         const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(attachmentFilePath)));
-        await trashRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath));
+        await trashRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), remote.owner);
     }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
@@ -162,6 +162,10 @@ export class SkillRepository {
      * perform the initial pull itself — the caller (the web route) does one
      * immediate poll right after this returns, so content shows up without
      * waiting for the first interval tick.
+     *
+     * `remote.name` (and `remote.mirrorDir`, derived from it) must already be the FINAL, resolved
+     * name — see resolveAvailableName, which the web route calls first (before it derives mirrorDir)
+     * so a possibly-auto-suffixed name is settled before anything touches disk.
      */
     registerRemoteFolder(remote) {
         if (this.folders.some((f) => f.name === remote.name)) {
@@ -169,11 +173,40 @@ export class SkillRepository {
         }
         fs.mkdirSync(remote.mirrorDir, { recursive: true });
         this.remoteFolders.push(remote);
-        this.addFolder({ name: remote.name, path: remote.mirrorDir });
+        this.addFolder({ name: remote.name, path: remote.mirrorDir }, { skipCollisionCheck: true });
     }
-    /** Registers a new folder: appends it, scans it once, and starts watching it live. */
-    addFolder(folder) {
-        if (this.folders.some((f) => f.name === folder.name)) {
+    /**
+     * `name` must stay globally unique across EVERY identity this process has ever seen — see
+     * memory/repository.ts's identical method for the full reasoning and the own-identity-vs-
+     * different-identity distinction (auto-suffix vs reject). Called by the web route BEFORE deriving
+     * mirrorDir/calling registerRemoteFolder, so the name is fully settled before anything touches disk.
+     */
+    resolveAvailableName(requestedName, connectingUsername) {
+        const takenByOwnIdentity = (name) => this.folders.some((f) => f.name === name) && this.isFolderNameVisible(name);
+        const taken = (name) => this.folders.some((f) => f.name === name);
+        if (!taken(requestedName))
+            return requestedName;
+        if (takenByOwnIdentity(requestedName)) {
+            throw new Error(`a skill folder named "${requestedName}" already exists`);
+        }
+        let candidate = `${requestedName} (${connectingUsername})`;
+        let suffix = 2;
+        while (taken(candidate)) {
+            if (takenByOwnIdentity(candidate)) {
+                throw new Error(`a skill folder named "${candidate}" already exists`);
+            }
+            candidate = `${requestedName} (${connectingUsername}) ${suffix}`;
+            suffix++;
+        }
+        return candidate;
+    }
+    /**
+     * Registers a new folder: appends it, scans it once, and starts watching it live. A purely LOCAL
+     * folder has no "different identity" to auto-suffix against — any collision here is
+     * unconditionally a plain rejection, unlike registerRemoteFolder's own resolveAvailableName.
+     */
+    addFolder(folder, options) {
+        if (!options?.skipCollisionCheck && this.folders.some((f) => f.name === folder.name)) {
             throw new Error(`a skill folder named "${folder.name}" already exists`);
         }
         this.folders.push(folder);
@@ -367,7 +400,7 @@ export class SkillRepository {
         // block around this already-frontmattered blob (see memory/
         // repository.ts's get() for the confirmed real-world corruption this
         // caused).
-        const liveBody = matter(await readRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, 'SKILL')).content.trim();
+        const liveBody = matter(await readRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, 'SKILL', remote.owner)).content.trim();
         return { ...doc, body: liveBody };
     }
     /** Fetches many skills by name in one call — e.g. hydrating full bodies for a batch of search() hits. Missing names are simply absent from the result, not errors. */
@@ -506,10 +539,10 @@ export class SkillRepository {
         await writeRemoteThenLocal(async () => {
             if (!remote || !this.credentialsBaseDir)
                 return;
-            await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, existing.folder);
+            await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, existing.folder, remote.owner);
             const oldDirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, oldDir));
             const newDirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, newDir));
-            await renameRemoteFolder(remote.server, this.credentialsBaseDir, remote.tenantId, oldDirRelPath, newDirRelPath);
+            await renameRemoteFolder(remote.server, this.credentialsBaseDir, remote.tenantId, oldDirRelPath, newDirRelPath, remote.owner);
         }, () => {
             fs.renameSync(oldDir, newDir);
             // The rename above already moved SKILL.md verbatim (old name/frontmatter) along with the
@@ -618,9 +651,9 @@ export class SkillRepository {
         const skillDir = path.dirname(existing.source_path);
         const remote = this.remoteFor(existing.folder);
         if (remote && this.credentialsBaseDir) {
-            await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, existing.folder);
+            await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, existing.folder, remote.owner);
             const skillDirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, skillDir));
-            await trashRemoteFolder(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath);
+            await trashRemoteFolder(remote.server, this.credentialsBaseDir, remote.tenantId, skillDirRelPath, remote.owner);
         }
         fs.rmSync(skillDir, { recursive: true, force: true });
         removeFile(this.db, 'skills', existing.source_path);

package/dist/src/web/routes.js

@@ -5,7 +5,7 @@ import express from 'express';
 import matter from 'gray-matter';
 import { saveFolder, saveRemoteFolder, removeFolder as removeFolderFromConfig, updateRemoteFolderPath as updateRemoteFolderPathInConfig, sanitizeFolderName, mirrorDirFor, } from '../config.js';
 import { stripKey } from '../memory/repository.js';
-import { initialScan } from '../store/sync.js';
+import { initialScan, walkMarkdownFiles } from '../store/sync.js';
 import { sanitizeFtsQuery } from '../store/search.js';
 import { resolveWithinBase } from '../store/safe-path.js';
 import { attachmentsDirFor, guessMimeType, ATTACHMENT_MAX_BYTES } from '../attachments/storage.js';
@@ -14,7 +14,7 @@ import { setCredential } from '../remote/credentials.js';
 import { pollOne } from '../remote/remote-sync.js';
 import { decodeUsername, isFolderVisible } from '../remote/identity.js';
 import { refreshSharedItems, listSharedItems, dismissRevokedSharedItem, addSharedItem, getSharedItem, resolveShareTarget, } from '../remote/shared-items.js';
-import { shareWithUser, unshareWithUser, createShareLink, createPublicLink, joinRemoteFolderPath } from '../remote/folderfoo-client.js';
+import { shareWithUser, unshareWithUser, createShareLink, createPublicLink, joinRemoteFolderPath, getSharedWithMe, FolderfooRequestError } from '../remote/folderfoo-client.js';
 import { readMarkdownFile } from '../store/markdown-file.js';
 import { getChannel, listChannels } from '../channels/store.js';
 function asArray(v) {
@@ -952,59 +952,109 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
      * opposed to whether its contents changed.
      *
      * Reuses folderfoo's existing GET /folders (via listFolderfooFolders) — one bulk call per
-     * distinct folderfoo server returns every currently-existing folder path for that login, cheaper
-     * than a per-folder existence check would be for an account with many connected sources. Sources
-     * sharing one server (the common case — see credentials.ts, one login per server) dedupe to a
-     * single call. A confirmed-gone folder is auto-removed via the same removeFolder()+
-     * removeFolderFromConfig() pair the manual "✕ remove folder" route above already uses — this
-     * never touches a folder's contents, only mem-bucket's own registration of it (see
-     * removeFolder's doc comment: it drops DB rows + the local mirror dir, never anything the
-     * folder's write path would consider "the user's own content" beyond that mirror).
+     * distinct folderfoo server returns every currently-existing folder path for the caller's OWN
+     * tree, cheaper than a per-folder existence check would be for an account with many connected own
+     * sources; these dedupe to one call per server (the common case — see credentials.ts, one login
+     * per server). A source connected to a folder someone ELSE shared (RemoteFolder.owner set) is a
+     * different case entirely — GET /folders without an owner never includes a shared folder at all,
+     * so each of those is checked individually via owner+rootFolder instead (see the loop below). A
+     * confirmed-gone folder is auto-removed via the same removeFolder()+removeFolderFromConfig() pair
+     * the manual "✕ remove folder" route above already uses — this never touches a folder's contents,
+     * only mem-bucket's own registration of it (see removeFolder's doc comment: it drops DB rows + the
+     * local mirror dir, never anything the folder's write path would consider "the user's own content"
+     * beyond that mirror).
      *
      * Deliberately does NOT run at write time: a write against a since-deleted remote folder instead
      * fails loudly with its own specific error (see repository create()/update()'s remote-push
      * handling) rather than silently recreating the folder — auto-recreating on write would silently
      * undo a deletion the user may have made deliberately, with no visibility that it happened.
+     *
+     * Only ever checks/prunes sources connected under the CURRENTLY LOGGED-IN identity (see the
+     * isFolderVisible guard in the loop below) — credentials.ts stores exactly one JWT per server, so
+     * a different identity's source checked against the wrong credential would always look
+     * "confirmed gone" and get silently deleted the moment ANY other identity's login triggered a
+     * /api/folders load. This was a real, confirmed bug: switching from user A to user B made B's own
+     * previously-connected folders vanish, because A's login (or nobody's) was the only credential on
+     * hand to check them with.
      */
     async function pruneDeletedRemoteFolders() {
-        const byServer = new Map();
+        const ownFolderSources = [];
+        const sharedFolderSources = [];
+        const currentIdentity = identity.current();
         for (const [kind, repo] of [
             ['skill', skillRepo],
             ['memory', memoryRepo],
         ]) {
             for (const remote of repo.listRemoteFolders()) {
-                const list = byServer.get(remote.server) ?? [];
-                list.push({ kind, name: remote.name, folderPath: remote.folderPath, tenantId: remote.tenantId });
-                byServer.set(remote.server, list);
+                // Only ever check a source connected under the IDENTITY CURRENTLY LOGGED IN — credentials.ts
+                // stores exactly one JWT per server, overwritten on every login, so a source belonging to a
+                // different identity (e.g. bbb's own folder, checked right after anatoli logs in) would be
+                // checked with the WRONG credential: that credential's owner's tree obviously never contains
+                // the other identity's folder, so it would always look "confirmed gone" and get silently
+                // deleted the moment ANY other identity's login triggered a /api/folders load — exactly the
+                // "my folder disappeared after switching users" bug this skip fixes. A source that doesn't
+                // match is left untouched here entirely; it re-enters this check once its own identity logs
+                // back in and can be verified with the right credential again.
+                if (!isFolderVisible(remote, currentIdentity))
+                    continue;
+                if (remote.owner) {
+                    sharedFolderSources.push({ kind, name: remote.name, folderPath: remote.folderPath, server: remote.server, tenantId: remote.tenantId, owner: remote.owner });
+                }
+                else {
+                    ownFolderSources.push({ kind, name: remote.name, folderPath: remote.folderPath, server: remote.server, tenantId: remote.tenantId });
+                }
             }
         }
-        if (byServer.size === 0)
-            return;
-        for (const [server, sources] of byServer) {
-            let livePaths;
+        const doRemove = (source) => {
+            const repo = source.kind === 'skill' ? skillRepo : memoryRepo;
             try {
-                // Every source on one server shares one login/tenant (credentials.ts is keyed by server
-                // alone), so any one source's tenantId is representative for the whole group's GET /folders
-                // call.
-                const folders = await listFolderfooFolders(server, config.baseDir, sources[0].tenantId);
-                livePaths = new Set(folders.map((f) => f.path));
+                repo.removeFolder(source.name);
+                removeFolderFromConfig(config, source.kind, source.name);
             }
-            catch {
-                // Not logged in, network blip, etc. — leave every source on this server untouched rather
-                // than treating "couldn't check" as "confirmed gone."
-                continue;
+            catch (err) {
+                console.error(`[memory-bucket] failed to auto-remove deleted remote folder "${source.name}":`, err);
             }
-            for (const source of sources) {
-                if (livePaths.has(source.folderPath))
-                    continue;
-                const repo = source.kind === 'skill' ? skillRepo : memoryRepo;
+        };
+        // Own-folder sources: unchanged from before — GET /folders without an owner returns the
+        // caller's own flat tree in one call per distinct server (sources sharing one server share one
+        // login/tenant, so any one source's tenantId is representative for the whole group).
+        if (ownFolderSources.length > 0) {
+            const byServer = new Map();
+            for (const source of ownFolderSources) {
+                const list = byServer.get(source.server) ?? [];
+                list.push(source);
+                byServer.set(source.server, list);
+            }
+            for (const [server, sources] of byServer) {
+                let livePaths;
                 try {
-                    repo.removeFolder(source.name);
-                    removeFolderFromConfig(config, source.kind, source.name);
+                    const folders = await listFolderfooFolders(server, config.baseDir, sources[0].tenantId);
+                    livePaths = new Set(folders.map((f) => f.path));
                 }
-                catch (err) {
-                    console.error(`[memory-bucket] failed to auto-remove deleted remote folder "${source.name}":`, err);
+                catch {
+                    continue; // not logged in, network blip, etc. — "couldn't check" is not "confirmed gone"
                 }
+                for (const source of sources) {
+                    if (!livePaths.has(source.folderPath))
+                        doRemove(source);
+                }
+            }
+        }
+        // Shared-folder sources: GET /folders without an owner never includes them at all (a shared
+        // folder isn't part of the caller's own tree — see listFolders' doc comment), so the own-folder
+        // check above would wrongly treat every one of these as "confirmed gone" on every single
+        // /api/folders load if it ran against them. Each is checked individually instead, via
+        // owner+rootFolder=its own folderPath — this is exactly what the share grant is for, so success
+        // confirms both "the folder still exists" AND "the share still stands"; a 403 (share revoked) or
+        // 404 (folder deleted) confirms gone, while any OTHER failure (not logged in, network blip)
+        // again means "couldn't check," not "confirmed gone."
+        for (const source of sharedFolderSources) {
+            try {
+                await listFolderfooFolders(source.server, config.baseDir, source.tenantId, { owner: source.owner, rootFolder: source.folderPath });
+            }
+            catch (err) {
+                if (err instanceof FolderfooRequestError && (err.status === 403 || err.status === 404))
+                    doRemove(source);
             }
         }
     }
@@ -1160,23 +1210,49 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
         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).
+    // Lists folderfoo folders for the "connect a folder" picker, once already logged in to `server`
+    // (via the route above). Own folders by default; pass `owner`+`rootFolder` (a folder from
+    // GET /api/folderfoo/shared-folders below) to browse INTO a folder someone else shared instead —
+    // folderfoo's own GET /folders gates that via the same hasAccess check every other shared read
+    // uses, so this route just forwards the params through rather than re-checking anything itself.
     router.get('/api/folderfoo/folders', async (req, res) => {
         const server = req.query.server;
         const tenantId = req.query.tenantId;
+        const owner = req.query.owner;
+        const rootFolder = req.query.rootFolder;
         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);
+            const folders = await listFolderfooFolders(server, config.baseDir, tenantId, { owner, rootFolder });
             res.json(folders);
         }
         catch (err) {
             res.status(401).json({ error: err.message });
         }
     });
+    // Lists whole FOLDERS (not individual memory docs/skills — see /api/shared-items above for that)
+    // someone has shared directly with the caller, across every owner — backs the "connect a folder"
+    // picker's "Shared with me" source, so a folder like bbbmemz shows up as something to connect
+    // instead of only being visible via folderfoo's own File Open UI. Filters getSharedWithMe's
+    // combined file+folder list down to type:'folder' — a shared FILE has no meaning here, that's the
+    // item-level sharing feature instead.
+    router.get('/api/folderfoo/shared-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 shared = await getSharedWithMe(server, config.baseDir, tenantId);
+            res.json(shared.filter((entry) => entry.type === 'folder').map((entry) => ({ owner: entry.owner, path: entry.name, role: entry.role })));
+        }
+        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
@@ -1184,7 +1260,7 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     // 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;
+        const { kind, name, server, tenantId, folderPath, owner } = req.body;
         if (kind !== 'skill' && kind !== 'memory') {
             res.status(400).json({ error: 'kind must be "skill" or "memory"' });
             return;
@@ -1208,18 +1284,53 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
         }
         const repo = kind === 'skill' ? skillRepo : memoryRepo;
         const spec = kind === 'skill' ? skillSpec : memorySpec;
-        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 {
+            // Resolved FIRST (before deriving mirrorDir) — auto-suffixes the requested name when it
+            // collides with a folder connected under a DIFFERENT folderfoo login (e.g. two different users
+            // each naturally wanting "bbbmemz"), still rejecting a collision against the CALLER's own
+            // identity (a genuine naming mistake) — see resolveAvailableName's own doc comment. Everything
+            // downstream (mirrorDir, the saved config entry, the response, the kind-mismatch check) uses
+            // this resolved name, never the originally-requested one, so nothing reads/writes to a path
+            // computed from a name that ended up not being what actually got connected.
+            const resolvedName = repo.resolveAvailableName(folderName, current.username);
+            const mirrorDir = mirrorDirFor(config.baseDir, current.mode, current.username, resolvedName, owner);
+            const remote = { name: resolvedName, server, tenantId, folderPath, mirrorDir, mode: current.mode, username: current.username, owner };
             repo.registerRemoteFolder(remote);
-            saveRemoteFolder(config, kind, { name: folderName, server, tenantId, folderPath, mode: current.mode, username: current.username });
+            saveRemoteFolder(config, kind, { name: resolvedName, server, tenantId, folderPath, mode: current.mode, username: current.username, owner });
             await pollOne(db, spec, remote, config.baseDir);
-            res.json({ name: folderName, server, tenantId, folderPath, kind });
+            res.json({ name: resolvedName, server, tenantId, folderPath, kind, owner, kindMismatchWarning: detectKindMismatch(kind, mirrorDir) });
         }
         catch (err) {
             res.status(409).json({ error: err.message });
         }
     });
+    // Cheap best-effort "did the user pick the wrong kind" heuristic, checked once right after connect
+    // (content is already mirrored locally from the pollOne call above, so this is a local directory
+    // walk, not another network round trip) — surfaced to the client as a dismissible warning, never a
+    // hard block, since a folder can legitimately be empty or genuinely mixed. A skill's remote content
+    // always lives under a fixed literal filename "SKILL.md" (see remoteFilename's own doc comment in
+    // sync.ts — skills push under that name regardless of local filename), so "every .md file mirrored
+    // is literally named SKILL.md" is a strong, cheap skill-shaped signal; a memory folder's files keep
+    // their own varied names and are never named exactly that. Returns undefined (no warning) for an
+    // empty folder — nothing synced yet is not evidence of anything.
+    function detectKindMismatch(kind, mirrorDir) {
+        let total = 0;
+        let skillNamed = 0;
+        for (const file of walkMarkdownFiles(mirrorDir)) {
+            total++;
+            if (path.basename(file) === 'SKILL.md')
+                skillNamed++;
+        }
+        if (total === 0)
+            return undefined;
+        if (kind === 'memory' && skillNamed === total) {
+            return `This folder looks like it contains skills (every file is a SKILL.md), not memory docs — you connected it as a memory folder. Remove and reconnect it as a skill folder instead.`;
+        }
+        if (kind === 'skill' && skillNamed === 0) {
+            return `This folder looks like it contains memory docs, not skills (no SKILL.md files found) — you connected it as a skill folder. Remove and reconnect it as a memory folder instead.`;
+        }
+        return undefined;
+    }
     // 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
@@ -1349,11 +1460,19 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(500).json({ error: err.message });
         }
     });
-    // The ONLY way shared_items ever updates after a share is first accepted —
-    // the recycle-icon button in the "Shared with me" panel calls this.
+    // The recycle-icon button in the "Shared with me" panel calls this — also the only way a direct
+    // (non-link) share ever gets discovered and added in the first place, since folderfoo's Share
+    // Manager UI and bucket_share_item grant access with no redeem event for this app to react to
+    // (see refreshSharedItems' own doc comment). Polls every server+tenant the caller is connected to
+    // via a remote folder, not just ones already represented in shared_items, so this works even
+    // before the very first share has been accepted.
     router.post('/api/shared-items/refresh', async (_req, res) => {
         try {
-            const summary = await refreshSharedItems(db, config.baseDir, skillSpec, memorySpec);
+            const remoteFolders = [...skillRepo.listRemoteFolders(), ...memoryRepo.listRemoteFolders()].map((f) => ({
+                server: f.server,
+                tenantId: f.tenantId,
+            }));
+            const summary = await refreshSharedItems(db, config.baseDir, skillSpec, memorySpec, remoteFolders);
             res.json(summary);
         }
         catch (err) {

package/package.json

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