@browserstack/mcp-server 2.2.0-beta.2 → 2.2.0

package/dist/lib/central-oauth.d.ts

@@ -1,133 +0,0 @@
-/**
- * Mint a BrowserStack central-OAuth JWT from the caller's username and access key.
- *
- * WHAT IS MINTED IS THE CALLER, NOT A SERVICE ACCOUNT. The exchange takes the user's own
- * credentials and returns a JWT whose `user` claim carries their `user_id`/`group_id`, so a
- * product authorises against signed claims rather than against anything we put in a request
- * body. Scopes narrow it further. The property this preserves is the one the whole surface
- * rests on: an agent can never do what the user could not.
- *
- * SECRET HYGIENE IS THE WHOLE POINT OF THIS MODULE, and Atlas's `central_oauth.py` learned
- * it the hard way: "The body can echo the credential back on some errors, so it is NOT
- * logged or raised — only the status." Neither the access key nor the minted token is ever
- * logged, returned in an error, or put in a message. Only a status code is.
- *
- * THIS MODULE IS THE MECHANISM AND NOTHING ELSE. It throws `CentralAuthError` carrying a
- * `kind`, and each caller words its own message from that: `ask-browserstack` tells the
- * reader nothing reached the agent, the capability registry tells them which product could
- * not be reached. Sharing the mechanism is what stops a second, subtly different minter
- * existing; sharing the prose would put Atlas's wording in front of a registry user.
- */
-export interface Credentials {
-    username: string;
-    accessKey: string;
-}
-export interface TokenResponse {
-    status: number;
-    body: unknown;
-    /** Only when there was no response at all to speak for itself. */
-    error?: string;
-}
-export type TokenTransport = (url: string, form: Record<string, string>) => Promise<TokenResponse>;
-/** What we ask for. The endpoint clamps to its own maximum, so the response wins. */
-export declare const REQUESTED_EXPIRES_IN = 3600;
-/**
- * The token endpoint gets its own, short budget — it is not the call being made.
- *
- * READ AT CALL TIME, NEVER IN A DEFAULT PARAMETER — see `fetchTokenTransport`.
- */
-export declare const TOKEN_TIMEOUT_MS = 15000;
-/**
- * How a mint failed, in the terms a reader can act on.
- *
- * `refused_scope` is a provisioning problem, `refused_credentials` is "your password is
- * wrong", `server_error` is "auth is down" and `unreachable` is "we could not get there".
- * Four different fixes, so they must not collapse into one — routing a 503 to "your
- * credentials were rejected" has already sent someone to audit env vars that had worked
- * minutes earlier.
- */
-export type AuthFailureKind = "no_credentials" | "unreachable" | "server_error" | "refused_scope" | "refused_credentials" | "unusable";
-/** Carries the classification and the status. NEVER any part of the response body. */
-export declare class CentralAuthError extends Error {
-    readonly kind: AuthFailureKind;
-    readonly status: number;
-    readonly scope: string;
-    constructor(kind: AuthFailureKind, status: number, scope: string);
-}
-/**
- * Was this refusal about the SCOPE or about the CREDENTIAL?
- *
- * The two need completely different fixes — provisioning versus a password — so collapsing
- * them into one message sends someone to the wrong place entirely. Our form has five fields
- * and four of them are constants, so a refusal of the REQUEST (as opposed to the caller) can
- * only really be about the scope.
- *
- * Nothing from the body is ever surfaced; the code is used to classify and then discarded.
- */
-export declare function refusalIsAboutScope(status: number, body: unknown): boolean;
-/**
- * One canonical string for a scope set.
- *
- * `["a","b"]` and `["b","a"]` are the same grant, and without this they are two cache keys
- * and two mints for it. Sorted and deduped so the key is a property of the grant rather
- * than of how someone happened to write it down.
- */
-export declare function normaliseScopes(scopes: readonly string[]): string;
-/** The exact form body of the `client_credentials` grant. */
-export declare function mintForm(credentials: Credentials, scope: string, expiresIn?: number): Record<string, string>;
-/**
- * The token endpoint, through `apiClient` per rules/security.md — no bare `fetch`.
- *
- * `raise_error: false` keeps the status-first contract this transport has always had: the
- * caller distinguishes a 400 scope refusal from a 401 rejection from an unreachable host,
- * so a thrown AxiosError on any non-2xx would destroy the only signal it reads.
- *
- * `timeoutMs` IS RESOLVED INSIDE THE CLOSURE, NOT AS A DEFAULT PARAMETER, and that is load
- * bearing.
- *
- * This module sits inside an import cycle — `lib/apiClient` -> `lib/utils` -> `src/index`,
- * the entry — so its top-level bindings are evaluated AFTER the entry starts running. Tool
- * registration calls `fetchTokenTransport()` during that window: the function itself is
- * hoisted and callable, but a default parameter reading `TOKEN_TIMEOUT_MS` is still in its
- * temporal dead zone and threw `Cannot access 'TOKEN_TIMEOUT_MS' before initialization` on
- * every server start. Reading it when a token is actually minted defers it past init.
- *
- * Anything else added here must follow the same rule until that cycle is broken.
- */
-export declare function fetchTokenTransport(timeoutMs?: number): TokenTransport;
-/** Drop every cached token. For tests, and for a credential rotation. */
-export declare function resetTokenCache(): void;
-export interface MintOptions {
-    url: string;
-    /** Already normalised — `normaliseScopes` at the edge, not here. */
-    scope: string;
-    credentials: Credentials;
-    transport: TokenTransport;
-    /**
-     * Treat a token as stale this long before it actually expires.
-     *
-     * It must cover everything the token has to outlive, not merely clock skew: a caller that
-     * holds it for the length of a run needs a skew at least that long, or a human approves a
-     * write and the egress that follows fails on an expired credential.
-     */
-    refreshSkewMs: number;
-    /**
-     * False in a multi-tenant process. These are per-user attested credentials and the hosted
-     * process is shared by every tenant — `rules/multi-tenant-safety.md` forbids holding user
-     * data in module-level state there, so hosted mode mints per call. The cache key already
-     * means one user can never be SERVED another's token, but containment is not the
-     * contract; not holding it at all is.
-     */
-    cacheEnabled: boolean;
-    onMinted?: (lifetimeMs: number) => void;
-    now?: number;
-}
-/**
- * Return a valid token, minting one only when the cache has nothing fresh.
- *
- * Minting per call would add a round trip to every request and make the token endpoint a hot
- * dependency of the whole surface.
- */
-export declare function mintCentralToken(options: MintOptions): Promise<string>;
-/** Drop the cached token for exactly these credentials — used after an upstream 401. */
-export declare function invalidateToken(url: string, scope: string, credentials: Credentials): void;

