@dbx-tools/auth 0.9.31 → 0.9.36

package/lib/src/{storage.d.ts → _storage.d.ts}

@@ -1,8 +1,8 @@
-import type { CredentialStore, LockAdapter, Token } from "./types.ts";
-/** Process-local generic lease registry used by the in-memory store. */
+import type { CredentialStore, LockAdapter, Token } from "./_types.ts";
+/** Process-local keyed credential lock. */
 export declare class MemoryLockAdapter implements LockAdapter {
     #private;
-    acquire(key: string, timeoutMs: number): Promise<string>;
+    acquire(key: string, timeoutMs?: number): Promise<string>;
     release(lease: string): Promise<void>;
 }
 /** Process-local credential store with per-key refresh locks. */
@@ -11,10 +11,8 @@ export declare class MemoryCredentialStore implements CredentialStore {
     private readonly locks;
     constructor(locks?: LockAdapter);
     load(key: string): Promise<Token | undefined>;
-    prepareWrite(): Promise<void>;
     save(key: string, token: Token): Promise<void>;
     remove(key: string): Promise<void>;
-    acquireLock(key: string, timeoutMs: number): Promise<string>;
+    acquireLock(key: string, timeoutMs?: number): Promise<string>;
     releaseLock(lease: string): Promise<void>;
-    name(): string;
 }

package/lib/src/_storage.js

