mcp-google-multi 6.0.0-alpha.16 → 6.0.0-alpha.18

package/README.md

@@ -20,6 +20,8 @@ New to all this? It's written for someone who just installed Claude Code and has
    npm install -g mcp-google-multi
    ```
 
+   Claude Desktop user? You can skip npm entirely: download the `mcp-google-multi.mcpb` bundle from the [latest release](https://github.com/bakissation/mcp-google-multi/releases/latest), double-click it (or drag it into Claude Desktop → Settings → Extensions), and fill in the values from step 2 when prompted.
+
 2. **Make your Google key** (the one manual part, a few minutes, because Google has no way to script it). Follow the step-by-step [Google Cloud setup](./docs/google-cloud-setup.md), or just ask Claude Code: *"walk me through creating a Google OAuth Desktop client for mcp-google-multi."* You finish with two values, a **Client ID** and a **Client Secret**. It's free and private to you.
 
 3. **Put them in a file.** In the folder you'll run from, make a file named `.env` and paste this, filling in your values:

package/dist/auth.js

@@ -1,12 +1,10 @@
-import { OAuth2Client } from 'googleapis-common';
-import http from 'node:http';
-import { URL } from 'node:url';
 import { randomBytes } from 'node:crypto';
 import { openUrl } from './open-url.js';
 import { ACCOUNTS, getAccountSet } from './accounts.js';
 import { ADMIN_SCOPES, BUNDLE_CATALOG, closestBundle, resolveBundleAliases } from './scope-catalog.js';
 import { resolveMasterKey } from './master-key.js';
 import { writeToken } from './token-store.js';
+import { buildConsentClient, openLoopbackConsent, TESTING_MODE_WARNING } from './oauth-consent.js';
 // Personal (non-Workspace) accounts 403 on admin scopes; ADMIN_SCOPES stays per-account opt-in, never granted by default.
 export const BASE_SCOPES = [
     'https://www.googleapis.com/auth/gmail.modify',
@@ -134,7 +132,11 @@ export async function runAuthFlow(args) {
     // Auto-provisions on a fresh install (env > keychain > file > generate);
     // resolves eagerly so a provisioning failure surfaces before the browser opens.
     resolveMasterKey();
-    const oauth2Client = new OAuth2Client(process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET, 'http://localhost:4242/oauth2callback');
+    // Shared ephemeral-port loopback flow (oauth-consent.ts): listen first, then
+    // build the auth URL from the assigned redirect. CLI gets a patient timeout;
+    // errors propagate to main()'s fatal handler like every other CLI failure.
+    const loop = await openLoopbackConsent({ timeoutMs: 10 * 60_000 });
+    const oauth2Client = buildConsentClient(loop.redirect);
     // CSRF protection for the OAuth callback (RFC 6749 §10.12).
     const expectedState = randomBytes(32).toString('hex');
     const authorizeUrl = oauth2Client.generateAuthUrl({
@@ -149,72 +151,13 @@ export async function runAuthFlow(args) {
     if (getAdminAccounts().includes(alias)) {
         console.log('  ⚠ Admin scopes included — this account will be granted Workspace admin access.');
     }
-    console.log(`Opening browser for authorization...`);
-    return new Promise((resolve, reject) => {
-        const server = http
-            .createServer(async (req, res) => {
-            try {
-                if (req.url && req.url.startsWith('/oauth2callback')) {
-                    const qs = new URL(req.url, 'http://localhost:4242').searchParams;
-                    const error = qs.get('error');
-                    if (error) {
-                        res.writeHead(400, { 'Content-Type': 'text/plain' });
-                        res.end(`Authorization denied: ${error}`);
-                        server.close();
-                        server.closeAllConnections();
-                        reject(new Error(`Authorization denied: ${error}`));
-                        return;
-                    }
-                    const code = qs.get('code');
-                    if (!code) {
-                        res.writeHead(400, { 'Content-Type': 'text/plain' });
-                        res.end('No authorization code received.');
-                        server.close();
-                        server.closeAllConnections();
-                        reject(new Error('No authorization code received'));
-                        return;
-                    }
-                    const returnedState = qs.get('state');
-                    if (returnedState !== expectedState) {
-                        res.writeHead(400, { 'Content-Type': 'text/plain' });
-                        res.end('State mismatch — possible CSRF attempt. Aborting.');
-                        server.close();
-                        server.closeAllConnections();
-                        reject(new Error('OAuth state token mismatch'));
-                        return;
-                    }
-                    const { tokens } = await oauth2Client.getToken(code);
-                    writeToken(alias, tokens);
-                    res.writeHead(200, { 'Content-Type': 'text/html' });
-                    res.end('<h2>Authentication successful!</h2><p>You can close this tab.</p>');
-                    server.close();
-                    server.closeAllConnections();
-                    console.log(`Token saved (encrypted) for ${alias}.`);
-                    console.log('Next: authenticate your other aliases, then verify with: mcp-google-multi config check');
-                    resolve();
-                }
-            }
-            catch (e) {
-                res.writeHead(500, { 'Content-Type': 'text/plain' });
-                res.end('Internal error during authentication.');
-                server.close();
-                server.closeAllConnections();
-                reject(e);
-            }
-        })
-            // Bind to loopback only — never expose the OAuth callback to the local network.
-            .listen(4242, '127.0.0.1', () => {
-            // Always print the URL first: the browser launch is best-effort and
-            // silently does nothing on headless/SSH sessions.
-            console.log(`Opening your browser to authorize "${alias}". If nothing opens, visit:\n${authorizeUrl}`);
-            openUrl(authorizeUrl);
-        });
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                console.error('Port 4242 is already in use. Close the process using it and retry.');
-                process.exit(1);
-            }
-            reject(err);
-        });
-    });
+    // Always print the URL first: the browser launch is best-effort and
+    // silently does nothing on headless/SSH sessions.
+    console.log(`Opening your browser to authorize "${alias}". If nothing opens, visit:\n${authorizeUrl}`);
+    openUrl(authorizeUrl);
+    const tokens = await loop.finish(oauth2Client, expectedState);
+    writeToken(alias, tokens);
+    console.log(`Token saved (encrypted) for ${alias}.`);
+    console.log(TESTING_MODE_WARNING);
+    console.log('Next: authenticate your other aliases, then verify with: mcp-google-multi config check');
 }

package/dist/client.js

@@ -14,7 +14,9 @@ export async function getClient(account) {
         throw new Error('GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET must be set. ' +
             'Check that .env exists in the project root or pass them as env vars.');
     }
-    const oauth2Client = new OAuth2Client(process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET, 'http://localhost:4242/oauth2callback');
+    // Redirect URI is unused on the refresh-token grant; consent flows bind an
+    // ephemeral loopback port at auth time (oauth-consent.ts).
+    const oauth2Client = new OAuth2Client(process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET, 'http://localhost/oauth2callback');
     const tokenData = readToken(account);
     if (!tokenData) {
         throw new Error(`No token found for account "${account}" (${config.email}). ${reauthHint(account)}`);

package/dist/oauth-consent.d.ts

@@ -1,6 +1,4 @@
 import { OAuth2Client } from 'googleapis-common';
-export declare const LOOPBACK_PORT = 4242;
-export declare const LOOPBACK_REDIRECT = "http://localhost:4242/oauth2callback";
 /** GOOGLE_CLIENT_ID/SECRET absent — caller maps to E_CLIENT_CREDENTIALS_MISSING. */
 export declare class ClientCredentialsMissingError extends Error {
     constructor();
@@ -14,15 +12,32 @@ export declare class ConsentTimeoutError extends Error {
 export declare class ConsentDeniedError extends Error {
     constructor(reason: string);
 }
+export declare const TESTING_MODE_WARNING: string;
 export declare function hasClientCredentials(): boolean;
-/** Build the loopback OAuth2 client from env credentials (throws if unset). */
-export declare function buildConsentClient(): OAuth2Client;
 /**
- * Start the loopback server, await the OAuth redirect, validate the CSRF
- * `state` (RFC 6749 §10.12), and exchange the code. Returns the token set for
- * the caller to persist. Never process.exit's (safe inside a live server) and
- * times out so a stalled consent can't wedge a tool call.
+ * Build the loopback OAuth2 client from env credentials (throws if unset).
+ * `redirect` comes from openLoopbackConsent(): the port is only known once the
+ * listener is bound.
  */
-export declare function awaitLoopbackConsent(client: OAuth2Client, expectedState: string, opts?: {
+export declare function buildConsentClient(redirect: string): OAuth2Client;
+export interface LoopbackConsent {
+    /** `http://localhost:<ephemeral port>/oauth2callback` — build the auth URL from this. */
+    redirect: string;
+    /**
+     * Await the OAuth redirect, validate the CSRF `state` (RFC 6749 §10.12), and
+     * exchange the code. Returns the token set for the caller to persist.
+     */
+    finish(client: OAuth2Client, expectedState: string): Promise<Record<string, unknown>>;
+    /**
+     * Abandon the consent: shuts the listener down WITHOUT settling finish(), so
+     * an abandoned flow can never surface as an unhandled rejection later.
+     */
+    close(): void;
+}
+/**
+ * Bind the loopback listener first (ephemeral port), so the redirect URI is
+ * known before the auth URL is built and the callback can't race the browser.
+ */
+export declare function openLoopbackConsent(opts?: {
     timeoutMs?: number;
-}): Promise<Record<string, unknown>>;
+}): Promise<LoopbackConsent>;

