mcp-google-multi 6.0.0-beta.2 → 6.0.0-beta.4

package/dist/tools/account-wizard.js

@@ -1,28 +1,25 @@
 import { z } from 'zod';
-import { getAccountSet, invalidateAccountSet } from '../accounts.js';
-import { mutateConfigFile } from '../config-file.js';
+import { getAccountSet, invalidateAccountSet, refreshAccountSetIfStale } from '../accounts.js';
+import { ALIAS_RE, mutateConfigFile } from '../config-file.js';
 import { writeToken } from '../token-store.js';
 import { resolveScopesForAccount } from '../auth.js';
-import { BUNDLE_CATALOG, closestBundle, resolveBundleAliases } from '../scope-catalog.js';
+import { BUNDLE_CATALOG, closestBundle, isKnownBundle, refusedBundlesFor, resolveBundleAliases } from '../scope-catalog.js';
 import { openUrl } from '../open-url.js';
 import { coerceBoolean } from './_coerce.js';
 import { safeMessage, stringifyEnvelope } from './_errors.js';
 import { buildConsentClient, openLoopbackConsent, hasClientCredentials, TESTING_MODE_WARNING, } from '../oauth-consent.js';
 import { detectClients, buildServerEntry, renderInstruction, applyFileEntry, resolveMode, DEFAULT_SERVER_NAME, } from '../client-config.js';
-// B7: the elicitation-driven account_add / account_reauth wizard. It rebuilds
-// interactive account management on the mutable config.json registry so a
-// running server can add an account without the deployer editing env + running
-// a CLI. Google consent reuses the loopback flow (leg C); the HTTP-transport
-// consent path (${BASE}/authorize) is owned by the OAuth AS and lands with that
-// cluster. account_add over http is gated behind it.
-const ALIAS_RE = /^[a-zA-Z0-9_-]+$/;
-// The common optional bundles get their own checkbox (MCP elicitation has no
-// multi-select, so a boolean per bundle IS the checklist); the long tail stays
-// a comma-separated field for power users, and `allBundles` grants every one.
+// Each common bundle gets its own checkbox since MCP elicitation has no
+// multi-select; the long tail stays a comma-separated field, `allBundles` grants all.
 const CHECKBOX_BUNDLES = ['forms', 'chat'];