@@ -0,0 +1,94 @@
+import { authLogger, credentialId, tokenMetadata } from "./_logging.js";
+const logger = authLogger("memory-storage");
+/** Process-local keyed credential lock. */
+export class MemoryLockAdapter {
+    #states = new Map();
+    #sequence = 0;
+    acquire(key, timeoutMs) {
+        const credential = credentialId(key);
+        const state = this.#states.get(key);
+        if (!state) {
+            const lease = this.#nextLease(key);
+            this.#states.set(key, { lease, queue: [] });
+            logger.debug("memory lock acquired", { credential });
+            return Promise.resolve(lease);
+        }
+        logger.debug("waiting for memory lock", { credential, timeoutMs });
+        return new Promise((resolve, reject) => {
+            let timer;
+            const waiter = {
+                resolve: (lease) => {
+                    if (timer)
+                        clearTimeout(timer);
+                    logger.debug("memory lock acquired", { credential });
+                    resolve(lease);
+                },
+                reject: (error) => {
+                    if (timer)
+                        clearTimeout(timer);
+                    reject(error);
+                },
+            };
+            state.queue.push(waiter);
+            if (timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    const index = state.queue.indexOf(waiter);
+                    if (index >= 0)
+                        state.queue.splice(index, 1);
+                    waiter.reject(new Error(`Timed out waiting for lock ${key}`));
+                }, timeoutMs);
+            }
+        });
+    }
+    release(lease) {
+        const key = lease.split(":").slice(1).join(":");
+        const state = this.#states.get(key);
+        if (!state || state.lease !== lease)
+            return Promise.resolve();
+        const next = state.queue.shift();
+        if (!next) {
+            this.#states.delete(key);
+            return Promise.resolve();
+        }
+        state.lease = this.#nextLease(key);
+        next.resolve(state.lease);
+        return Promise.resolve();
+    }
+    #nextLease(key) {
+        return `${++this.#sequence}:${key}`;
+    }
+}
+/** Process-local credential store with per-key refresh locks. */
+export class MemoryCredentialStore {
+    locks;
+    #tokens = new Map();
+    constructor(locks = new MemoryLockAdapter()) {
+        this.locks = locks;
+    }
+    async load(key) {
+        const token = this.#tokens.get(key);
+        logger.debug("loaded memory credential", {
+            credential: credentialId(key),
+            token: tokenMetadata(token),
+        });
+        return token ? structuredClone(token) : undefined;
+    }
+    async save(key, token) {
+        this.#tokens.set(key, structuredClone(token));
+        logger.debug("saved memory credential", {
+            credential: credentialId(key),
+            token: tokenMetadata(token),
+        });
+    }
+    async remove(key) {
+        this.#tokens.delete(key);
+        logger.debug("removed memory credential", { credential: credentialId(key) });
+    }
+    acquireLock(key, timeoutMs) {
+        return this.locks.acquire(key, timeoutMs);
+    }
+    releaseLock(lease) {
+        return this.locks.release(lease);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_storage.js","sourceRoot":"","sources":["../../src/_storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { authLogger, credentialId, tokenMetadata } from \"./_logging.ts\";\nimport type { CredentialStore, LockAdapter, Token } from \"./_types.ts\";\n\nconst logger = authLogger(\"memory-storage\");\n\ninterface MemoryLockWaiter {\n  resolve: (lease: string) => void;\n  reject: (error: unknown) => void;\n}\n\ninterface MemoryLockState {\n  lease: string;\n  queue: MemoryLockWaiter[];\n}\n\n/** Process-local keyed credential lock. */\nexport class MemoryLockAdapter implements LockAdapter {\n  readonly #states = new Map<string, MemoryLockState>();\n  #sequence = 0;\n\n  acquire(key: string, timeoutMs?: number): Promise<string> {\n    const credential = credentialId(key);\n    const state = this.#states.get(key);\n    if (!state) {\n      const lease = this.#nextLease(key);\n      this.#states.set(key, { lease, queue: [] });\n      logger.debug(\"memory lock acquired\", { credential });\n      return Promise.resolve(lease);\n    }\n    logger.debug(\"waiting for memory lock\", { credential, timeoutMs });\n    return new Promise<string>((resolve, reject) => {\n      let timer: ReturnType<typeof setTimeout> | undefined;\n      const waiter: MemoryLockWaiter = {\n        resolve: (lease) => {\n          if (timer) clearTimeout(timer);\n          logger.debug(\"memory lock acquired\", { credential });\n          resolve(lease);\n        },\n        reject: (error) => {\n          if (timer) clearTimeout(timer);\n          reject(error);\n        },\n      };\n      state.queue.push(waiter);\n      if (timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs > 0) {\n        timer = setTimeout(() => {\n          const index = state.queue.indexOf(waiter);\n          if (index >= 0) state.queue.splice(index, 1);\n          waiter.reject(new Error(`Timed out waiting for lock ${key}`));\n        }, timeoutMs);\n      }\n    });\n  }\n\n  release(lease: string): Promise<void> {\n    const key = lease.split(\":\").slice(1).join(\":\");\n    const state = this.#states.get(key);\n    if (!state || state.lease !== lease) return Promise.resolve();\n    const next = state.queue.shift();\n    if (!next) {\n      this.#states.delete(key);\n      return Promise.resolve();\n    }\n    state.lease = this.#nextLease(key);\n    next.resolve(state.lease);\n    return Promise.resolve();\n  }\n\n  #nextLease(key: string): string {\n    return `${++this.#sequence}:${key}`;\n  }\n}\n\n/** Process-local credential store with per-key refresh locks. */\nexport class MemoryCredentialStore implements CredentialStore {\n  readonly #tokens = new Map<string, Token>();\n\n  constructor(private readonly locks: LockAdapter = new MemoryLockAdapter()) {}\n\n  async load(key: string): Promise<Token | undefined> {\n    const token = this.#tokens.get(key);\n    logger.debug(\"loaded memory credential\", {\n      credential: credentialId(key),\n      token: tokenMetadata(token),\n    });\n    return token ? structuredClone(token) : undefined;\n  }\n\n  async save(key: string, token: Token): Promise<void> {\n    this.#tokens.set(key, structuredClone(token));\n    logger.debug(\"saved memory credential\", {\n      credential: credentialId(key),\n      token: tokenMetadata(token),\n    });\n  }\n\n  async remove(key: string): Promise<void> {\n    this.#tokens.delete(key);\n    logger.debug(\"removed memory credential\", { credential: credentialId(key) });\n  }\n\n  acquireLock(key: string, timeoutMs?: number): Promise<string> {\n    return this.locks.acquire(key, timeoutMs);\n  }\n\n  releaseLock(lease: string): Promise<void> {\n    return this.locks.release(lease);\n  }\n}\n"]}