package/dist/oauth-consent.js

@@ -2,13 +2,11 @@ import { OAuth2Client } from 'googleapis-common';
 import http from 'node:http';
 import { URL } from 'node:url';
 // Shared loopback OAuth consent (leg C of cc-auth), used by the account wizard
-// (B7). The `auth --account` CLI keeps its own inline copy for now; this module
-// is the reusable, live-server-safe form (throws typed errors instead of
-// process.exit, and times out so a never-completed consent can't wedge a tool
-// call forever). The redirect matches the CLI exactly so an existing registered
-// Desktop client keeps working.
-export const LOOPBACK_PORT = 4242;
-export const LOOPBACK_REDIRECT = `http://localhost:${LOOPBACK_PORT}/oauth2callback`;
+// (B7) and the `auth --account` CLI. Live-server-safe: typed errors instead of
+// process.exit, and a timeout so a never-completed consent can't wedge a tool
+// call forever. The listener binds an EPHEMERAL loopback port (RFC 8252 §7.3;
+// Google Desktop clients accept any http://localhost:<port> redirect), so a
+// second local process on a fixed port can never break auth.
 /** GOOGLE_CLIENT_ID/SECRET absent — caller maps to E_CLIENT_CREDENTIALS_MISSING. */
 export class ClientCredentialsMissingError extends Error {
     constructor() {
@@ -17,7 +15,7 @@ export class ClientCredentialsMissingError extends Error {
 }
 export class LoopbackPortInUseError extends Error {
     constructor() {
-        super(`E_LOOPBACK_PORT_IN_USE: port ${LOOPBACK_PORT} is already in use; close the other process and retry.`);
+        super('E_LOOPBACK_PORT_IN_USE: the loopback consent listener could not bind a port; retry.');
     }
 }
 export class ConsentTimeoutError extends Error {
@@ -30,80 +28,128 @@ export class ConsentDeniedError extends Error {
         super(`E_CONSENT_DENIED: ${reason}`);
     }
 }
+// Surfaced after every successful consent: the expiry is invisible until the
+// token dies a week later as reauth_required, so the moment of success is the
+// one place the warning is guaranteed to be seen. Full walkthrough in
+// docs/google-cloud-setup.md.
+export const TESTING_MODE_WARNING = 'Heads-up: while your OAuth client\'s Publishing status is "Testing", Google expires refresh tokens after 7 days (weekly re-auth for every account). ' +
+    'When your setup works, set it to "In production" at https://console.cloud.google.com/auth/audience. ' +
+    'No verification review is needed for personal use; see docs/google-cloud-setup.md.';
 export function hasClientCredentials() {
     return Boolean(process.env.GOOGLE_CLIENT_ID && process.env.GOOGLE_CLIENT_SECRET);
 }
-/** Build the loopback OAuth2 client from env credentials (throws if unset). */
-export function buildConsentClient() {
+/**
+ * Build the loopback OAuth2 client from env credentials (throws if unset).
+ * `redirect` comes from openLoopbackConsent(): the port is only known once the
+ * listener is bound.
+ */
+export function buildConsentClient(redirect) {
     if (!hasClientCredentials())
         throw new ClientCredentialsMissingError();
-    return new OAuth2Client(process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET, LOOPBACK_REDIRECT);
+    return new OAuth2Client(process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_SECRET, redirect);
 }
 /**
- * Start the loopback server, await the OAuth redirect, validate the CSRF
- * `state` (RFC 6749 §10.12), and exchange the code. Returns the token set for
- * the caller to persist. Never process.exit's (safe inside a live server) and
- * times out so a stalled consent can't wedge a tool call.
+ * Bind the loopback listener first (ephemeral port), so the redirect URI is
+ * known before the auth URL is built and the callback can't race the browser.
  */
-export function awaitLoopbackConsent(client, expectedState, opts = {}) {
+export function openLoopbackConsent(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 5 * 60_000;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolveOpen, rejectOpen) => {
+        let redirect = '';
         let timer;
+        let closed = false;
+        let pending;
+        const shutdown = () => {
+            if (closed)
+                return;
+            closed = true;
+            if (timer)
+                clearTimeout(timer);
+            server.close();
+            server.closeAllConnections();
+        };
+        const fail = (err) => {
+            const p = pending;
+            pending = undefined;
+            shutdown();
+            p?.reject(err);
+        };
         const server = http.createServer(async (req, res) => {
             if (!req.url || !req.url.startsWith('/oauth2callback')) {
                 res.writeHead(404).end();
                 return;
             }
+            if (!pending) {
+                // Only reachable if something other than our own browser launch hit
+                // the port before finish() armed the exchange; nothing to do with it.
+                res.writeHead(503).end();
+                return;
+            }
+            const p = pending;
             const done = (code, body) => {
                 res.writeHead(code, { 'Content-Type': 'text/html' });
                 res.end(body);
-                if (timer)
-                    clearTimeout(timer);
-                server.close();
-                server.closeAllConnections();
             };
             try {
-                const qs = new URL(req.url, LOOPBACK_REDIRECT).searchParams;
+                const qs = new URL(req.url, redirect).searchParams;
                 const error = qs.get('error');
                 if (error) {
                     done(400, `<p>Authorization denied: ${error}</p>`);
-                    reject(new ConsentDeniedError(error));
+                    fail(new ConsentDeniedError(error));
                     return;
                 }
                 const returnedState = qs.get('state');
-                if (returnedState !== expectedState) {
-                    done(400, '<p>State mismatch — possible CSRF attempt. Aborting.</p>');
-                    reject(new Error('E_OAUTH_STATE_MISMATCH: OAuth state token mismatch'));
+                if (returnedState !== p.expectedState) {
+                    done(400, '<p>State mismatch: possible CSRF attempt. Aborting.</p>');
+                    fail(new Error('E_OAUTH_STATE_MISMATCH: OAuth state token mismatch'));
                     return;
                 }
                 const code = qs.get('code');
                 if (!code) {
                     done(400, '<p>No authorization code received.</p>');
-                    reject(new ConsentDeniedError('no authorization code received'));
+                    fail(new ConsentDeniedError('no authorization code received'));
                     return;
                 }
-                const { tokens } = await client.getToken(code);
+                const { tokens } = await p.client.getToken(code);
                 done(200, '<h2>Authentication successful!</h2><p>You can close this tab.</p>');
-                resolve(tokens);
+                pending = undefined;
+                shutdown();
+                p.resolve(tokens);
             }
             catch (e) {
                 done(500, '<p>Internal error during authentication.</p>');
-                reject(e);
+                fail(e);
             }
         });
         server.on('error', (err) => {
-            if (timer)
-                clearTimeout(timer);
-            reject(err.code === 'EADDRINUSE' ? new LoopbackPortInUseError() : err);
+            const mapped = err.code === 'EADDRINUSE' ? new LoopbackPortInUseError() : err;
+            if (pending) {
+                fail(mapped);
+            }
+            else {
+                shutdown();
+                rejectOpen(mapped);
+            }
         });
-        server.listen(LOOPBACK_PORT, '127.0.0.1', () => {
-            timer = setTimeout(() => {
-                server.close();
-                server.closeAllConnections();
-                reject(new ConsentTimeoutError());
-            }, timeoutMs);
+        // Bind to loopback only — never expose the OAuth callback to the local network.
+        server.listen(0, '127.0.0.1', () => {
+            redirect = `http://localhost:${server.address().port}/oauth2callback`;
+            timer = setTimeout(() => fail(new ConsentTimeoutError()), timeoutMs);
             // unref so a pending consent never keeps the process alive on its own.
             timer.unref?.();
+            resolveOpen({
+                redirect,
+                finish(client, expectedState) {
+                    return new Promise((resolve, reject) => {
+                        if (closed) {
+                            reject(new ConsentTimeoutError());
+                            return;
+                        }
+                        pending = { client, expectedState, resolve, reject };
+                    });
+                },
+                close: shutdown,
+            });
         });
     });
 }

package/dist/tools/account-wizard.d.ts

@@ -27,6 +27,16 @@ export type AddValidation = {
 /** Validate the collected form against the alias rules, dup check, and the
  * bundle catalog. Pure (no I/O) for unit testing. */
 export declare function validateAddForm(input: Partial<AddForm>, existingAliases: string[]): AddValidation;
+/** Map direct tool arguments onto the elicitation form shape: the argument-
+ * mode fallback for clients without form elicitation. All bundle picks travel
+ * through otherBundles, which validateAddForm resolves and validates. Pure. */
+export declare function argsToAddForm(a: {
+    alias?: string;
+    email?: string;
+    bundles?: string;
+    allBundles?: boolean;
+    admin?: boolean;
+}): Partial<AddForm>;
 /** Scopes requested by the profile but NOT granted at consent (granular
  * consent / unchecked bundles). Pure. */
 export declare function scopeGrantDiff(requested: string[], grantedScope: string | undefined): string[];

package/dist/tools/account-wizard.js

@@ -5,7 +5,8 @@ import { writeToken } from '../token-store.js';
 import { resolveScopesForAccount } from '../auth.js';
 import { BUNDLE_CATALOG, closestBundle, resolveBundleAliases } from '../scope-catalog.js';
 import { openUrl } from '../open-url.js';
-import { buildConsentClient, awaitLoopbackConsent, hasClientCredentials, } from '../oauth-consent.js';
+import { coerceBoolean } from './_coerce.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
@@ -70,6 +71,18 @@ export function validateAddForm(input, existingAliases) {
     }
     return { ok: true, alias, email, bundles, admin: input.admin === true };
 }
+/** Map direct tool arguments onto the elicitation form shape: the argument-
+ * mode fallback for clients without form elicitation. All bundle picks travel
+ * through otherBundles, which validateAddForm resolves and validates. Pure. */
+export function argsToAddForm(a) {
+    return {
+        alias: a.alias ?? '',
+        email: a.email ?? '',
+        allBundles: a.allBundles === true,
+        otherBundles: a.bundles ?? '',
+        admin: a.admin === true,
+    };
+}
 /** Scopes requested by the profile but NOT granted at consent (granular
  * consent / unchecked bundles). Pure. */
 export function scopeGrantDiff(requested, grantedScope) {
@@ -103,19 +116,22 @@ async function runConsent(server, alias) {
     const cfg = getAccountSet().configs[alias];
     if (!cfg)
         return { ok: false, text: `E_VALIDATION: account "${alias}" is not in the live registry (env-sourced accounts are not editable here).` };
-    const client = buildConsentClient();
+    // 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.
+    const loop = await openLoopbackConsent();
+    const client = buildConsentClient(loop.redirect);
     const expectedState = randomBytes(32).toString('hex');
     const scopes = resolveScopesForAccount(alias);
     const url = client.generateAuthUrl({ access_type: 'offline', prompt: 'consent', scope: scopes, login_hint: cfg.email, state: expectedState });
-    // Start the loopback listener BEFORE opening the browser so it can't miss the
-    // redirect. Any startup error (e.g. port in use) surfaces synchronously.
-    const consent = awaitLoopbackConsent(client, expectedState);
+    const consent = loop.finish(client, expectedState);
     const caps = server.server.getClientCapabilities?.();
     let opened = false;
     if (caps?.elicitation?.url) {
         try {
             const r = await server.server.elicitInput({ mode: 'url', message: `Authorize the "${alias}" Google account in your browser.`, url });
             if (r.action !== 'accept') {
+                loop.close();
                 return { ok: false, text: 'confirmation_declined: consent was cancelled; the account row was kept but no token was stored (doctor will show it as "missing").' };
             }
             opened = true;
@@ -138,9 +154,10 @@ async function runConsent(server, alias) {
     return { ok: true, missing: scopeGrantDiff(scopes, typeof tokens.scope === 'string' ? tokens.scope : undefined) };
 }
 function s4Text(alias, missing) {
-    if (missing.length === 0)
-        return `✔ "${alias}" authenticated; all requested scopes granted. It is now usable without a restart.`;
-    return `⚠ "${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.`;
+    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}`;
 }
 const REQUIRES_INTERACTION = { 'anthropic/requiresUserInteraction': true };
 export function registerAccountWizardTools(registry, server) {
@@ -151,9 +168,15 @@ export function registerAccountWizardTools(registry, server) {
     registerMeta('account_add', {
         _meta: REQUIRES_INTERACTION,
         annotations: { openWorldHint: true },
-        description: 'Add a new Google account interactively: collects alias/email/scope bundles via a form, 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).',
-        inputSchema: {},
-    }, async () => {
+        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).',
+        inputSchema: {
+            alias: z.string().optional().describe('Account alias (letters, digits, _ or -). Pass with email to add directly, skipping the form.'),
+            email: z.string().optional().describe("The account's Google address (used as the login hint)"),
+            bundles: z.string().optional().describe('Optional scope bundles, comma-separated (e.g. "forms,chat"); blank = base scopes only'),
+            allBundles: coerceBoolean.optional().describe('Grant every optional bundle (biggest consent screen); overrides bundles'),
+            admin: coerceBoolean.optional().describe('Grant Workspace admin scopes (super-admin accounts only)'),
+        },
+    }, 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
@@ -164,16 +187,26 @@ export function registerAccountWizardTools(registry, server) {
             if (!hasClientCredentials()) {
                 return textResult('E_CLIENT_CREDENTIALS_MISSING: GOOGLE_CLIENT_ID/GOOGLE_CLIENT_SECRET are not set. Run the `setup` prompt (/mcp__google-multi__setup) to create an OAuth client, then set them.', true);
             }
-            const caps = server.server.getClientCapabilities?.();
-            if (!caps?.elicitation?.form) {
-                return textResult('This client does not support form elicitation. Add the account from the CLI instead: `npx mcp-google-multi account add --alias <alias> --email <email> [--profile a,b] [--admin]`.', true);
+            // 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).
+            const a = (args ?? {});
+            let input;
+            if (a.alias?.trim() || a.email?.trim()) {
+                input = argsToAddForm(a);
             }
-            // S1: collect the registry row.
-            const form = await server.server.elicitInput({ message: 'Add a Google account', requestedSchema: addFormSchema() });
-            if (form.action !== 'accept') {
-                return textResult('confirmation_declined: no account was added.');
+            else {
+                const caps = server.server.getClientCapabilities?.();
+                if (!caps?.elicitation?.form) {
+                    return textResult('E_NO_FORM_ELICITATION: this client does not support the interactive form. Call account_add again with arguments instead, e.g. {"alias": "work", "email": "you@example.com"} (optional: "bundles" as a comma-separated list, "allBundles": true, "admin": true).', true);
+                }
+                const form = await server.server.elicitInput({ message: 'Add a Google account', requestedSchema: addFormSchema() });
+                if (form.action !== 'accept') {
+                    return textResult('confirmation_declined: no account was added.');
+                }
+                input = form.content ?? {};
             }
-            const validated = validateAddForm(form.content ?? {}, getAccountSet().aliases);
+            const validated = validateAddForm(input, getAccountSet().aliases);
             if (!validated.ok)
                 return textResult(`${validated.slug}: ${validated.message}`, true);
             // S2: atomic write + make the alias callable without a restart (BR3).

package/package.json

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