@dbx-tools/auth 0.6.180 → 0.9.28

package/lib/src/_logging.d.ts

@@ -0,0 +1,10 @@
+import * as log from "@dbx-tools/shared-core/log";
+import type { Token } from "./types.ts";
+/** Auth logger with a stable capability-specific tag. */
+export declare function authLogger(scope: string): log.Logger;
+/** Stable non-secret identifier for a credential cache key. */
+export declare function credentialId(key: string): string;
+/** Secret-free token lifecycle metadata for debug output. */
+export declare function tokenMetadata(token: Token | undefined, now?: Date): Record<string, unknown>;
+/** Failure classification without serializing error messages or causes. */
+export declare function failureMetadata(cause: unknown): Record<string, unknown>;

package/lib/src/_logging.js

@@ -0,0 +1,38 @@
+import * as hash from "@dbx-tools/shared-core/hash";
+import * as log from "@dbx-tools/shared-core/log";
+import { AuthError } from "./errors.js";
+/** Auth logger with a stable capability-specific tag. */
+export function authLogger(scope) {
+    return log.logger(`auth:${scope}`);
+}
+/** Stable non-secret identifier for a credential cache key. */
+export function credentialId(key) {
+    return hash.fnvHash(key);
+}
+/** Secret-free token lifecycle metadata for debug output. */
+export function tokenMetadata(token, now = new Date()) {
+    if (!token)
+        return { present: false };
+    const expiryMs = token.expiry ? Date.parse(token.expiry) : undefined;
+    return {
+        present: true,
+        tokenType: token.tokenType,
+        scopeCount: token.scopes.length,
+        hasRefreshToken: Boolean(token.refreshToken),
+        hasExpiry: Boolean(token.expiry),
+        ...(expiryMs !== undefined && Number.isFinite(expiryMs)
+            ? {
+                expired: expiryMs <= now.getTime(),
+                expiresInSeconds: Math.round((expiryMs - now.getTime()) / 1000),
+            }
+            : {}),
+    };
+}
+/** Failure classification without serializing error messages or causes. */
+export function failureMetadata(cause) {
+    return {
+        name: cause instanceof Error ? cause.name : typeof cause,
+        ...(cause instanceof AuthError ? { kind: cause.kind } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_profile-core.d.ts

@@ -0,0 +1,28 @@
+import { AuthKind, TargetKind } from "./types.ts";
+export declare const SETTINGS_SECTION = "__settings__";
+export type Environment = Readonly<Record<string, string | undefined>>;
+export type IniConfig = Map<string, Map<string, string>>;
+export interface RawProfile {
+    host?: string;
+    accountId?: string;
+    workspaceId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+    groupId?: string;
+    scopes?: string;
+    authType?: string;
+}
+/** Parse Databricks INI text through the maintained `ini` package. */
+export declare function parseDatabricksConfig(source: string): IniConfig;
+export declare function loadRawProfile(config: IniConfig | undefined, name: string): RawProfile;
+export declare function resolveProfileName(requested: string | undefined, explicit: boolean, config: IniConfig | undefined, preferUserToMachine: boolean): string;
+/** Normalize Databricks hosts and require TLS outside loopback development. */
+export declare function normalizeHost(value: string | undefined, profile?: string): string;
+export declare function resolveAuthKind(authType: string | undefined, clientId: string | undefined, clientSecret: string | undefined, accessToken: string | undefined): AuthKind;
+export declare function requestOboToken(headers?: Record<string, string>, headerName?: string): string | undefined;
+export declare function inferTarget(host: string | undefined, accountId: string | undefined): TargetKind;
+export declare function parseTarget(value: string): TargetKind;
+export declare function cleanList(values: readonly string[]): string[];
+export declare function nonempty(value: string | undefined): string | undefined;
+export declare function missing(profile: string, field: string): never;

package/lib/src/_profile-core.js

@@ -0,0 +1,216 @@
+import { parse as parseIni } from "ini";
+import { authLogger } from "./_logging.js";
+import { AuthError } from "./errors.js";
+import { AUTH_TYPE_APP_OBO, AUTH_TYPE_APP_SP, AuthKind, DEFAULT_ACCESS_TOKEN_HEADER, TargetKind, } from "./types.js";
+const logger = authLogger("profile-selection");
+export const SETTINGS_SECTION = "__settings__";
+/** 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() || !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: nonempty(section?.get("auth_type"))?.toLowerCase(),
+    };
+}
+export function resolveProfileName(requested, explicit, config, preferUserToMachine) {
+    let selected = requested;
+    let source = requested ? "requested" : undefined;
+    if (!selected) {
+        selected = nonempty(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 = nonempty(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 resolveAuthKind(authType, clientId, clientSecret, accessToken) {
+    switch (authType) {
+        case "databricks-cli":
+        case "oauth-u2m":
+            return AuthKind.UserToMachine;
+        case "oauth-m2m":
+            if (!clientId || !clientSecret)
+                throw new AuthError("config", "oauth-m2m requires client_id and client_secret");
+            return AuthKind.MachineToMachine;
+        case "pat":
+            if (!accessToken)
+                throw new AuthError("config", "pat requires token");
+            return AuthKind.PersonalAccessToken;
+        case AUTH_TYPE_APP_OBO:
+        case "app-obo":
+            if (!accessToken)
+                throw new AuthError("config", "app_obo requires the configured access token header");
+            return AuthKind.AppOnBehalfOf;
+        case AUTH_TYPE_APP_SP:
+        case "app-sp":
+            if (!clientId || !clientSecret)
+                throw new AuthError("config", "app_sp requires client id and secret");
+            return AuthKind.AppServicePrincipal;
+        case undefined:
+            if (clientId && clientSecret)
+                return AuthKind.MachineToMachine;
+            if (clientSecret)
+                throw new AuthError("config", "oauth-m2m client_secret requires client_id");
+            return accessToken ? AuthKind.PersonalAccessToken : AuthKind.UserToMachine;
+        default:
+            throw new AuthError("config", `Authentication type ${authType} 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 = nonempty(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" ? nonempty(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 cleanList(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+export function nonempty(value) {
+    const selected = value?.trim();
+    return selected ? selected : undefined;
+}
+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 === "oauth-m2m" ||
+        (!profile.authType && Boolean(profile.clientId && profile.clientSecret)));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_profile-core.js","sourceRoot":"","sources":["../../src/_profile-core.ts"],"names":[],"mappings":"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","sourcesContent":["import { parse as parseIni } from \"ini\";\n\nimport { authLogger } from \"./_logging.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport {\n  AUTH_TYPE_APP_OBO,\n  AUTH_TYPE_APP_SP,\n  AuthKind,\n  DEFAULT_ACCESS_TOKEN_HEADER,\n  TargetKind,\n} from \"./types.ts\";\n\nconst logger = authLogger(\"profile-selection\");\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/** 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() || !isRecord(value))\n      throw new AuthError(\"config\", \"Databricks configuration values must belong to a profile\");\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: nonempty(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 = nonempty(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  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 = nonempty(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 resolveAuthKind(\n  authType: string | undefined,\n  clientId: string | undefined,\n  clientSecret: string | undefined,\n  accessToken: string | undefined,\n): AuthKind {\n  switch (authType) {\n    case \"databricks-cli\":\n    case \"oauth-u2m\":\n      return AuthKind.UserToMachine;\n    case \"oauth-m2m\":\n      if (!clientId || !clientSecret)\n        throw new AuthError(\"config\", \"oauth-m2m requires client_id and client_secret\");\n      return AuthKind.MachineToMachine;\n    case \"pat\":\n      if (!accessToken) throw new AuthError(\"config\", \"pat requires token\");\n      return AuthKind.PersonalAccessToken;\n    case AUTH_TYPE_APP_OBO:\n    case \"app-obo\":\n      if (!accessToken)\n        throw new AuthError(\"config\", \"app_obo requires the configured access token header\");\n      return AuthKind.AppOnBehalfOf;\n    case AUTH_TYPE_APP_SP:\n    case \"app-sp\":\n      if (!clientId || !clientSecret)\n        throw new AuthError(\"config\", \"app_sp requires client id and secret\");\n      return AuthKind.AppServicePrincipal;\n    case undefined:\n      if (clientId && clientSecret) return AuthKind.MachineToMachine;\n      if (clientSecret) throw new AuthError(\"config\", \"oauth-m2m client_secret requires client_id\");\n      return accessToken ? AuthKind.PersonalAccessToken : AuthKind.UserToMachine;\n    default:\n      throw new AuthError(\"config\", `Authentication type ${authType} is not supported`);\n  }\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 = nonempty(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\" ? nonempty(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    } 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 cleanList(values: readonly string[]): string[] {\n  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];\n}\n\nexport function nonempty(value: string | undefined): string | undefined {\n  const selected = value?.trim();\n  return selected ? selected : undefined;\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 === \"oauth-m2m\" ||\n    (!profile.authType && Boolean(profile.clientId && profile.clientSecret))\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return Boolean(value) && typeof value === \"object\" && !Array.isArray(value);\n}\n"]}

package/lib/src/_profile.d.ts

@@ -0,0 +1,15 @@
+import { type Environment } from "./_profile-core.ts";
+import { type DatabricksAuthOptions, type DatabricksProfile, type DatabricksProfileSummary } from "./types.ts";
+export { normalizeHost, parseDatabricksConfig } from "./_profile-core.ts";
+/** Expand and resolve the selected Databricks CLI configuration path. */
+export declare function resolveConfigFile(explicit?: string, environment?: Environment): string;
+/** Invalidate the process-wide parsed configuration cache after an external write. */
+export declare function invalidateConfigFile(configFile?: string): void;
+/** Return whether a named profile exists in the selected configuration. */
+export declare function configProfileExists(profile: string, configFile?: string): boolean;
+/** Enumerate secret-free profile metadata from the cached CLI configuration. */
+export declare function listDatabricksProfiles(configFile?: string, refresh?: boolean, environment?: Environment): DatabricksProfileSummary[];
+/** Resolve options, environment, request headers, and CLI configuration into one profile. */
+export declare function resolveDatabricksProfile(options: DatabricksAuthOptions, environment?: Environment): DatabricksProfile;
+export declare function effectiveScopes(scopes: readonly string[]): string[];
+export declare function machineScopes(scopes: readonly string[]): string[];