@dbx-tools/auth 0.6.180 → 0.9.28

package/lib/src/databricks-auth.js

@@ -0,0 +1,314 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as environmentUtils from "@dbx-tools/shared-core/environment-utils";
+import { authLogger, tokenMetadata } from "./_logging.js";
+import { AuthError } from "./errors.js";
+import { DatabricksCliProvider, resolveDatabricksCli } from "./databricks-cli.js";
+import { publicToken, TokenLifecycle } from "./lifecycle.js";
+import { FileCredentialStore } from "./node-storage.js";
+import { DatabricksPersonalAccessTokenProvider } from "./personal-access-token.js";
+import { listDatabricksProfiles, machineScopes, resolveConfigFile, resolveDatabricksProfile, } from "./_profile.js";
+import { DatabricksServicePrincipalProvider } from "./service-principal.js";
+import { MemoryCredentialStore } from "./storage.js";
+import { AuthKind, AuthOptions, DEFAULT_ACCESS_TOKEN_HEADER, Storage, TargetKind, WORKSPACE_ID_HEADER, } from "./types.js";
+const logger = authLogger("databricks");
+/** Persistent Databricks auth facade over the provider-neutral lifecycle. */
+class PersistentAuth {
+    profileValue;
+    storageValue;
+    options;
+    environment;
+    client;
+    requestToken;
+    constructor(profileValue, storageValue, options, environment, client, requestToken) {
+        this.profileValue = profileValue;
+        this.storageValue = storageValue;
+        this.options = options;
+        this.environment = environment;
+        this.client = client;
+        this.requestToken = requestToken;
+    }
+    async challenge() {
+        if (!this.client)
+            throw new AuthError("oauth", "app_obo uses the current request token and cannot start login");
+        logger.debug("authentication challenge requested", this.context());
+        await this.client.login();
+        logger.debug("authentication challenge completed", this.context());
+    }
+    token(login) {
+        logger.debug("Databricks token requested", {
+            ...this.context(),
+            login: login ?? "auto",
+            source: this.requestToken ? "request" : "lifecycle",
+        });
+        return this.requestToken
+            ? Promise.resolve(publicToken(this.requestToken))
+            : this.requiredClient().tokenWithLogin(login);
+    }
+    async authenticate(login) {
+        const token = await this.token(login);
+        const headers = {
+            [DEFAULT_ACCESS_TOKEN_HEADER]: `${token.tokenType} ${token.accessToken}`,
+            ...(this.profileValue.workspaceId
+                ? { [WORKSPACE_ID_HEADER]: this.profileValue.workspaceId }
+                : {}),
+        };
+        logger.debug("generated Databricks authentication headers", {
+            ...this.context(),
+            headerNames: Object.keys(headers),
+            token: tokenMetadata(token),
+        });
+        return headers;
+    }
+    async authorizationHeaderForUrl(requestUrl, login) {
+        return (await this.requestHeadersForUrl(requestUrl, login))[DEFAULT_ACCESS_TOKEN_HEADER];
+    }
+    async requestHeadersForUrl(requestUrl, login) {
+        const request = new URL(requestUrl);
+        const credentialOrigin = new URL(this.profileValue.host).origin;
+        if (request.origin !== credentialOrigin) {
+            logger.debug("skipped authentication for different origin", {
+                ...this.context(),
+                requestOrigin: request.origin,
+                credentialOrigin,
+            });
+            return {};
+        }
+        logger.debug("applying authentication to matching origin", {
+            ...this.context(),
+            requestOrigin: request.origin,
+        });
+        return this.authenticate(login);
+    }
+    forceRefreshToken(login = true) {
+        logger.debug("Databricks token force refresh requested", { ...this.context(), login });
+        return this.requestToken
+            ? Promise.resolve(publicToken(this.requestToken))
+            : this.requiredClient().forceRefresh(login);
+    }
+    refreshRejectedToken(staleAccessToken, login = true) {
+        logger.debug("Databricks rejected token refresh requested", {
+            ...this.context(),
+            login,
+            requestToken: Boolean(this.requestToken),
+        });
+        return this.requestToken
+            ? Promise.resolve(publicToken(this.requestToken))
+            : this.requiredClient().refreshRejectedToken(staleAccessToken, login);
+    }
+    logout() {
+        logger.debug("Databricks logout requested", this.context());
+        return this.client?.logout() ?? Promise.resolve();
+    }
+    status() {
+        return {
+            profile: this.profileValue.name,
+            host: this.profileValue.host,
+            storage: this.storageValue,
+        };
+    }
+    principal() {
+        return this.profileValue.principal;
+    }
+    workspaceId() {
+        return this.profileValue.workspaceId;
+    }
+    authKind() {
+        return this.profileValue.authKind;
+    }
+    profile(name) {
+        const profile = !name || name === this.profileValue.name
+            ? this.profileValue
+            : resolveDatabricksProfile({ ...this.options, profile: name }, this.environment);
+        return profileSummary(profile);
+    }
+    listProfiles(refresh = false) {
+        return listDatabricksProfiles(this.options.configFile, refresh, this.environment);
+    }
+    requiredClient() {
+        if (!this.client)
+            throw new AuthError("oauth", "Authentication lifecycle is not available");
+        return this.client;
+    }
+    context() {
+        return {
+            profile: this.profileValue.name,
+            host: this.profileValue.host,
+            authKind: this.profileValue.authKind,
+            storage: this.storageValue,
+            hasWorkspaceId: Boolean(this.profileValue.workspaceId),
+        };
+    }
+}
+/** Create a Databricks authentication client. */
+export function createAuthClient(options = { preferUserToMachine: true }, storage = Storage.Auto, dependencies = {}) {
+    return createPersistentAuth(options, storage, dependencies);
+}
+/** Resolve a Databricks profile and open built-in credential storage. */
+async function createPersistentAuth(options, storage, dependencies) {
+    const environment = dependencies.environment ?? process.env;
+    const profile = resolveDatabricksProfile(options, environment);
+    const inApp = profile.authKind === AuthKind.AppOnBehalfOf ||
+        profile.authKind === AuthKind.AppServicePrincipal;
+    const backend = storage === Storage.Auto ? Storage.Memory : storage;
+    logger.debug("creating persistent Databricks auth", {
+        profile: profile.name,
+        host: profile.host,
+        authKind: profile.authKind,
+        requestedStorage: storage,
+        resolvedStorage: backend,
+        inApp,
+    });
+    const store = backend === Storage.Memory
+        ? new MemoryCredentialStore()
+        : new FileCredentialStore(options.cacheDir ?? join(homedir(), ".databricks"));
+    return createPersistentAuthWithStorage(options, store, storage, dependencies, profile);
+}
+/** Resolve a Databricks profile using caller-owned generic storage. */
+async function createPersistentAuthWithStorage(options, store, storage = store.name() === "memory" ? Storage.Memory : Storage.File, dependencies = {}, resolvedProfile) {
+    const profile = resolvedProfile ?? resolveDatabricksProfile(options, dependencies.environment ?? process.env);
+    if (profile.authKind === AuthKind.AppOnBehalfOf) {
+        logger.debug("created request-scoped App OBO authentication", {
+            profile: profile.name,
+            host: profile.host,
+            hasWorkspaceId: Boolean(profile.workspaceId),
+        });
+        return new PersistentAuth(profile, Storage.Memory, options, dependencies.environment ?? process.env, undefined, {
+            accessToken: profile.accessToken,
+            tokenType: "Bearer",
+            scopes: [...profile.scopes],
+        });
+    }
+    const provider = await providerFor(profile, options, dependencies);
+    const client = new TokenLifecycle(profile.cacheKey, provider, store, AuthOptions.create(options.auth));
+    const persistent = new PersistentAuth(profile, storage === Storage.Auto ? storageFromName(store.name()) : storage, options, dependencies.environment ?? process.env, client);
+    logger.debug("created persistent authentication lifecycle", {
+        profile: profile.name,
+        host: profile.host,
+        authKind: profile.authKind,
+        storage: persistent.status().storage,
+    });
+    return persistent;
+}
+async function providerFor(profile, options, dependencies) {
+    const environment = dependencies.environment ?? process.env;
+    const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });
+    switch (profile.authKind) {
+        case AuthKind.UserToMachine: {
+            const install = !inApp || options.installCliInApp === true;
+            logger.debug("selected Databricks CLI provider", {
+                profile: profile.name,
+                inApp,
+                install,
+            });
+            return new DatabricksCliProvider(profile.name, () => dependencies.resolveCli
+                ? dependencies.resolveCli({ install })
+                : resolveDatabricksCli(environment, { install }), cliEnvironment(profile, resolveConfigFile(options.configFile, environment)));
+        }
+        case AuthKind.PersonalAccessToken:
+            logger.debug("selected personal access token provider", { profile: profile.name });
+            return new DatabricksPersonalAccessTokenProvider(profile.accessToken);
+        case AuthKind.MachineToMachine:
+        case AuthKind.AppServicePrincipal: {
+            logger.debug("selected service-principal provider", {
+                profile: profile.name,
+                authKind: profile.authKind,
+                target: profile.target,
+            });
+            const endpoints = await resolveOAuthEndpoints(profile, dependencies.fetch);
+            return new DatabricksServicePrincipalProvider({
+                tokenEndpoint: endpoints.tokenEndpoint,
+                clientId: profile.clientId,
+                clientSecret: profile.clientSecret,
+                scopes: machineScopes(profile.scopes),
+                ...(profile.groupId ? { groupId: profile.groupId } : {}),
+                allowInsecureRequests: isLoopbackHttp(profile.host),
+                fetch: dependencies.fetch,
+            });
+        }
+        case AuthKind.AppOnBehalfOf:
+            throw new AuthError("config", "App OBO tokens do not use a persistent provider");
+    }
+}
+async function resolveOAuthEndpoints(profile, fetcher = globalThis.fetch) {
+    const host = profile.host.replace(/\/$/, "");
+    if (profile.target === TargetKind.Account) {
+        if (!profile.accountId)
+            throw new AuthError("config", "Account target requires account_id");
+        const endpoints = {
+            tokenEndpoint: `${host}/oidc/accounts/${profile.accountId}/v1/token`,
+        };
+        logger.debug("resolved account OAuth endpoint", {
+            profile: profile.name,
+            tokenOrigin: new URL(endpoints.tokenEndpoint).origin,
+        });
+        return endpoints;
+    }
+    const discovery = profile.target === TargetKind.Unified
+        ? `${host}/oidc/accounts/${requiredAccountId(profile)}/.well-known/oauth-authorization-server`
+        : `${host}/oidc/.well-known/oauth-authorization-server`;
+    logger.debug("requesting OAuth discovery", {
+        profile: profile.name,
+        target: profile.target,
+        discovery,
+    });
+    const response = await fetcher(discovery, { redirect: "manual" });
+    logger.debug("received OAuth discovery response", {
+        profile: profile.name,
+        status: response.status,
+    });
+    if (response.status === 404)
+        throw new AuthError("oauth", `OAuth is not supported at ${discovery}`);
+    if (!response.ok)
+        throw new AuthError("oauth", `OAuth discovery returned HTTP ${response.status}`);
+    const value = (await response.json());
+    const tokenEndpoint = stringValue(value.token_endpoint);
+    if (!tokenEndpoint)
+        throw new AuthError("oauth", "OAuth discovery response is incomplete");
+    logger.debug("resolved OAuth token endpoint", {
+        profile: profile.name,
+        tokenOrigin: new URL(tokenEndpoint).origin,
+    });
+    return { tokenEndpoint };
+}
+function requiredAccountId(profile) {
+    if (!profile.accountId)
+        throw new AuthError("config", "Unified target requires account_id");
+    return profile.accountId;
+}
+function storageFromName(name) {
+    return name === "memory" ? Storage.Memory : Storage.File;
+}
+function profileSummary(profile) {
+    return {
+        name: profile.name,
+        host: profile.host,
+        ...(profile.accountId ? { accountId: profile.accountId } : {}),
+        ...(profile.workspaceId ? { workspaceId: profile.workspaceId } : {}),
+        target: profile.target,
+        authKind: profile.authKind,
+    };
+}
+function isLoopbackHttp(host) {
+    const url = new URL(host);
+    return url.protocol === "http:" && ["127.0.0.1", "localhost"].includes(url.hostname);
+}
+function cliEnvironment(profile, configFile) {
+    return {
+        DATABRICKS_CONFIG_FILE: configFile,
+        DATABRICKS_CONFIG_PROFILE: profile.name,
+        DATABRICKS_HOST: profile.host,
+        ...(profile.accountId ? { DATABRICKS_ACCOUNT_ID: profile.accountId } : {}),
+        ...(profile.workspaceId ? { DATABRICKS_WORKSPACE_ID: profile.workspaceId } : {}),
+        ...(profile.authKind === AuthKind.PersonalAccessToken
+            ? {
+                DATABRICKS_AUTH_TYPE: "pat",
+                DATABRICKS_TOKEN: profile.accessToken,
+            }
+            : {}),
+    };
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-auth.js","sourceRoot":"","sources":["../../src/databricks-auth.ts"],"names":[],"mappings":"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","sourcesContent":["import { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\nimport * as environmentUtils from \"@dbx-tools/shared-core/environment-utils\";\n\nimport { authLogger, tokenMetadata } from \"./_logging.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport { DatabricksCliProvider, resolveDatabricksCli } from \"./databricks-cli.ts\";\nimport { publicToken, TokenLifecycle } from \"./lifecycle.ts\";\nimport { FileCredentialStore } from \"./node-storage.ts\";\nimport { DatabricksPersonalAccessTokenProvider } from \"./personal-access-token.ts\";\nimport {\n  listDatabricksProfiles,\n  machineScopes,\n  resolveConfigFile,\n  resolveDatabricksProfile,\n} from \"./_profile.ts\";\nimport { DatabricksServicePrincipalProvider } from \"./service-principal.ts\";\nimport { MemoryCredentialStore } from \"./storage.ts\";\nimport {\n  AuthKind,\n  type AuthClient,\n  AuthOptions,\n  type CredentialStore,\n  type DatabricksAuthOptions,\n  type DatabricksAuthStatus,\n  type DatabricksProfile,\n  DEFAULT_ACCESS_TOKEN_HEADER,\n  Storage,\n  TargetKind,\n  type Token,\n  type TokenProvider,\n  WORKSPACE_ID_HEADER,\n} from \"./types.ts\";\n\nconst logger = authLogger(\"databricks\");\n\n/** Injectable host capabilities for Databricks authentication. */\nexport interface DatabricksAuthDependencies {\n  environment?: Readonly<Record<string, string | undefined>>;\n  fetch?: typeof globalThis.fetch;\n  resolveCli?: (options: { install: boolean }) => Promise<string | undefined>;\n}\n\n/** Persistent Databricks auth facade over the provider-neutral lifecycle. */\nclass PersistentAuth implements AuthClient {\n  constructor(\n    private readonly profileValue: DatabricksProfile,\n    private readonly storageValue: Storage,\n    private readonly options: DatabricksAuthOptions,\n    private readonly environment: Readonly<Record<string, string | undefined>>,\n    private readonly client?: TokenLifecycle,\n    private readonly requestToken?: Token,\n  ) {}\n\n  async challenge(): Promise<void> {\n    if (!this.client)\n      throw new AuthError(\"oauth\", \"app_obo uses the current request token and cannot start login\");\n    logger.debug(\"authentication challenge requested\", this.context());\n    await this.client.login();\n    logger.debug(\"authentication challenge completed\", this.context());\n  }\n\n  token(login?: boolean) {\n    logger.debug(\"Databricks token requested\", {\n      ...this.context(),\n      login: login ?? \"auto\",\n      source: this.requestToken ? \"request\" : \"lifecycle\",\n    });\n    return this.requestToken\n      ? Promise.resolve(publicToken(this.requestToken))\n      : this.requiredClient().tokenWithLogin(login);\n  }\n\n  async authenticate(login?: boolean): Promise<Record<string, string>> {\n    const token = await this.token(login);\n    const headers = {\n      [DEFAULT_ACCESS_TOKEN_HEADER]: `${token.tokenType} ${token.accessToken}`,\n      ...(this.profileValue.workspaceId\n        ? { [WORKSPACE_ID_HEADER]: this.profileValue.workspaceId }\n        : {}),\n    };\n    logger.debug(\"generated Databricks authentication headers\", {\n      ...this.context(),\n      headerNames: Object.keys(headers),\n      token: tokenMetadata(token),\n    });\n    return headers;\n  }\n\n  async authorizationHeaderForUrl(\n    requestUrl: string,\n    login?: boolean,\n  ): Promise<string | undefined> {\n    return (await this.requestHeadersForUrl(requestUrl, login))[DEFAULT_ACCESS_TOKEN_HEADER];\n  }\n\n  async requestHeadersForUrl(requestUrl: string, login?: boolean): Promise<Record<string, string>> {\n    const request = new URL(requestUrl);\n    const credentialOrigin = new URL(this.profileValue.host).origin;\n    if (request.origin !== credentialOrigin) {\n      logger.debug(\"skipped authentication for different origin\", {\n        ...this.context(),\n        requestOrigin: request.origin,\n        credentialOrigin,\n      });\n      return {};\n    }\n    logger.debug(\"applying authentication to matching origin\", {\n      ...this.context(),\n      requestOrigin: request.origin,\n    });\n    return this.authenticate(login);\n  }\n\n  forceRefreshToken(login = true) {\n    logger.debug(\"Databricks token force refresh requested\", { ...this.context(), login });\n    return this.requestToken\n      ? Promise.resolve(publicToken(this.requestToken))\n      : this.requiredClient().forceRefresh(login);\n  }\n\n  refreshRejectedToken(staleAccessToken: string, login = true) {\n    logger.debug(\"Databricks rejected token refresh requested\", {\n      ...this.context(),\n      login,\n      requestToken: Boolean(this.requestToken),\n    });\n    return this.requestToken\n      ? Promise.resolve(publicToken(this.requestToken))\n      : this.requiredClient().refreshRejectedToken(staleAccessToken, login);\n  }\n\n  logout(): Promise<void> {\n    logger.debug(\"Databricks logout requested\", this.context());\n    return this.client?.logout() ?? Promise.resolve();\n  }\n\n  status(): DatabricksAuthStatus {\n    return {\n      profile: this.profileValue.name,\n      host: this.profileValue.host,\n      storage: this.storageValue,\n    };\n  }\n\n  principal(): string {\n    return this.profileValue.principal;\n  }\n\n  workspaceId(): string | undefined {\n    return this.profileValue.workspaceId;\n  }\n\n  authKind(): AuthKind {\n    return this.profileValue.authKind;\n  }\n\n  profile(name?: string) {\n    const profile =\n      !name || name === this.profileValue.name\n        ? this.profileValue\n        : resolveDatabricksProfile({ ...this.options, profile: name }, this.environment);\n    return profileSummary(profile);\n  }\n\n  listProfiles(refresh = false) {\n    return listDatabricksProfiles(this.options.configFile, refresh, this.environment);\n  }\n\n  private requiredClient(): TokenLifecycle {\n    if (!this.client) throw new AuthError(\"oauth\", \"Authentication lifecycle is not available\");\n    return this.client;\n  }\n\n  private context(): Record<string, unknown> {\n    return {\n      profile: this.profileValue.name,\n      host: this.profileValue.host,\n      authKind: this.profileValue.authKind,\n      storage: this.storageValue,\n      hasWorkspaceId: Boolean(this.profileValue.workspaceId),\n    };\n  }\n}\n\n/** Create a Databricks authentication client. */\nexport function createAuthClient(\n  options: DatabricksAuthOptions = { preferUserToMachine: true },\n  storage = Storage.Auto,\n  dependencies: DatabricksAuthDependencies = {},\n): Promise<AuthClient> {\n  return createPersistentAuth(options, storage, dependencies);\n}\n\n/** Resolve a Databricks profile and open built-in credential storage. */\nasync function createPersistentAuth(\n  options: DatabricksAuthOptions,\n  storage: Storage,\n  dependencies: DatabricksAuthDependencies,\n): Promise<PersistentAuth> {\n  const environment = dependencies.environment ?? process.env;\n  const profile = resolveDatabricksProfile(options, environment);\n  const inApp =\n    profile.authKind === AuthKind.AppOnBehalfOf ||\n    profile.authKind === AuthKind.AppServicePrincipal;\n  const backend = storage === Storage.Auto ? Storage.Memory : storage;\n  logger.debug(\"creating persistent Databricks auth\", {\n    profile: profile.name,\n    host: profile.host,\n    authKind: profile.authKind,\n    requestedStorage: storage,\n    resolvedStorage: backend,\n    inApp,\n  });\n  const store =\n    backend === Storage.Memory\n      ? new MemoryCredentialStore()\n      : new FileCredentialStore(options.cacheDir ?? join(homedir(), \".databricks\"));\n  return createPersistentAuthWithStorage(options, store, storage, dependencies, profile);\n}\n\n/** Resolve a Databricks profile using caller-owned generic storage. */\nasync function createPersistentAuthWithStorage(\n  options: DatabricksAuthOptions,\n  store: CredentialStore,\n  storage = store.name() === \"memory\" ? Storage.Memory : Storage.File,\n  dependencies: DatabricksAuthDependencies = {},\n  resolvedProfile?: DatabricksProfile,\n): Promise<PersistentAuth> {\n  const profile =\n    resolvedProfile ?? resolveDatabricksProfile(options, dependencies.environment ?? process.env);\n  if (profile.authKind === AuthKind.AppOnBehalfOf) {\n    logger.debug(\"created request-scoped App OBO authentication\", {\n      profile: profile.name,\n      host: profile.host,\n      hasWorkspaceId: Boolean(profile.workspaceId),\n    });\n    return new PersistentAuth(\n      profile,\n      Storage.Memory,\n      options,\n      dependencies.environment ?? process.env,\n      undefined,\n      {\n        accessToken: profile.accessToken!,\n        tokenType: \"Bearer\",\n        scopes: [...profile.scopes],\n      },\n    );\n  }\n  const provider = await providerFor(profile, options, dependencies);\n  const client = new TokenLifecycle(\n    profile.cacheKey,\n    provider,\n    store,\n    AuthOptions.create(options.auth),\n  );\n  const persistent = new PersistentAuth(\n    profile,\n    storage === Storage.Auto ? storageFromName(store.name()) : storage,\n    options,\n    dependencies.environment ?? process.env,\n    client,\n  );\n  logger.debug(\"created persistent authentication lifecycle\", {\n    profile: profile.name,\n    host: profile.host,\n    authKind: profile.authKind,\n    storage: persistent.status().storage,\n  });\n  return persistent;\n}\n\nasync function providerFor(\n  profile: DatabricksProfile,\n  options: DatabricksAuthOptions,\n  dependencies: DatabricksAuthDependencies,\n): Promise<TokenProvider> {\n  const environment = dependencies.environment ?? process.env;\n  const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });\n  switch (profile.authKind) {\n    case AuthKind.UserToMachine: {\n      const install = !inApp || options.installCliInApp === true;\n      logger.debug(\"selected Databricks CLI provider\", {\n        profile: profile.name,\n        inApp,\n        install,\n      });\n      return new DatabricksCliProvider(\n        profile.name,\n        () =>\n          dependencies.resolveCli\n            ? dependencies.resolveCli({ install })\n            : resolveDatabricksCli(environment, { install }),\n        cliEnvironment(profile, resolveConfigFile(options.configFile, environment)),\n      );\n    }\n    case AuthKind.PersonalAccessToken:\n      logger.debug(\"selected personal access token provider\", { profile: profile.name });\n      return new DatabricksPersonalAccessTokenProvider(profile.accessToken!);\n    case AuthKind.MachineToMachine:\n    case AuthKind.AppServicePrincipal: {\n      logger.debug(\"selected service-principal provider\", {\n        profile: profile.name,\n        authKind: profile.authKind,\n        target: profile.target,\n      });\n      const endpoints = await resolveOAuthEndpoints(profile, dependencies.fetch);\n      return new DatabricksServicePrincipalProvider({\n        tokenEndpoint: endpoints.tokenEndpoint,\n        clientId: profile.clientId,\n        clientSecret: profile.clientSecret!,\n        scopes: machineScopes(profile.scopes),\n        ...(profile.groupId ? { groupId: profile.groupId } : {}),\n        allowInsecureRequests: isLoopbackHttp(profile.host),\n        fetch: dependencies.fetch,\n      });\n    }\n    case AuthKind.AppOnBehalfOf:\n      throw new AuthError(\"config\", \"App OBO tokens do not use a persistent provider\");\n  }\n}\n\ninterface AuthorizationServer {\n  tokenEndpoint: string;\n}\n\nasync function resolveOAuthEndpoints(\n  profile: DatabricksProfile,\n  fetcher: typeof globalThis.fetch = globalThis.fetch,\n): Promise<AuthorizationServer> {\n  const host = profile.host.replace(/\\/$/, \"\");\n  if (profile.target === TargetKind.Account) {\n    if (!profile.accountId) throw new AuthError(\"config\", \"Account target requires account_id\");\n    const endpoints = {\n      tokenEndpoint: `${host}/oidc/accounts/${profile.accountId}/v1/token`,\n    };\n    logger.debug(\"resolved account OAuth endpoint\", {\n      profile: profile.name,\n      tokenOrigin: new URL(endpoints.tokenEndpoint).origin,\n    });\n    return endpoints;\n  }\n  const discovery =\n    profile.target === TargetKind.Unified\n      ? `${host}/oidc/accounts/${requiredAccountId(profile)}/.well-known/oauth-authorization-server`\n      : `${host}/oidc/.well-known/oauth-authorization-server`;\n  logger.debug(\"requesting OAuth discovery\", {\n    profile: profile.name,\n    target: profile.target,\n    discovery,\n  });\n  const response = await fetcher(discovery, { redirect: \"manual\" });\n  logger.debug(\"received OAuth discovery response\", {\n    profile: profile.name,\n    status: response.status,\n  });\n  if (response.status === 404)\n    throw new AuthError(\"oauth\", `OAuth is not supported at ${discovery}`);\n  if (!response.ok)\n    throw new AuthError(\"oauth\", `OAuth discovery returned HTTP ${response.status}`);\n  const value = (await response.json()) as Record<string, unknown>;\n  const tokenEndpoint = stringValue(value.token_endpoint);\n  if (!tokenEndpoint) throw new AuthError(\"oauth\", \"OAuth discovery response is incomplete\");\n  logger.debug(\"resolved OAuth token endpoint\", {\n    profile: profile.name,\n    tokenOrigin: new URL(tokenEndpoint).origin,\n  });\n  return { tokenEndpoint };\n}\n\nfunction requiredAccountId(profile: DatabricksProfile): string {\n  if (!profile.accountId) throw new AuthError(\"config\", \"Unified target requires account_id\");\n  return profile.accountId;\n}\n\nfunction storageFromName(name: string): Storage {\n  return name === \"memory\" ? Storage.Memory : Storage.File;\n}\n\nfunction profileSummary(profile: DatabricksProfile) {\n  return {\n    name: profile.name,\n    host: profile.host,\n    ...(profile.accountId ? { accountId: profile.accountId } : {}),\n    ...(profile.workspaceId ? { workspaceId: profile.workspaceId } : {}),\n    target: profile.target,\n    authKind: profile.authKind,\n  };\n}\n\nfunction isLoopbackHttp(host: string): boolean {\n  const url = new URL(host);\n  return url.protocol === \"http:\" && [\"127.0.0.1\", \"localhost\"].includes(url.hostname);\n}\n\nfunction cliEnvironment(profile: DatabricksProfile, configFile: string): Record<string, string> {\n  return {\n    DATABRICKS_CONFIG_FILE: configFile,\n    DATABRICKS_CONFIG_PROFILE: profile.name,\n    DATABRICKS_HOST: profile.host,\n    ...(profile.accountId ? { DATABRICKS_ACCOUNT_ID: profile.accountId } : {}),\n    ...(profile.workspaceId ? { DATABRICKS_WORKSPACE_ID: profile.workspaceId } : {}),\n    ...(profile.authKind === AuthKind.PersonalAccessToken\n      ? {\n          DATABRICKS_AUTH_TYPE: \"pat\",\n          DATABRICKS_TOKEN: profile.accessToken!,\n        }\n      : {}),\n  };\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.trim() ? value : undefined;\n}\n"]}

