mcp-google-multi 6.0.0-alpha.41 → 6.0.0-alpha.43

package/dist/auth.d.ts

@@ -1,14 +1,15 @@
+import type { AccountSet } from './accounts.js';
 import { ADMIN_SCOPES } from './scope-catalog.js';
 export declare const BASE_SCOPES: string[];
 export declare const OPTIONAL_SCOPE_BUNDLES: Record<string, string[]>;
 export { ADMIN_SCOPES };
 /** Union of every account's resolved bundles: a service registers if ANY
  * account can authorize it; per-account authz happens at call time (BR2). */
-export declare function getOptionalBundles(): string[];
+export declare function getOptionalBundles(set?: AccountSet): string[];
 /** Aliases granted ADMIN_SCOPES: per-account admin flag (env
  * GOOGLE_ADMIN_ACCOUNTS overrides config.json at resolve) OR the account's
  * scope profile carrying admin (boolean or "admin" bundle) — equivalent forms. */
-export declare function getAdminAccounts(): string[];
+export declare function getAdminAccounts(set?: AccountSet): string[];
 /** Scopes are fixed at consent time: changing an account's profile (or the
  * legacy env) changes its consent set and requires re-running auth. Evaluated
  * per account: `work` can carry admin + gmail_settings while `personal` is

package/dist/auth.js

@@ -55,11 +55,10 @@ function legacyGlobalProfile() {
     }
     return { bundles };
 }
-function profileForAccount(alias) {
+function profileForAccount(alias, set = getAccountSet()) {
     const legacy = legacyGlobalProfile();
     if (legacy)
         return legacy;
-    const set = getAccountSet();
     const name = set.configs[alias]?.scopeProfile ?? 'base';
     // hasOwn: a profile named like an Object.prototype member must never
     // resolve to the inherited function.
@@ -67,14 +66,13 @@ function profileForAccount(alias) {
 }
 /** Union of every account's resolved bundles: a service registers if ANY
  * account can authorize it; per-account authz happens at call time (BR2). */