package/lib/src/_types.d.ts

@@ -0,0 +1,40 @@
+import type { DatabricksProfileSummary } from "@dbx-tools/shared-auth/profile";
+/** Stored OAuth credential with renewal metadata. */
+export interface Token {
+    accessToken: string;
+    tokenType: string;
+    refreshToken?: string;
+    expiry?: string;
+    scopes: string[];
+}
+/** Resolved profile with secrets retained for provider construction. */
+export interface DatabricksProfile extends DatabricksProfileSummary {
+    host: string;
+    selectedProfile?: string;
+    clientId: string;
+    groupId?: string;
+    scopes: string[];
+    clientSecret?: string;
+    accessToken?: string;
+    cacheKey: string;
+}
+/** Process-local credential lease adapter. */
+export interface LockAdapter {
+    acquire(key: string, timeoutMs?: number): Promise<string>;
+    release(lease: string): Promise<void>;
+}
+/** Internal credential lifecycle storage. */
+export interface CredentialStore {
+    load(key: string): Promise<Token | undefined>;
+    save(key: string, token: Token): Promise<void>;
+    remove(key: string): Promise<void>;
+    acquireLock(key: string, timeoutMs?: number): Promise<string>;
+    releaseLock(lease: string): Promise<void>;
+}
+/** Provider-specific token acquisition. */
+export interface TokenProvider {
+    authenticate(timeoutMs: number): Promise<Token>;
+    login(timeoutMs: number): Promise<Token>;
+    refresh(token: Token): Promise<Token>;
+    canAuthenticateSilently(): boolean;
+}

package/lib/src/_types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/client.d.ts

@@ -0,0 +1,30 @@
+import type { DatabricksAuthClientInfo } from "@dbx-tools/shared-auth/client";
+import { type DatabricksAuthOptions } from "./config.ts";
+/** Public credential result with no refresh token. */
+export interface AccessToken {
+    accessToken: string;
+    tokenType: string;
+    expiry?: string;
+    scopes: string[];
+}
+/** Token acquisition controls. */
+export interface TokenOptions {
+    /** Permit interactive CLI login when required. */
+    login?: boolean;
+    /** Bypass a reusable cached token and refresh it. */
+    refresh?: boolean;
+}
+/** WorkspaceClient-shaped Databricks authentication facade. */
+export interface AuthClient extends DatabricksAuthClientInfo {
+    token(options?: TokenOptions): Promise<AccessToken>;
+    headers(options?: TokenOptions): Promise<Record<string, string>>;
+    logout(): Promise<void>;
+}
+/** Injectable host capabilities for Databricks authentication. */
+export interface DatabricksAuthDependencies {
+    environment?: Readonly<Record<string, string | undefined>>;
+    fetch?: typeof globalThis.fetch;
+    resolveCli?: () => Promise<string | undefined>;
+}
+/** Create a Databricks authentication client. */
+export declare function createAuthClient(options?: DatabricksAuthOptions, dependencies?: DatabricksAuthDependencies): Promise<AuthClient>;

package/lib/src/client.js

