@dbx-tools/auth 0.9.31 → 0.9.36

package/lib/src/_profile-config.js

@@ -0,0 +1,443 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import { AuthType, TargetKind } from "@dbx-tools/shared-auth/config";
+import * as environmentUtils from "@dbx-tools/shared-core/environment-utils";
+import * as object from "@dbx-tools/shared-core/object";
+import * as stringUtils from "@dbx-tools/shared-core/string-utils";
+import { trimToUndefined } from "@dbx-tools/shared-core/string-utils";
+import { parse as parseIni } from "ini";
+import { AuthError } from "./_errors.js";
+import { authLogger } from "./_logging.js";
+import { DEFAULT_ACCESS_TOKEN_HEADER, DEFAULT_CLIENT_ID, DEFAULT_CONFIG_FILE, } from "./config.js";
+const logger = authLogger("profile-selection");
+const configCache = new Map();
+export const SETTINGS_SECTION = "__settings__";
+/** Resolve the selected Databricks configuration path. */
+export function resolveConfigFile(explicit, environment = process.env) {
+    const selected = trimToUndefined(explicit) ??
+        trimToUndefined(environment.DATABRICKS_CONFIG_FILE) ??
+        DEFAULT_CONFIG_FILE;
+    const expanded = selected === "~"
+        ? homedir()
+        : selected.startsWith("~/")
+            ? resolve(homedir(), selected.slice(2))
+            : selected;
+    return isAbsolute(expanded) ? expanded : resolve(expanded);
+}
+/** Load and cache the selected Databricks configuration. */
+export function loadConfig(configFile, refresh = false, environment = process.env) {
+    const path = resolveConfigFile(configFile, environment);
+    if (refresh)
+        configCache.delete(path);
+    if (configCache.has(path)) {
+        const cached = configCache.get(path);
+        if (cached instanceof Error)
+            throw cached;
+        return cached;
+    }
+    if (!existsSync(path)) {
+        configCache.set(path, undefined);
+        return undefined;
+    }
+    try {
+        const config = parseDatabricksConfig(readFileSync(path, "utf8"));
+        configCache.set(path, config);
+        return config;
+    }
+    catch (cause) {
+        const error = cause instanceof Error ? cause : new AuthError("config", `Could not read ${path}`, { cause });
+        configCache.set(path, error);
+        throw error;
+    }
+}
+/** Invalidate cached configuration after an external write. */
+export function invalidateConfigFile(configFile) {
+    configCache.delete(resolveConfigFile(configFile));
+}
+/** Parse Databricks INI text through the maintained `ini` package. */
+export function parseDatabricksConfig(source) {
+    let parsed;
+    try {
+        parsed = parseIni(source);
+    }
+    catch (cause) {
+        throw new AuthError("config", "Databricks configuration is not valid INI", { cause });
+    }
+    const config = new Map();
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!name.trim() || !object.isRecord(value)) {
+            throw new AuthError("config", "Databricks configuration values must belong to a profile");
+        }
+        const section = new Map();
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === undefined || entry === null)
+                continue;
+            section.set(key.trim().toLowerCase(), String(entry).trim());
+        }
+        config.set(name.trim(), section);
+    }
+    return config;
+}
+export function loadRawProfile(config, name) {
+    const section = config?.get(name);
+    return {
+        host: section?.get("host"),
+        accountId: section?.get("account_id"),
+        workspaceId: section?.get("workspace_id"),
+        clientId: section?.get("client_id"),
+        clientSecret: section?.get("client_secret"),
+        accessToken: section?.get("token"),
+        groupId: section?.get("group_id"),
+        scopes: section?.get("scopes"),
+        authType: trimToUndefined(section?.get("auth_type"))?.toLowerCase(),
+    };
+}
+export function resolveProfileName(requested, explicit, config, preferUserToMachine) {
+    let selected = requested;
+    let source = requested ? "requested" : undefined;
+    if (!selected) {
+        selected = trimToUndefined(config?.get(SETTINGS_SECTION)?.get("default_profile"));
+        if (selected)
+            source = "settings-default";
+    }
+    if (!selected && config?.has("DEFAULT")) {
+        selected = "DEFAULT";
+        source = "default-section";
+    }
+    if (!selected) {
+        const profiles = [...(config?.keys() ?? [])].filter((name) => name !== SETTINGS_SECTION);
+        if (profiles.length === 1) {
+            selected = profiles[0];
+            source = "sole-profile";
+        }
+    }
+    if (!selected) {
+        selected = "DEFAULT";
+        source = "fallback";
+    }
+    if (selected === SETTINGS_SECTION) {
+        throw new AuthError("config", `${SETTINGS_SECTION} is reserved`);
+    }
+    if (explicit || !preferUserToMachine || !config) {
+        logger.debug("selected Databricks profile", {
+            profile: selected,
+            source,
+            explicit,
+            preferUserToMachine,
+        });
+        return selected;
+    }
+    const current = loadRawProfile(config, selected);
+    if (!isM2mProfile(current) || !current.host) {
+        logger.debug("selected Databricks profile", {
+            profile: selected,
+            source,
+            explicit,
+            preferUserToMachine,
+        });
+        return selected;
+    }
+    const matches = [...config.keys()].filter((name) => {
+        if (name === selected || name === SETTINGS_SECTION)
+            return false;
+        const candidate = loadRawProfile(config, name);
+        return candidate.authType === "databricks-cli" && sameTarget(current, candidate);
+    });
+    const preferred = matches.length === 1 ? matches[0] : selected;
+    logger.debug("selected Databricks profile", {
+        profile: preferred,
+        source: preferred === selected ? source : "matching-cli-profile",
+        originalProfile: preferred === selected ? undefined : selected,
+        explicit,
+        preferUserToMachine,
+        matchingCliProfiles: matches.length,
+    });
+    return preferred;
+}
+/** Normalize Databricks hosts and require TLS outside loopback development. */
+export function normalizeHost(value, profile = "DEFAULT") {
+    const selected = trimToUndefined(value);
+    if (!selected)
+        throw new AuthError("config", `Profile ${profile} has no host`);
+    const withScheme = /^https?:\/\//i.test(selected) ? selected : `https://${selected}`;
+    let url;
+    try {
+        url = new URL(withScheme);
+    }
+    catch (cause) {
+        throw new AuthError("config", `Profile ${profile} has an invalid host`, { cause });
+    }
+    if (url.protocol !== "https:" && url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+        throw new AuthError("config", "Databricks host must use HTTPS");
+    }
+    return url.toString().replace(/\/$/, "");
+}
+export function resolveAuthType(authType, clientId, clientSecret, accessToken) {
+    switch (authType) {
+        case AuthType.DatabricksCli:
+            return AuthType.DatabricksCli;
+        case AuthType.OAuthM2M:
+            if (!clientId || !clientSecret) {
+                throw new AuthError("config", "oauth-m2m requires client_id and client_secret");
+            }
+            return AuthType.OAuthM2M;
+        case AuthType.PersonalAccessToken:
+            if (!accessToken)
+                throw new AuthError("config", "pat requires token");
+            return AuthType.PersonalAccessToken;
+        case AuthType.AppOnBehalfOf:
+            if (!accessToken) {
+                throw new AuthError("config", "app_obo requires the configured access token header");
+            }
+            return AuthType.AppOnBehalfOf;
+        case AuthType.AppServicePrincipal:
+            if (!clientId || !clientSecret) {
+                throw new AuthError("config", "app_sp requires client id and secret");
+            }
+            return AuthType.AppServicePrincipal;
+        case undefined:
+            if (clientId && clientSecret)
+                return AuthType.OAuthM2M;
+            if (clientSecret)
+                throw new AuthError("config", "oauth-m2m client_secret requires client_id");
+            return accessToken ? AuthType.PersonalAccessToken : AuthType.DatabricksCli;
+    }
+}
+/** Parse one external auth-type value into the canonical enum. */
+export function parseAuthType(value) {
+    const selected = trimToUndefined(value)?.toLowerCase();
+    if (selected === undefined)
+        return undefined;
+    if (Object.values(AuthType).includes(selected))
+        return selected;
+    throw new AuthError("config", `Authentication type ${selected} is not supported`);
+}
+export function requestOboToken(headers, headerName = DEFAULT_ACCESS_TOKEN_HEADER) {
+    const entry = Object.entries(headers ?? {}).find(([name]) => name.toLowerCase() === headerName.toLowerCase());
+    const value = trimToUndefined(entry?.[1]);
+    if (!value)
+        return undefined;
+    if (headerName.toLowerCase() !== DEFAULT_ACCESS_TOKEN_HEADER)
+        return value;
+    const [scheme, ...parts] = value.split(/\s+/);
+    return scheme?.toLowerCase() === "bearer" ? trimToUndefined(parts.join(" ")) : undefined;
+}
+export function inferTarget(host, accountId) {
+    if (accountId && host) {
+        try {
+            if (new URL(normalizeHost(host)).hostname === "accounts.cloud.databricks.com") {
+                return TargetKind.Account;
+            }
+        }
+        catch { }
+    }
+    return TargetKind.Workspace;
+}
+export function parseTarget(value) {
+    switch (value.trim().toLowerCase()) {
+        case TargetKind.Workspace:
+            return TargetKind.Workspace;
+        case TargetKind.Account:
+            return TargetKind.Account;
+        case TargetKind.Unified:
+            return TargetKind.Unified;
+        default:
+            throw new AuthError("config", "Target must be workspace, account, or unified");
+    }
+}
+export function missing(profile, field) {
+    throw new AuthError("config", `Profile ${profile} requires ${field}`);
+}
+function sameTarget(left, right) {
+    try {
+        if (normalizeHost(left.host) !== normalizeHost(right.host))
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return ((!left.accountId || left.accountId === right.accountId) &&
+        (!left.workspaceId || left.workspaceId === right.workspaceId));
+}
+function isM2mProfile(profile) {
+    return (profile.authType === AuthType.OAuthM2M ||
+        (!profile.authType && Boolean(profile.clientId && profile.clientSecret)));
+}
+/** Enumerate secret-free profile metadata from cached configuration. */
+export function listDatabricksProfiles(configFile, refresh = false, environment = process.env) {
+    const path = resolveConfigFile(configFile, environment);
+    const config = loadConfig(configFile, refresh, environment);
+    if (!config) {
+        logger.debug("listed Databricks profiles", { path, refresh, count: 0 });
+        return [];
+    }
+    const profiles = [...config.keys()]
+        .filter((name) => name !== SETTINGS_SECTION)
+        .map((name) => {
+        const profile = loadRawProfile(config, name);
+        const host = stringUtils.trimToUndefined(profile.host);
+        const accountId = stringUtils.trimToUndefined(profile.accountId);
+        const workspaceId = stringUtils.trimToUndefined(profile.workspaceId);
+        const authType = resolveAuthType(parseAuthType(profile.authType), profile.clientId, profile.clientSecret, profile.accessToken);
+        return {
+            name,
+            ...(host ? { host } : {}),
+            ...(accountId ? { accountId } : {}),
+            ...(workspaceId ? { workspaceId } : {}),
+            target: inferTarget(host, accountId),
+            authType,
+            principal: authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal
+                ? (stringUtils.trimToUndefined(profile.clientId) ?? name)
+                : name,
+        };
+    })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    logger.debug("listed Databricks profiles", { path, refresh, count: profiles.length });
+    return profiles;
+}
+/** Resolve options, environment, request headers, and configuration into credentials. */
+export function resolveDatabricksProfile(options, environment = process.env) {
+    const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });
+    const environmentProfile = stringUtils.trimToUndefined(environment.DATABRICKS_CONFIG_PROFILE);
+    const explicitProfile = Boolean(stringUtils.trimToUndefined(options.profile) ?? environmentProfile);
+    const requestToken = requestOboToken(options.requestHeaders, options.accessTokenHeader);
+    const explicitAuthType = options.authType ??
+        (!inApp && !explicitProfile ? parseAuthType(environment.DATABRICKS_AUTH_TYPE) : undefined);
+    const appServicePrincipal = [
+        environment.DATABRICKS_HOST,
+        environment.DATABRICKS_CLIENT_ID,
+        environment.DATABRICKS_CLIENT_SECRET,
+    ].every((value) => Boolean(stringUtils.trimToUndefined(value)));
+    const selectedAuthType = !inApp || explicitProfile || explicitAuthType
+        ? explicitAuthType
+        : requestToken
+            ? AuthType.AppOnBehalfOf
+            : appServicePrincipal
+                ? AuthType.AppServicePrincipal
+                : undefined;
+    const appAuth = selectedAuthType === AuthType.AppOnBehalfOf ||
+        selectedAuthType === AuthType.AppServicePrincipal;
+    const ignoreAmbientCredentials = explicitProfile && !appAuth;
+    const configPath = resolveConfigFile(options.configFile, environment);
+    const config = loadConfig(options.configFile, false, environment);
+    const requestedName = stringUtils.trimToUndefined(options.profile) ?? environmentProfile;
+    const profileName = resolveProfileName(requestedName, explicitProfile, config, options.preferUserToMachine ?? true);
+    const ambientCredentials = [
+        options.accessToken,
+        options.clientId,
+        options.clientSecret,
+        environment.DATABRICKS_TOKEN,
+        environment.DATABRICKS_CLIENT_ID,
+        environment.DATABRICKS_CLIENT_SECRET,
+    ].some((value) => Boolean(stringUtils.trimToUndefined(value)));
+    const selectedProfile = explicitProfile || (!ambientCredentials && config?.has(profileName)) ? profileName : undefined;
+    const configured = loadRawProfile(config, profileName);
+    const ambient = (name) => ignoreAmbientCredentials ? undefined : stringUtils.trimToUndefined(environment[name]);
+    const host = normalizeHost(options.host ?? ambient("DATABRICKS_HOST") ?? configured.host, profileName);
+    const accountId = stringUtils.trimToUndefined(options.accountId) ??
+        ambient("DATABRICKS_ACCOUNT_ID") ??
+        stringUtils.trimToUndefined(configured.accountId);
+    const workspaceId = stringUtils.trimToUndefined(options.workspaceId) ??
+        ambient("DATABRICKS_WORKSPACE_ID") ??
+        stringUtils.trimToUndefined(configured.workspaceId);
+    const clientIdValue = stringUtils.trimToUndefined(options.clientId) ??
+        ambient("DATABRICKS_CLIENT_ID") ??
+        stringUtils.trimToUndefined(configured.clientId);
+    const clientSecret = stringUtils.trimToUndefined(options.clientSecret) ??
+        ambient("DATABRICKS_CLIENT_SECRET") ??
+        stringUtils.trimToUndefined(configured.clientSecret);
+    const accessToken = selectedAuthType === AuthType.AppOnBehalfOf
+        ? requestToken
+        : (stringUtils.trimToUndefined(options.accessToken) ??
+            ambient("DATABRICKS_TOKEN") ??
+            stringUtils.trimToUndefined(configured.accessToken));
+    const configuredAuthType = selectedAuthType ??
+        parseAuthType(ambient("DATABRICKS_AUTH_TYPE")) ??
+        parseAuthType(configured.authType);
+    const authType = resolveAuthType(configuredAuthType, clientIdValue, clientSecret, accessToken);
+    const clientId = authType === AuthType.DatabricksCli
+        ? (clientIdValue ?? DEFAULT_CLIENT_ID)
+        : authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal
+            ? (clientIdValue ?? missing(profileName, "client_id"))
+            : (clientIdValue ?? "");
+    const scopes = options.scopes?.length
+        ? stringUtils.parseList(options.scopes)
+        : stringUtils.parseList(configured.scopes?.split(",") ?? ["all-apis"]);
+    const target = options.target ? parseTarget(options.target) : inferTarget(host, accountId);
+    const groupId = stringUtils.trimToUndefined(options.groupId) ??
+        ambient("DATABRICKS_GROUP_ID") ??
+        stringUtils.trimToUndefined(configured.groupId);
+    const principal = authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal
+        ? clientId
+        : profileName;
+    const cacheKey = credentialCacheKey({
+        name: profileName,
+        host,
+        accountId,
+        workspaceId,
+        clientId,
+        groupId,
+        scopes,
+        authType,
+        accessToken,
+    });
+    logger.debug("resolved Databricks profile", {
+        profile: profileName,
+        host,
+        authType,
+        target,
+        inApp,
+        explicitProfile,
+        configuredAuthType: configuredAuthType ?? "automatic",
+        hasAccountId: Boolean(accountId),
+        hasWorkspaceId: Boolean(workspaceId),
+        hasGroupId: Boolean(groupId),
+        scopeCount: scopes.length,
+        configPath,
+    });
+    return {
+        name: profileName,
+        ...(selectedProfile ? { selectedProfile } : {}),
+        host,
+        ...(accountId ? { accountId } : {}),
+        ...(workspaceId ? { workspaceId } : {}),
+        clientId,
+        ...(groupId ? { groupId } : {}),
+        scopes,
+        target,
+        authType,
+        ...(clientSecret ? { clientSecret } : {}),
+        ...(accessToken ? { accessToken } : {}),
+        cacheKey,
+        principal,
+    };
+}
+/** Normalize OAuth scopes for machine credentials. */
+export function machineScopes(scopes) {
+    return stringUtils.parseList(scopes.length ? scopes : ["all-apis"]).sort();
+}
+function credentialCacheKey(profile) {
+    if (profile.authType === AuthType.DatabricksCli)
+        return profile.name;
+    if (profile.authType === AuthType.PersonalAccessToken) {
+        const digest = createHash("sha256")
+            .update(profile.accessToken ?? "")
+            .digest("hex");
+        return `${profile.name}-pat-${digest}`;
+    }
+    if (profile.authType === AuthType.AppOnBehalfOf)
+        return `${profile.name}-app-obo`;
+    const identity = [
+        profile.host,
+        profile.accountId ?? "",
+        profile.workspaceId ?? "",
+        profile.clientId,
+        profile.groupId ?? "",
+        machineScopes(profile.scopes).join(" "),
+    ].join("\0");
+    const digest = createHash("sha256").update(identity).digest("hex");
+    return `${profile.name}-${profile.authType === AuthType.AppServicePrincipal ? "app-sp" : "oauth-m2m"}-${digest}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_profile-config.js","sourceRoot":"","sources":["../../src/_profile-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"node:crypto\";\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { isAbsolute, resolve } from \"node:path\";\n\nimport { AuthType, TargetKind } from \"@dbx-tools/shared-auth/config\";\nimport type { DatabricksProfileSummary } from \"@dbx-tools/shared-auth/profile\";\nimport * as environmentUtils from \"@dbx-tools/shared-core/environment-utils\";\nimport * as object from \"@dbx-tools/shared-core/object\";\nimport * as stringUtils from \"@dbx-tools/shared-core/string-utils\";\nimport { trimToUndefined } from \"@dbx-tools/shared-core/string-utils\";\nimport { parse as parseIni } from \"ini\";\n\nimport { AuthError } from \"./_errors.ts\";\nimport { authLogger } from \"./_logging.ts\";\nimport type { DatabricksProfile } from \"./_types.ts\";\nimport {\n  type DatabricksAuthOptions,\n  DEFAULT_ACCESS_TOKEN_HEADER,\n  DEFAULT_CLIENT_ID,\n  DEFAULT_CONFIG_FILE,\n} from \"./config.ts\";\n\nconst logger = authLogger(\"profile-selection\");\nconst configCache = new Map<string, IniConfig | Error | undefined>();\n\nexport const SETTINGS_SECTION = \"__settings__\";\n\nexport type Environment = Readonly<Record<string, string | undefined>>;\nexport type IniConfig = Map<string, Map<string, string>>;\n\nexport interface RawProfile {\n  host?: string;\n  accountId?: string;\n  workspaceId?: string;\n  clientId?: string;\n  clientSecret?: string;\n  accessToken?: string;\n  groupId?: string;\n  scopes?: string;\n  authType?: string;\n}\n\n/** Resolve the selected Databricks configuration path. */\nexport function resolveConfigFile(\n  explicit?: string,\n  environment: Environment = process.env,\n): string {\n  const selected =\n    trimToUndefined(explicit) ??\n    trimToUndefined(environment.DATABRICKS_CONFIG_FILE) ??\n    DEFAULT_CONFIG_FILE;\n  const expanded =\n    selected === \"~\"\n      ? homedir()\n      : selected.startsWith(\"~/\")\n        ? resolve(homedir(), selected.slice(2))\n        : selected;\n  return isAbsolute(expanded) ? expanded : resolve(expanded);\n}\n\n/** Load and cache the selected Databricks configuration. */\nexport function loadConfig(\n  configFile?: string,\n  refresh = false,\n  environment: Environment = process.env,\n): IniConfig | undefined {\n  const path = resolveConfigFile(configFile, environment);\n  if (refresh) configCache.delete(path);\n  if (configCache.has(path)) {\n    const cached = configCache.get(path);\n    if (cached instanceof Error) throw cached;\n    return cached;\n  }\n  if (!existsSync(path)) {\n    configCache.set(path, undefined);\n    return undefined;\n  }\n  try {\n    const config = parseDatabricksConfig(readFileSync(path, \"utf8\"));\n    configCache.set(path, config);\n    return config;\n  } catch (cause) {\n    const error =\n      cause instanceof Error ? cause : new AuthError(\"config\", `Could not read ${path}`, { cause });\n    configCache.set(path, error);\n    throw error;\n  }\n}\n\n/** Invalidate cached configuration after an external write. */\nexport function invalidateConfigFile(configFile?: string): void {\n  configCache.delete(resolveConfigFile(configFile));\n}\n\n/** Parse Databricks INI text through the maintained `ini` package. */\nexport function parseDatabricksConfig(source: string): IniConfig {\n  let parsed: Record<string, unknown>;\n  try {\n    parsed = parseIni(source) as Record<string, unknown>;\n  } catch (cause) {\n    throw new AuthError(\"config\", \"Databricks configuration is not valid INI\", { cause });\n  }\n  const config: IniConfig = new Map();\n  for (const [name, value] of Object.entries(parsed)) {\n    if (!name.trim() || !object.isRecord(value)) {\n      throw new AuthError(\"config\", \"Databricks configuration values must belong to a profile\");\n    }\n    const section = new Map<string, string>();\n    for (const [key, entry] of Object.entries(value)) {\n      if (entry === undefined || entry === null) continue;\n      section.set(key.trim().toLowerCase(), String(entry).trim());\n    }\n    config.set(name.trim(), section);\n  }\n  return config;\n}\n\nexport function loadRawProfile(config: IniConfig | undefined, name: string): RawProfile {\n  const section = config?.get(name);\n  return {\n    host: section?.get(\"host\"),\n    accountId: section?.get(\"account_id\"),\n    workspaceId: section?.get(\"workspace_id\"),\n    clientId: section?.get(\"client_id\"),\n    clientSecret: section?.get(\"client_secret\"),\n    accessToken: section?.get(\"token\"),\n    groupId: section?.get(\"group_id\"),\n    scopes: section?.get(\"scopes\"),\n    authType: trimToUndefined(section?.get(\"auth_type\"))?.toLowerCase(),\n  };\n}\n\nexport function resolveProfileName(\n  requested: string | undefined,\n  explicit: boolean,\n  config: IniConfig | undefined,\n  preferUserToMachine: boolean,\n): string {\n  let selected = requested;\n  let source = requested ? \"requested\" : undefined;\n  if (!selected) {\n    selected = trimToUndefined(config?.get(SETTINGS_SECTION)?.get(\"default_profile\"));\n    if (selected) source = \"settings-default\";\n  }\n  if (!selected && config?.has(\"DEFAULT\")) {\n    selected = \"DEFAULT\";\n    source = \"default-section\";\n  }\n  if (!selected) {\n    const profiles = [...(config?.keys() ?? [])].filter((name) => name !== SETTINGS_SECTION);\n    if (profiles.length === 1) {\n      selected = profiles[0];\n      source = \"sole-profile\";\n    }\n  }\n  if (!selected) {\n    selected = \"DEFAULT\";\n    source = \"fallback\";\n  }\n  if (selected === SETTINGS_SECTION) {\n    throw new AuthError(\"config\", `${SETTINGS_SECTION} is reserved`);\n  }\n  if (explicit || !preferUserToMachine || !config) {\n    logger.debug(\"selected Databricks profile\", {\n      profile: selected,\n      source,\n      explicit,\n      preferUserToMachine,\n    });\n    return selected;\n  }\n  const current = loadRawProfile(config, selected);\n  if (!isM2mProfile(current) || !current.host) {\n    logger.debug(\"selected Databricks profile\", {\n      profile: selected,\n      source,\n      explicit,\n      preferUserToMachine,\n    });\n    return selected;\n  }\n  const matches = [...config.keys()].filter((name) => {\n    if (name === selected || name === SETTINGS_SECTION) return false;\n    const candidate = loadRawProfile(config, name);\n    return candidate.authType === \"databricks-cli\" && sameTarget(current, candidate);\n  });\n  const preferred = matches.length === 1 ? matches[0]! : selected;\n  logger.debug(\"selected Databricks profile\", {\n    profile: preferred,\n    source: preferred === selected ? source : \"matching-cli-profile\",\n    originalProfile: preferred === selected ? undefined : selected,\n    explicit,\n    preferUserToMachine,\n    matchingCliProfiles: matches.length,\n  });\n  return preferred;\n}\n\n/** Normalize Databricks hosts and require TLS outside loopback development. */\nexport function normalizeHost(value: string | undefined, profile = \"DEFAULT\"): string {\n  const selected = trimToUndefined(value);\n  if (!selected) throw new AuthError(\"config\", `Profile ${profile} has no host`);\n  const withScheme = /^https?:\\/\\//i.test(selected) ? selected : `https://${selected}`;\n  let url: URL;\n  try {\n    url = new URL(withScheme);\n  } catch (cause) {\n    throw new AuthError(\"config\", `Profile ${profile} has an invalid host`, { cause });\n  }\n  if (url.protocol !== \"https:\" && url.hostname !== \"localhost\" && url.hostname !== \"127.0.0.1\") {\n    throw new AuthError(\"config\", \"Databricks host must use HTTPS\");\n  }\n  return url.toString().replace(/\\/$/, \"\");\n}\n\nexport function resolveAuthType(\n  authType: AuthType | undefined,\n  clientId: string | undefined,\n  clientSecret: string | undefined,\n  accessToken: string | undefined,\n): AuthType {\n  switch (authType) {\n    case AuthType.DatabricksCli:\n      return AuthType.DatabricksCli;\n    case AuthType.OAuthM2M:\n      if (!clientId || !clientSecret) {\n        throw new AuthError(\"config\", \"oauth-m2m requires client_id and client_secret\");\n      }\n      return AuthType.OAuthM2M;\n    case AuthType.PersonalAccessToken:\n      if (!accessToken) throw new AuthError(\"config\", \"pat requires token\");\n      return AuthType.PersonalAccessToken;\n    case AuthType.AppOnBehalfOf:\n      if (!accessToken) {\n        throw new AuthError(\"config\", \"app_obo requires the configured access token header\");\n      }\n      return AuthType.AppOnBehalfOf;\n    case AuthType.AppServicePrincipal:\n      if (!clientId || !clientSecret) {\n        throw new AuthError(\"config\", \"app_sp requires client id and secret\");\n      }\n      return AuthType.AppServicePrincipal;\n    case undefined:\n      if (clientId && clientSecret) return AuthType.OAuthM2M;\n      if (clientSecret) throw new AuthError(\"config\", \"oauth-m2m client_secret requires client_id\");\n      return accessToken ? AuthType.PersonalAccessToken : AuthType.DatabricksCli;\n  }\n}\n\n/** Parse one external auth-type value into the canonical enum. */\nexport function parseAuthType(value: string | undefined): AuthType | undefined {\n  const selected = trimToUndefined(value)?.toLowerCase();\n  if (selected === undefined) return undefined;\n  if (Object.values(AuthType).includes(selected as AuthType)) return selected as AuthType;\n  throw new AuthError(\"config\", `Authentication type ${selected} is not supported`);\n}\n\nexport function requestOboToken(\n  headers?: Record<string, string>,\n  headerName = DEFAULT_ACCESS_TOKEN_HEADER,\n): string | undefined {\n  const entry = Object.entries(headers ?? {}).find(\n    ([name]) => name.toLowerCase() === headerName.toLowerCase(),\n  );\n  const value = trimToUndefined(entry?.[1]);\n  if (!value) return undefined;\n  if (headerName.toLowerCase() !== DEFAULT_ACCESS_TOKEN_HEADER) return value;\n  const [scheme, ...parts] = value.split(/\\s+/);\n  return scheme?.toLowerCase() === \"bearer\" ? trimToUndefined(parts.join(\" \")) : undefined;\n}\n\nexport function inferTarget(host: string | undefined, accountId: string | undefined): TargetKind {\n  if (accountId && host) {\n    try {\n      if (new URL(normalizeHost(host)).hostname === \"accounts.cloud.databricks.com\") {\n        return TargetKind.Account;\n      }\n    } catch {}\n  }\n  return TargetKind.Workspace;\n}\n\nexport function parseTarget(value: string): TargetKind {\n  switch (value.trim().toLowerCase()) {\n    case TargetKind.Workspace:\n      return TargetKind.Workspace;\n    case TargetKind.Account:\n      return TargetKind.Account;\n    case TargetKind.Unified:\n      return TargetKind.Unified;\n    default:\n      throw new AuthError(\"config\", \"Target must be workspace, account, or unified\");\n  }\n}\n\nexport function missing(profile: string, field: string): never {\n  throw new AuthError(\"config\", `Profile ${profile} requires ${field}`);\n}\n\nfunction sameTarget(left: RawProfile, right: RawProfile): boolean {\n  try {\n    if (normalizeHost(left.host) !== normalizeHost(right.host)) return false;\n  } catch {\n    return false;\n  }\n  return (\n    (!left.accountId || left.accountId === right.accountId) &&\n    (!left.workspaceId || left.workspaceId === right.workspaceId)\n  );\n}\n\nfunction isM2mProfile(profile: RawProfile): boolean {\n  return (\n    profile.authType === AuthType.OAuthM2M ||\n    (!profile.authType && Boolean(profile.clientId && profile.clientSecret))\n  );\n}\n\n/** Enumerate secret-free profile metadata from cached configuration. */\nexport function listDatabricksProfiles(\n  configFile?: string,\n  refresh = false,\n  environment: Environment = process.env,\n): DatabricksProfileSummary[] {\n  const path = resolveConfigFile(configFile, environment);\n  const config = loadConfig(configFile, refresh, environment);\n  if (!config) {\n    logger.debug(\"listed Databricks profiles\", { path, refresh, count: 0 });\n    return [];\n  }\n  const profiles = [...config.keys()]\n    .filter((name) => name !== SETTINGS_SECTION)\n    .map((name) => {\n      const profile = loadRawProfile(config, name);\n      const host = stringUtils.trimToUndefined(profile.host);\n      const accountId = stringUtils.trimToUndefined(profile.accountId);\n      const workspaceId = stringUtils.trimToUndefined(profile.workspaceId);\n      const authType = resolveAuthType(\n        parseAuthType(profile.authType),\n        profile.clientId,\n        profile.clientSecret,\n        profile.accessToken,\n      );\n      return {\n        name,\n        ...(host ? { host } : {}),\n        ...(accountId ? { accountId } : {}),\n        ...(workspaceId ? { workspaceId } : {}),\n        target: inferTarget(host, accountId),\n        authType,\n        principal:\n          authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal\n            ? (stringUtils.trimToUndefined(profile.clientId) ?? name)\n            : name,\n      };\n    })\n    .sort((left, right) => left.name.localeCompare(right.name));\n  logger.debug(\"listed Databricks profiles\", { path, refresh, count: profiles.length });\n  return profiles;\n}\n\n/** Resolve options, environment, request headers, and configuration into credentials. */\nexport function resolveDatabricksProfile(\n  options: DatabricksAuthOptions,\n  environment: Environment = process.env,\n): DatabricksProfile {\n  const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });\n  const environmentProfile = stringUtils.trimToUndefined(environment.DATABRICKS_CONFIG_PROFILE);\n  const explicitProfile = Boolean(\n    stringUtils.trimToUndefined(options.profile) ?? environmentProfile,\n  );\n  const requestToken = requestOboToken(options.requestHeaders, options.accessTokenHeader);\n  const explicitAuthType =\n    options.authType ??\n    (!inApp && !explicitProfile ? parseAuthType(environment.DATABRICKS_AUTH_TYPE) : undefined);\n  const appServicePrincipal = [\n    environment.DATABRICKS_HOST,\n    environment.DATABRICKS_CLIENT_ID,\n    environment.DATABRICKS_CLIENT_SECRET,\n  ].every((value) => Boolean(stringUtils.trimToUndefined(value)));\n  const selectedAuthType =\n    !inApp || explicitProfile || explicitAuthType\n      ? explicitAuthType\n      : requestToken\n        ? AuthType.AppOnBehalfOf\n        : appServicePrincipal\n          ? AuthType.AppServicePrincipal\n          : undefined;\n  const appAuth =\n    selectedAuthType === AuthType.AppOnBehalfOf ||\n    selectedAuthType === AuthType.AppServicePrincipal;\n  const ignoreAmbientCredentials = explicitProfile && !appAuth;\n  const configPath = resolveConfigFile(options.configFile, environment);\n  const config = loadConfig(options.configFile, false, environment);\n  const requestedName = stringUtils.trimToUndefined(options.profile) ?? environmentProfile;\n  const profileName = resolveProfileName(\n    requestedName,\n    explicitProfile,\n    config,\n    options.preferUserToMachine ?? true,\n  );\n  const ambientCredentials = [\n    options.accessToken,\n    options.clientId,\n    options.clientSecret,\n    environment.DATABRICKS_TOKEN,\n    environment.DATABRICKS_CLIENT_ID,\n    environment.DATABRICKS_CLIENT_SECRET,\n  ].some((value) => Boolean(stringUtils.trimToUndefined(value)));\n  const selectedProfile =\n    explicitProfile || (!ambientCredentials && config?.has(profileName)) ? profileName : undefined;\n  const configured = loadRawProfile(config, profileName);\n  const ambient = (name: keyof NodeJS.ProcessEnv): string | undefined =>\n    ignoreAmbientCredentials ? undefined : stringUtils.trimToUndefined(environment[name]);\n  const host = normalizeHost(\n    options.host ?? ambient(\"DATABRICKS_HOST\") ?? configured.host,\n    profileName,\n  );\n  const accountId =\n    stringUtils.trimToUndefined(options.accountId) ??\n    ambient(\"DATABRICKS_ACCOUNT_ID\") ??\n    stringUtils.trimToUndefined(configured.accountId);\n  const workspaceId =\n    stringUtils.trimToUndefined(options.workspaceId) ??\n    ambient(\"DATABRICKS_WORKSPACE_ID\") ??\n    stringUtils.trimToUndefined(configured.workspaceId);\n  const clientIdValue =\n    stringUtils.trimToUndefined(options.clientId) ??\n    ambient(\"DATABRICKS_CLIENT_ID\") ??\n    stringUtils.trimToUndefined(configured.clientId);\n  const clientSecret =\n    stringUtils.trimToUndefined(options.clientSecret) ??\n    ambient(\"DATABRICKS_CLIENT_SECRET\") ??\n    stringUtils.trimToUndefined(configured.clientSecret);\n  const accessToken =\n    selectedAuthType === AuthType.AppOnBehalfOf\n      ? requestToken\n      : (stringUtils.trimToUndefined(options.accessToken) ??\n        ambient(\"DATABRICKS_TOKEN\") ??\n        stringUtils.trimToUndefined(configured.accessToken));\n  const configuredAuthType =\n    selectedAuthType ??\n    parseAuthType(ambient(\"DATABRICKS_AUTH_TYPE\")) ??\n    parseAuthType(configured.authType);\n  const authType = resolveAuthType(configuredAuthType, clientIdValue, clientSecret, accessToken);\n  const clientId =\n    authType === AuthType.DatabricksCli\n      ? (clientIdValue ?? DEFAULT_CLIENT_ID)\n      : authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal\n        ? (clientIdValue ?? missing(profileName, \"client_id\"))\n        : (clientIdValue ?? \"\");\n  const scopes = options.scopes?.length\n    ? stringUtils.parseList(options.scopes)\n    : stringUtils.parseList(configured.scopes?.split(\",\") ?? [\"all-apis\"]);\n  const target = options.target ? parseTarget(options.target) : inferTarget(host, accountId);\n  const groupId =\n    stringUtils.trimToUndefined(options.groupId) ??\n    ambient(\"DATABRICKS_GROUP_ID\") ??\n    stringUtils.trimToUndefined(configured.groupId);\n  const principal =\n    authType === AuthType.OAuthM2M || authType === AuthType.AppServicePrincipal\n      ? clientId\n      : profileName;\n  const cacheKey = credentialCacheKey({\n    name: profileName,\n    host,\n    accountId,\n    workspaceId,\n    clientId,\n    groupId,\n    scopes,\n    authType,\n    accessToken,\n  });\n  logger.debug(\"resolved Databricks profile\", {\n    profile: profileName,\n    host,\n    authType,\n    target,\n    inApp,\n    explicitProfile,\n    configuredAuthType: configuredAuthType ?? \"automatic\",\n    hasAccountId: Boolean(accountId),\n    hasWorkspaceId: Boolean(workspaceId),\n    hasGroupId: Boolean(groupId),\n    scopeCount: scopes.length,\n    configPath,\n  });\n  return {\n    name: profileName,\n    ...(selectedProfile ? { selectedProfile } : {}),\n    host,\n    ...(accountId ? { accountId } : {}),\n    ...(workspaceId ? { workspaceId } : {}),\n    clientId,\n    ...(groupId ? { groupId } : {}),\n    scopes,\n    target,\n    authType,\n    ...(clientSecret ? { clientSecret } : {}),\n    ...(accessToken ? { accessToken } : {}),\n    cacheKey,\n    principal,\n  };\n}\n\n/** Normalize OAuth scopes for machine credentials. */\nexport function machineScopes(scopes: readonly string[]): string[] {\n  return stringUtils.parseList(scopes.length ? scopes : [\"all-apis\"]).sort();\n}\n\nfunction credentialCacheKey(\n  profile: Pick<\n    DatabricksProfile,\n    | \"name\"\n    | \"host\"\n    | \"accountId\"\n    | \"workspaceId\"\n    | \"clientId\"\n    | \"groupId\"\n    | \"scopes\"\n    | \"authType\"\n    | \"accessToken\"\n  >,\n): string {\n  if (profile.authType === AuthType.DatabricksCli) return profile.name;\n  if (profile.authType === AuthType.PersonalAccessToken) {\n    const digest = createHash(\"sha256\")\n      .update(profile.accessToken ?? \"\")\n      .digest(\"hex\");\n    return `${profile.name}-pat-${digest}`;\n  }\n  if (profile.authType === AuthType.AppOnBehalfOf) return `${profile.name}-app-obo`;\n  const identity = [\n    profile.host,\n    profile.accountId ?? \"\",\n    profile.workspaceId ?? \"\",\n    profile.clientId,\n    profile.groupId ?? \"\",\n    machineScopes(profile.scopes).join(\" \"),\n  ].join(\"\\0\");\n  const digest = createHash(\"sha256\").update(identity).digest(\"hex\");\n  return `${profile.name}-${profile.authType === AuthType.AppServicePrincipal ? \"app-sp\" : \"oauth-m2m\"}-${digest}`;\n}\n"]}

package/lib/src/{service-principal.d.ts → _service-principal.d.ts}

@@ -1,4 +1,4 @@
-import type { Token, TokenProvider } from "./types.ts";
+import type { Token, TokenProvider } from "./_types.ts";
 /** Client-credentials inputs and transport options for Databricks OAuth. */
 export interface DatabricksServicePrincipalConfig {
     tokenEndpoint: string;

package/lib/src/_service-principal.js

@@ -0,0 +1,69 @@
+import * as oauth from "oauth4webapi";
+import { AuthError } from "./_errors.js";
+import { authLogger, failureMetadata, tokenMetadata } from "./_logging.js";
+const logger = authLogger("service-principal");
+/** Databricks service-principal provider backed by client credentials. */
+export class DatabricksServicePrincipalProvider {
+    config;
+    authorizationServer;
+    client;
+    requestOptions;
+    constructor(config) {
+        this.config = config;
+        this.authorizationServer = {
+            issuer: new URL(config.tokenEndpoint).origin,
+            token_endpoint: config.tokenEndpoint,
+        };
+        this.client = { client_id: config.clientId };
+        this.requestOptions = {
+            ...(config.fetch ? { [oauth.customFetch]: config.fetch } : {}),
+            ...(config.allowInsecureRequests ? { [oauth.allowInsecureRequests]: true } : {}),
+        };
+    }
+    authenticate() {
+        return this.acquire();
+    }
+    login() {
+        return this.acquire();
+    }
+    refresh() {
+        return this.acquire();
+    }
+    canAuthenticateSilently() {
+        return true;
+    }
+    async acquire() {
+        logger.debug("requesting service-principal token", {
+            tokenOrigin: new URL(this.config.tokenEndpoint).origin,
+            scopeCount: this.config.scopes.length,
+            hasGroupId: Boolean(this.config.groupId),
+            allowInsecureRequests: Boolean(this.config.allowInsecureRequests),
+        });
+        try {
+            const response = await oauth.clientCredentialsGrantRequest(this.authorizationServer, this.client, oauth.ClientSecretBasic(this.config.clientSecret), {
+                scope: [...new Set(this.config.scopes)].sort().join(" "),
+                ...(this.config.groupId ? { assume_group: this.config.groupId } : {}),
+            }, this.requestOptions);
+            const value = await oauth.processClientCredentialsResponse(this.authorizationServer, this.client, response);
+            const token = {
+                accessToken: value.access_token,
+                tokenType: value.token_type.toLowerCase() === "bearer" ? "Bearer" : value.token_type,
+                ...(value.expires_in !== undefined
+                    ? { expiry: new Date(Date.now() + value.expires_in * 1000).toISOString() }
+                    : {}),
+                scopes: value.scope?.split(/\s+/).filter(Boolean) ?? [...this.config.scopes],
+            };
+            logger.debug("received service-principal token", { token: tokenMetadata(token) });
+            return token;
+        }
+        catch (cause) {
+            logger.debug("service-principal token request failed", {
+                error: failureMetadata(cause),
+            });
+            throw new AuthError("oauth", "Databricks service-principal authentication failed", {
+                cause,
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_service-principal.js","sourceRoot":"","sources":["../../src/_service-principal.ts"],"names":[],"mappings":"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","sourcesContent":["import * as oauth from \"oauth4webapi\";\n\nimport { AuthError } from \"./_errors.ts\";\nimport { authLogger, failureMetadata, tokenMetadata } from \"./_logging.ts\";\nimport type { Token, TokenProvider } from \"./_types.ts\";\n\nconst logger = authLogger(\"service-principal\");\n\n/** Client-credentials inputs and transport options for Databricks OAuth. */\nexport interface DatabricksServicePrincipalConfig {\n  tokenEndpoint: string;\n  clientId: string;\n  clientSecret: string;\n  scopes: string[];\n  groupId?: string;\n  fetch?: typeof globalThis.fetch;\n  allowInsecureRequests?: boolean;\n}\n\n/** Databricks service-principal provider backed by client credentials. */\nexport class DatabricksServicePrincipalProvider implements TokenProvider {\n  private readonly authorizationServer: oauth.AuthorizationServer;\n  private readonly client: oauth.Client;\n  private readonly requestOptions: oauth.HttpRequestOptions<string, URLSearchParams>;\n\n  constructor(private readonly config: DatabricksServicePrincipalConfig) {\n    this.authorizationServer = {\n      issuer: new URL(config.tokenEndpoint).origin,\n      token_endpoint: config.tokenEndpoint,\n    };\n    this.client = { client_id: config.clientId };\n    this.requestOptions = {\n      ...(config.fetch ? { [oauth.customFetch]: config.fetch as typeof globalThis.fetch } : {}),\n      ...(config.allowInsecureRequests ? { [oauth.allowInsecureRequests]: true } : {}),\n    };\n  }\n\n  authenticate(): Promise<Token> {\n    return this.acquire();\n  }\n\n  login(): Promise<Token> {\n    return this.acquire();\n  }\n\n  refresh(): Promise<Token> {\n    return this.acquire();\n  }\n\n  canAuthenticateSilently(): boolean {\n    return true;\n  }\n\n  private async acquire(): Promise<Token> {\n    logger.debug(\"requesting service-principal token\", {\n      tokenOrigin: new URL(this.config.tokenEndpoint).origin,\n      scopeCount: this.config.scopes.length,\n      hasGroupId: Boolean(this.config.groupId),\n      allowInsecureRequests: Boolean(this.config.allowInsecureRequests),\n    });\n    try {\n      const response = await oauth.clientCredentialsGrantRequest(\n        this.authorizationServer,\n        this.client,\n        oauth.ClientSecretBasic(this.config.clientSecret),\n        {\n          scope: [...new Set(this.config.scopes)].sort().join(\" \"),\n          ...(this.config.groupId ? { assume_group: this.config.groupId } : {}),\n        },\n        this.requestOptions,\n      );\n      const value = await oauth.processClientCredentialsResponse(\n        this.authorizationServer,\n        this.client,\n        response,\n      );\n      const token = {\n        accessToken: value.access_token,\n        tokenType: value.token_type.toLowerCase() === \"bearer\" ? \"Bearer\" : value.token_type,\n        ...(value.expires_in !== undefined\n          ? { expiry: new Date(Date.now() + value.expires_in * 1000).toISOString() }\n          : {}),\n        scopes: value.scope?.split(/\\s+/).filter(Boolean) ?? [...this.config.scopes],\n      };\n      logger.debug(\"received service-principal token\", { token: tokenMetadata(token) });\n      return token;\n    } catch (cause) {\n      logger.debug(\"service-principal token request failed\", {\n        error: failureMetadata(cause),\n      });\n      throw new AuthError(\"oauth\", \"Databricks service-principal authentication failed\", {\n        cause,\n      });\n    }\n  }\n}\n"]}