mcp-google-multi 6.0.0-alpha.61 → 6.0.0-alpha.62

package/dist/discovery-client.js

@@ -74,6 +74,21 @@ export function discoveryCacheDir(env = process.env) {
     return (env.DISCOVERY_CACHE_PATH ??
         path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'mcp-google-multi', 'discovery'));
 }
+// Default cache path only (an operator's DISCOVERY_CACHE_PATH may be shared,
+// even /tmp, and keeps its mode), only when this process owns it, and best
+// effort. Clears group/other bits and keeps setuid/setgid/sticky.
+function tightenOwnDir(dir) {
+    if (process.platform === 'win32')
+        return;
+    try {
+        const st = fs.statSync(dir);
+        if (st.uid === process.getuid?.() && (st.mode & 0o077) !== 0)
+            fs.chmodSync(dir, st.mode & ~0o077 & 0o7777);
+    }
+    catch {
+        // the cache still works with the directory's own mode
+    }
+}
 // A poisoned cache file could repoint baseUrl off-Google; refuse to send the
 // user's Bearer token anywhere but a googleapis.com host.
 export function isGoogleApiUrl(url) {
@@ -135,6 +150,7 @@ export async function loadMethodIndex(api, deps = {}) {
         throw new Error(`Unknown api "${api}". Known: ${Object.keys(SUPPORTED_APIS).join(', ')}`);
     }
     const fetchFn = deps.fetchFn ?? ((url) => fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }));
+    const defaultDir = deps.cacheDir === undefined && process.env.DISCOVERY_CACHE_PATH === undefined;
     const cacheDir = deps.cacheDir ?? discoveryCacheDir();
     const cacheFile = path.join(cacheDir, `${api}.json`);
     const readCache = () => {
@@ -172,7 +188,9 @@ export async function loadMethodIndex(api, deps = {}) {
                 if (!res.ok)
                     throw new Error(`HTTP ${res.status}`);
                 doc = (await res.json());
-                fs.mkdirSync(cacheDir, { recursive: true });
+                fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+                if (defaultDir)
+                    tightenOwnDir(cacheDir);
                 fs.writeFileSync(cacheFile, JSON.stringify(doc), { mode: 0o600 });
                 break;
             }

package/dist/http-transport.js

@@ -66,6 +66,16 @@ function stopReading(socket) {
     socket.pause();
     socket.resume = () => socket;
 }
+// For a log line: the pathname only (a query can carry a code or a state),
+// and never a throw, since the caller is the catch-all.
+function pathOf(req) {
+    try {
+        return new URL(req.url ?? '/', 'http://localhost').pathname;
+    }
+    catch {
+        return '?';
+    }
+}
 export class HttpTransportHost {
     opts;
     httpServer;
@@ -140,8 +150,23 @@ export class HttpTransportHost {
             res.once('close', settle);
             // Never rejects: close() waits on it, and a catch-all that itself threw
             // must neither reject close() nor surface as an unhandled rejection.
+            // The thrown message can name server paths (a lock timeout does), so it
+            // goes only to the host's log.
             const done = this.handle(req, res)
-                .catch((e) => this.fail(res, 500, 'internal_error', e.message))
+                .catch((e) => {
+                try {
+                    this.fail(res, 500, 'internal_error', 'internal error');
+                }
+                finally {
+                    // A throwing log must not reach the destroy below: the answer is sent.
+                    try {
+                        this.log(`500 internal_error path=${pathOf(req)}: ${e instanceof Error ? e.message : 'non-Error throw'}`);
+                    }
+                    catch {
+                        // nowhere left to report it
+                    }
+                }
+            })
                 .catch(() => void res.destroy());
             this.handling.add(done);
             void done.finally(() => this.handling.delete(done));

package/dist/mcp-token.d.ts

@@ -110,8 +110,7 @@ export declare class RefreshStore {
         sub: string;
     } | null;
     /** Drop every ACTIVE record minted under `sub` (linear scan under the store
-     * lock). Spent entries carry no sub and stay: with their families gone, a
-     * reuse finds nothing to revoke — inert by construction. Returns the number
-     * of active tokens dropped. */
+     * lock); the save then drops the spent entries of every family left with no
+     * active token. Returns the number of active tokens dropped. */
     purgeTenant(sub: string): number;
 }

package/dist/mcp-token.js

@@ -155,11 +155,42 @@ export class RefreshStore {
         }
     }
     save(data) {
-        // bound the spent set (drop oldest-inserted) so it can't grow forever.
-        const keys = Object.keys(data.spent);
-        if (keys.length > SPENT_CAP) {
-            for (const k of keys.slice(0, keys.length - SPENT_CAP))
-                delete data.spent[k];
+        // A family with no active token has nothing left to revoke. Over the cap,
+        // the subject holding the most spent tokens loses its oldest (ties: the
+        // oldest entry), so a subject's rotations, across all its families, only
+        // push out its own history (docs/internals.md). Insertion order = rotation
+        // order.
+        const owner = new Map();
+        for (const r of Object.values(data.active))
+            owner.set(r.family, r.sub);
+        const order = Object.keys(data.spent);
+        const held = new Map();
+        let total = 0;
+        order.forEach((t, i) => {
+            const sub = owner.get(data.spent[t]);
+            if (sub === undefined) {
+                delete data.spent[t];
+                return;
+            }
+            const h = held.get(sub);
+            if (h)
+                h.at.push(i);
+            else
+                held.set(sub, { at: [i], head: 0 });
+            total += 1;
+        });
+        while (total > SPENT_CAP) {
+            let most = { at: [], head: 0 };
+            let mostN = 0;
+            for (const h of held.values()) {
+                const n = h.at.length - h.head;
+                if (n > mostN || (n === mostN && n > 0 && h.at[h.head] < most.at[most.head])) {
+                    most = h;
+                    mostN = n;
+                }
+            }
+            delete data.spent[order[most.at[most.head++]]];
+            total -= 1;
         }
         atomicWriteFileSync(this.path, encryptToken(data, this.masterKey), 0o600);
     }
@@ -212,9 +243,8 @@ export class RefreshStore {
         });
     }
     /** Drop every ACTIVE record minted under `sub` (linear scan under the store
-     * lock). Spent entries carry no sub and stay: with their families gone, a
-     * reuse finds nothing to revoke — inert by construction. Returns the number
-     * of active tokens dropped. */
+     * lock); the save then drops the spent entries of every family left with no
+     * active token. Returns the number of active tokens dropped. */
     purgeTenant(sub) {
         return withFileLock(this.path, () => {
             const data = this.load();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-alpha.61",
+  "version": "6.0.0-alpha.62",
   "mcpName": "io.github.bakissation/mcp-google-multi",
   "description": "Local MCP server for Google Workspace (Gmail, Drive, Calendar, Sheets, Docs, Contacts, Tasks, Meet, Search Console, +Forms/Chat/Admin) across multiple accounts — OAuth-only, encrypted token storage, deny-by-default writes.",
   "type": "module",