-export function getOptionalBundles() {
+export function getOptionalBundles(set = getAccountSet()) {
     const legacy = legacyGlobalProfile();
     if (legacy)
         return legacy.bundles.filter(b => b !== 'admin');
     const union = new Set();
-    const set = getAccountSet();
     for (const alias of set.aliases) {
-        for (const b of profileForAccount(alias).bundles) {
+        for (const b of profileForAccount(alias, set).bundles) {
             if (b !== 'admin')
                 union.add(b);
         }
@@ -84,12 +82,12 @@ export function getOptionalBundles() {
 /** Aliases granted ADMIN_SCOPES: per-account admin flag (env
  * GOOGLE_ADMIN_ACCOUNTS overrides config.json at resolve) OR the account's
  * scope profile carrying admin (boolean or "admin" bundle) — equivalent forms. */
-export function getAdminAccounts() {
-    const { aliases, configs } = getAccountSet();
+export function getAdminAccounts(set = getAccountSet()) {
+    const { aliases, configs } = set;
     return aliases.filter((a) => {
         if (configs[a].admin === true)
             return true;
-        const p = profileForAccount(a);
+        const p = profileForAccount(a, set);
         return p.admin === true || p.bundles.includes('admin');
     });
 }

package/dist/client.d.ts

@@ -1,3 +1,24 @@
 import { OAuth2Client } from 'googleapis-common';
-import type { Account } from './accounts.js';
-export declare function getClient(account: Account): Promise<OAuth2Client>;
+import type { Account, AccountSet } from './accounts.js';
+import type { TokenData } from './types.js';
+export interface GetClientDeps {
+    /** Live account view — read at call time, never a captured snapshot. */
+    accounts: () => AccountSet;
+    readToken: (alias: string) => TokenData | null;
+    updateToken: (alias: string, updates: object) => void;
+    /** Cross-process staleness probe (single-owner global registry only). */
+    refreshIfStale?: () => void;
+}
+/** Test-only visibility into the dedupe map. */
+export declare function __inflightSizeForTest(): number;
+/**
+ * Per-context client factory: `contextKey` namespaces the single-flight map
+ * (one lane per tenant), `deps` carry that context's account view and token
+ * custody. The free core builds exactly one, bound to the global registry.
+ */
+export declare function makeGetClient(contextKey: string, deps: GetClientDeps): (account: Account) => Promise<OAuth2Client>;
+/** The single-owner client, bound to the global registry + token store. The
+ * operator surfaces that never carry a tenant (api-probe, executor and
+ * escape-hatch `deps.getClientFn ?? getClient` defaults, stdio dispatch)
+ * resolve through this. */
+export declare const getClient: (account: Account) => Promise<OAuth2Client>;

package/dist/identity.js

@@ -1,8 +1,12 @@
-import { getAccountSet } from './accounts.js';
-import { getClient } from './client.js';
-import { hasToken, readToken, updateToken, writeToken } from './token-store.js';
+import { getAccountSet, getTokenDir, refreshAccountSetIfStale } from './accounts.js';
+import { makeGetClient } from './client.js';
+import { createTokenStore } from './token-store.js';
 import { resolvePolicy } from './write-control.js';
 export function buildIdentityContext(env = process.env, opts = {}) {
+    // Real closures over the single-owner state (the SAME factories EE
+    // instantiates per tenant), bound here to the global registry + token dir —
+    // behavior-identical to the module-level functions for the free core.
+    const tokenStore = createTokenStore(getTokenDir());
     return {
         subject: 'owner',
         // Live getter: the seam must always see the current registry, never a
@@ -13,7 +17,12 @@ export function buildIdentityContext(env = process.env, opts = {}) {
         // The dispatch transport rides into the resolved policy as a reserved seam
         // (cc-write-control B14); it does not change any write-control verdict.
         policy: resolvePolicy(env, { transport: opts.transport }),
-        getClient,
-        tokenStore: { readToken, writeToken, updateToken, hasToken },
+        getClient: makeGetClient('owner', {
+            accounts: getAccountSet,
+            readToken: tokenStore.readToken,
+            updateToken: tokenStore.updateToken,
+            refreshIfStale: refreshAccountSetIfStale,
+        }),
+        tokenStore,
     };
 }

package/dist/index.js

@@ -58,7 +58,7 @@ function buildRegistry(server, ctx, mode, metrics = null) {
     for (const svc of SERVICES) {
         if (!toolsetEnabled(toolsets, svc.name))
             continue;
-        if (svc.enabled && !svc.enabled()) {
+        if (svc.enabled && !svc.enabled(ctx.accounts)) {
             if (toolsets !== 'all') {
                 const hint = svc.name === 'admin' ? 'set admin on an account/profile (or GOOGLE_ADMIN_ACCOUNTS)' : `add "${svc.name}" to an account's scope profile (or legacy GOOGLE_OPTIONAL_SCOPES)`;
                 process.stderr.write(`GOOGLE_TOOLSETS: "${svc.name}" requested but not enabled — ${hint}\n`);
@@ -72,7 +72,7 @@ function buildRegistry(server, ctx, mode, metrics = null) {
             continue;
         const curated = SERVICES.find((s) => s.name === gen.name);
         const gate = curated?.enabled ?? GENERATED_GATES[gen.name]?.enabled;
-        if (gate && !gate()) {
+        if (gate && !gate(ctx.accounts)) {
             if (!curated && toolsets !== 'all') {
                 process.stderr.write(`GOOGLE_TOOLSETS: "${gen.name}" requested but not enabled — ${GENERATED_GATES[gen.name].hint}\n`);
             }

package/dist/registry-transfer.d.ts

@@ -1,3 +1,8 @@
+/** D11 (refuse-only for v1): export/import operate on the FLAT single-owner
+ * store. A tenant-namespaced layout means the bundle would either miss every
+ * tenant's tokens or exfiltrate all of them in one file — refuse instead.
+ * Returns the offending dir, or null when the store is flat. */
+export declare function refuseIfMultiTenant(dir?: string): string | null;
 export interface TransferBundle {
     manifest: {
         v: 1;

package/dist/registry-transfer.js

@@ -9,8 +9,22 @@ import * as readline from 'node:readline';
 import path from 'node:path';
 import { encryptToken, decryptToken } from './token-store.js';
 import { atomicWriteFileSync, atomicWriteWithLock } from './fs-atomic.js';
-import { ALIAS_RE, configFilePath, CONFIG_VERSION } from './config-file.js';
+import { ALIAS_RE, configFilePath, CONFIG_VERSION, tenantsDir } from './config-file.js';
 import { getTokenDir } from './accounts.js';
+/** D11 (refuse-only for v1): export/import operate on the FLAT single-owner
+ * store. A tenant-namespaced layout means the bundle would either miss every
+ * tenant's tokens or exfiltrate all of them in one file — refuse instead.
+ * Returns the offending dir, or null when the store is flat. */
+export function refuseIfMultiTenant(dir = tenantsDir()) {
+    try {
+        if (readdirSync(dir).length > 0)
+            return dir;
+    }
+    catch {
+        // absent or unreadable tenants/ = flat store
+    }
+    return null;
+}
 function resolveDeps(deps) {
     return {
         configPath: deps.configPath ?? configFilePath(),
@@ -152,6 +166,11 @@ async function resolvePassphrase(prompt) {
     }
 }
 export async function runExportCli(argv) {
+    const mtDir = refuseIfMultiTenant();
+    if (mtDir) {
+        console.error(`E_MULTI_TENANT_EXPORT_REFUSED: tenant-namespaced token stores exist under ${mtDir}; account export only operates on a flat single-owner store.`);
+        return 2;
+    }
     const out = argFlag(argv, '--out');
     if (!out) {
         console.error('Usage: mcp-google-multi account export --out <bundle.enc>');
@@ -169,6 +188,11 @@ export async function runExportCli(argv) {
     return 0;
 }
 export async function runImportCli(argv) {
+    const mtDir = refuseIfMultiTenant();
+    if (mtDir) {
+        console.error(`E_MULTI_TENANT_EXPORT_REFUSED: tenant-namespaced token stores exist under ${mtDir}; account import only operates on a flat single-owner store.`);
+        return 2;
+    }
     const file = argv[argv.indexOf('import') + 1];
     if (!file || file.startsWith('--')) {
         console.error('Usage: mcp-google-multi account import <bundle.enc> [--replace]');

package/dist/services.d.ts

@@ -1,12 +1,16 @@
+import type { AccountSet } from './accounts.js';
 import type { ToolRegistry } from './registry.js';
 export interface ServiceEntry {
     name: string;
     register: (registry: ToolRegistry) => void;
-    enabled?: () => boolean;
+    /** Absent = always on. Gates evaluate against the PASSED account set (the
+     * calling tenant's view); omitted set = the global registry, today's
+     * behavior. */
+    enabled?: (set?: AccountSet) => boolean;
 }
 export declare const SERVICES: ServiceEntry[];
 export declare const GENERATED_GATES: Record<string, {
-    enabled: () => boolean;
+    enabled: (set?: AccountSet) => boolean;
     hint: string;
 }>;
 /**

package/dist/services.js

@@ -25,16 +25,16 @@ export const SERVICES = [
     { name: 'searchconsole', register: registerSearchConsoleTools },
     { name: 'tasks', register: registerTasksTools },
     { name: 'meet', register: registerMeetTools },
-    { name: 'slides', register: registerSlidesTools, enabled: () => new Set(getOptionalBundles()).has('slides') },
-    { name: 'forms', register: registerFormsTools, enabled: () => new Set(getOptionalBundles()).has('forms') },
-    { name: 'chat', register: registerChatTools, enabled: () => new Set(getOptionalBundles()).has('chat') },
-    { name: 'analytics', register: registerAnalyticsTools, enabled: () => { const b = new Set(getOptionalBundles()); return b.has('analytics') || b.has('analytics_write'); } },
-    { name: 'admin', register: registerAdminTools, enabled: () => getAdminAccounts().length > 0 },
+    { name: 'slides', register: registerSlidesTools, enabled: (set) => new Set(getOptionalBundles(set)).has('slides') },
+    { name: 'forms', register: registerFormsTools, enabled: (set) => new Set(getOptionalBundles(set)).has('forms') },
+    { name: 'chat', register: registerChatTools, enabled: (set) => new Set(getOptionalBundles(set)).has('chat') },
+    { name: 'analytics', register: registerAnalyticsTools, enabled: (set) => { const b = new Set(getOptionalBundles(set)); return b.has('analytics') || b.has('analytics_write'); } },
+    { name: 'admin', register: registerAdminTools, enabled: (set) => getAdminAccounts(set).length > 0 },
 ];
 // Generated-only services with opt-in scopes; admin/forms/chat/analytics reuse their curated gate in buildRegistry,
 // and workspaceevents is deliberately absent — no dedicated scope (subscriptions use resource scopes).
 const bundleGate = (name) => ({
-    enabled: () => new Set(getOptionalBundles()).has(name),
+    enabled: (set) => new Set(getOptionalBundles(set)).has(name),
     hint: `add "${name}" to an account's scope profile (or legacy GOOGLE_OPTIONAL_SCOPES)`,
 });
 export const GENERATED_GATES = {

package/dist/token-store.d.ts

@@ -7,3 +7,20 @@ export declare function readToken(alias: string): TokenData | null;
 export declare function writeToken(alias: string, data: object): void;
 export declare function updateToken(alias: string, updates: object): void;
 export declare function hasToken(alias: string): boolean;
+export interface TokenStore {
+    readToken(alias: string): TokenData | null;
+    writeToken(alias: string, data: object): void;
+    updateToken(alias: string, updates: object): void;
+    hasToken(alias: string): boolean;
+}
+/**
+ * Context-scoped token store: `.enc` files live under `dir`, ciphertext keyed
+ * by `tenantId` when present (HKDF v2 envelope; omitted = the single-owner v1
+ * envelope). Same lock + atomic-write + error contract as the module-level
+ * functions: readToken returns null ONLY when the file is missing and throws
+ * on a decrypt failure.
+ */
+export declare function createTokenStore(dir: string, opts?: {
+    tenantId?: string;
+    resolveKey?: () => string;
+}): TokenStore;

package/package.json

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