@dbx-tools/auth 0.6.182 → 0.9.28

package/lib/src/databricks-cli.js

@@ -0,0 +1,239 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as bin from "@dbx-tools/core/bin";
+import * as exec from "@dbx-tools/core/exec";
+import * as stringUtils from "@dbx-tools/shared-core/string-utils";
+import cliAssets from "./generated/databricks-cli-assets.json" with { type: "json" };
+import { authLogger, failureMetadata, tokenMetadata } from "./_logging.js";
+import { AuthError } from "./errors.js";
+const resolutionCache = new Map();
+const logger = authLogger("cli");
+/** Resolve a compatible Databricks CLI, installing the pinned build asset when needed. */
+export function resolveDatabricksCli(environment = process.env, options = {}) {
+    const candidate = stringValue(environment.DATABRICKS_CLI_PATH) ?? "databricks";
+    const key = `${candidate}\0${homedir()}\0${process.platform}\0${process.arch}\0${options.install !== false}`;
+    const cached = resolutionCache.get(key);
+    if (cached) {
+        logger.debug("reused Databricks CLI resolution", {
+            candidate,
+            install: options.install !== false,
+        });
+        return cached;
+    }
+    logger.debug("resolving Databricks CLI", {
+        candidate,
+        install: options.install !== false,
+        platform: process.platform,
+        arch: process.arch,
+        minimumVersion: cliAssets.minimumVersion,
+    });
+    const resolved = resolveDatabricksCliUncached(candidate, options.install !== false).catch((error) => {
+        resolutionCache.delete(key);
+        throw error;
+    });
+    resolutionCache.set(key, resolved);
+    return resolved;
+}
+/** Clear cached CLI resolution, primarily after installation or environment changes. */
+export function resetDatabricksCliResolution() {
+    resolutionCache.clear();
+    logger.debug("cleared Databricks CLI resolution cache");
+}
+async function resolveDatabricksCliUncached(candidate, install) {
+    if (await compatibleDatabricksCli(candidate)) {
+        logger.debug("selected installed Databricks CLI", { executable: candidate });
+        return candidate;
+    }
+    const managed = managedExecutable();
+    if (await compatibleDatabricksCli(managed)) {
+        logger.debug("selected managed Databricks CLI", { executable: managed });
+        return managed;
+    }
+    if (!install) {
+        logger.debug("compatible Databricks CLI unavailable and installation disabled");
+        return undefined;
+    }
+    const asset = platformAsset();
+    if (!asset) {
+        logger.debug("no managed Databricks CLI asset for platform", {
+            platform: process.platform,
+            arch: process.arch,
+        });
+        return undefined;
+    }
+    const root = join(homedir(), ".databricks");
+    const binDir = join(root, "bin");
+    const executable = managedExecutableName();
+    const installed = await bin.ensure("databricks", asset, {
+        autoUnpackage: true,
+        destination: { root, binDir, path: join(binDir, executable) },
+        minVersion: cliAssets.minimumVersion,
+        selector: ({ source }) => join(source, executable),
+        versionParser: (output) => {
+            const version = bin.parseVersion(output);
+            return version === cliAssets.version ? version : undefined;
+        },
+    });
+    logger.debug("ensured managed Databricks CLI", {
+        executable: installed.path,
+        version: cliAssets.version,
+    });
+    return installed.path;
+}
+function managedExecutable() {
+    return join(homedir(), ".databricks", "bin", managedExecutableName());
+}
+function managedExecutableName() {
+    return process.platform === "win32" ? "databricks.exe" : "databricks";
+}
+async function compatibleDatabricksCli(executable) {
+    try {
+        const result = await runProcess(executable, ["--version"], {}, 10_000);
+        if (result.exitCode !== 0) {
+            logger.debug("Databricks CLI version probe failed", {
+                executable,
+                exitCode: result.exitCode,
+            });
+            return false;
+        }
+        const version = bin.parseVersion(result);
+        const compatible = version !== undefined && bin.isVersionAtLeast(version, cliAssets.minimumVersion);
+        logger.debug("probed Databricks CLI version", {
+            executable,
+            version: version ?? "unknown",
+            minimumVersion: cliAssets.minimumVersion,
+            compatible,
+        });
+        return compatible;
+    }
+    catch (cause) {
+        logger.debug("Databricks CLI version probe unavailable", {
+            executable,
+            error: failureMetadata(cause),
+        });
+        return false;
+    }
+}
+function platformAsset() {
+    const key = `${process.platform}-${process.arch}`;
+    return cliAssets.assets[key];
+}
+/** Run interactive Databricks CLI login for one profile. */
+export async function databricksCliLogin(profile, timeoutMs, executable = process.env.DATABRICKS_CLI_PATH ?? "databricks", environment = {}) {
+    logger.debug("starting Databricks CLI login", { profile, executable, timeoutMs });
+    const result = await runProcess(executable, ["auth", "login", "--profile", profile, "--timeout", `${Math.ceil(timeoutMs / 1000)}s`], environment);
+    if (result.exitCode !== 0)
+        throw new AuthError("cli", result.stderr || `databricks auth login exited ${result.exitCode}`);
+    logger.debug("Databricks CLI login completed", { profile, executable });
+}
+/** Request one profile token from the Databricks CLI. */
+export async function databricksCliToken(profile, forceRefresh = false, executable = process.env.DATABRICKS_CLI_PATH ?? "databricks", environment = {}) {
+    logger.debug("requesting Databricks CLI token", { profile, executable, forceRefresh });
+    const args = ["auth", "token", "--profile", profile, "--output", "json"];
+    if (forceRefresh)
+        args.push("--force-refresh");
+    const result = await runProcess(executable, args, environment);
+    if (result.exitCode !== 0)
+        throw new AuthError("cli", result.stderr || `databricks auth token exited ${result.exitCode}`);
+    let value;
+    try {
+        value = JSON.parse(result.stdout ?? "");
+    }
+    catch (cause) {
+        throw new AuthError("cli", "Databricks CLI token output was not JSON", { cause });
+    }
+    const accessToken = stringValue(value.access_token ?? value.accessToken);
+    if (!accessToken)
+        throw new AuthError("cli", "Databricks CLI token output had no access token");
+    const token = {
+        accessToken,
+        tokenType: stringValue(value.token_type ?? value.tokenType) ?? "Bearer",
+        ...(stringValue(value.refresh_token ?? value.refreshToken)
+            ? { refreshToken: stringValue(value.refresh_token ?? value.refreshToken) }
+            : {}),
+        ...(stringValue(value.expiry ?? value.expires_at)
+            ? { expiry: stringValue(value.expiry ?? value.expires_at) }
+            : {}),
+        scopes: Array.isArray(value.scopes)
+            ? value.scopes.filter((scope) => typeof scope === "string")
+            : [],
+    };
+    logger.debug("received Databricks CLI token", {
+        profile,
+        forceRefresh,
+        token: tokenMetadata(token),
+    });
+    return token;
+}
+async function runProcess(command, args, environment, timeoutMs) {
+    const controller = timeoutMs === undefined ? undefined : new AbortController();
+    const timeout = controller ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        return await exec.spawn(command, args, {
+            env: { ...process.env, ...environment },
+            stdin: "ignore",
+            stdout: "capture",
+            stderr: "capture",
+            signal: controller?.signal,
+        });
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+/** Provider that lazily delegates U2M credentials to the Databricks CLI. */
+export class DatabricksCliProvider {
+    profile;
+    executableOrResolver;
+    environment;
+    resolution;
+    constructor(profile, executableOrResolver = () => resolveDatabricksCli(), environment = {}) {
+        this.profile = profile;
+        this.executableOrResolver = executableOrResolver;
+        this.environment = environment;
+    }
+    async authenticate(_timeoutMs) {
+        return databricksCliToken(this.profile, false, await this.resolveExecutable(), this.environment);
+    }
+    async login(timeoutMs) {
+        const executable = await this.resolveExecutable();
+        await databricksCliLogin(this.profile, timeoutMs, executable, this.environment);
+        return databricksCliToken(this.profile, false, executable, this.environment);
+    }
+    async refresh(_token) {
+        return databricksCliToken(this.profile, true, await this.resolveExecutable(), this.environment);
+    }
+    canAuthenticateSilently() {
+        return true;
+    }
+    resolveExecutable() {
+        if (typeof this.executableOrResolver === "string") {
+            logger.debug("using configured Databricks CLI executable", {
+                profile: this.profile,
+                executable: this.executableOrResolver,
+            });
+            return Promise.resolve(this.executableOrResolver);
+        }
+        if (this.resolution) {
+            logger.debug("reused provider CLI resolution", { profile: this.profile });
+            return this.resolution;
+        }
+        logger.debug("resolving provider CLI lazily", { profile: this.profile });
+        this.resolution = this.executableOrResolver()
+            .then((executable) => {
+            if (!executable)
+                throw new AuthError("cli", "Databricks CLI is unavailable on this platform");
+            return executable;
+        })
+            .catch((error) => {
+            this.resolution = undefined;
+            throw error;
+        });
+        return this.resolution;
+    }
+}
+function stringValue(value) {
+    return stringUtils.trimToNull(value) ?? undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-cli.js","sourceRoot":"","sources":["../../src/databricks-cli.ts"],"names":[],"mappings":"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","sourcesContent":["import { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\nimport * as bin from \"@dbx-tools/core/bin\";\nimport * as exec from \"@dbx-tools/core/exec\";\nimport * as stringUtils from \"@dbx-tools/shared-core/string-utils\";\n\nimport cliAssets from \"./generated/databricks-cli-assets.json\" with { type: \"json\" };\nimport { authLogger, failureMetadata, tokenMetadata } from \"./_logging.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport type { Token, TokenProvider } from \"./types.ts\";\n\nconst resolutionCache = new Map<string, Promise<string | undefined>>();\nconst logger = authLogger(\"cli\");\n\ninterface DatabricksCliAsset {\n  readonly url: string;\n  readonly sha256: string;\n}\n\n/** Deferred Databricks CLI lookup used by U2M token acquisition. */\nexport type DatabricksCliResolver = () => Promise<string | undefined>;\n\n/** Controls whether CLI resolution may install the pinned managed executable. */\nexport interface DatabricksCliResolutionOptions {\n  install?: boolean;\n}\n\n/** Resolve a compatible Databricks CLI, installing the pinned build asset when needed. */\nexport function resolveDatabricksCli(\n  environment: Readonly<Record<string, string | undefined>> = process.env,\n  options: DatabricksCliResolutionOptions = {},\n): Promise<string | undefined> {\n  const candidate = stringValue(environment.DATABRICKS_CLI_PATH) ?? \"databricks\";\n  const key = `${candidate}\\0${homedir()}\\0${process.platform}\\0${process.arch}\\0${options.install !== false}`;\n  const cached = resolutionCache.get(key);\n  if (cached) {\n    logger.debug(\"reused Databricks CLI resolution\", {\n      candidate,\n      install: options.install !== false,\n    });\n    return cached;\n  }\n  logger.debug(\"resolving Databricks CLI\", {\n    candidate,\n    install: options.install !== false,\n    platform: process.platform,\n    arch: process.arch,\n    minimumVersion: cliAssets.minimumVersion,\n  });\n  const resolved = resolveDatabricksCliUncached(candidate, options.install !== false).catch(\n    (error) => {\n      resolutionCache.delete(key);\n      throw error;\n    },\n  );\n  resolutionCache.set(key, resolved);\n  return resolved;\n}\n\n/** Clear cached CLI resolution, primarily after installation or environment changes. */\nexport function resetDatabricksCliResolution(): void {\n  resolutionCache.clear();\n  logger.debug(\"cleared Databricks CLI resolution cache\");\n}\n\nasync function resolveDatabricksCliUncached(\n  candidate: string,\n  install: boolean,\n): Promise<string | undefined> {\n  if (await compatibleDatabricksCli(candidate)) {\n    logger.debug(\"selected installed Databricks CLI\", { executable: candidate });\n    return candidate;\n  }\n  const managed = managedExecutable();\n  if (await compatibleDatabricksCli(managed)) {\n    logger.debug(\"selected managed Databricks CLI\", { executable: managed });\n    return managed;\n  }\n  if (!install) {\n    logger.debug(\"compatible Databricks CLI unavailable and installation disabled\");\n    return undefined;\n  }\n  const asset = platformAsset();\n  if (!asset) {\n    logger.debug(\"no managed Databricks CLI asset for platform\", {\n      platform: process.platform,\n      arch: process.arch,\n    });\n    return undefined;\n  }\n  const root = join(homedir(), \".databricks\");\n  const binDir = join(root, \"bin\");\n  const executable = managedExecutableName();\n  const installed = await bin.ensure(\"databricks\", asset, {\n    autoUnpackage: true,\n    destination: { root, binDir, path: join(binDir, executable) },\n    minVersion: cliAssets.minimumVersion,\n    selector: ({ source }) => join(source, executable),\n    versionParser: (output) => {\n      const version = bin.parseVersion(output);\n      return version === cliAssets.version ? version : undefined;\n    },\n  });\n  logger.debug(\"ensured managed Databricks CLI\", {\n    executable: installed.path,\n    version: cliAssets.version,\n  });\n  return installed.path;\n}\n\nfunction managedExecutable(): string {\n  return join(homedir(), \".databricks\", \"bin\", managedExecutableName());\n}\n\nfunction managedExecutableName(): string {\n  return process.platform === \"win32\" ? \"databricks.exe\" : \"databricks\";\n}\n\nasync function compatibleDatabricksCli(executable: string): Promise<boolean> {\n  try {\n    const result = await runProcess(executable, [\"--version\"], {}, 10_000);\n    if (result.exitCode !== 0) {\n      logger.debug(\"Databricks CLI version probe failed\", {\n        executable,\n        exitCode: result.exitCode,\n      });\n      return false;\n    }\n    const version = bin.parseVersion(result);\n    const compatible =\n      version !== undefined && bin.isVersionAtLeast(version, cliAssets.minimumVersion);\n    logger.debug(\"probed Databricks CLI version\", {\n      executable,\n      version: version ?? \"unknown\",\n      minimumVersion: cliAssets.minimumVersion,\n      compatible,\n    });\n    return compatible;\n  } catch (cause) {\n    logger.debug(\"Databricks CLI version probe unavailable\", {\n      executable,\n      error: failureMetadata(cause),\n    });\n    return false;\n  }\n}\n\nfunction platformAsset(): DatabricksCliAsset | undefined {\n  const key = `${process.platform}-${process.arch}` as keyof typeof cliAssets.assets;\n  return cliAssets.assets[key];\n}\n\n/** Run interactive Databricks CLI login for one profile. */\nexport async function databricksCliLogin(\n  profile: string,\n  timeoutMs: number,\n  executable = process.env.DATABRICKS_CLI_PATH ?? \"databricks\",\n  environment: Record<string, string> = {},\n): Promise<void> {\n  logger.debug(\"starting Databricks CLI login\", { profile, executable, timeoutMs });\n  const result = await runProcess(\n    executable,\n    [\"auth\", \"login\", \"--profile\", profile, \"--timeout\", `${Math.ceil(timeoutMs / 1000)}s`],\n    environment,\n  );\n  if (result.exitCode !== 0)\n    throw new AuthError(\"cli\", result.stderr || `databricks auth login exited ${result.exitCode}`);\n  logger.debug(\"Databricks CLI login completed\", { profile, executable });\n}\n\n/** Request one profile token from the Databricks CLI. */\nexport async function databricksCliToken(\n  profile: string,\n  forceRefresh = false,\n  executable = process.env.DATABRICKS_CLI_PATH ?? \"databricks\",\n  environment: Record<string, string> = {},\n): Promise<Token> {\n  logger.debug(\"requesting Databricks CLI token\", { profile, executable, forceRefresh });\n  const args = [\"auth\", \"token\", \"--profile\", profile, \"--output\", \"json\"];\n  if (forceRefresh) args.push(\"--force-refresh\");\n  const result = await runProcess(executable, args, environment);\n  if (result.exitCode !== 0)\n    throw new AuthError(\"cli\", result.stderr || `databricks auth token exited ${result.exitCode}`);\n  let value: Record<string, unknown>;\n  try {\n    value = JSON.parse(result.stdout ?? \"\") as Record<string, unknown>;\n  } catch (cause) {\n    throw new AuthError(\"cli\", \"Databricks CLI token output was not JSON\", { cause });\n  }\n  const accessToken = stringValue(value.access_token ?? value.accessToken);\n  if (!accessToken) throw new AuthError(\"cli\", \"Databricks CLI token output had no access token\");\n  const token = {\n    accessToken,\n    tokenType: stringValue(value.token_type ?? value.tokenType) ?? \"Bearer\",\n    ...(stringValue(value.refresh_token ?? value.refreshToken)\n      ? { refreshToken: stringValue(value.refresh_token ?? value.refreshToken) }\n      : {}),\n    ...(stringValue(value.expiry ?? value.expires_at)\n      ? { expiry: stringValue(value.expiry ?? value.expires_at) }\n      : {}),\n    scopes: Array.isArray(value.scopes)\n      ? value.scopes.filter((scope): scope is string => typeof scope === \"string\")\n      : [],\n  };\n  logger.debug(\"received Databricks CLI token\", {\n    profile,\n    forceRefresh,\n    token: tokenMetadata(token),\n  });\n  return token;\n}\n\nasync function runProcess(\n  command: string,\n  args: string[],\n  environment: Record<string, string>,\n  timeoutMs?: number,\n): Promise<{ exitCode: number; stdout: string; stderr: string }> {\n  const controller = timeoutMs === undefined ? undefined : new AbortController();\n  const timeout = controller ? setTimeout(() => controller.abort(), timeoutMs) : undefined;\n  try {\n    return await exec.spawn(command, args, {\n      env: { ...process.env, ...environment },\n      stdin: \"ignore\",\n      stdout: \"capture\",\n      stderr: \"capture\",\n      signal: controller?.signal,\n    });\n  } finally {\n    if (timeout) clearTimeout(timeout);\n  }\n}\n\n/** Provider that lazily delegates U2M credentials to the Databricks CLI. */\nexport class DatabricksCliProvider implements TokenProvider {\n  private resolution?: Promise<string>;\n\n  constructor(\n    private readonly profile: string,\n    private readonly executableOrResolver: string | DatabricksCliResolver = () =>\n      resolveDatabricksCli(),\n    private readonly environment: Record<string, string> = {},\n  ) {}\n\n  async authenticate(_timeoutMs: number): Promise<Token> {\n    return databricksCliToken(\n      this.profile,\n      false,\n      await this.resolveExecutable(),\n      this.environment,\n    );\n  }\n\n  async login(timeoutMs: number): Promise<Token> {\n    const executable = await this.resolveExecutable();\n    await databricksCliLogin(this.profile, timeoutMs, executable, this.environment);\n    return databricksCliToken(this.profile, false, executable, this.environment);\n  }\n\n  async refresh(_token: Token): Promise<Token> {\n    return databricksCliToken(this.profile, true, await this.resolveExecutable(), this.environment);\n  }\n\n  canAuthenticateSilently(): boolean {\n    return true;\n  }\n\n  private resolveExecutable(): Promise<string> {\n    if (typeof this.executableOrResolver === \"string\") {\n      logger.debug(\"using configured Databricks CLI executable\", {\n        profile: this.profile,\n        executable: this.executableOrResolver,\n      });\n      return Promise.resolve(this.executableOrResolver);\n    }\n    if (this.resolution) {\n      logger.debug(\"reused provider CLI resolution\", { profile: this.profile });\n      return this.resolution;\n    }\n    logger.debug(\"resolving provider CLI lazily\", { profile: this.profile });\n    this.resolution = this.executableOrResolver()\n      .then((executable) => {\n        if (!executable)\n          throw new AuthError(\"cli\", \"Databricks CLI is unavailable on this platform\");\n        return executable;\n      })\n      .catch((error) => {\n        this.resolution = undefined;\n        throw error;\n      });\n    return this.resolution;\n  }\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  return stringUtils.trimToNull(value) ?? undefined;\n}\n"]}

package/lib/src/errors.d.ts

@@ -0,0 +1,7 @@
+/** Authentication failure with a stable category for callers and language shims. */
+export declare class AuthError extends Error {
+    readonly kind: "config" | "oauth" | "storage" | "lock-timeout" | "cli" | "http";
+    constructor(kind: "config" | "oauth" | "storage" | "lock-timeout" | "cli" | "http", message: string, options?: ErrorOptions);
+}
+/** Normalize arbitrary failures without erasing their original cause. */
+export declare function authError(kind: AuthError["kind"], message: string, cause?: unknown): AuthError;

package/lib/src/errors.js

@@ -0,0 +1,14 @@
+/** Authentication failure with a stable category for callers and language shims. */
+export class AuthError extends Error {
+    kind;
+    constructor(kind, message, options) {
+        super(message, options);
+        this.kind = kind;
+        this.name = "AuthError";
+    }
+}
+/** Normalize arbitrary failures without erasing their original cause. */
+export function authError(kind, message, cause) {
+    return cause instanceof AuthError ? cause : new AuthError(kind, message, { cause });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvRkFBb0Y7QUFDcEYsTUFBTSxPQUFPLFNBQVUsU0FBUSxLQUFLO0lBRXZCO0lBRFgsWUFDVyxJQUFzRSxFQUMvRSxPQUFlLEVBQ2YsT0FBc0I7UUFFdEIsS0FBSyxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztRQUpmLFNBQUksR0FBSixJQUFJLENBQWtFO1FBSy9FLElBQUksQ0FBQyxJQUFJLEdBQUcsV0FBVyxDQUFDO0lBQzFCLENBQUM7Q0FDRjtBQUVELHlFQUF5RTtBQUN6RSxNQUFNLFVBQVUsU0FBUyxDQUFDLElBQXVCLEVBQUUsT0FBZSxFQUFFLEtBQWU7SUFDakYsT0FBTyxLQUFLLFlBQVksU0FBUyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksU0FBUyxDQUFDLElBQUksRUFBRSxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0FBQ3RGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQXV0aGVudGljYXRpb24gZmFpbHVyZSB3aXRoIGEgc3RhYmxlIGNhdGVnb3J5IGZvciBjYWxsZXJzIGFuZCBsYW5ndWFnZSBzaGltcy4gKi9cbmV4cG9ydCBjbGFzcyBBdXRoRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHJlYWRvbmx5IGtpbmQ6IFwiY29uZmlnXCIgfCBcIm9hdXRoXCIgfCBcInN0b3JhZ2VcIiB8IFwibG9jay10aW1lb3V0XCIgfCBcImNsaVwiIHwgXCJodHRwXCIsXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIG9wdGlvbnM/OiBFcnJvck9wdGlvbnMsXG4gICkge1xuICAgIHN1cGVyKG1lc3NhZ2UsIG9wdGlvbnMpO1xuICAgIHRoaXMubmFtZSA9IFwiQXV0aEVycm9yXCI7XG4gIH1cbn1cblxuLyoqIE5vcm1hbGl6ZSBhcmJpdHJhcnkgZmFpbHVyZXMgd2l0aG91dCBlcmFzaW5nIHRoZWlyIG9yaWdpbmFsIGNhdXNlLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGF1dGhFcnJvcihraW5kOiBBdXRoRXJyb3JbXCJraW5kXCJdLCBtZXNzYWdlOiBzdHJpbmcsIGNhdXNlPzogdW5rbm93bik6IEF1dGhFcnJvciB7XG4gIHJldHVybiBjYXVzZSBpbnN0YW5jZW9mIEF1dGhFcnJvciA/IGNhdXNlIDogbmV3IEF1dGhFcnJvcihraW5kLCBtZXNzYWdlLCB7IGNhdXNlIH0pO1xufVxuIl19

package/lib/src/generated/databricks-cli-assets.json

@@ -0,0 +1,33 @@
+{
+    "schemaVersion": 1,
+    "dbxToolsVersion": "0.9.21",
+    "minimumVersion": "0.296.0",
+    "version": "1.19.0",
+    "publishedAt": "2026-09-30T13:13:22Z",
+    "assets": {
+        "darwin-arm64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_darwin_arm64.tar.gz",
+            "sha256": "b84c6a8c623578308a724cdd7181b92b0816c2531564f16f8de7559b2a39f51f"
+        },
+        "darwin-x64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_darwin_amd64.tar.gz",
+            "sha256": "d29a5dc1ea7d44d0d892fd4beac05d22daa932982ca6bf98a06d52c95f5ed4cd"
+        },
+        "linux-arm64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_linux_arm64.tar.gz",
+            "sha256": "2997ccbda57090ee48bd9282d5cb3a5bef78025db64fd1573fbd7c8726856086"
+        },
+        "linux-x64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_linux_amd64.tar.gz",
+            "sha256": "bddf87df3d72b61384da724b40f18ab483a98af742748260097a7bb8154b070e"
+        },
+        "win32-arm64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_windows_arm64.tar.gz",
+            "sha256": "c28d098490ea1966230c07585312f8bc66e18d468e34b06319d44e29d61c4602"
+        },
+        "win32-x64": {
+            "url": "https://github.com/databricks/cli/releases/download/v1.19.0/databricks_cli_1.19.0_windows_amd64.tar.gz",
+            "sha256": "0ded24a2b001e001c815b9c1c66dc2ef1f6c2e60c64f63c6d9afb8e9fe85afdb"
+        }
+    }
+}