-/** Every optional bundle (admin is granted via its own checkbox, not here). */
-export function allOptionalBundles() {
-    return Object.keys(BUNDLE_CATALOG).filter((n) => n !== 'admin');
+/** Every optional bundle (admin is granted via its own checkbox, not here),
+ * less those Google refuses for the account at `email` when one is given. */
+export function allOptionalBundles(email) {
+    const all = Object.keys(BUNDLE_CATALOG).filter((n) => n !== 'admin');
+    if (email === undefined)
+        return all;
+    const refused = new Set(refusedBundlesFor(email, all));
+    return all.filter((n) => !refused.has(n));
 }
 /** elicitation/create form schema (flat primitives only, per the MCP spec). */
 export function addFormSchema() {
@@ -55,8 +52,7 @@ export function validateAddForm(input, existingAliases) {
         return { ok: false, slug: 'E_VALIDATION', message: 'Email is required.', hint: "It is used as the Google login hint, so it must be the account's real Google address.", alias };
     }
     if (input.allBundles === true) {
-        // "All optional scopes" supersedes the individual picks.
-        return { ok: true, alias, email, bundles: allOptionalBundles(), admin: input.admin === true };
+        return { ok: true, alias, email, bundles: allOptionalBundles(email), admin: input.admin === true };
     }
     const picked = CHECKBOX_BUNDLES.filter((b) => input[b] === true);
     const rawOther = (input.otherBundles ?? '').split(',').map((s) => s.trim()).filter(Boolean);
@@ -65,7 +61,7 @@ export function validateAddForm(input, existingAliases) {
         if (b === 'admin') {
             return { ok: false, slug: 'E_UNKNOWN_BUNDLE', message: '"admin" is not a scope bundle.', hint: 'Use the admin checkbox instead, or pass "admin": true.', alias };
         }
-        if (!(b in BUNDLE_CATALOG)) {
+        if (!isKnownBundle(b)) {
             const closest = closestBundle(b);
             const known = Object.keys(BUNDLE_CATALOG).filter((n) => n !== 'admin').join(', ');
             return {
@@ -77,6 +73,16 @@ export function validateAddForm(input, existingAliases) {
             };
         }
     }
+    const refused = refusedBundlesFor(email, bundles);
+    if (refused.length > 0) {
+        return {
+            ok: false,
+            slug: 'E_VALIDATION',
+            message: `Google does not let a personal account grant ${refused.map((b) => `"${b}"`).join(', ')}.`,
+            hint: 'Leave it out, or link a Google Workspace account for it.',
+            alias,
+        };
+    }
     return { ok: true, alias, email, bundles, admin: input.admin === true };
 }
 /** URL-mode elicitation params. `elicitationId` is REQUIRED by the spec
@@ -109,8 +115,6 @@ export function scopeGrantDiff(requested, grantedScope) {
     const granted = new Set((grantedScope ?? '').split(' ').filter(Boolean));
     return requested.filter((s) => !granted.has(s));
 }
-/** Persist a new account row (+ a per-account scope profile when bundles/admin
- * were chosen) through the atomic registry mutation path (BR2). */
 function writeAccountRow(alias, email, bundles, admin) {
     mutateConfigFile((current) => {
         const next = { ...current, accounts: { ...(current.accounts ?? {}) } };
@@ -128,9 +132,8 @@ function writeAccountRow(alias, email, bundles, admin) {
 function textResult(text) {
     return { content: [{ type: 'text', text }] };
 }
-/** Wizard failures carry the same envelope as every other tool's, so a client
- * can branch on the slug and metrics can classify them. Success stays prose:
- * it is a human-readable onboarding report, not data. */
+// Errors use the shared envelope so clients can branch on slug; success stays
+// plain prose (a human-readable report, not data).
 function errorResult(slug, message, hint, account) {
     return {
         content: [{ type: 'text', text: stringifyEnvelope({
@@ -143,9 +146,24 @@ function errorResult(slug, message, hint, account) {
         isError: true,
     };
 }
-/** Run Google consent for `alias` and persist the token. Opens the browser via
- * URL-mode elicitation when the client supports it, else server-side + prints
- * the URL. Returns the granted-scope diff for the S4 report. */
+let httpConsent = null;
+export function setWizardHttpConsent(ctx) {
+    httpConsent = ctx;
+}
+// Services register tools at startup: an account's first-enabled service
+// stays unregistered until a restart, so say so rather than claim it just works.
+function restartNote(pending) {
+    if (pending.length === 0)
+        return '';
+    const names = pending.map((s) => `"${s}"`).join(', ');
+    const what = pending.length > 1 ? `services ${names} register their` : `service ${names} registers its`;
+    return `\nThe ${what} tools when the server starts: restart the server to use them. Until then, google_api_call can reach the same API.`;
+}
+function pendingText(alias, url, pending) {
+    return (`Account "${alias}" is ready to authorize. Open this link in a browser (it belongs to whoever owns the Google account):\n${url}\n` +
+        `On completion the token is stored server-side and the account is usable immediately — no restart. ` +
+        `If the link expires, run account_reauth for a fresh one.${restartNote(pending)}\n${TESTING_MODE_WARNING}`);
+}
 async function runConsent(server, alias) {
     const { randomBytes } = await import('node:crypto');
     const cfg = getAccountSet().configs[alias];
@@ -157,9 +175,30 @@ async function runConsent(server, alias) {
             hint: 'Accounts sourced from GOOGLE_ACCOUNTS are not editable here. Run `mcp-google-multi migrate-config` to move them into config.json.',
         };
     }
-    // Bind the ephemeral loopback listener BEFORE building the auth URL: the
-    // redirect URI needs the assigned port, and listening first means the
-    // callback can't race the browser.
+    // HTTP: consent completes out-of-band at the AS /callback; never bind a
+    // loopback listener; surface the URL up front, elicitation is just a convenience.
+    const http = httpConsent;
+    if (http) {
+        let url;
+        try {
+            url = await http.mintConsentUrl(alias);
+        }
+        catch (e) {
+            return { ok: false, slug: 'internal', message: safeMessage(e) };
+        }
+        const caps = server.server.getClientCapabilities?.();
+        if (caps?.elicitation?.url !== undefined) {
+            try {
+                await server.server.elicitInput(urlElicitationParams(alias, url, randomBytes(16).toString('hex')));
+            }
+            catch {
+                // pending text has the recovery URL
+            }
+        }
+        return { ok: 'pending', url };
+    }
+    // Bind the loopback listener before building the auth URL: the redirect URI
+    // needs the assigned port, and listening first avoids a race with the callback.
     const loop = await openLoopbackConsent();
     const client = buildConsentClient(loop.redirect);
     const expectedState = randomBytes(32).toString('hex');
@@ -172,9 +211,8 @@ async function runConsent(server, alias) {
     let opened = false;
     if (caps?.elicitation?.url !== undefined) {
         try {
-            // elicitationId is REQUIRED by the spec schema; omitting it made every
-            // url-mode request fail client-side validation, so this branch always
-            // fell through to the server-side browser open.
+            // elicitationId is REQUIRED by the spec; omitting it silently fails
+            // client-side validation, falling through to the server-side browser open.
             const r = await server.server.elicitInput(urlElicitationParams(alias, url, randomBytes(16).toString('hex')));
             if (r.action !== 'accept') {
                 loop.close();
@@ -211,22 +249,21 @@ async function runConsent(server, alias) {
     writeToken(alias, tokens);
     return { ok: true, missing: scopeGrantDiff(scopes, typeof tokens.scope === 'string' ? tokens.scope : undefined) };
 }
-function s4Text(alias, missing) {
+function s4Text(alias, missing, pending) {
     const outcome = missing.length === 0
         ? `✔ "${alias}" authenticated; all requested scopes granted. It is now usable without a restart.`
         : `⚠ "${alias}" authenticated, but ${missing.length} requested scope(s) were NOT granted (E_SCOPE_NOT_GRANTED). You may have unchecked some on the consent screen. Re-run account_reauth to grant them. The account is usable for the granted scopes.`;
-    return `${outcome}\n${TESTING_MODE_WARNING}`;
+    return `${outcome}${restartNote(pending)}\n${TESTING_MODE_WARNING}`;
 }
 const REQUIRES_INTERACTION = { 'anthropic/requiresUserInteraction': true };
-export function registerAccountWizardTools(registry, server) {
-    // Registered as META (always-visible, like account_list) so onboarding tools
-    // are reachable in lazy mode without discover_all first; registerMeta still
-    // preserves the requiresUserInteraction clientMeta and skips the fan-out path.
+export function registerAccountWizardTools(registry, server, awaitingRestart = () => []) {
+    // Registered as meta (like account_list) so onboarding tools are reachable in
+    // lazy mode without discover_all; this still preserves requiresUserInteraction and skips fan-out.
     const registerMeta = registry.registerMeta;
     registerMeta('account_add', {
         _meta: REQUIRES_INTERACTION,
         annotations: { openWorldHint: true },
-        description: 'Add a new Google account: pass alias + email directly (plus optional bundles/allBundles/admin), or pass nothing for an interactive form where the client supports elicitation. Writes the registry and runs Google consent in the browser. No file editing or restart needed. Requires GOOGLE_CLIENT_ID/SECRET (run the `setup` prompt first if missing).',
+        description: 'Add a new Google account: pass alias + email directly (plus optional bundles/allBundles/admin), or pass nothing for an interactive form where the client supports elicitation. Writes the registry and runs Google consent in the browser. No file editing or restart needed to use the account (tools of a service it newly enables register at the next restart). Requires GOOGLE_CLIENT_ID/SECRET (run the `setup` prompt first if missing).',
         inputSchema: {
             alias: z.string().optional().describe('Account alias (letters, digits, _ or -). Pass with email to add directly, skipping the form.'),
             account: z.string().optional().describe('Alias for the new account (same as `alias`; every other tool spells it `account`)'),
@@ -237,18 +274,16 @@ export function registerAccountWizardTools(registry, server) {
         },
     }, async (args) => {
         try {
-            // Env-sourced registry: GOOGLE_ACCOUNTS is the exclusive source and
-            // config.json accounts are ignored, so a wizard add would be a phantom
-            // write. Refuse up front (BR-10) rather than write a row nothing reads.
+            // GOOGLE_ACCOUNTS is the exclusive registry source when set; config.json
+            // is ignored, so refuse here rather than write a row nothing reads.
             if (process.env.GOOGLE_ACCOUNTS?.trim()) {
                 return errorResult('E_ENV_ACCOUNTS_MODE', 'Accounts are defined by the GOOGLE_ACCOUNTS environment variable, so a new account cannot be added interactively: config.json is ignored while it is set, and the row would be written where nothing reads it.', 'Either add the alias to GOOGLE_ACCOUNTS and run account_reauth, or run `mcp-google-multi migrate-config` to move accounts into config.json and unset GOOGLE_ACCOUNTS.');
             }
             if (!hasClientCredentials()) {
                 return errorResult('invalid_client', 'GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET are not set, so there is no OAuth client to run consent against.', 'Run the `setup` prompt (/mcp__google-multi__setup) to create an OAuth client, then set them. See docs/google-cloud-setup.md.');
             }
-            // S1: collect the registry row. Arguments win over the form so the
-            // wizard still works in clients without form elicitation (where the
-            // interactive path used to dead-end).
+            // Arguments win over the form so the wizard still works for clients
+            // without form elicitation support.
             const a = (args ?? {});
             let input;
             if (a.alias?.trim() || a.account?.trim() || a.email?.trim()) {
@@ -269,15 +304,23 @@ export function registerAccountWizardTools(registry, server) {
             const validated = validateAddForm(input, getAccountSet().aliases);
             if (!validated.ok)
                 return errorResult(validated.slug, validated.message, validated.hint, validated.alias);
-            // S2: atomic write + make the alias callable without a restart (BR3).
+            // Atomic write + make the alias callable without a restart.
             writeAccountRow(validated.alias, validated.email, validated.bundles, validated.admin);
             invalidateAccountSet();
-            // S3 + S4: consent + validate.
+            // Account args already validate against the refreshed registry; the
+            // nudge just gets clients to re-fetch tools/list for the new account enum.
+            try {
+                server.sendToolListChanged();
+            }
+            catch {
+                // harmless if unsupported
+            }
             const consent = await runConsent(server, validated.alias);
+            if (consent.ok === 'pending')
+                return textResult(pendingText(validated.alias, consent.url, awaitingRestart()));
             if (!consent.ok)
                 return errorResult(consent.slug, consent.message, consent.hint, validated.alias);
-            // B15: offer to register the server with another MCP client.
-            return textResult(`${s4Text(validated.alias, consent.missing)}\nTip: run account_write_config to register this server with another MCP client (Claude Desktop / Cursor / Claude Code).`);
+            return textResult(`${s4Text(validated.alias, consent.missing, awaitingRestart())}\nTip: run account_write_config to register this server with another MCP client (Claude Desktop / Cursor / Claude Code).`);
         }
         catch (e) {
             // safeMessage, not error.message: an arbitrary throw here can carry a
@@ -293,16 +336,17 @@ export function registerAccountWizardTools(registry, server) {
             // Plain string (NOT the account enum) so this never joins the
             // multi-account fan-out path; validated against the registry below.
             alias: z.string().min(1).optional().describe('Existing account alias to re-authenticate'),
-            // Every other tool in the server spells this `account`, so that is
-            // what a caller reaches for. Accepting both removes a dead end that
-            // no did-you-mean can rescue: `account` is 5 edits from `alias`, so
-            // the matcher cannot bridge them.
+            // Every other tool spells this `account`; accepting both avoids a dead
+            // end no did-you-mean can bridge (too many edits from `alias`).
             account: z.string().min(1).optional().describe('Alias of the account to re-authenticate (same as `alias`)'),
         },
     }, async (args) => {
         try {
             const a = args;
             const alias = a.alias ?? a.account ?? '';
+            // No default-account wrapper runs for this tool, so pick up a
+            // hand-edited config.json here: that edit is why a re-auth is asked for.
+            refreshAccountSetIfStale();
             if (!hasClientCredentials()) {
                 return errorResult('invalid_client', 'GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET are not set, so there is no OAuth client to run consent against.', 'Run the `setup` prompt (/mcp__google-multi__setup) to create an OAuth client, then set them. See docs/google-cloud-setup.md.');
             }
@@ -310,9 +354,11 @@ export function registerAccountWizardTools(registry, server) {
                 return errorResult('validation_error', `Unknown account "${alias}".`, `Pass one of the configured aliases: ${getAccountSet().aliases.join(', ')}. Use account_add to create a new one.`, alias);
             }
             const consent = await runConsent(server, alias);
+            if (consent.ok === 'pending')
+                return textResult(pendingText(alias, consent.url, awaitingRestart()));
             if (!consent.ok)
                 return errorResult(consent.slug, consent.message, consent.hint, alias);
-            return textResult(s4Text(alias, consent.missing));
+            return textResult(s4Text(alias, consent.missing, awaitingRestart()));
         }
         catch (e) {
             return errorResult('internal', `account_reauth failed: ${safeMessage(e)}`);
@@ -340,7 +386,7 @@ export function registerAccountWizardTools(registry, server) {
                 resourceUri = m.resourceUri;
             }
             catch {
-                // stdio fallback on any config error
+                // fallback to stdio on error
             }
             let entry;
             try {
@@ -360,6 +406,11 @@ export function registerAccountWizardTools(registry, server) {
                 if (client.managed === 'cli') {
                     blocks.push(`${client.label}: run\n  ${instr.text}`);
                 }
+                else if (a.write && mode === 'http') {
+                    // Over HTTP this runs on the daemon, not the caller's machine: write:true
+                    // would edit the operator's own client configs (a tenancy hazard), so snippet only.
+                    blocks.push(`${client.label}: write:true is ignored over HTTP — this tool runs on the server, not your machine. Add to ${instr.path}\n${instr.text}`);
+                }
                 else if (a.write) {
                     const res = applyFileEntry(client, name, entry);
                     blocks.push(res.ok

package/dist/tools/accounts-tool.d.ts

@@ -1,5 +1,7 @@
 import type { ToolRegistry } from '../registry.js';
+import { type AccountSet } from '../accounts.js';
 import { type ScopesReport } from '../scope-observability.js';
+import { type TokenStore } from '../token-store.js';
 export interface AccountHealthDeps {
     hasToken: (alias: string) => boolean;
     readToken: (alias: string) => {
@@ -10,10 +12,15 @@ export interface AccountHealthDeps {
     fileExists: (p: string) => boolean;
     now: () => number;
     /** Scopes required by registered tools — feeds doctor's tool-grained
-     * "registered but not requestable" view (B9). account_list stays compact:
+     * "registered but not requestable" view. account_list stays compact:
      * its report universe is profile ∪ granted only. */
     registeredScopes?: () => string[];
+    /** Account view health is derived against; absent = the global registry. */
+    accounts?: () => AccountSet;
 }
+/** Health deps over one context's token store (and, optionally, its account
+ * view); the module-level functions are the single owner's store. */
+export declare function accountHealthDepsFor(store: Pick<TokenStore, 'hasToken' | 'readToken'>, accounts?: () => AccountSet): AccountHealthDeps;
 export type TokenStatus = 'ok' | 'expired_refreshable' | 'needs_reauth' | 'missing' | 'decrypt_error';
 export interface AccountHealth {
     alias: string;

package/dist/tools/accounts-tool.js

@@ -1,19 +1,28 @@
+import { reauthHint } from '../reauth-hint.js';
 import * as fs from 'node:fs';
 import { getAccountSet, refreshAccountSetIfStale } from '../accounts.js';
 import { buildScopesReport } from '../scope-observability.js';
 import { getAdminAccounts, resolveScopesForAccount } from '../auth.js';
 import { hasToken, readToken } from '../token-store.js';
-const DEFAULT_DEPS = {
-    hasToken,
-    readToken,
-    fileExists: fs.existsSync,
-    now: Date.now,
-};
+import { hints } from '../hint-provider.js';
+/** Health deps over one context's token store (and, optionally, its account
+ * view); the module-level functions are the single owner's store. */
+export function accountHealthDepsFor(store, accounts) {
+    return {
+        hasToken: store.hasToken,
+        readToken: store.readToken,
+        fileExists: fs.existsSync,
+        now: Date.now,
+        ...(accounts ? { accounts } : {}),
+    };
+}
+const DEFAULT_DEPS = accountHealthDepsFor({ hasToken, readToken });
 export function deriveAccountHealth(alias, deps = DEFAULT_DEPS) {
-    const config = getAccountSet().configs[alias];
-    const admin = getAdminAccounts().includes(alias);
-    const configured = resolveScopesForAccount(alias);
-    // BR-10: env-sourced accounts are not persisted in config.json, so the
+    const set = (deps.accounts ?? getAccountSet)();
+    const config = set.configs[alias];
+    const admin = getAdminAccounts(set).includes(alias);
+    const configured = resolveScopesForAccount(alias, set);
+    // Env-sourced accounts are not persisted in config.json, so the
     // account wizard cannot edit them — the deployer edits env instead.
     const base = {
         alias,
@@ -29,13 +38,17 @@ export function deriveAccountHealth(alias, deps = DEFAULT_DEPS) {
     const noScopes = buildScopesReport(new Set(), profileSet, registered);
     if (!deps.hasToken(alias)) {
         const legacy = deps.fileExists(config.tokenPath);
+        const rendered = legacy
+            ? hints()?.render({ kind: 'legacy_plaintext_token', account: alias })
+            : hints()?.render({ kind: 'reauth', account: alias });
         return {
             ...base,
             token: {
                 status: 'missing',
-                hint: legacy
-                    ? 'Plaintext token.json found — run: npx mcp-google-multi migrate-tokens'
-                    : `Run: npx mcp-google-multi auth --account ${alias}`,
+                hint: rendered?.hint ??
+                    (legacy
+                        ? 'Plaintext token.json found — run: npx mcp-google-multi migrate-tokens'
+                        : reauthHint(alias)),
             },
             scopes: noScopes,
         };
@@ -45,9 +58,10 @@ export function deriveAccountHealth(alias, deps = DEFAULT_DEPS) {
         token = deps.readToken(alias);
     }
     catch {
+        const rendered = hints()?.render({ kind: 'token_unreadable', account: alias });
         return {
             ...base,
-            token: { status: 'decrypt_error', hint: 'Wrong MASTER_KEY or corrupt token file — re-auth or restore the key.' },
+            token: { status: 'decrypt_error', hint: rendered?.hint ?? 'Wrong MASTER_KEY or corrupt token file — re-auth or restore the key.' },
             scopes: noScopes,
         };
     }
@@ -69,9 +83,9 @@ export function deriveAccountHealth(alias, deps = DEFAULT_DEPS) {
             status,
             expiryDate: expiry !== undefined ? new Date(expiry).toISOString() : undefined,
             hint: status === 'needs_reauth'
-                ? `Run: npx mcp-google-multi auth --account ${alias}`
+                ? (hints()?.render({ kind: 'reauth', account: alias })?.hint ?? reauthHint(alias))
                 : missing.length > 0
-                    ? 'Re-auth to grant the missing scopes'
+                    ? (hints()?.render({ kind: 'scopes_missing', account: alias })?.hint ?? 'Re-auth to grant the missing scopes')
                     : undefined,
         },
         scopes: report,
@@ -87,14 +101,16 @@ export function registerAccountTools(registry, deps = DEFAULT_DEPS) {
         _meta: { 'anthropic/alwaysLoad': true },
     }, async () => {
         refreshAccountSetIfStale();
+        const set = registry.accountSet();
+        const health = { ...deps, accounts: () => set };
         return {
             content: [
                 {
                     type: 'text',
                     text: JSON.stringify({
-                        defaultAccount: getAccountSet().defaultAccount ?? null,
-                        defaultAccountSource: getAccountSet().defaultAccountSource ?? null,
-                        accounts: getAccountSet().aliases.map((alias) => deriveAccountHealth(alias, deps)),
+                        defaultAccount: set.defaultAccount ?? null,
+                        defaultAccountSource: set.defaultAccountSource ?? null,
+                        accounts: set.aliases.map((alias) => deriveAccountHealth(alias, health)),
                     }),
                 },
             ],

package/dist/tools/admin.d.ts

@@ -1,2 +1,11 @@
 import type { ToolRegistry } from '../registry.js';
-export declare function registerAdminTools(server: ToolRegistry): void;
+import type { Account } from '../accounts.js';
+import { type CuratedToolDeps } from '../client.js';
+export declare function registerAdminTools(server: ToolRegistry, deps?: CuratedToolDeps): void;
+export declare function handleAdminError(error: any, account: Account): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};

package/dist/tools/admin.js

@@ -1,12 +1,15 @@
 import { z } from 'zod';
 import { coerceBoolean } from './_coerce.js';
 import { admin as adminClient } from '@googleapis/admin';
-import { accountAliasSchema } from '../accounts.js';
+import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError, invalidParams } from './_errors.js';
-const accountEnum = accountAliasSchema.optional();
 // Admin SDK requires Workspace super-admin (or delegated admin) on the account — personal @gmail.com accounts 403 on every endpoint.
-export function registerAdminTools(server) {
+export function registerAdminTools(server, deps = {}) {
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
+    const accountEnum = accountArgLive(() => server.accountAliases()).optional();
+    const getClientFn = deps.getClientFn ?? getClient;
     // ─── Reports / audit log ───────────────────────────────────────────────
     server.registerTool('reports_activities_list', {
         description: 'List Admin Activity audit log entries. Filter by application (login, drive, gmail, admin, token, etc.), user, date range, event. The single most useful admin endpoint for SMB visibility.',
@@ -34,7 +37,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, applicationName, userKey, startTime, endTime, eventName, actorIpAddress, filters, orgUnitID, groupIdFilter, customerId, maxResults, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const reports = adminClient({ version: 'reports_v1', auth });
             const res = await reports.activities.list({
                 applicationName,
@@ -74,7 +77,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, customer, domain, query, maxResults, pageToken, orderBy, showDeleted, projection }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const directory = adminClient({ version: 'directory_v1', auth });
             const res = await directory.users.list({
                 customer: customer ?? 'my_customer',
@@ -103,7 +106,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, userKey, projection }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const directory = adminClient({ version: 'directory_v1', auth });
             const res = await directory.users.get({
                 userKey,
@@ -131,7 +134,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, userKey, givenName, familyName, suspended, password, changePasswordAtNextLogin, orgUnitPath }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const directory = adminClient({ version: 'directory_v1', auth });
             const requestBody = {};
             if (givenName !== undefined || familyName !== undefined) {
@@ -175,7 +178,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, customer, domain, userKey, query, maxResults, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const directory = adminClient({ version: 'directory_v1', auth });
             const res = await directory.groups.list({
                 customer: customer ?? 'my_customer',
@@ -205,7 +208,7 @@ export function registerAdminTools(server) {
         },
     }, async ({ account, groupKey, roles, includeDerivedMembership, maxResults, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const directory = adminClient({ version: 'directory_v1', auth });
             const res = await directory.members.list({
                 groupKey,
@@ -223,7 +226,7 @@ export function registerAdminTools(server) {
         }
     });
 }
-function handleAdminError(error, account) {
+export function handleAdminError(error, account) {
     const admin = 'Admin tools require Workspace super-admin privileges AND the account must be listed as an admin account (then re-authenticated). Personal Gmail accounts cannot use these endpoints.';
-    return handleGoogleApiError(error, account, { scope: admin, resource: admin });
+    return handleGoogleApiError(error, account, { scope: admin, resource: admin, bundle: 'admin' });
 }

package/dist/tools/analytics.d.ts

@@ -1,4 +1,6 @@
 import type { ToolRegistry } from '../registry.js';
+import type { Account } from '../accounts.js';
+import { type CuratedToolDeps } from '../client.js';
 /** Accepts "213025502" or "properties/213025502"; rejects the identifiers
  * people paste by mistake (G-… measurement IDs, UA-… properties) with a
  * pointer to the right one. */
@@ -15,4 +17,11 @@ export declare function shapeAccountSummaries(data: any): Record<string, unknown
 /** Full metadata descriptions run to paragraphs; the first ~160 chars carry
  * the disambiguation the model needs without bloating a ~300-entry list. */
 export declare function shapeMetadata(data: any): Record<string, unknown>;
-export declare function registerAnalyticsTools(server: ToolRegistry): void;
+export declare function registerAnalyticsTools(server: ToolRegistry, deps?: CuratedToolDeps): void;
+export declare function handleAnalyticsError(error: any, account: Account): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};

package/dist/tools/analytics.js

@@ -2,10 +2,9 @@ import { z } from 'zod';
 import { coerceArray, coerceBoolean, coerceJson } from './_coerce.js';
 import { analyticsdata as analyticsdataClient } from '@googleapis/analyticsdata';
 import { analyticsadmin as analyticsadminClient } from '@googleapis/analyticsadmin';
-import { accountAliasSchema } from '../accounts.js';
+import { accountArgLive } from '../accounts.js';
 import { getClient } from '../client.js';
 import { handleGoogleApiError } from './_errors.js';
-const accountEnum = accountAliasSchema.optional();
 /** Accepts "213025502" or "properties/213025502"; rejects the identifiers
  * people paste by mistake (G-… measurement IDs, UA-… properties) with a
  * pointer to the right one. */
@@ -105,7 +104,11 @@ export function shapeMetadata(data) {
 const propertySchema = z
     .string()
     .describe('GA4 property: numeric ID like "213025502" or "properties/213025502" — NOT a "G-..." measurement ID and not "UA-...". Find yours with analytics_account_summaries.');
-export function registerAnalyticsTools(server) {
+export function registerAnalyticsTools(server, deps = {}) {
+    // Per-registry, live account enum + injectable client: the schema follows
+    // the registry's account view at parse time, not a process-global default.
+    const accountEnum = accountArgLive(() => server.accountAliases()).optional();
+    const getClientFn = deps.getClientFn ?? getClient;
     server.registerTool('analytics_account_summaries', {
         description: 'List every Google Analytics (GA4) account and property this Google account can access, with their numeric property IDs. The starting point for any Analytics question ("what properties do I have?").',
         inputSchema: {
@@ -115,7 +118,7 @@ export function registerAnalyticsTools(server) {
         },
     }, async ({ account, pageSize, pageToken }) => {
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const admin = analyticsadminClient({ version: 'v1beta', auth });
             const res = await admin.accountSummaries.list({ pageSize, pageToken });
             return {
@@ -159,7 +162,7 @@ export function registerAnalyticsTools(server) {
         if ('hint' in prop)
             return invalidProperty(prop.hint, account);
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const dataApi = analyticsdataClient({ version: 'v1beta', auth });
             const requestBody = {
                 dateRanges: [{ startDate, endDate }],
@@ -216,7 +219,7 @@ export function registerAnalyticsTools(server) {
         if ('hint' in prop)
             return invalidProperty(prop.hint, account);
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const dataApi = analyticsdataClient({ version: 'v1beta', auth });
             const requestBody = { metrics: metrics.map((name) => ({ name })) };
             if (dimensions?.length)
@@ -251,7 +254,7 @@ export function registerAnalyticsTools(server) {
         if ('hint' in prop)
             return invalidProperty(prop.hint, account);
         try {
-            const auth = await getClient(account);
+            const auth = await getClientFn(account);
             const dataApi = analyticsdataClient({ version: 'v1beta', auth });
             const res = await dataApi.properties.getMetadata({ name: `${prop.name}/metadata` });
             return {
@@ -274,11 +277,12 @@ function invalidProperty(hint, account) {
         isError: true,
     };
 }
-function handleAnalyticsError(error, account) {
+export function handleAnalyticsError(error, account) {
     return handleGoogleApiError(error, account, {
         scope: 'Needs the "analytics" bundle on this account: add it to the scope profile, then re-auth.',
-        // GA4 answers PERMISSION_DENIED for a property ACL too, and the old
-        // combined hint sent those callers to re-auth a scope they already had.
+        // GA4 returns PERMISSION_DENIED for a property-access issue too, not just
+        // a missing scope; keep the hints distinct, or callers get sent to re-auth a scope they already have.
         resource: 'The scope is not the problem: this Google account has no access to that GA4 property. Grant it in GA4 Admin > Property Access Management, or call analytics_account_summaries to see the properties it can read.',
+        bundle: 'analytics',
     });
 }

package/dist/tools/calendar.d.ts

@@ -1,5 +1,6 @@
 import type { ToolRegistry } from '../registry.js';
-export declare function registerCalendarTools(server: ToolRegistry): void;
+import { type CuratedToolDeps } from '../client.js';
+export declare function registerCalendarTools(server: ToolRegistry, deps?: CuratedToolDeps): void;
 /** Google disagrees with itself on a backwards window: events.list answers 200
  * with [], which reads as "nothing scheduled", while freebusy.query 400s on the
  * identical input. Decide locally so an empty list always means empty. Returns