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

package/dist/migrate-config.js

@@ -1,5 +1,5 @@
 import { CONFIG_VERSION, configFilePath, loadConfigFile, mutateConfigFile } from './config-file.js';
-import { BUNDLE_CATALOG, closestBundle, resolveBundleAliases } from './scope-catalog.js';
+import { closestBundle, isKnownBundle, resolveBundleAliases } from './scope-catalog.js';
 function parseCsv(value) {
     return (value ?? '').split(',').map((s) => s.trim()).filter(Boolean);
 }
@@ -47,7 +47,7 @@ export function runMigrateConfig(env = process.env) {
                 process.exitCode = 1;
                 return;
             }
-            if (!(bundle in BUNDLE_CATALOG)) {
+            if (!isKnownBundle(bundle)) {
                 const hint = closestBundle(bundle);
                 console.error(`E_UNKNOWN_BUNDLE: unknown bundle "${bundle}" in GOOGLE_OPTIONAL_SCOPES${hint ? ` — did you mean "${hint}"?` : ''}. Nothing written.`);
                 process.exitCode = 1;

package/dist/oauth-as.d.ts

@@ -6,6 +6,10 @@ export declare const DCR_MAX_REDIRECT_URIS = 10;
 export interface GoogleExchangeResult {
     tokens: Record<string, unknown>;
     email?: string;
+    /** Google's stable account id; unlike the address it is never reassigned. */
+    sub?: string;
+    /** Google Workspace hosted domain; absent for a consumer account. */
+    hd?: string;
 }
 export interface AuthServerConfig {
     base: string;
@@ -16,21 +20,72 @@ export interface AuthServerConfig {
     accessTtlSec?: number;
     masterKey: string;
     refreshStorePath: string;
+    /** `maxAgeSec` of the refresh store buildAuthServer creates: sessions end
+     * this long after their sign-in. Unset: unlimited. */
+    refreshMaxAgeSec?: number;
+    /** `idleSec` of that store: sessions end this long after their last
+     * refresh. Unset: unlimited. */
+    refreshIdleSec?: number;
+    /** `maxFamiliesPerSub` of that store: bounds how many live refresh-token
+     * families one subject may hold, dropping its least-recently-used one to
+     * make room. Unset: unlimited. */
+    refreshMaxFamiliesPerSub?: number;
+    /** Default true. The clientless `flow=alias_reauth` link names an alias with
+     * no tenant binding, so a multi-tenant deployment sets false: with several
+     * tenants an alias name alone is ambiguous and the branch becomes a
+     * cross-tenant re-auth vector. Server-minted alias_add flows are unaffected. */
+    legacyAliasReauth?: boolean;
 }
+/** What /callback hands the alias_add binder once Google returned a verified
+ * identity for a server-minted link. */
+export interface TenantAliasBind {
+    tenantId: string;
+    alias: string;
+    email: string;
+    bundles?: string[];
+    nonce?: string;
+    tokens: Record<string, unknown>;
+    sub?: string;
+}
+/** A binder's deliberate refusal (policy, not failure): /callback answers 403
+ * with this slug and message. The message reaches an unauthenticated browser. */
+export interface AliasBindRefusal {
+    refused: {
+        slug: string;
+        message: string;
+    };
+}
+export interface GoogleIdentity {
+    email?: string;
+    sub?: string;
+    hd?: string;
+}
+/** Only trust the id_token identity when Google marks the email verified (#8).
+ * The token comes straight from Google's token endpoint, so its claims are
+ * read unsigned. A malformed sub or hd is dropped, never passed on. */
+export declare function verifiedIdentityFromIdToken(idToken?: string | null): GoogleIdentity | undefined;
+export declare function verifiedEmailFromIdToken(idToken?: string | null): string | undefined;
 export interface AuthServerDeps {
     fetchCimd?: (clientId: string) => Promise<Record<string, unknown>>;
     /** Exchange a Google auth code at `${base}/callback` for tokens (+ owner email). */
     exchangeCode?: (code: string, flow: StatePayload['flow']) => Promise<GoogleExchangeResult>;
     /** Build the Google authorization URL (redirect back to `${base}/callback`).
-     *  The impl chooses scope/prompt/login_hint from the flow: owner_gate =
-     *  `openid email` + select_account; alias_reauth = the alias's resource scopes
-     *  + consent. */
+     *  The impl chooses scope/prompt from the flow: owner_gate = `openid email`
+     *  + select_account; alias_reauth = the alias's resource scopes + select_account
+     *  consent, and no login_hint (the link needs no authentication). */
     buildGoogleAuthUrl?: (opts: {
         flow: StatePayload['flow'];
         alias?: string;
         state: string;
+        bundles?: string[];
     }) => string;
     writeToken?: (alias: string, tokens: Record<string, unknown>) => void;
+    /** Scopes the alias asked for that `grantedScope` lacks, so the alias_reauth
+     * completion page can say what Google's granular consent left out. */
+    missingScopes?: (alias: string, grantedScope: string | undefined) => string[];
+    /** Whether a readable token is stored for the alias; a narrower re-auth
+     * grant keeps it rather than replace it. */
+    hasToken?: (alias: string) => boolean;
     registeredClients?: Map<string, {
         redirect_uris: string[];
     }>;
@@ -41,10 +96,55 @@ export interface AuthServerDeps {
     log?: (line: string) => void;
     /** The alias's configured Google email, for the alias_reauth identity binding. */
     aliasEmail?: (alias: string) => string | undefined;
+    /** Map a verified sign-in email to the subject its tokens are minted under.
+     * Default = the MCP_OWNER_EMAILS allowlist -> {sub:'owner'}; null = denied.
+     * The tenant resolver (invite claim / email->tenant lookup) plugs in here.
+     * `identity` carries Google's `sub` and `hd` when the exchange returned
+     * them, so a resolver can key on the stable account id rather than an
+     * address that can be reassigned. */
+    resolveSubject?: (email: string, identity?: {
+        sub?: string;
+        hd?: string;
+    }) => {
+        sub: string;
+    } | null | {
+        denied: {
+            description: string;
+        };
+    };
+    /** alias_add completion: persist the new alias's config row and tokens under
+     * its tenant. /callback awaits it only after a successful Google exchange.
+     * A returned refusal answers 403 with its slug; a throw or rejection answers
+     * 500 E_ALIAS_ADD_FAILED. */
+    bindTenantAlias?: (bind: TenantAliasBind) => void | AliasBindRefusal | Promise<void | AliasBindRefusal>;
+    /** False for a subject this host no longer serves (a multi-tenant host that
+     * removed or suspended it): /token then issues and rotates nothing for it
+     * (400 invalid_grant; a rotated sub's refresh tokens are dropped). A throw
+     * means the answer is unknown right now: 503 temporarily_unavailable, and
+     * the presented refresh token is not spent. Absent: every subject is active. */
+    subjectActive?: (sub: string) => boolean;
 }
 export interface AuthServer {
     routes: Record<string, RouteHandler>;
     authenticate: (req: IncomingMessage) => Promise<AuthOutcome>;
+    /** Mint a signed, single-use, TTL-bound clientless flow URL
+     * (`${base}/authorize?flow=...&state=<signed>`). The tenantId/bundles ride
+     * INSIDE the signed state, so nothing at /authorize or /callback trusts a
+     * caller-supplied identity. The URL works only on this AuthServer, and only
+     * until its process restarts: sign-in artifacts are signed with a key each
+     * buildAuthServer call generates. Inert unless something calls it. */
+    mintFlowState: (opts: {
+        flow: 'alias_add';
+        alias: string;
+        tenantId?: string;
+        bundles?: string[];
+        nonce?: string;
+    }) => Promise<string>;
+    /** The owner's re-auth link for `alias`: HMAC-signed, expiring, not single
+     * use (a chat client may prefetch it). /authorize refuses any alias_reauth
+     * request without a valid one, so an unauthenticated caller can neither
+     * start a re-auth nor learn which aliases exist or what they hold. */
+    reauthLink: (alias: string) => string;
 }
 /** C6: exact redirect_uri match, with RFC 8252 §7.3 port-agnostic loopback and
  *  the fixed claude.ai callback. */