package/dist/lib/central-oauth.js

@@ -1,246 +0,0 @@
-/**
- * Mint a BrowserStack central-OAuth JWT from the caller's username and access key.
- *
- * WHAT IS MINTED IS THE CALLER, NOT A SERVICE ACCOUNT. The exchange takes the user's own
- * credentials and returns a JWT whose `user` claim carries their `user_id`/`group_id`, so a
- * product authorises against signed claims rather than against anything we put in a request
- * body. Scopes narrow it further. The property this preserves is the one the whole surface
- * rests on: an agent can never do what the user could not.
- *
- * SECRET HYGIENE IS THE WHOLE POINT OF THIS MODULE, and Atlas's `central_oauth.py` learned
- * it the hard way: "The body can echo the credential back on some errors, so it is NOT
- * logged or raised — only the status." Neither the access key nor the minted token is ever
- * logged, returned in an error, or put in a message. Only a status code is.
- *
- * THIS MODULE IS THE MECHANISM AND NOTHING ELSE. It throws `CentralAuthError` carrying a
- * `kind`, and each caller words its own message from that: `ask-browserstack` tells the
- * reader nothing reached the agent, the capability registry tells them which product could
- * not be reached. Sharing the mechanism is what stops a second, subtly different minter
- * existing; sharing the prose would put Atlas's wording in front of a registry user.
- */
-import { createHash } from "node:crypto";
-import { apiClient } from "./apiClient.js";
-/** What we ask for. The endpoint clamps to its own maximum, so the response wins. */
-export const REQUESTED_EXPIRES_IN = 3600;
-/**
- * The token endpoint gets its own, short budget — it is not the call being made.
- *
- * READ AT CALL TIME, NEVER IN A DEFAULT PARAMETER — see `fetchTokenTransport`.
- */
-export const TOKEN_TIMEOUT_MS = 15_000;
-/** Carries the classification and the status. NEVER any part of the response body. */
-export class CentralAuthError extends Error {
-    kind;
-    status;
-    scope;
-    constructor(kind, status, scope) {
-        super(`central auth ${kind} (HTTP ${status})`);
-        this.kind = kind;
-        this.status = status;
-        this.scope = scope;
-        this.name = "CentralAuthError";
-    }
-}
-/**
- * The OAuth2 error codes we are willing to read out of a failure body.
- *
- * `error` is a fixed enum token in the spec, so it cannot carry a credential;
- * `error_description` is free text and demonstrably CAN ("access_key <key> is invalid"),
- * which is why only the code is ever looked at and only when it is one of these. Anything
- * else is ignored entirely and the classification falls back to the status.
- */
-const SCOPE_ERROR_CODES = [
-    "invalid_scope",
-    "unauthorized_client",
-    "invalid_request",
-];
-const CREDENTIAL_ERROR_CODES = [
-    "invalid_client",
-    "invalid_grant",
-    "access_denied",
-];
-/**
- * Was this refusal about the SCOPE or about the CREDENTIAL?
- *
- * The two need completely different fixes — provisioning versus a password — so collapsing
- * them into one message sends someone to the wrong place entirely. Our form has five fields
- * and four of them are constants, so a refusal of the REQUEST (as opposed to the caller) can
- * only really be about the scope.
- *
- * Nothing from the body is ever surfaced; the code is used to classify and then discarded.
- */
-export function refusalIsAboutScope(status, body) {
-    const payload = typeof body === "object" && body !== null
-        ? body
-        : {};
-    const code = typeof payload.error === "string" ? payload.error : "";
-    if (SCOPE_ERROR_CODES.includes(code))
-        return true;
-    if (CREDENTIAL_ERROR_CODES.includes(code))
-        return false;
-    // No usable code. OAuth2 answers a bad REQUEST with 400 and a bad CLIENT with 401/403, so
-    // the status is the next best evidence.
-    return status === 400;
-}
-/**
- * One canonical string for a scope set.
- *
- * `["a","b"]` and `["b","a"]` are the same grant, and without this they are two cache keys
- * and two mints for it. Sorted and deduped so the key is a property of the grant rather
- * than of how someone happened to write it down.
- */
-export function normaliseScopes(scopes) {
-    return [
-        ...new Set(scopes.flatMap((scope) => scope.split(/\s+/)).filter(Boolean)),
-    ]
-        .sort()
-        .join(" ");
-}
-/** The exact form body of the `client_credentials` grant. */
-export function mintForm(credentials, scope, expiresIn = REQUESTED_EXPIRES_IN) {
-    return {
-        grant_type: "client_credentials",
-        username: credentials.username,
-        access_key: credentials.accessKey,
-        scope,
-        expires_in: String(expiresIn),
-    };
-}
-/**
- * The token endpoint, through `apiClient` per rules/security.md — no bare `fetch`.
- *
- * `raise_error: false` keeps the status-first contract this transport has always had: the
- * caller distinguishes a 400 scope refusal from a 401 rejection from an unreachable host,
- * so a thrown AxiosError on any non-2xx would destroy the only signal it reads.
- *
- * `timeoutMs` IS RESOLVED INSIDE THE CLOSURE, NOT AS A DEFAULT PARAMETER, and that is load
- * bearing.
- *
- * This module sits inside an import cycle — `lib/apiClient` -> `lib/utils` -> `src/index`,
- * the entry — so its top-level bindings are evaluated AFTER the entry starts running. Tool
- * registration calls `fetchTokenTransport()` during that window: the function itself is
- * hoisted and callable, but a default parameter reading `TOKEN_TIMEOUT_MS` is still in its
- * temporal dead zone and threw `Cannot access 'TOKEN_TIMEOUT_MS' before initialization` on
- * every server start. Reading it when a token is actually minted defers it past init.
- *
- * Anything else added here must follow the same rule until that cycle is broken.
- */
-export function fetchTokenTransport(timeoutMs) {
-    return async (url, form) => {
-        try {
-            const response = await apiClient.post({
-                url,
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded",
-                    Accept: "application/json",
-                },
-                body: new URLSearchParams(form).toString(),
-                timeout: timeoutMs ?? TOKEN_TIMEOUT_MS,
-                raise_error: false,
-            });
-            return { status: response.status, body: response.data ?? null };
-        }
-        catch {
-            // DNS, TLS, timeout — all of them mean "no token". The reason is deliberately not
-            // carried: it can name the URL and, on some stacks, echo the request body.
-            return { status: 0, body: null, error: "auth could not be reached" };
-        }
-    };
-}
-const cache = new Map();
-/** Drop every cached token. For tests, and for a credential rotation. */
-export function resetTokenCache() {
-    cache.clear();
-}
-/**
- * The cache key.
- *
- * Every part of it is something that changes WHICH token is correct:
- *
- *   url      a different issuer is a different token
- *   scope    a token minted for one scope set must never be served for another
- *   username the identity the JWT attests
- *   digest   so ROTATING the access key mints immediately rather than leaving a revoked
- *            credential working until expiry — hashed, never the value, so the secret is
- *            not left sitting in a map key for the life of the process
- *
- * The PRODUCT is deliberately absent: the token is the caller's identity, not a product's,
- * so two products on the same endpoint and scopes share one mint.
- */
-function cacheKey(url, scope, credentials) {
-    const digest = createHash("sha256")
-        .update(credentials.accessKey)
-        .digest("hex");
-    return `${url} ${credentials.username} ${scope} ${digest}`;
-}
-async function mintOnce(url, scope, credentials, transport) {
-    const response = await transport(url, mintForm(credentials, scope));
-    if (response.status === 0)
-        throw new CentralAuthError("unreachable", 0, scope);
-    // 5xx BEFORE the refusal branch: a server error is not a refusal, and reading it as one
-    // is worse than saying nothing — it names the caller's credentials as the fault.
-    if (response.status >= 500)
-        throw new CentralAuthError("server_error", response.status, scope);
-    if (response.status !== 200) {
-        // ONLY THE STATUS CROSSES. The body is read solely to tell a provisioning problem from a
-        // credential one, and nothing out of it is ever put in the error.
-        throw new CentralAuthError(refusalIsAboutScope(response.status, response.body)
-            ? "refused_scope"
-            : "refused_credentials", response.status, scope);
-    }
-    const body = typeof response.body === "object" && response.body !== null
-        ? response.body
-        : {};
-    const token = body.access_token;
-    if (typeof token !== "string" || !token)
-        throw new CentralAuthError("unusable", response.status, scope);
-    // Trust the SERVER's lifetime over what we asked for — it clamps to its own maximum, and
-    // caching for the requested hour when it granted less would hand out a dead token.
-    const granted = Number(body.expires_in);
-    const seconds = Number.isFinite(granted) && granted > 0 ? granted : REQUESTED_EXPIRES_IN;
-    return { token, lifetimeMs: seconds * 1000 };
-}
-/**
- * Return a valid token, minting one only when the cache has nothing fresh.
- *
- * Minting per call would add a round trip to every request and make the token endpoint a hot
- * dependency of the whole surface.
- */
-export async function mintCentralToken(options) {
-    const { url, scope, credentials, transport, cacheEnabled } = options;
-    const now = options.now ?? Date.now();
-    // Refused before any network call, and by name: these ARE the auth credential now, not
-    // merely attribution, so an empty one is our missing configuration rather than the user's
-    // rejected password, and must not read like one.
-    if (!credentials?.username || !credentials?.accessKey)
-        throw new CentralAuthError("no_credentials", 0, scope);
-    const finish = ({ token, lifetimeMs, }) => {
-        options.onMinted?.(lifetimeMs);
-        return token;
-    };
-    if (!cacheEnabled)
-        return mintOnce(url, scope, credentials, transport).then(finish);
-    const key = cacheKey(url, scope, credentials);
-    const entry = cache.get(key);
-    if (entry && entry.token && now < entry.expiresAt - options.refreshSkewMs)
-        return entry.token;
-    // Double-checked through a shared promise: concurrent callers await the same mint.
-    if (entry?.inflight)
-        return entry.inflight;
-    const pending = mintOnce(url, scope, credentials, transport)
-        .then(({ token, lifetimeMs }) => {
-        cache.set(key, { token, expiresAt: now + lifetimeMs });
-        return finish({ token, lifetimeMs });
-    })
-        .catch((error) => {
-        // Never leave a rejected promise cached, or every later call inherits this failure.
-        cache.delete(key);
-        throw error;
-    });
-    cache.set(key, { token: "", expiresAt: 0, inflight: pending });
-    return pending;
-}
-/** Drop the cached token for exactly these credentials — used after an upstream 401. */
-export function invalidateToken(url, scope, credentials) {
-    cache.delete(cacheKey(url, scope, credentials));
-}