package/lib/src/databricks-cli.d.ts

@@ -0,0 +1,28 @@
+import type { Token, TokenProvider } from "./types.ts";
+/** Deferred Databricks CLI lookup used by U2M token acquisition. */
+export type DatabricksCliResolver = () => Promise<string | undefined>;
+/** Controls whether CLI resolution may install the pinned managed executable. */
+export interface DatabricksCliResolutionOptions {
+    install?: boolean;
+}
+/** Resolve a compatible Databricks CLI, installing the pinned build asset when needed. */
+export declare function resolveDatabricksCli(environment?: Readonly<Record<string, string | undefined>>, options?: DatabricksCliResolutionOptions): Promise<string | undefined>;
+/** Clear cached CLI resolution, primarily after installation or environment changes. */
+export declare function resetDatabricksCliResolution(): void;
+/** Run interactive Databricks CLI login for one profile. */
+export declare function databricksCliLogin(profile: string, timeoutMs: number, executable?: string, environment?: Record<string, string>): Promise<void>;
+/** Request one profile token from the Databricks CLI. */
+export declare function databricksCliToken(profile: string, forceRefresh?: boolean, executable?: string, environment?: Record<string, string>): Promise<Token>;
+/** Provider that lazily delegates U2M credentials to the Databricks CLI. */
+export declare class DatabricksCliProvider implements TokenProvider {
+    private readonly profile;
+    private readonly executableOrResolver;
+    private readonly environment;
+    private resolution?;
+    constructor(profile: string, executableOrResolver?: string | DatabricksCliResolver, environment?: Record<string, string>);
+    authenticate(_timeoutMs: number): Promise<Token>;
+    login(timeoutMs: number): Promise<Token>;
+    refresh(_token: Token): Promise<Token>;
+    canAuthenticateSilently(): boolean;
+    private resolveExecutable;
+}