mcp-google-multi 6.0.0-alpha.54 → 6.0.0-alpha.55

package/dist/accounts.d.ts

@@ -20,6 +20,7 @@ export interface AccountSet {
 }
 export declare function resolveAccounts(env?: NodeJS.ProcessEnv, filePath?: string, onInvalid?: 'exit' | 'throw', opts?: {
     tokenDir?: string;
+    emptyOk?: boolean;
 }): AccountSet;
 export declare function fileStamp(filePath: string, version: number): string;
 /** Live accessor: dispatch-time readers use this, never a captured snapshot. */

package/dist/accounts.js

@@ -74,7 +74,10 @@ function noAccountsMessage() {
  * empty behaves as unset, mirroring GOOGLE_ACCOUNTS semantics.
  */
 let warnedLegacy = false;
-export function resolveAccounts(env = process.env, filePath = configFilePath(), onInvalid = 'exit', opts = {}) {
+export function resolveAccounts(env = process.env, filePath = configFilePath(), onInvalid = 'exit', 
+// emptyOk: zero accounts is a valid set, not an error, even with 'throw'
+// (a context that has linked nothing yet). An invalid file still fails.
+opts = {}) {
     const dir = opts.tokenDir ?? tokenDir;
     const adminEnv = parseCsv(env.GOOGLE_ADMIN_ACCOUNTS);
     const rawEnv = env.GOOGLE_ACCOUNTS;
@@ -130,7 +133,7 @@ export function resolveAccounts(env = process.env, filePath = configFilePath(),
         // empty (BR-4), enforced by assertServerAccountsConfigured() in index.ts.
         // The dispatch-path reload ('throw') still throws so a mid-session emptied
         // config.json keeps the last-good registry (BR-7) instead of dropping tools.
-        if (onInvalid === 'throw') {
+        if (onInvalid === 'throw' && !opts.emptyOk) {
             throw new Error(`E_NO_ACCOUNTS_CONFIGURED: ${noAccountsMessage()}`);
         }
         return {

package/dist/compose.d.ts

@@ -1,5 +1,11 @@
 import type { McpServer } from "@modelcontextprotocol/server";
+import type { ServerTarget } from './http-transport.js';
 import { ToolRegistry, type DiscoveryMode } from './registry.js';
 import { type IdentityContext } from './identity.js';
 import type { Metrics } from './usage-metrics.js';
 export declare function buildRegistry(server: McpServer, ctx: IdentityContext, mode?: DiscoveryMode, metrics?: Metrics | null): ToolRegistry;
+/** The per-request hooks bound to one registry: argument shapes, unknown-
+ * argument screening and the account a validation envelope names. Both
+ * transports and every resolved server target build them here, so a mistyped
+ * argument behaves the same wherever it arrives. */
+export declare function requestHooksFor(registry: ToolRegistry, ctx: Pick<IdentityContext, 'accounts'>, metrics?: Metrics | null, env?: NodeJS.ProcessEnv): Omit<ServerTarget, 'server'>;

package/dist/compose.js

@@ -4,7 +4,9 @@
 // parsing, no process.exit, no prints (accounts.js module-load resolution is
 // the one inherited, pre-existing exception on the import chain).
 import { GENERATED_SERVICES } from './tools/generated/index.js';
-import { GENERATED_GATES, SERVICES } from './services.js';
+import { GENERATED_GATES, SERVICES, unknownToolMessage } from './services.js';
+import { argNormalizationEnabled } from './arg-normalize.js';
+import { unknownArgMode } from './arg-strict.js';
 import { ToolRegistry } from './registry.js';
 import { registerDiscoverTools } from './discover.js';
 import { registerEscapeTools } from './tools/google-api.js';
@@ -82,3 +84,26 @@ export function buildRegistry(server, ctx, mode, metrics = null) {
         registerAccountWizardTools(registry, server);
     return registry;
 }
+/** The per-request hooks bound to one registry: argument shapes, unknown-
+ * argument screening and the account a validation envelope names. Both
+ * transports and every resolved server target build them here, so a mistyped
+ * argument behaves the same wherever it arrives. */
+export function requestHooksFor(registry, ctx, metrics = null, env = process.env) {
+    const mode = unknownArgMode(env);
+    return {
+        argShapeFor: argNormalizationEnabled(env) ? (tool) => registry.argShape(tool) : undefined,
+        strictArgs: mode === 'off'
+            ? undefined
+            : {
+                mode,
+                declaredFor: (tool) => registry.declaredKeys(tool),
+                siblingsFor: (tool, keys) => registry.siblingSpellings(tool, keys),
+                unknownTool: (name) => unknownToolMessage(registry, name),
+                onDrop: metrics ? (tool, keys) => metrics.recordArgDrop(tool, keys) : undefined,
+            },
+        validationEnvelope: {
+            isKnownTool: (name) => registry.hasTool(name),
+            defaultAccount: () => ctx.accounts.defaultAccount,
+        },
+    };
+}

package/dist/http-transport.d.ts

@@ -15,6 +15,16 @@ export type AuthOutcome = {
 export type Authenticator = (req: IncomingMessage) => AuthOutcome | Promise<AuthOutcome>;
 /** A mounted extra route (the AS endpoints, B13). Return true if it wrote a response. */
 export type RouteHandler = (req: IncomingMessage, res: ServerResponse, url: URL) => boolean | Promise<boolean>;
+/** What a verified subject resolves to: ITS server plus the per-request hooks
+ * bound to that server's registry (tool shapes, declared keys, the default
+ * account a validation envelope names). The metrics observers (metricsTap,
+ * onArgRename) stay host-wide and must not be bound to any one registry. */
+export interface ServerTarget {
+    server: McpServer;
+    argShapeFor?: (tool: string) => ArgShape | undefined;
+    strictArgs?: StrictArgOptions;
+    validationEnvelope?: ValidationEnvelopeOptions;
+}
 export interface HttpHostOptions {
     /** The ONE McpServer + registry built at boot (P1 / BV gap #4: never per request). */
     server: McpServer;
@@ -25,14 +35,13 @@ export interface HttpHostOptions {
     /** Tenant-resolution seam: map the verified subject to ITS server. Absent
      * (free core) = every request dispatches to the one boot `server`. Return
      * null for an unknown subject -> 403 tenant_not_found. Each distinct
-     * resolved server gets its own serialize key. */
+     * resolved server gets its own dispatch lane. With a resolver, the
+     * per-request hooks come from the resolved target ONLY: the host-level
+     * argShapeFor / strictArgs / validationEnvelope describe the boot server's
+     * registry, never another subject's. */
     resolveServer?: (claims: {
         sub: string;
-    }) => Promise<{
-        server: McpServer;
-    } | null> | {
-        server: McpServer;
-    } | null;
+    }) => Promise<ServerTarget | null> | ServerTarget | null;
     /** Extra routes keyed by exact pathname (AS endpoints mount here in B13). */
     routes?: Record<string, RouteHandler>;
     log?: (line: string) => void;

package/dist/http-transport.js

@@ -43,12 +43,12 @@ export function jsonRpcMethod(body) {
 export class HttpTransportHost {
     opts;
     httpServer;
-    // Serialize the connect→dispatch critical section PER KEY: a McpServer
+    // Serialize the connect→dispatch critical section PER SERVER: a McpServer
     // captures its transport per request (protocol.js), but the gap between
     // connect() and the dispatch capturing it would still race under true
     // concurrency, so all traffic to ONE server runs under one mutex. The free
-    // core uses a single key (one boot server); with resolveServer each subject
-    // gets its own server and therefore its own independent lock lane.
+    // core has one lane (the boot server); with resolveServer each resolved
+    // server gets its own, however subjects map onto servers.
     locks = new Map();
     constructor(opts) {
         this.opts = opts;
@@ -56,7 +56,15 @@ export class HttpTransportHost {
     serializeFor(key, fn) {
         const prev = this.locks.get(key) ?? Promise.resolve();
         const run = prev.then(fn, fn);
-        this.locks.set(key, run.then(() => undefined, () => undefined));
+        const tail = run.then(() => undefined, () => undefined);
+        this.locks.set(key, tail);
+        // An idle lane drops out, so the map holds only in-flight subjects rather
+        // than every subject ever seen. A request that chained on this tail has
+        // already replaced it, so the identity check never frees a live lane.
+        void tail.then(() => {
+            if (this.locks.get(key) === tail)
+                this.locks.delete(key);
+        });
         return run;
     }
     log(line) {
@@ -154,7 +162,12 @@ export class HttpTransportHost {
         const sub = auth.sub ?? 'owner';
         // Tenant resolution (the seam EE fills): map the verified subject to ITS
         // server. Absent resolver = the one boot server for every subject.
-        let target = { server: this.opts.server };
+        let target = {
+            server: this.opts.server,
+            argShapeFor: this.opts.argShapeFor,
+            strictArgs: this.opts.strictArgs,
+            validationEnvelope: this.opts.validationEnvelope,
+        };
         if (this.opts.resolveServer) {
             try {
                 target = await this.opts.resolveServer({ sub });
@@ -204,12 +217,11 @@ export class HttpTransportHost {
         // releases. (A shared initialized-state persists across stateless requests;
         // benign for the single-owner design.)
         const deadlineMs = this.opts.dispatchTimeoutMs ?? DISPATCH_TIMEOUT_DEFAULT;
-        // The lock lane must match the SERVER identity, not the subject: without a
-        // resolver every subject shares the one boot server, so keying on sub
-        // would let two subjects race one server through the connect gap.
-        const serializeKey = this.opts.resolveServer ? sub : '__single__';
-        const mcpServer = target.server;
-        await this.serializeFor(serializeKey, async () => {
+        // The lock lane is the SERVER identity, never the subject: two subjects
+        // reaching one server (the boot server, or a resolver mapping several
+        // subjects to one) would otherwise race it through the connect gap.
+        const { server: mcpServer, argShapeFor, strictArgs, validationEnvelope } = target;
+        await this.serializeFor(mcpServer, async () => {
             const disconnected = new Promise((resolve) => res.once('close', () => resolve('closed')));
             let timer;
             const timedOut = new Promise((resolve) => {
@@ -218,10 +230,10 @@ export class HttpTransportHost {
             });
             // Same composition as the stdio leg: the envelope rewrite is innermost,
             // so the tap above it still classifies the original validation prose.
-            const enveloped = withValidationEnvelope(transport, this.opts.validationEnvelope ?? {});
+            const enveloped = withValidationEnvelope(transport, validationEnvelope ?? {});
             const tapped = this.opts.metricsTap ? this.opts.metricsTap(enveloped) : enveloped;
-            await mcpServer.connect(this.opts.argShapeFor || this.opts.strictArgs
-                ? withArgNormalization(tapped, this.opts.argShapeFor ?? (() => undefined), this.opts.log, this.opts.onArgRename, this.opts.strictArgs)
+            await mcpServer.connect(argShapeFor || strictArgs
+                ? withArgNormalization(tapped, argShapeFor ?? (() => undefined), this.opts.log, this.opts.onArgRename, strictArgs)
                 : tapped);
             // Reflect the dispatch into a non-rejecting arm: if the deadline wins the
             // race, an orphaned handler settling later must not surface as an unhandled

package/dist/index.js

@@ -1,42 +1,26 @@
 #!/usr/bin/env node
 // First import: triggers accounts.js module load (env files + registry) before
 // anything else. Named to also pull the server-only empty-registry guard (BR-4).
-import { assertServerAccountsConfigured, getAccountSet } from './accounts.js';
+import { assertServerAccountsConfigured } from './accounts.js';
 import { accountsAssertRequired, assertNoEnvAccountsMode, assertNoEnvOptionalScopesMode, isMultiTenantBoot, mtBootGates } from './boot-gates.js';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { McpServer } from "@modelcontextprotocol/server";
-import { unknownToolMessage } from './services.js';
 import { resolveDiscoveryMode } from './registry.js';
 import { isAllowed, describePolicy } from './write-control.js';
 import { buildIdentityContext } from './identity.js';
-import { buildRegistry } from './compose.js';
+import { buildRegistry, requestHooksFor } from './compose.js';
 import { registerSetupPrompt } from './setup-prompt.js';
 import { applyNetTuning } from './net-tuning.js';
-import { argNormalizationEnabled, withArgNormalization, withValidationEnvelope } from './arg-normalize.js';
-import { unknownArgMode } from './arg-strict.js';
+import { withArgNormalization, withValidationEnvelope } from './arg-normalize.js';
 import { envValueSource } from './env-load.js';
 import { loadConfigFile } from './config-file.js';
 import { initUsageMetrics, resolveUsageMetrics, sourceLabel } from './usage-metrics.js';
 applyNetTuning();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
-/** Unknown-argument screening options, or undefined when the feature is off.
- * Shared by both transports so a mistyped argument behaves identically. */
-function strictArgOptions(registry, metrics) {
-    const mode = unknownArgMode();
-    if (mode === 'off')
-        return undefined;
-    return {
-        mode,
-        declaredFor: (tool) => registry.declaredKeys(tool),
-        siblingsFor: (tool, keys) => registry.siblingSpellings(tool, keys),
-        unknownTool: (name) => unknownToolMessage(registry, name),
-        onDrop: metrics ? (tool, keys) => metrics.recordArgDrop(tool, keys) : undefined,
-    };
-}
 async function main() {
     if (process.argv.includes('auth')) {
         const { runAuthFlow } = await import('./auth.js');
@@ -208,30 +192,28 @@ async function main() {
     if (wantStdio) {
         const server = new McpServer({ name: 'mcp-google-multi', version: pkg.version });
         const stdioMetrics = initMetricsFor('stdio', resolveDiscoveryMode());
-        const registry = buildRegistry(server, buildIdentityContext(process.env, { transport: 'stdio' }), undefined, stdioMetrics);
+        const stdioCtx = buildIdentityContext(process.env, { transport: 'stdio' });
+        const registry = buildRegistry(server, stdioCtx, undefined, stdioMetrics);
         registry.installListHandler();
         registerSetupPrompt(server);
+        const stdioHooks = requestHooksFor(registry, stdioCtx, stdioMetrics);
         // Outbound runs outermost-first, so the composition is deliberate: the
         // envelope rewrite is INNERMOST (last to touch the frame), the tap sits
         // above it (classifying the ORIGINAL validation prose), arg normalization
         // outermost. The tap only counts outbound JSON-RPC error frames (no
         // handler ran) plus id->tool names.
-        let transport = withValidationEnvelope(new StdioServerTransport(), {
-            isKnownTool: (n) => registry.hasTool(n),
-            defaultAccount: () => getAccountSet().defaultAccount,
-        });
+        let transport = withValidationEnvelope(new StdioServerTransport(), stdioHooks.validationEnvelope);
         if (stdioMetrics) {
             const { tapUsageMetrics } = await import('./metrics-tap.js');
             transport = tapUsageMetrics(transport, stdioMetrics, (n) => registry.hasTool(n));
         }
-        const strictStdio = strictArgOptions(registry, stdioMetrics);
-        await server.connect(argNormalizationEnabled() || strictStdio
+        await server.connect(stdioHooks.argShapeFor || stdioHooks.strictArgs
             ? withArgNormalization(transport, 
             // Gated exactly as the HTTP leg gates `argShapeFor`. Passing the
             // shape unconditionally made stdio rename keys while
             // GOOGLE_ARG_NORMALIZE=off, so the same call succeeded on stdio
             // and failed on HTTP once screening rejects.
-            argNormalizationEnabled() ? (n) => registry.argShape(n) : () => undefined, undefined, stdioMetrics ? (tool, n) => stdioMetrics.recordArgFix(tool, n) : undefined, strictStdio)
+            stdioHooks.argShapeFor ?? (() => undefined), undefined, stdioMetrics ? (tool, n) => stdioMetrics.recordArgFix(tool, n) : undefined, stdioHooks.strictArgs)
             : transport);
     }
     if (wantHttp) {
@@ -259,7 +241,8 @@ async function main() {
         }
         const httpServer = new McpServer({ name: 'mcp-google-multi', version: pkg.version });
         const httpMetrics = initMetricsFor('http', 'curated');
-        const registry = buildRegistry(httpServer, buildIdentityContext(process.env, { transport: 'http' }), 'curated', httpMetrics);
+        const httpCtx = buildIdentityContext(process.env, { transport: 'http' });
+        const registry = buildRegistry(httpServer, httpCtx, 'curated', httpMetrics);
         registry.installListHandler();
         registerSetupPrompt(httpServer);
         // B13: mount the OAuth 2.1 AS (legs A + B) + the Bearer authenticator.
@@ -345,14 +328,9 @@ async function main() {
             authenticate: authServer.authenticate,
             routes: authServer.routes,
             log: (l) => process.stderr.write(`[http] ${l}\n`),
-            argShapeFor: argNormalizationEnabled() ? (n) => registry.argShape(n) : undefined,
+            ...requestHooksFor(registry, httpCtx, httpMetrics),
             metricsTap: httpTap,
-            validationEnvelope: {
-                isKnownTool: (n) => registry.hasTool(n),
-                defaultAccount: () => getAccountSet().defaultAccount,
-            },
             onArgRename: httpMetrics ? (tool, n) => httpMetrics.recordArgFix(tool, n) : undefined,
-            strictArgs: strictArgOptions(registry, httpMetrics),
         });
         await host.start();
         process.stderr.write(`HTTP transport listening on http://${httpCfg.host}:${httpCfg.port} (public ${httpCfg.publicUrl})\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-google-multi",
-  "version": "6.0.0-alpha.54",
+  "version": "6.0.0-alpha.55",
   "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",