package/lib/src/http-client.d.ts

@@ -0,0 +1,23 @@
+import { type DatabricksAuthDependencies } from "./databricks-auth.ts";
+import type { AuthClient, DatabricksAuthOptions } from "./types.ts";
+/** Options for one Databricks JSON API request. */
+export interface DatabricksRequestOptions {
+    method?: string;
+    body?: unknown;
+    headers?: Headers | Record<string, string> | [string, string][];
+    login?: boolean;
+    signal?: AbortSignal;
+}
+/** Dependency-light Databricks JSON client with one rejected-token refresh. */
+export declare class DatabricksClient {
+    readonly auth: AuthClient;
+    private readonly fetcher;
+    private constructor();
+    static create(options?: DatabricksAuthOptions, dependencies?: DatabricksAuthDependencies): Promise<DatabricksClient>;
+    profile(): string;
+    host(): string;
+    principal(): string;
+    workspaceId(): string | undefined;
+    request(path: string, options?: DatabricksRequestOptions): Promise<unknown>;
+    private send;
+}

package/lib/src/http-client.js

@@ -0,0 +1,116 @@
+import { authLogger } from "./_logging.js";
+import { AuthError } from "./errors.js";
+import { createAuthClient } from "./databricks-auth.js";
+import { DEFAULT_ACCESS_TOKEN_HEADER, WORKSPACE_ID_HEADER } from "./types.js";
+const logger = authLogger("http");
+/** Dependency-light Databricks JSON client with one rejected-token refresh. */
+export class DatabricksClient {
+    auth;
+    fetcher;
+    constructor(auth, fetcher) {
+        this.auth = auth;
+        this.fetcher = fetcher;
+    }
+    static async create(options = { preferUserToMachine: true }, dependencies = {}) {
+        const client = new DatabricksClient(await createAuthClient(options, undefined, dependencies), dependencies.fetch ?? globalThis.fetch);
+        logger.debug("created Databricks HTTP client", {
+            profile: client.profile(),
+            host: client.host(),
+            hasWorkspaceId: Boolean(client.workspaceId()),
+        });
+        return client;
+    }
+    profile() {
+        return this.auth.status().profile;
+    }
+    host() {
+        return this.auth.status().host;
+    }
+    principal() {
+        return this.auth.principal();
+    }
+    workspaceId() {
+        return this.auth.workspaceId();
+    }
+    async request(path, options = {}) {
+        const url = new URL(path, `${this.host().replace(/\/$/, "")}/`).toString();
+        const method = options.method ?? (options.body === undefined ? "GET" : "POST");
+        const requestUrl = new URL(url);
+        logger.debug("sending Databricks API request", {
+            method,
+            origin: requestUrl.origin,
+            path: requestUrl.pathname,
+            hasBody: options.body !== undefined,
+            login: options.login ?? "auto",
+        });
+        let authHeaders = await this.auth.authenticate(options.login);
+        let response = await this.send(url, method, authHeaders, options);
+        logger.debug("received Databricks API response", {
+            method,
+            path: requestUrl.pathname,
+            status: response.status,
+            attempt: 1,
+        });
+        if (response.status === 401) {
+            logger.debug("refreshing rejected Databricks API credential", {
+                method,
+                path: requestUrl.pathname,
+            });
+            await this.auth.refreshRejectedToken(accessTokenFromHeaders(authHeaders), options.login ?? true);
+            authHeaders = await this.auth.authenticate(false);
+            response = await this.send(url, method, authHeaders, options);
+            logger.debug("received Databricks API response", {
+                method,
+                path: requestUrl.pathname,
+                status: response.status,
+                attempt: 2,
+            });
+        }
+        const text = await response.text();
+        if (!response.ok)
+            throw new AuthError("http", `Databricks API ${path} returned HTTP ${response.status}: ${text}`);
+        if (!text) {
+            logger.debug("Databricks API response had no body", {
+                method,
+                path: requestUrl.pathname,
+            });
+            return undefined;
+        }
+        try {
+            const value = JSON.parse(text);
+            logger.debug("parsed Databricks API JSON response", {
+                method,
+                path: requestUrl.pathname,
+            });
+            return value;
+        }
+        catch (cause) {
+            throw new AuthError("http", `Databricks API ${path} did not return JSON`, { cause });
+        }
+    }
+    send(url, method, authHeaders, options) {
+        const headers = new Headers(options.headers);
+        headers.delete(DEFAULT_ACCESS_TOKEN_HEADER);
+        headers.delete(WORKSPACE_ID_HEADER);
+        for (const [name, value] of Object.entries(authHeaders))
+            headers.set(name, value);
+        headers.set("accept", "application/json");
+        if (options.body !== undefined)
+            headers.set("content-type", "application/json");
+        return this.fetcher(url, {
+            method,
+            headers,
+            ...(options.body !== undefined ? { body: JSON.stringify(options.body) } : {}),
+            signal: options.signal,
+        });
+    }
+}
+function accessTokenFromHeaders(headers) {
+    const authorization = headers[DEFAULT_ACCESS_TOKEN_HEADER];
+    const separator = authorization?.indexOf(" ") ?? -1;
+    if (separator < 1 || !authorization?.slice(separator + 1).trim()) {
+        throw new AuthError("http", "Authentication headers did not contain an access token");
+    }
+    return authorization.slice(separator + 1).trim();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-client.js","sourceRoot":"","sources":["../../src/http-client.ts"],"names":[],"mappings":"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","sourcesContent":["import { authLogger } from \"./_logging.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport { createAuthClient, type DatabricksAuthDependencies } from \"./databricks-auth.ts\";\nimport type { AuthClient, DatabricksAuthOptions } from \"./types.ts\";\nimport { DEFAULT_ACCESS_TOKEN_HEADER, WORKSPACE_ID_HEADER } from \"./types.ts\";\n\nconst logger = authLogger(\"http\");\n\n/** Options for one Databricks JSON API request. */\nexport interface DatabricksRequestOptions {\n  method?: string;\n  body?: unknown;\n  headers?: Headers | Record<string, string> | [string, string][];\n  login?: boolean;\n  signal?: AbortSignal;\n}\n\n/** Dependency-light Databricks JSON client with one rejected-token refresh. */\nexport class DatabricksClient {\n  private constructor(\n    readonly auth: AuthClient,\n    private readonly fetcher: typeof globalThis.fetch,\n  ) {}\n\n  static async create(\n    options: DatabricksAuthOptions = { preferUserToMachine: true },\n    dependencies: DatabricksAuthDependencies = {},\n  ): Promise<DatabricksClient> {\n    const client = new DatabricksClient(\n      await createAuthClient(options, undefined, dependencies),\n      dependencies.fetch ?? globalThis.fetch,\n    );\n    logger.debug(\"created Databricks HTTP client\", {\n      profile: client.profile(),\n      host: client.host(),\n      hasWorkspaceId: Boolean(client.workspaceId()),\n    });\n    return client;\n  }\n\n  profile(): string {\n    return this.auth.status().profile;\n  }\n\n  host(): string {\n    return this.auth.status().host;\n  }\n\n  principal(): string {\n    return this.auth.principal();\n  }\n\n  workspaceId(): string | undefined {\n    return this.auth.workspaceId();\n  }\n\n  async request(path: string, options: DatabricksRequestOptions = {}): Promise<unknown> {\n    const url = new URL(path, `${this.host().replace(/\\/$/, \"\")}/`).toString();\n    const method = options.method ?? (options.body === undefined ? \"GET\" : \"POST\");\n    const requestUrl = new URL(url);\n    logger.debug(\"sending Databricks API request\", {\n      method,\n      origin: requestUrl.origin,\n      path: requestUrl.pathname,\n      hasBody: options.body !== undefined,\n      login: options.login ?? \"auto\",\n    });\n    let authHeaders = await this.auth.authenticate(options.login);\n    let response = await this.send(url, method, authHeaders, options);\n    logger.debug(\"received Databricks API response\", {\n      method,\n      path: requestUrl.pathname,\n      status: response.status,\n      attempt: 1,\n    });\n    if (response.status === 401) {\n      logger.debug(\"refreshing rejected Databricks API credential\", {\n        method,\n        path: requestUrl.pathname,\n      });\n      await this.auth.refreshRejectedToken(\n        accessTokenFromHeaders(authHeaders),\n        options.login ?? true,\n      );\n      authHeaders = await this.auth.authenticate(false);\n      response = await this.send(url, method, authHeaders, options);\n      logger.debug(\"received Databricks API response\", {\n        method,\n        path: requestUrl.pathname,\n        status: response.status,\n        attempt: 2,\n      });\n    }\n    const text = await response.text();\n    if (!response.ok)\n      throw new AuthError(\n        \"http\",\n        `Databricks API ${path} returned HTTP ${response.status}: ${text}`,\n      );\n    if (!text) {\n      logger.debug(\"Databricks API response had no body\", {\n        method,\n        path: requestUrl.pathname,\n      });\n      return undefined;\n    }\n    try {\n      const value = JSON.parse(text);\n      logger.debug(\"parsed Databricks API JSON response\", {\n        method,\n        path: requestUrl.pathname,\n      });\n      return value;\n    } catch (cause) {\n      throw new AuthError(\"http\", `Databricks API ${path} did not return JSON`, { cause });\n    }\n  }\n\n  private send(\n    url: string,\n    method: string,\n    authHeaders: Record<string, string>,\n    options: DatabricksRequestOptions,\n  ): Promise<Response> {\n    const headers = new Headers(options.headers);\n    headers.delete(DEFAULT_ACCESS_TOKEN_HEADER);\n    headers.delete(WORKSPACE_ID_HEADER);\n    for (const [name, value] of Object.entries(authHeaders)) headers.set(name, value);\n    headers.set(\"accept\", \"application/json\");\n    if (options.body !== undefined) headers.set(\"content-type\", \"application/json\");\n    return this.fetcher(url, {\n      method,\n      headers,\n      ...(options.body !== undefined ? { body: JSON.stringify(options.body) } : {}),\n      signal: options.signal,\n    });\n  }\n}\n\nfunction accessTokenFromHeaders(headers: Record<string, string>): string {\n  const authorization = headers[DEFAULT_ACCESS_TOKEN_HEADER];\n  const separator = authorization?.indexOf(\" \") ?? -1;\n  if (separator < 1 || !authorization?.slice(separator + 1).trim()) {\n    throw new AuthError(\"http\", \"Authentication headers did not contain an access token\");\n  }\n  return authorization.slice(separator + 1).trim();\n}\n"]}

package/lib/src/lifecycle.d.ts

@@ -0,0 +1,26 @@
+import type { AccessToken, AuthOptions, CredentialStore, Token, TokenProvider } from "./types.ts";
+/** Provider-neutral check-lock-check authentication and persistent token lifecycle. */
+export declare class TokenLifecycle {
+    private readonly key;
+    private readonly provider;
+    private readonly store;
+    private readonly options;
+    private readonly now;
+    constructor(key: string, provider: TokenProvider, store: CredentialStore, options: AuthOptions, now?: () => Date);
+    storeName(): string;
+    login(): Promise<AccessToken>;
+    token(): Promise<AccessToken>;
+    tokenOrLogin(): Promise<AccessToken>;
+    tokenWithLogin(login?: boolean): Promise<AccessToken>;
+    forceRefresh(login?: boolean): Promise<AccessToken>;
+    refreshRejectedToken(staleAccessToken: string, login?: boolean): Promise<AccessToken>;
+    logout(): Promise<void>;
+    private loadToken;
+    private refreshRejected;
+    private renew;
+    private canReuse;
+    private withLock;
+    private context;
+}
+export declare function publicToken(token: Token): AccessToken;
+export declare function validateToken(token: Token, previous?: Token): Token;