package/dist/tools/capability-registry/oauth.d.ts

@@ -1,63 +0,0 @@
-/**
- * Bearer-JWT auth for products whose API does not accept `Api-Token`.
- *
- * The registry was built on "the caller's credentials, forwarded — never a token this server
- * mints", and this is the first product that cannot work that way. The security property is
- * unchanged: the exchange uses the caller's own username and access key, the JWT carries
- * their `user_id`/`group_id` as signed claims, and the scopes narrow it BELOW what the raw
- * credential could do. What changes is that a token is now minted rather than formatted, so
- * the sentence to hold onto is "the server grants nothing beyond the caller's own identity",
- * not "the server mints nothing".
- *
- * The mint itself lives in `lib/central-oauth.ts` and is shared with `askBrowserStackAI`.
- * This module is only the part that is the registry's: where the endpoint and scopes come
- * from, what a product is allowed to ask for, and how a failure is worded.
- */
-import { Credentials, TokenTransport } from "../../lib/central-oauth.js";
-import { AuthScheme } from "./types.js";
-/**
- * Where a central-OAuth JWT is minted, when a product does not name its own.
- *
- * Staging, for anyone setting the override:
- *   CAPABILITY_REGISTRY_AUTH_TOKEN_URL = https://auth-preprod.bsstag.com/oauth2/v2/token
- */
-export declare const DEFAULT_AUTH_TOKEN_URL = "https://auth.browserstack.com/oauth2/v2/token";
-/**
- * The default scope set, and why it is a PAIR.
- *
- * `ai_agent` is the scope a product's gate matches on. `oauth_user_profile` is not extra
- * authority — it is what makes the scope obtainable through the username+access_key flow at
- * all, and this is measured rather than assumed: `ai_agent` alone comes back
- * `400 invalid_request`, the pair mints, and the granted token's `scopes` claim carries both.
- *
- * Deliberately NOT `ask-browserstack`'s `CENTRAL_SCOPE`, which pairs `ai_agent_notify`
- * instead — Atlas names its own so that changing this one cannot silently change what Atlas
- * is authorised for.
- */
-export declare const DEFAULT_SCOPES: readonly ["ai_agent", "oauth_user_profile"];
-/**
- * Small, because the registry uses the token for ONE HTTP call.
- *
- * Nothing here holds it for the length of a run the way Atlas does, so this only has to
- * cover clock skew and the flight time of the request it opens.
- */
-export declare const REFRESH_SKEW_MS = 60000;
-/** For tests, and for anything that legitimately re-resolves. */
-export declare function resetOAuthAnnouncements(): void;
-/**
- * Three rungs: the operator's override, then the product's declaration, then the built-in.
- *
- * Matching `base_url`, where config is explicitly "a default, not the last word" — a
- * deployment pointed at staging must not be overruled by whatever an index happens to carry.
- */
-export declare function resolveTokenUrl(product: string, auth?: AuthScheme): string;
-/** Two rungs. A scope does not vary by deployment the way a host does, so there is no env one. */
-export declare function resolveScope(auth?: AuthScheme): string;
-/**
- * The Bearer value for one invocation.
- *
- * Cached per user for the life of the token when this process serves one caller, and not at
- * all when it serves many — `mintCentralToken` is handed `cacheEnabled` rather than deciding
- * for itself, because the rule is about THIS deployment, not about the mint.
- */
-export declare function bearerToken(product: string, auth: AuthScheme | undefined, credentials: Credentials, transport: TokenTransport): Promise<string>;

