mcp-google-multi 6.0.0-alpha.66 → 6.0.0-alpha.68

package/dist/http-transport.d.ts

@@ -85,6 +85,7 @@ export declare class HttpTransportHost {
     private readonly depth;
     private readonly sockets;
     private readonly pending;
+    private readonly served;
     private readonly handling;
     private closing;
     private graceful?;

package/dist/http-transport.js

@@ -70,6 +70,10 @@ const MAX_GRACE_MS = 2 ** 31 - 1;
 function endAfterFlush(socket) {
     if (socket.destroyed || socket.writableEnded)
         return;
+    // Node arms a keep-alive timer when a response finishes and destroys the
+    // socket when it fires, which would cut a slow reader's unread tail just as
+    // an early destroy does. Only the client's FIN or the grace ends it now.
+    socket.setTimeout(0);
     socket.end();
 }
 // A request that arrives while closing is never answered, so Node keeps it
@@ -109,6 +113,9 @@ export class HttpTransportHost {
     // every handle() that has not settled.
     sockets = new Set();
     pending = new Map();
+    // Sockets that have accepted a request: nothing pending means the last
+    // response finished writing, but its tail can still sit in kernel buffers.
+    served = new WeakSet();
     handling = new Set();
     closing = false;
     graceful;
@@ -143,6 +150,7 @@ export class HttpTransportHost {
                 stopReading(socket);
                 return;
             }
+            this.served.add(socket);
             const entry = this.pending.get(socket);
             if (entry) {
                 entry.count++;
@@ -232,7 +240,8 @@ export class HttpTransportHost {
             this.httpServer = undefined;
             return;
         }
-        // Starting over would destroy every socket in its lingering close.
+        // Starting over would arm a second grace, and a shorter one would cut
+        // what the first still lets finish.
         this.graceful ??= this.closeGracefully(s, graceMs).finally(() => (this.graceful = undefined));
         return this.graceful;
     }
@@ -249,15 +258,19 @@ export class HttpTransportHost {
         // after the last of them: that one says so if it has not started, and the
         // settle hook in start() ends the socket once it finishes. Node itself
         // destroys a socket once a Connection: close response is flushed, which
-        // resets it just as endAfterFlush explains, so that end lingers too.
+        // resets it just as endAfterFlush explains, so that end lingers too. A
+        // socket with nothing pending may still be delivering the tail of its
+        // last response, so only one that never accepted a request is destroyed.
         for (const socket of this.sockets) {
             const entry = this.pending.get(socket);
-            if (!entry) {
+            if (!entry && !this.served.has(socket)) {
                 socket.destroy();
                 continue;
             }
             socket.destroySoon = () => endAfterFlush(socket);
-            if (!entry.last.headersSent)
+            if (!entry)
+                endAfterFlush(socket);
+            else if (!entry.last.headersSent)
                 entry.last.setHeader('Connection', 'close');
         }
         let timer;

package/dist/mcp-token.d.ts

@@ -123,6 +123,14 @@ export interface RefreshStoreOptions {
     maxAgeSec?: number;
     /** Idle lifetime in seconds, counted from the last issue or rotation. Unset: unlimited. */
     idleSec?: number;
+    /** Max live refresh-token families per subject (both formats). Unset:
+     * unlimited (default; the single-owner server passes none). When issuing a
+     * new family would put a subject over this, that subject's own
+     * least-recently-used family is dropped (by its last issue or rotation
+     * time) until it fits; a dropped family behaves exactly like a revoked
+     * one. Only the subject signing in ever triggers it, and only its own
+     * families are ever touched. */
+    maxFamiliesPerSub?: number;
     /** Server-side log for a revoked, dropped or expired family. Never given a token or a subject. */
     log?: (line: string) => void;
 }
@@ -141,6 +149,7 @@ export declare class RefreshStore {
     private readonly log;
     private readonly maxAgeMs;
     private readonly idleMs;
+    private readonly maxFamiliesPerSub;
     private macKey;
     private legacyEmpty;
     constructor(path: string, masterKey: string, options?: RefreshStoreOptions);
@@ -156,6 +165,17 @@ export declare class RefreshStore {
     private load;
     private save;
     private emit;
+    /** Evict `sub`'s own least-recently-used sessions (both formats) so at
+     * most `limit` of its live sessions remain; dropping one here is the same
+     * as deleting it from `data.families` / `data.active` on a revoke, so it
+     * can never be presented again (reuse detection for every OTHER family is
+     * untouched). Only `sub`'s own entries are ever inspected.
+     *
+     * `keepKey` is the family just issued: it is excluded from the ranking so
+     * a clock step back, or a concurrent rotate's `usedAt = max(usedAt, nowMs)`
+     * racing ahead of it under the lock, can never make the brand-new family
+     * look like the least recently used one and drop itself. */
+    private enforceFamilyCap;
     private newFamilyId;
     issue(nowMs: number, sub: string): string;
     /** Rotate a presented refresh token; null if it is unknown, malformed, or

package/dist/mcp-token.js

@@ -363,12 +363,16 @@ export function assertRefreshStoreReadable(file, masterKey) {
     }
     checkFormat(file, d);
 }
-function lifetimeMs(name, v) {
+function positiveInt(name, v) {
     if (v === undefined)
         return undefined;
     if (typeof v !== 'number' || !Number.isSafeInteger(v) || v <= 0)
         throw new Error(`E_REFRESH_OPTION_INVALID: ${name} must be a positive whole number`);
-    return v * 1000;
+    return v;
+}
+function lifetimeMs(name, v) {
+    const n = positiveInt(name, v);
+    return n === undefined ? undefined : n * 1000;
 }
 /**
  * Persisted (encrypted under MASTER_KEY) refresh-token store. Rotates on every
@@ -385,6 +389,7 @@ export class RefreshStore {
     log;
     maxAgeMs;
     idleMs;
+    maxFamiliesPerSub;
     macKey;
     // Set once a load finds no earlier-release record. Nothing here adds one,
     // so from then on a legacy-shaped token is refused before the lock.
@@ -394,6 +399,7 @@ export class RefreshStore {
         this.masterKey = masterKey;
         this.maxAgeMs = lifetimeMs('maxAgeSec', options.maxAgeSec);
         this.idleMs = lifetimeMs('idleSec', options.idleSec);
+        this.maxFamiliesPerSub = positiveInt('maxFamiliesPerSub', options.maxFamiliesPerSub);
         this.log = options.log ?? (() => undefined);
     }
     get timed() {
@@ -502,6 +508,47 @@ export class RefreshStore {
             }
         }
     }
+    /** Evict `sub`'s own least-recently-used sessions (both formats) so at
+     * most `limit` of its live sessions remain; dropping one here is the same
+     * as deleting it from `data.families` / `data.active` on a revoke, so it
+     * can never be presented again (reuse detection for every OTHER family is
+     * untouched). Only `sub`'s own entries are ever inspected.
+     *
+     * `keepKey` is the family just issued: it is excluded from the ranking so
+     * a clock step back, or a concurrent rotate's `usedAt = max(usedAt, nowMs)`
+     * racing ahead of it under the lock, can never make the brand-new family
+     * look like the least recently used one and drop itself. */
+    enforceFamilyCap(data, sub, limit, lines, keepKey) {
+        const entries = [];
+        for (const [k, f] of Object.entries(data.families)) {
+            if (f.sub !== sub || k === keepKey)
+                continue;
+            entries.push({
+                at: f.usedAt,
+                drop: () => {
+                    delete data.families[k];
+                    lines.push(`refresh family dropped: cap tag=${familyTag(Buffer.from(k, 'base64url'))}`);
+                },
+            });
+        }
+        for (const [t, r] of Object.entries(data.active)) {
+            if (r.sub !== sub)
+                continue;
+            entries.push({
+                at: r.issuedAt,
+                drop: () => {
+                    delete data.active[t];
+                    lines.push(`refresh family dropped: cap tag=${familyTag(r.family)}`);
+                },
+            });
+        }
+        // +1 accounts for the kept family, which stays live but is never ranked.
+        if (entries.length + 1 <= limit)
+            return;
+        entries.sort((a, b) => a.at - b.at);
+        for (const e of entries.slice(0, entries.length + 1 - limit))
+            e.drop();
+    }
     newFamilyId(data) {
         let fid;
         do
@@ -517,8 +564,11 @@ export class RefreshStore {
             const lines = [];
             const { data } = this.load(nowMs, lines);
             const fid = this.newFamilyId(data);
+            const fidKey = fid.toString('base64url');
             const { token, cur } = mintR1(key, fid, 0);
-            data.families[fid.toString('base64url')] = { sub, gen: 0, cur, createdAt: nowMs, usedAt: nowMs };
+            data.families[fidKey] = { sub, gen: 0, cur, createdAt: nowMs, usedAt: nowMs };
+            if (this.maxFamiliesPerSub !== undefined)
+                this.enforceFamilyCap(data, sub, this.maxFamiliesPerSub, lines, fidKey);
             this.save(data);
             this.emit(lines);
             return token;

package/dist/oauth-as.d.ts

@@ -26,6 +26,10 @@ export interface AuthServerConfig {
     /** `idleSec` of that store: sessions end this long after their last
      * refresh. Unset: unlimited. */
     refreshIdleSec?: number;
+    /** `maxFamiliesPerSub` of that store: bounds how many live refresh-token
+     * families one subject may hold, dropping its least-recently-used one to
+     * make room. Unset: unlimited. */
+    refreshMaxFamiliesPerSub?: number;
     /** Default true. The clientless `flow=alias_reauth` link names an alias with
      * no tenant binding, so a multi-tenant deployment sets false: with several
      * tenants an alias name alone is ambiguous and the branch becomes a

package/dist/oauth-as.js

@@ -200,10 +200,10 @@ export function buildAuthServer(config, deps = {}) {
     const now = deps.now ?? (() => Date.now());
     const log = deps.log ?? (() => undefined);
     // Silently dropping a lifetime the caller asked for would leave sessions unlimited.
-    if (deps.refreshStore && (config.refreshMaxAgeSec !== undefined || config.refreshIdleSec !== undefined)) {
-        throw new Error('E_REFRESH_OPTION_CONFLICT: refreshMaxAgeSec and refreshIdleSec configure the refresh store buildAuthServer creates; set them on the injected refreshStore instead');
+    if (deps.refreshStore && (config.refreshMaxAgeSec !== undefined || config.refreshIdleSec !== undefined || config.refreshMaxFamiliesPerSub !== undefined)) {
+        throw new Error('E_REFRESH_OPTION_CONFLICT: refreshMaxAgeSec, refreshIdleSec and refreshMaxFamiliesPerSub configure the refresh store buildAuthServer creates; set them on the injected refreshStore instead');
     }
-    const refresh = deps.refreshStore ?? new RefreshStore(config.refreshStorePath, config.masterKey, { maxAgeSec: config.refreshMaxAgeSec, idleSec: config.refreshIdleSec, log });
+    const refresh = deps.refreshStore ?? new RefreshStore(config.refreshStorePath, config.masterKey, { maxAgeSec: config.refreshMaxAgeSec, idleSec: config.refreshIdleSec, maxFamiliesPerSub: config.refreshMaxFamiliesPerSub, log });
     const nowSec = () => Math.floor(now() / 1000);
     // A full guard is refused at whatever rate the caller likes, so its line is
     // written at most once a minute (or at once after the clock stepped back).

package/dist/usage-metrics.d.ts

@@ -86,11 +86,26 @@ export interface InitOptions {
     now?: () => number;
     monotonic?: () => number;
     log?: (line: string) => void;
-    /** Default true. The retry and bigram chains correlate CONSECUTIVE calls,
-     * which is only meaningful when one caller owns the whole process; a host
-     * serving several callers sets false so their sequences never cross-link.
-     * DayAgg shape is unchanged (retries/bigrams stay empty maps). */
+    /** Default true. Three chains correlate CONSECUTIVE calls, which is only
+     * meaningful when one caller owns the whole process: the retry and bigram
+     * chains, and pendingMid (the escape hatch's resolved methodId, attached to
+     * the next google_api_call event's `mid`). A host serving several callers
+     * sets false so none of the three ever cross-link a call between tenants.
+     * DayAgg shape is unchanged (retries/bigrams stay empty maps);
+     * escape.methods still counts every resolved call either way. */
     sequencingEnabled?: boolean;
+    /** Default true. When false, no events.jsonl / events.1.jsonl is ever
+     * created or appended to; only agg/ exists. A host serving several callers
+     * sets false: each event line carries a minute timestamp, the boot id and a
+     * per-process sequence number, which can be joined against a per-caller log
+     * such as an audit trail; the day aggregate keeps the same counters without
+     * order. */
+    eventLog?: boolean;
+    /** Default none. A host's own closed slug set, unioned with
+     * KNOWN_ERROR_SLUGS for this instance only; each entry must match
+     * /^[A-Za-z][A-Za-z0-9_]{0,63}$/ or it is dropped silently. Absent,
+     * behavior is byte-identical to today. */
+    extraErrorSlugs?: readonly string[];
 }
 /** Deep-add b into a for the DayAgg shape (numbers add, maps union). */
 export declare function mergeDay(a: DayAgg, b: DayAgg): DayAgg;
@@ -114,6 +129,8 @@ export declare class Metrics {
     private failures;
     private disabled;
     private readonly sequencing;
+    private readonly eventLog;
+    private readonly errorSlugs;
     constructor(opts: InitOptions);
     private day;
     private initStorage;

package/dist/usage-metrics.js

@@ -33,6 +33,7 @@ const TOOL_NAME_RE = /^[a-z][a-z0-9_]{0,63}$/;
 // Declared argument keys are camelCase identifiers, some dotted
 // (groupKey.id, debugOptions.enableDebugging).
 const ARG_KEY_RE = /^[A-Za-z][A-Za-z0-9_.]{0,63}$/;
+const EXTRA_ERROR_SLUG_RE = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
 /** Union of every `error:` slug literal emitted anywhere in src/ (kept honest
  * by a set-equality grep test). Anything outside buckets to `other`. */
 export const KNOWN_ERROR_SLUGS = new Set([
@@ -222,8 +223,13 @@ export class Metrics {
     failures = 0;
     disabled = false;
     sequencing;
+    eventLog;
+    errorSlugs;
     constructor(opts) {
         this.sequencing = opts.sequencingEnabled !== false;
+        this.eventLog = opts.eventLog !== false;
+        const extras = (opts.extraErrorSlugs ?? []).filter((s) => EXTRA_ERROR_SLUG_RE.test(s));
+        this.errorSlugs = extras.length ? new Set([...KNOWN_ERROR_SLUGS, ...extras]) : KNOWN_ERROR_SLUGS;
         this.dir = opts.dir ?? path.join(stateDir(opts.env), METRICS_DIR_NAME);
         this.aggDir = path.join(this.dir, 'agg');
         this.eventsFile = path.join(this.dir, 'events.jsonl');
@@ -252,7 +258,8 @@ export class Metrics {
                 }
             }
             this.pruneAggs();
-            this.pruneEventAge(this.eventsFile);
+            if (this.eventLog)
+                this.pruneEventAge(this.eventsFile);
         }
         catch (e) {
             this.log(`local usage metrics: init failed (${e.message}); disabled for this process\n`);
@@ -320,7 +327,7 @@ export class Metrics {
                 if (typeof first === 'string' && first.length < 65_536) {
                     const env = JSON.parse(first);
                     if (typeof env.error === 'string')
-                        slug = KNOWN_ERROR_SLUGS.has(env.error) ? env.error : 'other';
+                        slug = this.errorSlugs.has(env.error) ? env.error : 'other';
                     hinted = typeof env.hint === 'string' && env.hint.length > 0;
                 }
             }
@@ -379,29 +386,31 @@ export class Metrics {
             }
             this.lastTool = { name: entry.name, at: nowM };
         }
-        const event = {
-            ts: new Date(this.now()).toISOString().slice(0, 16) + ':00Z',
-            boot: this.bootId,
-            seq: this.seq++,
-            tool: entry.name,
-            ok,
-            ms: Math.round(ms),
-            chars: charsBucket(chars),
-            src: 'handler',
-        };
-        if (slug)
-            event.err = slug;
-        if (hinted !== undefined)
-            event.hint = hinted;
-        if (fan)
-            event.fan = fan;
-        // mid: set mid-dispatch by recordEscapeMethod, attached to the escape
-        // call's own event line (per-event field, never a synthetic event).
-        if (entry.name === 'google_api_call' && this.pendingMid) {
-            event.mid = this.pendingMid;
-            this.pendingMid = undefined;
+        if (this.eventLog) {
+            const event = {
+                ts: new Date(this.now()).toISOString().slice(0, 16) + ':00Z',
+                boot: this.bootId,
+                seq: this.seq++,
+                tool: entry.name,
+                ok,
+                ms: Math.round(ms),
+                chars: charsBucket(chars),
+                src: 'handler',
+            };
+            if (slug)
+                event.err = slug;
+            if (hinted !== undefined)
+                event.hint = hinted;
+            if (fan)
+                event.fan = fan;
+            // mid: set mid-dispatch by recordEscapeMethod, attached to the escape
+            // call's own event line (per-event field, never a synthetic event).
+            if (this.sequencing && entry.name === 'google_api_call' && this.pendingMid) {
+                event.mid = this.pendingMid;
+                this.pendingMid = undefined;
+            }
+            this.events.push(JSON.stringify(event));
         }
-        this.events.push(JSON.stringify(event));
         this.dirty = true;
     }
     /** Escape hatch: only the RESOLVED methodId (double-gated) or a miss. */
@@ -413,7 +422,8 @@ export class Metrics {
             }
             else if (idOrNull.length <= METHOD_ID_MAX && METHOD_ID_RE.test(idOrNull)) {
                 addInto(this.deltas.escape.methods, idOrNull);
-                this.pendingMid = idOrNull;
+                if (this.sequencing)
+                    this.pendingMid = idOrNull;
             }
             this.dirty = true;
         }
@@ -481,12 +491,14 @@ export class Metrics {
             else {
                 addInto(this.deltas.rpc, RPC_CODES.has(kind) ? `rpc_error_${kind}` : 'rpc_error_other');
             }
-            this.events.push(JSON.stringify({
-                ts: new Date(this.now()).toISOString().slice(0, 16) + ':00Z',
-                boot: this.bootId, seq: this.seq++,
-                tool: tool && TOOL_NAME_RE.test(tool) ? tool : 'other',
-                ok: false, ms: 0, chars: 'le64', src: 'rpc',
-            }));
+            if (this.eventLog) {
+                this.events.push(JSON.stringify({
+                    ts: new Date(this.now()).toISOString().slice(0, 16) + ':00Z',
+                    boot: this.bootId, seq: this.seq++,
+                    tool: tool && TOOL_NAME_RE.test(tool) ? tool : 'other',
+                    ok: false, ms: 0, chars: 'le64', src: 'rpc',
+                }));
+            }
             this.dirty = true;
         }
         catch { /* never throws outward */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-alpha.66",
+  "version": "6.0.0-alpha.68",
   "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",
@@ -30,6 +30,8 @@
     "./write-control": "./dist/write-control.js",
     "./scope-catalog": "./dist/scope-catalog.js",
     "./auth": "./dist/auth.js",
+    "./usage-metrics": "./dist/usage-metrics.js",
+    "./metrics-tap": "./dist/metrics-tap.js",
     "./package.json": "./package.json"
   },
   "files": [