@@ -0,0 +1,223 @@
+import { AuthType, TargetKind } from "@dbx-tools/shared-auth/config";
+import { DatabricksCliProvider, resolveDatabricksCli } from "./_databricks-cli.js";
+import { AuthError } from "./_errors.js";
+import { publicToken, TokenLifecycle } from "./_lifecycle.js";
+import { authLogger, tokenMetadata } from "./_logging.js";
+import { DatabricksPersonalAccessTokenProvider } from "./_personal-access-token.js";
+import { machineScopes, resolveConfigFile, resolveDatabricksProfile } from "./_profile-config.js";
+import { DatabricksServicePrincipalProvider } from "./_service-principal.js";
+import { MemoryCredentialStore } from "./_storage.js";
+import { AUTH_DEFAULTS, DEFAULT_ACCESS_TOKEN_HEADER, WORKSPACE_ID_HEADER, } from "./config.js";
+const logger = authLogger("databricks");
+/** Default Databricks auth facade over the provider-neutral lifecycle. */
+class DefaultAuthClient {
+    profileValue;
+    client;
+    requestToken;
+    profile;
+    host;
+    accountId;
+    workspaceId;
+    target;
+    authType;
+    principal;
+    constructor(profileValue, client, requestToken) {
+        this.profileValue = profileValue;
+        this.client = client;
+        this.requestToken = requestToken;
+        this.profile = profileValue.selectedProfile;
+        this.host = profileValue.host;
+        this.accountId = profileValue.accountId;
+        this.workspaceId = profileValue.workspaceId;
+        this.target = profileValue.target;
+        this.authType = profileValue.authType;
+        this.principal = profileValue.principal;
+    }
+    token(options = {}) {
+        logger.debug("Databricks token requested", {
+            ...this.context(),
+            login: options.login ?? "auto",
+            refresh: options.refresh ?? false,
+            source: this.requestToken ? "request" : "lifecycle",
+        });
+        if (this.requestToken)
+            return Promise.resolve(publicToken(this.requestToken));
+        return options.refresh
+            ? this.requiredClient().forceRefresh(options.login ?? true)
+            : this.requiredClient().tokenWithLogin(options.login);
+    }
+    async headers(options = {}) {
+        const token = await this.token(options);
+        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;
+    }
+    logout() {
+        logger.debug("Databricks logout requested", this.context());
+        return this.client?.logout() ?? Promise.resolve();
+    }
+    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,
+            authType: this.profileValue.authType,
+            hasWorkspaceId: Boolean(this.profileValue.workspaceId),
+        };
+    }
+}
+/** Create a Databricks authentication client. */
+export async function createAuthClient(options = {}, dependencies = {}) {
+    return createResolvedAuth(options, dependencies);
+}
+/** Resolve a Databricks profile and create its token lifecycle. */
+async function createResolvedAuth(options, dependencies) {
+    const environment = dependencies.environment ?? process.env;
+    const profile = resolveDatabricksProfile(options, environment);
+    logger.debug("creating Databricks auth", {
+        profile: profile.name,
+        host: profile.host,
+        authType: profile.authType,
+    });
+    if (profile.authType === AuthType.AppOnBehalfOf) {
+        logger.debug("created request-scoped App OBO authentication", {
+            profile: profile.name,
+            host: profile.host,
+            hasWorkspaceId: Boolean(profile.workspaceId),
+        });
+        return new DefaultAuthClient(profile, undefined, {
+            accessToken: profile.accessToken,
+            tokenType: "Bearer",
+            scopes: [...profile.scopes],
+        });
+    }
+    const provider = await providerFor(profile, options, dependencies);
+    const store = new MemoryCredentialStore();
+    const client = new TokenLifecycle(profile.cacheKey, provider, store, {
+        ...AUTH_DEFAULTS,
+        ...options.auth,
+    });
+    const auth = new DefaultAuthClient(profile, client);
+    logger.debug("created authentication lifecycle", {
+        profile: profile.name,
+        host: profile.host,
+        authType: profile.authType,
+    });
+    return auth;
+}
+async function providerFor(profile, options, dependencies) {
+    const environment = dependencies.environment ?? process.env;
+    switch (profile.authType) {
+        case AuthType.DatabricksCli: {
+            logger.debug("selected Databricks CLI provider", { profile: profile.name });
+            return new DatabricksCliProvider(profile.name, () => dependencies.resolveCli ? dependencies.resolveCli() : resolveDatabricksCli(environment), cliEnvironment(profile, resolveConfigFile(options.configFile, environment)));
+        }
+        case AuthType.PersonalAccessToken:
+            logger.debug("selected personal access token provider", { profile: profile.name });
+            return new DatabricksPersonalAccessTokenProvider(profile.accessToken);
+        case AuthType.OAuthM2M:
+        case AuthType.AppServicePrincipal: {
+            logger.debug("selected service-principal provider", {
+                profile: profile.name,
+                authType: profile.authType,
+                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 AuthType.AppOnBehalfOf:
+            throw new AuthError("config", "App OBO tokens do not use a token 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 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.authType === AuthType.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":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DatabricksAuthClientInfo } from \"@dbx-tools/shared-auth/client\";\nimport { AuthType, TargetKind } from \"@dbx-tools/shared-auth/config\";\nimport { DatabricksCliProvider, resolveDatabricksCli } from \"./_databricks-cli.ts\";\nimport { AuthError } from \"./_errors.ts\";\nimport { publicToken, TokenLifecycle } from \"./_lifecycle.ts\";\nimport { authLogger, tokenMetadata } from \"./_logging.ts\";\nimport { DatabricksPersonalAccessTokenProvider } from \"./_personal-access-token.ts\";\nimport { machineScopes, resolveConfigFile, resolveDatabricksProfile } from \"./_profile-config.ts\";\nimport { DatabricksServicePrincipalProvider } from \"./_service-principal.ts\";\nimport { MemoryCredentialStore } from \"./_storage.ts\";\nimport { type DatabricksProfile, type Token, type TokenProvider } from \"./_types.ts\";\nimport {\n  AUTH_DEFAULTS,\n  type DatabricksAuthOptions,\n  DEFAULT_ACCESS_TOKEN_HEADER,\n  WORKSPACE_ID_HEADER,\n} from \"./config.ts\";\n\nconst logger = authLogger(\"databricks\");\n\n/** Public credential result with no refresh token. */\nexport interface AccessToken {\n  accessToken: string;\n  tokenType: string;\n  expiry?: string;\n  scopes: string[];\n}\n\n/** Token acquisition controls. */\nexport interface TokenOptions {\n  /** Permit interactive CLI login when required. */\n  login?: boolean;\n  /** Bypass a reusable cached token and refresh it. */\n  refresh?: boolean;\n}\n\n/** WorkspaceClient-shaped Databricks authentication facade. */\nexport interface AuthClient extends DatabricksAuthClientInfo {\n  token(options?: TokenOptions): Promise<AccessToken>;\n  headers(options?: TokenOptions): Promise<Record<string, string>>;\n  logout(): Promise<void>;\n}\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?: () => Promise<string | undefined>;\n}\n\n/** Default Databricks auth facade over the provider-neutral lifecycle. */\nclass DefaultAuthClient implements AuthClient {\n  readonly profile?: string;\n  readonly host: string;\n  readonly accountId?: string;\n  readonly workspaceId?: string;\n  readonly target: TargetKind;\n  readonly authType: AuthType;\n  readonly principal: string;\n\n  constructor(\n    private readonly profileValue: DatabricksProfile,\n    private readonly client?: TokenLifecycle,\n    private readonly requestToken?: Token,\n  ) {\n    this.profile = profileValue.selectedProfile;\n    this.host = profileValue.host;\n    this.accountId = profileValue.accountId;\n    this.workspaceId = profileValue.workspaceId;\n    this.target = profileValue.target;\n    this.authType = profileValue.authType;\n    this.principal = profileValue.principal;\n  }\n\n  token(options: TokenOptions = {}) {\n    logger.debug(\"Databricks token requested\", {\n      ...this.context(),\n      login: options.login ?? \"auto\",\n      refresh: options.refresh ?? false,\n      source: this.requestToken ? \"request\" : \"lifecycle\",\n    });\n    if (this.requestToken) return Promise.resolve(publicToken(this.requestToken));\n    return options.refresh\n      ? this.requiredClient().forceRefresh(options.login ?? true)\n      : this.requiredClient().tokenWithLogin(options.login);\n  }\n\n  async headers(options: TokenOptions = {}): Promise<Record<string, string>> {\n    const token = await this.token(options);\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  logout(): Promise<void> {\n    logger.debug(\"Databricks logout requested\", this.context());\n    return this.client?.logout() ?? Promise.resolve();\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      authType: this.profileValue.authType,\n      hasWorkspaceId: Boolean(this.profileValue.workspaceId),\n    };\n  }\n}\n\n/** Create a Databricks authentication client. */\nexport async function createAuthClient(\n  options: DatabricksAuthOptions = {},\n  dependencies: DatabricksAuthDependencies = {},\n): Promise<AuthClient> {\n  return createResolvedAuth(options, dependencies);\n}\n\n/** Resolve a Databricks profile and create its token lifecycle. */\nasync function createResolvedAuth(\n  options: DatabricksAuthOptions,\n  dependencies: DatabricksAuthDependencies,\n): Promise<DefaultAuthClient> {\n  const environment = dependencies.environment ?? process.env;\n  const profile = resolveDatabricksProfile(options, environment);\n  logger.debug(\"creating Databricks auth\", {\n    profile: profile.name,\n    host: profile.host,\n    authType: profile.authType,\n  });\n  if (profile.authType === AuthType.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 DefaultAuthClient(profile, undefined, {\n      accessToken: profile.accessToken!,\n      tokenType: \"Bearer\",\n      scopes: [...profile.scopes],\n    });\n  }\n  const provider = await providerFor(profile, options, dependencies);\n  const store = new MemoryCredentialStore();\n  const client = new TokenLifecycle(profile.cacheKey, provider, store, {\n    ...AUTH_DEFAULTS,\n    ...options.auth,\n  });\n  const auth = new DefaultAuthClient(profile, client);\n  logger.debug(\"created authentication lifecycle\", {\n    profile: profile.name,\n    host: profile.host,\n    authType: profile.authType,\n  });\n  return auth;\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  switch (profile.authType) {\n    case AuthType.DatabricksCli: {\n      logger.debug(\"selected Databricks CLI provider\", { profile: profile.name });\n      return new DatabricksCliProvider(\n        profile.name,\n        () =>\n          dependencies.resolveCli ? dependencies.resolveCli() : resolveDatabricksCli(environment),\n        cliEnvironment(profile, resolveConfigFile(options.configFile, environment)),\n      );\n    }\n    case AuthType.PersonalAccessToken:\n      logger.debug(\"selected personal access token provider\", { profile: profile.name });\n      return new DatabricksPersonalAccessTokenProvider(profile.accessToken!);\n    case AuthType.OAuthM2M:\n    case AuthType.AppServicePrincipal: {\n      logger.debug(\"selected service-principal provider\", {\n        profile: profile.name,\n        authType: profile.authType,\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 AuthType.AppOnBehalfOf:\n      throw new AuthError(\"config\", \"App OBO tokens do not use a token 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  }\n  if (!response.ok) {\n    throw new AuthError(\"oauth\", `OAuth discovery returned HTTP ${response.status}`);\n  }\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 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.authType === AuthType.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/config.d.ts

@@ -0,0 +1,36 @@
+import type { AuthType, TargetKind } from "@dbx-tools/shared-auth/config";
+/** Token lifecycle timing configuration in milliseconds. */
+export interface AuthOptions {
+    refreshBufferMs?: number;
+    lockTimeoutMs?: number;
+    loginTimeoutMs?: number;
+}
+/** Default token refresh, lock, and interactive login timing values. */
+export declare const AUTH_DEFAULTS: Required<AuthOptions>;
+/** Databricks profile and credential-source options. */
+export interface DatabricksAuthOptions {
+    profile?: string;
+    host?: string;
+    accountId?: string;
+    workspaceId?: string;
+    configFile?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+    groupId?: string;
+    authType?: AuthType;
+    scopes?: string[];
+    target?: TargetKind;
+    auth?: AuthOptions;
+    requestHeaders?: Record<string, string>;
+    accessTokenHeader?: string;
+    preferUserToMachine?: boolean;
+}
+/** OAuth client used by Databricks CLI-compatible user authentication. */
+export declare const DEFAULT_CLIENT_ID = "databricks-cli";
+/** Default Databricks profile configuration path. */
+export declare const DEFAULT_CONFIG_FILE = "~/.databrickscfg";
+/** Request header carrying a bearer access token. */
+export declare const DEFAULT_ACCESS_TOKEN_HEADER = "authorization";
+/** Request header carrying the resolved Databricks workspace ID. */
+export declare const WORKSPACE_ID_HEADER = "x-databricks-workspace-id";

package/lib/src/config.js

@@ -0,0 +1,15 @@
+/** Default token refresh, lock, and interactive login timing values. */
+export const AUTH_DEFAULTS = {
+    refreshBufferMs: 300_000,
+    lockTimeoutMs: 0,
+    loginTimeoutMs: 900_000,
+};
+/** OAuth client used by Databricks CLI-compatible user authentication. */
+export const DEFAULT_CLIENT_ID = "databricks-cli";
+/** Default Databricks profile configuration path. */
+export const DEFAULT_CONFIG_FILE = "~/.databrickscfg";
+/** Request header carrying a bearer access token. */
+export const DEFAULT_ACCESS_TOKEN_HEADER = "authorization";
+/** Request header carrying the resolved Databricks workspace ID. */
+export const WORKSPACE_ID_HEADER = "x-databricks-workspace-id";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/profile.d.ts

@@ -0,0 +1,11 @@
+import type { DatabricksProfileSummary } from "@dbx-tools/shared-auth/profile";
+import type { DatabricksAuthOptions } from "./config.ts";
+/** Profile-listing controls. */
+export interface ListProfilesOptions {
+    configFile?: string;
+    refresh?: boolean;
+}
+/** Resolve one selected profile without exposing credentials. */
+export declare function resolveProfile(options?: DatabricksAuthOptions): DatabricksProfileSummary;
+/** List configured profiles without exposing credentials. */
+export declare function listProfiles(options?: ListProfilesOptions): DatabricksProfileSummary[];

package/lib/src/profile.js

@@ -0,0 +1,21 @@
+import { listDatabricksProfiles, resolveDatabricksProfile } from "./_profile-config.js";
+/** Resolve one selected profile without exposing credentials. */
+export function resolveProfile(options = {}) {
+    return toProfileSummary(resolveDatabricksProfile(options));
+}
+/** List configured profiles without exposing credentials. */
+export function listProfiles(options = {}) {
+    return listDatabricksProfiles(options.configFile, options.refresh);
+}
+function toProfileSummary(profile) {
+    return {
+        name: profile.name,
+        host: profile.host,
+        ...(profile.accountId ? { accountId: profile.accountId } : {}),
+        ...(profile.workspaceId ? { workspaceId: profile.workspaceId } : {}),
+        target: profile.target,
+        authType: profile.authType,
+        principal: profile.principal,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_logging.ts","../src/_profile-core.ts","../src/_profile.ts","../src/databricks-auth.ts","../src/databricks-cli.ts","../src/errors.ts","../src/http-client.ts","../src/lifecycle.ts","../src/node-storage.ts","../src/personal-access-token.ts","../src/service-principal.ts","../src/storage.ts","../src/types.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_databricks-cli.ts","../src/_errors.ts","../src/_lifecycle.ts","../src/_logging.ts","../src/_personal-access-token.ts","../src/_profile-config.ts","../src/_service-principal.ts","../src/_storage.ts","../src/_types.ts","../src/client.ts","../src/config.ts","../src/profile.ts","../index.ts"],"version":"5.9.3"}