package/dist/tools/capability-registry/oauth.js

@@ -1,176 +0,0 @@
-/**
- * Bearer-JWT auth for products whose API does not accept `Api-Token`.
- *
- * The registry was built on "the caller's credentials, forwarded — never a token this server
- * mints", and this is the first product that cannot work that way. The security property is
- * unchanged: the exchange uses the caller's own username and access key, the JWT carries
- * their `user_id`/`group_id` as signed claims, and the scopes narrow it BELOW what the raw
- * credential could do. What changes is that a token is now minted rather than formatted, so
- * the sentence to hold onto is "the server grants nothing beyond the caller's own identity",
- * not "the server mints nothing".
- *
- * The mint itself lives in `lib/central-oauth.ts` and is shared with `askBrowserStackAI`.
- * This module is only the part that is the registry's: where the endpoint and scopes come
- * from, what a product is allowed to ask for, and how a failure is worded.
- */
-import appConfig from "../../config.js";
-import logger from "../../logger.js";
-import { CentralAuthError, mintCentralToken, normaliseScopes, } from "../../lib/central-oauth.js";
-import { InvocationError } from "./index-loader.js";
-/**
- * Where a central-OAuth JWT is minted, when a product does not name its own.
- *
- * Staging, for anyone setting the override:
- *   CAPABILITY_REGISTRY_AUTH_TOKEN_URL = https://auth-preprod.bsstag.com/oauth2/v2/token
- */
-export const DEFAULT_AUTH_TOKEN_URL = "https://auth.browserstack.com/oauth2/v2/token";
-/**
- * The default scope set, and why it is a PAIR.
- *
- * `ai_agent` is the scope a product's gate matches on. `oauth_user_profile` is not extra
- * authority — it is what makes the scope obtainable through the username+access_key flow at
- * all, and this is measured rather than assumed: `ai_agent` alone comes back
- * `400 invalid_request`, the pair mints, and the granted token's `scopes` claim carries both.
- *
- * Deliberately NOT `ask-browserstack`'s `CENTRAL_SCOPE`, which pairs `ai_agent_notify`
- * instead — Atlas names its own so that changing this one cannot silently change what Atlas
- * is authorised for.
- */
-export const DEFAULT_SCOPES = ["ai_agent", "oauth_user_profile"];
-/**
- * Small, because the registry uses the token for ONE HTTP call.
- *
- * Nothing here holds it for the length of a run the way Atlas does, so this only has to
- * cover clock skew and the flight time of the request it opens.
- */
-export const REFRESH_SKEW_MS = 60_000;
-/**
- * Hosts a PRODUCT INDEX may name as its token endpoint.
- *
- * The index is a data file that ships to public npm and is read at startup. Letting it name
- * an arbitrary `token_url` would let a file decide where the caller's username and access key
- * get POSTed — so the file declares intent and this list bounds it. An operator setting the
- * environment variable is a deliberate act and is trusted; shipping an index is not.
- */
-const ALLOWED_TOKEN_HOSTS = [
-    "auth.browserstack.com",
-    "auth-preprod.bsstag.com",
-];
-/** Announced once per distinct resolution, so a wrong endpoint is a log line, not a deduction. */
-const announced = new Set();
-/** For tests, and for anything that legitimately re-resolves. */
-export function resetOAuthAnnouncements() {
-    announced.clear();
-}
-function announce(product, url, source) {
-    const line = `${product}|${url}|${source}`;
-    if (announced.has(line))
-        return;
-    announced.add(line);
-    logger.info("capability registry: %s mints its token at %s (source: %s)", product, url, source);
-}
-function assertMintable(url, product) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        throw new InvocationError(`product '${product}' declares a token_url that is not a URL: ${JSON.stringify(url)}`);
-    }
-    // Same rule as the product call itself: credentials are never attached over plaintext.
-    if (parsed.protocol !== "https:") {
-        throw new InvocationError(`product '${product}' declares a token_url that is not https. The caller's ` +
-            `credentials are sent to it, so plaintext is refused.`);
-    }
-    if (!ALLOWED_TOKEN_HOSTS.includes(parsed.hostname)) {
-        throw new InvocationError(`product '${product}' declares a token_url on an unrecognised host ` +
-            `'${parsed.hostname}'. An index may only mint against ${ALLOWED_TOKEN_HOSTS.join(" or ")}; ` +
-            `set CAPABILITY_REGISTRY_AUTH_TOKEN_URL if this deployment really does mint elsewhere.`);
-    }
-    return url.replace(/\/+$/, "");
-}
-/**
- * Three rungs: the operator's override, then the product's declaration, then the built-in.
- *
- * Matching `base_url`, where config is explicitly "a default, not the last word" — a
- * deployment pointed at staging must not be overruled by whatever an index happens to carry.
- */
-export function resolveTokenUrl(product, auth) {
-    const explicit = process.env.CAPABILITY_REGISTRY_AUTH_TOKEN_URL;
-    if (explicit && explicit.trim()) {
-        const url = explicit.trim().replace(/\/+$/, "");
-        announce(product, url, "env");
-        return url;
-    }
-    if (auth?.token_url && auth.token_url.trim()) {
-        const url = assertMintable(auth.token_url.trim(), product);
-        announce(product, url, "index");
-        return url;
-    }
-    announce(product, DEFAULT_AUTH_TOKEN_URL, "default");
-    return DEFAULT_AUTH_TOKEN_URL;
-}
-/** Two rungs. A scope does not vary by deployment the way a host does, so there is no env one. */
-export function resolveScope(auth) {
-    const declared = auth?.scopes;
-    if (Array.isArray(declared) && declared.length > 0)
-        return normaliseScopes(declared);
-    return normaliseScopes([...DEFAULT_SCOPES]);
-}
-/**
- * A failure to mint is not a failure of the product, and must not read like one.
- *
- * Nothing from the token endpoint's body reaches these messages — it can echo the access key
- * straight back. Only the classification and the status do.
- */
-function toInvocationError(error, product) {
-    if (!(error instanceof CentralAuthError))
-        return error;
-    const prefix = `token_mint_failed: could not sign in to '${product}'`;
-    switch (error.kind) {
-        case "no_credentials":
-            return new InvocationError(`${prefix}: BrowserStack username and access key are required`);
-        case "unreachable":
-            return new InvocationError(`${prefix}: BrowserStack auth could not be reached. This is a connectivity or ` +
-                `auth-server problem, not a problem with your credentials. Nothing was sent to ` +
-                `'${product}'.`);
-        case "server_error":
-            return new InvocationError(`${prefix}: BrowserStack auth is unavailable (HTTP ${error.status}). YOUR ` +
-                `CREDENTIALS ARE NOT THE PROBLEM — a 5xx is the auth service failing, not a ` +
-                `rejection. Nothing was sent to '${product}'.`);
-        case "refused_scope":
-            return new InvocationError(`${prefix}: BrowserStack auth would not issue a token for the scope ` +
-                `"${error.scope}" (HTTP ${error.status}). YOUR CREDENTIALS ARE NOT THE PROBLEM — ` +
-                `this is a provisioning problem and the scope has to be enabled for this account ` +
-                `or application. This server will NOT retry with a weaker scope. Nothing was ` +
-                `sent to '${product}'.`);
-        case "refused_credentials":
-            return new InvocationError(`${prefix}: your BrowserStack credentials were rejected by BrowserStack auth ` +
-                `(HTTP ${error.status}). Nothing was sent to '${product}'.`);
-        default:
-            return new InvocationError(`${prefix}: BrowserStack auth answered HTTP ${error.status} without issuing a ` +
-                `token. Nothing was sent to '${product}'.`);
-    }
-}
-/**
- * The Bearer value for one invocation.
- *
- * Cached per user for the life of the token when this process serves one caller, and not at
- * all when it serves many — `mintCentralToken` is handed `cacheEnabled` rather than deciding
- * for itself, because the rule is about THIS deployment, not about the mint.
- */
-export async function bearerToken(product, auth, credentials, transport) {
-    try {
-        return await mintCentralToken({
-            url: resolveTokenUrl(product, auth),
-            scope: resolveScope(auth),
-            credentials,
-            transport,
-            refreshSkewMs: REFRESH_SKEW_MS,
-            cacheEnabled: !appConfig.REMOTE_MCP,
-        });
-    }
-    catch (error) {
-        throw toInvocationError(error, product);
-    }
-}

package/dist/tools/capability-registry/routing-token.d.ts

@@ -1,25 +0,0 @@
-/** What a routing call concluded about the user's request. */
-export interface RoutingVerdict {
-    /** `clash`: several products claim it. `blank`: no product's words at all. `settled`: one. */
-    verdict: "clash" | "blank" | "settled";
-    /** The product it settled on, for `settled`. */
-    product?: string;
-    /** The shared words, for `clash` — what the user has to be asked about. */
-    terms?: string[];
-    /** Issued-at, epoch seconds. */
-    iat: number;
-}
-/** Tokens outlive a turn, not a sitting. Long enough to answer a question, not to bank. */
-export declare const TOKEN_TTL_SECONDS: number;
-/** Sign a verdict into an opaque token the caller hands back. */
-export declare function signRouting(verdict: Omit<RoutingVerdict, "iat"> & {
-    iat?: number;
-}): string;
-/**
- * Read a token back, or `undefined` if it was not issued here, was edited, or has expired.
- *
- * Every failure returns the same nothing on purpose: a caller learning WHY its token was
- * rejected learns how to build a better one, and there is no legitimate caller that needs
- * to know the difference.
- */
-export declare function readRouting(token: string | undefined, now?: number): RoutingVerdict | undefined;