@dbx-tools/auth 0.6.182 → 0.9.29

package/lib/src/lifecycle.js

@@ -0,0 +1,229 @@
+import { AuthError } from "./errors.js";
+import { authLogger, credentialId, failureMetadata, tokenMetadata } from "./_logging.js";
+const logger = authLogger("lifecycle");
+/** Provider-neutral check-lock-check authentication and persistent token lifecycle. */
+export class TokenLifecycle {
+    key;
+    provider;
+    store;
+    options;
+    now;
+    constructor(key, provider, store, options, now = () => new Date()) {
+        this.key = key;
+        this.provider = provider;
+        this.store = store;
+        this.options = options;
+        this.now = now;
+        logger.debug("created authentication lifecycle", {
+            credential: credentialId(key),
+            storage: store.name(),
+            refreshBufferSeconds: options.refreshBufferSeconds,
+            lockTimeoutSeconds: options.lockTimeoutSeconds,
+            loginTimeoutSeconds: options.loginTimeoutSeconds,
+            silentProvider: provider.canAuthenticateSilently(),
+        });
+    }
+    storeName() {
+        return this.store.name();
+    }
+    async login() {
+        logger.debug("interactive login requested", this.context());
+        return this.withLock(async () => {
+            await this.store.prepareWrite();
+            const token = validateToken(await this.provider.login(this.options.loginTimeoutSeconds * 1000));
+            await this.store.save(this.key, token);
+            logger.debug("interactive login stored credential", {
+                ...this.context(),
+                token: tokenMetadata(token, this.now()),
+            });
+            return publicToken(token);
+        });
+    }
+    token() {
+        return this.loadToken(false);
+    }
+    tokenOrLogin() {
+        return this.loadToken(true);
+    }
+    async tokenWithLogin(login) {
+        logger.debug("token requested", { ...this.context(), login: login ?? "auto" });
+        if (login === true)
+            return this.login();
+        if (login === false)
+            return this.token();
+        return this.tokenOrLogin();
+    }
+    forceRefresh(login = true) {
+        logger.debug("forced refresh requested", { ...this.context(), login });
+        return this.refreshRejected(undefined, login);
+    }
+    refreshRejectedToken(staleAccessToken, login = true) {
+        logger.debug("rejected token refresh requested", { ...this.context(), login });
+        return this.refreshRejected(staleAccessToken, login);
+    }
+    async logout() {
+        logger.debug("logout requested", this.context());
+        await this.withLock(() => this.store.remove(this.key));
+        logger.debug("stored credential removed", this.context());
+    }
+    async loadToken(login) {
+        const existing = await this.store.load(this.key);
+        const reusable = Boolean(existing && this.canReuse(existing));
+        logger.debug("checked credential cache", {
+            ...this.context(),
+            login,
+            reusable,
+            token: tokenMetadata(existing, this.now()),
+        });
+        if (existing && reusable)
+            return publicToken(existing);
+        return this.withLock(async () => {
+            const current = await this.store.load(this.key);
+            const currentReusable = Boolean(current && this.canReuse(current));
+            logger.debug("rechecked credential cache after lock", {
+                ...this.context(),
+                reusable: currentReusable,
+                token: tokenMetadata(current, this.now()),
+            });
+            if (current && currentReusable)
+                return publicToken(current);
+            return this.renew(current, login);
+        });
+    }
+    async refreshRejected(staleAccessToken, login) {
+        return this.withLock(async () => {
+            const current = await this.store.load(this.key);
+            if (staleAccessToken &&
+                current?.accessToken &&
+                current.accessToken !== staleAccessToken &&
+                isValid(current, this.now())) {
+                logger.debug("reused replacement for rejected credential", {
+                    ...this.context(),
+                    token: tokenMetadata(current, this.now()),
+                });
+                return publicToken(current);
+            }
+            return this.renew(current, login);
+        });
+    }
+    async renew(current, login) {
+        let token;
+        if (current) {
+            logger.debug("refreshing stored credential", {
+                ...this.context(),
+                loginFallback: login,
+                token: tokenMetadata(current, this.now()),
+            });
+            try {
+                token = await this.provider.refresh(current);
+            }
+            catch (error) {
+                logger.debug("credential refresh failed", {
+                    ...this.context(),
+                    loginFallback: login,
+                    error: failureMetadata(error),
+                });
+                if (!login)
+                    throw error;
+                logger.debug("falling back to interactive login", this.context());
+                token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);
+            }
+        }
+        else if (this.provider.canAuthenticateSilently()) {
+            logger.debug("attempting silent credential acquisition", {
+                ...this.context(),
+                loginFallback: login,
+            });
+            try {
+                token = await this.provider.authenticate(this.options.loginTimeoutSeconds * 1000);
+            }
+            catch (error) {
+                logger.debug("silent credential acquisition failed", {
+                    ...this.context(),
+                    loginFallback: login,
+                    error: failureMetadata(error),
+                });
+                if (!login)
+                    throw error;
+                logger.debug("falling back to interactive login", this.context());
+                token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);
+            }
+        }
+        else if (login) {
+            logger.debug("provider requires interactive login", this.context());
+            token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);
+        }
+        else {
+            throw new AuthError("oauth", "No stored credential is available and interactive login is disabled");
+        }
+        token = validateToken(token, current);
+        logger.debug("credential acquisition completed", {
+            ...this.context(),
+            token: tokenMetadata(token, this.now()),
+        });
+        await this.store.prepareWrite();
+        await this.store.save(this.key, token);
+        logger.debug("credential saved", this.context());
+        return publicToken(token);
+    }
+    canReuse(token) {
+        if (!isValid(token, this.now()))
+            return false;
+        if (!token.expiry)
+            return true;
+        return (Date.parse(token.expiry) - this.now().getTime() > this.options.refreshBufferSeconds * 1000);
+    }
+    async withLock(action) {
+        logger.debug("waiting for credential lock", this.context());
+        const lease = await this.store.acquireLock(this.key, this.options.lockTimeoutSeconds * 1000);
+        logger.debug("credential lock acquired", this.context());
+        let failure;
+        try {
+            return await action();
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            try {
+                await this.store.releaseLock(lease);
+                logger.debug("credential lock released", this.context());
+            }
+            catch (releaseError) {
+                logger.debug("credential lock release failed", {
+                    ...this.context(),
+                    error: failureMetadata(releaseError),
+                });
+                if (failure === undefined)
+                    throw releaseError;
+            }
+        }
+    }
+    context() {
+        return { credential: credentialId(this.key), storage: this.store.name() };
+    }
+}
+export function publicToken(token) {
+    return {
+        accessToken: token.accessToken,
+        tokenType: token.tokenType,
+        ...(token.expiry ? { expiry: token.expiry } : {}),
+        scopes: [...token.scopes],
+    };
+}
+export function validateToken(token, previous) {
+    if (!token.accessToken.trim())
+        throw new AuthError("oauth", "Token response did not contain an access token");
+    return {
+        accessToken: token.accessToken,
+        tokenType: token.tokenType || "Bearer",
+        refreshToken: token.refreshToken ?? previous?.refreshToken,
+        expiry: token.expiry,
+        scopes: token.scopes.length ? [...token.scopes] : [...(previous?.scopes ?? [])],
+    };
+}
+function isValid(token, now) {
+    return Boolean(token.accessToken) && (!token.expiry || Date.parse(token.expiry) > now.getTime());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/lifecycle.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthError } from \"./errors.ts\";\nimport { authLogger, credentialId, failureMetadata, tokenMetadata } from \"./_logging.ts\";\nimport type { AccessToken, AuthOptions, CredentialStore, Token, TokenProvider } from \"./types.ts\";\n\nconst logger = authLogger(\"lifecycle\");\n\n/** Provider-neutral check-lock-check authentication and persistent token lifecycle. */\nexport class TokenLifecycle {\n  constructor(\n    private readonly key: string,\n    private readonly provider: TokenProvider,\n    private readonly store: CredentialStore,\n    private readonly options: AuthOptions,\n    private readonly now: () => Date = () => new Date(),\n  ) {\n    logger.debug(\"created authentication lifecycle\", {\n      credential: credentialId(key),\n      storage: store.name(),\n      refreshBufferSeconds: options.refreshBufferSeconds,\n      lockTimeoutSeconds: options.lockTimeoutSeconds,\n      loginTimeoutSeconds: options.loginTimeoutSeconds,\n      silentProvider: provider.canAuthenticateSilently(),\n    });\n  }\n\n  storeName(): string {\n    return this.store.name();\n  }\n\n  async login(): Promise<AccessToken> {\n    logger.debug(\"interactive login requested\", this.context());\n    return this.withLock(async () => {\n      await this.store.prepareWrite();\n      const token = validateToken(\n        await this.provider.login(this.options.loginTimeoutSeconds * 1000),\n      );\n      await this.store.save(this.key, token);\n      logger.debug(\"interactive login stored credential\", {\n        ...this.context(),\n        token: tokenMetadata(token, this.now()),\n      });\n      return publicToken(token);\n    });\n  }\n\n  token(): Promise<AccessToken> {\n    return this.loadToken(false);\n  }\n\n  tokenOrLogin(): Promise<AccessToken> {\n    return this.loadToken(true);\n  }\n\n  async tokenWithLogin(login?: boolean): Promise<AccessToken> {\n    logger.debug(\"token requested\", { ...this.context(), login: login ?? \"auto\" });\n    if (login === true) return this.login();\n    if (login === false) return this.token();\n    return this.tokenOrLogin();\n  }\n\n  forceRefresh(login = true): Promise<AccessToken> {\n    logger.debug(\"forced refresh requested\", { ...this.context(), login });\n    return this.refreshRejected(undefined, login);\n  }\n\n  refreshRejectedToken(staleAccessToken: string, login = true): Promise<AccessToken> {\n    logger.debug(\"rejected token refresh requested\", { ...this.context(), login });\n    return this.refreshRejected(staleAccessToken, login);\n  }\n\n  async logout(): Promise<void> {\n    logger.debug(\"logout requested\", this.context());\n    await this.withLock(() => this.store.remove(this.key));\n    logger.debug(\"stored credential removed\", this.context());\n  }\n\n  private async loadToken(login: boolean): Promise<AccessToken> {\n    const existing = await this.store.load(this.key);\n    const reusable = Boolean(existing && this.canReuse(existing));\n    logger.debug(\"checked credential cache\", {\n      ...this.context(),\n      login,\n      reusable,\n      token: tokenMetadata(existing, this.now()),\n    });\n    if (existing && reusable) return publicToken(existing);\n    return this.withLock(async () => {\n      const current = await this.store.load(this.key);\n      const currentReusable = Boolean(current && this.canReuse(current));\n      logger.debug(\"rechecked credential cache after lock\", {\n        ...this.context(),\n        reusable: currentReusable,\n        token: tokenMetadata(current, this.now()),\n      });\n      if (current && currentReusable) return publicToken(current);\n      return this.renew(current, login);\n    });\n  }\n\n  private async refreshRejected(\n    staleAccessToken: string | undefined,\n    login: boolean,\n  ): Promise<AccessToken> {\n    return this.withLock(async () => {\n      const current = await this.store.load(this.key);\n      if (\n        staleAccessToken &&\n        current?.accessToken &&\n        current.accessToken !== staleAccessToken &&\n        isValid(current, this.now())\n      ) {\n        logger.debug(\"reused replacement for rejected credential\", {\n          ...this.context(),\n          token: tokenMetadata(current, this.now()),\n        });\n        return publicToken(current);\n      }\n      return this.renew(current, login);\n    });\n  }\n\n  private async renew(current: Token | undefined, login: boolean): Promise<AccessToken> {\n    let token: Token;\n    if (current) {\n      logger.debug(\"refreshing stored credential\", {\n        ...this.context(),\n        loginFallback: login,\n        token: tokenMetadata(current, this.now()),\n      });\n      try {\n        token = await this.provider.refresh(current);\n      } catch (error) {\n        logger.debug(\"credential refresh failed\", {\n          ...this.context(),\n          loginFallback: login,\n          error: failureMetadata(error),\n        });\n        if (!login) throw error;\n        logger.debug(\"falling back to interactive login\", this.context());\n        token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);\n      }\n    } else if (this.provider.canAuthenticateSilently()) {\n      logger.debug(\"attempting silent credential acquisition\", {\n        ...this.context(),\n        loginFallback: login,\n      });\n      try {\n        token = await this.provider.authenticate(this.options.loginTimeoutSeconds * 1000);\n      } catch (error) {\n        logger.debug(\"silent credential acquisition failed\", {\n          ...this.context(),\n          loginFallback: login,\n          error: failureMetadata(error),\n        });\n        if (!login) throw error;\n        logger.debug(\"falling back to interactive login\", this.context());\n        token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);\n      }\n    } else if (login) {\n      logger.debug(\"provider requires interactive login\", this.context());\n      token = await this.provider.login(this.options.loginTimeoutSeconds * 1000);\n    } else {\n      throw new AuthError(\n        \"oauth\",\n        \"No stored credential is available and interactive login is disabled\",\n      );\n    }\n    token = validateToken(token, current);\n    logger.debug(\"credential acquisition completed\", {\n      ...this.context(),\n      token: tokenMetadata(token, this.now()),\n    });\n    await this.store.prepareWrite();\n    await this.store.save(this.key, token);\n    logger.debug(\"credential saved\", this.context());\n    return publicToken(token);\n  }\n\n  private canReuse(token: Token): boolean {\n    if (!isValid(token, this.now())) return false;\n    if (!token.expiry) return true;\n    return (\n      Date.parse(token.expiry) - this.now().getTime() > this.options.refreshBufferSeconds * 1000\n    );\n  }\n\n  private async withLock<T>(action: () => Promise<T>): Promise<T> {\n    logger.debug(\"waiting for credential lock\", this.context());\n    const lease = await this.store.acquireLock(this.key, this.options.lockTimeoutSeconds * 1000);\n    logger.debug(\"credential lock acquired\", this.context());\n    let failure: unknown;\n    try {\n      return await action();\n    } catch (error) {\n      failure = error;\n      throw error;\n    } finally {\n      try {\n        await this.store.releaseLock(lease);\n        logger.debug(\"credential lock released\", this.context());\n      } catch (releaseError) {\n        logger.debug(\"credential lock release failed\", {\n          ...this.context(),\n          error: failureMetadata(releaseError),\n        });\n        if (failure === undefined) throw releaseError;\n      }\n    }\n  }\n\n  private context(): Record<string, unknown> {\n    return { credential: credentialId(this.key), storage: this.store.name() };\n  }\n}\n\nexport function publicToken(token: Token): AccessToken {\n  return {\n    accessToken: token.accessToken,\n    tokenType: token.tokenType,\n    ...(token.expiry ? { expiry: token.expiry } : {}),\n    scopes: [...token.scopes],\n  };\n}\n\nexport function validateToken(token: Token, previous?: Token): Token {\n  if (!token.accessToken.trim())\n    throw new AuthError(\"oauth\", \"Token response did not contain an access token\");\n  return {\n    accessToken: token.accessToken,\n    tokenType: token.tokenType || \"Bearer\",\n    refreshToken: token.refreshToken ?? previous?.refreshToken,\n    expiry: token.expiry,\n    scopes: token.scopes.length ? [...token.scopes] : [...(previous?.scopes ?? [])],\n  };\n}\n\nfunction isValid(token: Token, now: Date): boolean {\n  return Boolean(token.accessToken) && (!token.expiry || Date.parse(token.expiry) > now.getTime());\n}\n"]}

package/lib/src/node-storage.d.ts

@@ -0,0 +1,20 @@
+import type { CredentialStore, LockAdapter, Token } from "./types.ts";
+import { FileLayout } from "./types.ts";
+/** File-backed credential store preserving unrelated Databricks CLI entries. */
+export declare class FileCredentialStore implements CredentialStore {
+    private readonly root;
+    private readonly layout;
+    private readonly locks;
+    constructor(root?: string, layout?: FileLayout, 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>;
+    releaseLock(lease: string): Promise<void>;
+    name(): string;
+    private forKey;
+    private withCacheLock;
+    private readCache;
+    private writeCache;
+}

package/lib/src/node-storage.js

@@ -0,0 +1,207 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { acquireFileLock } from "@dbx-tools/core/file-lock";
+import { authLogger, credentialId, tokenMetadata } from "./_logging.js";
+import { AuthError } from "./errors.js";
+import { FileLayout } from "./types.js";
+const logger = authLogger("file-storage");
+class NodeFileLocks {
+    lockDirectory;
+    leases = new Map();
+    constructor(lockDirectory) {
+        this.lockDirectory = lockDirectory;
+    }
+    async acquire(key, timeoutMs) {
+        logger.debug("waiting for file lock", {
+            credential: credentialId(key),
+            timeoutMs,
+        });
+        const lease = await acquireFileLock(key, { dir: this.lockDirectory, timeoutMs });
+        const id = randomUUID();
+        this.leases.set(id, lease);
+        logger.debug("file lock acquired", {
+            credential: credentialId(key),
+            backend: lease.backend,
+        });
+        return id;
+    }
+    async release(id) {
+        const lease = this.leases.get(id);
+        if (!lease)
+            return;
+        this.leases.delete(id);
+        await lease.release();
+        logger.debug("file lock released", { backend: lease.backend });
+    }
+}
+/** File-backed credential store preserving unrelated Databricks CLI entries. */
+export class FileCredentialStore {
+    root;
+    layout;
+    locks;
+    constructor(root = join(homedir(), ".databricks"), layout = FileLayout.Single, locks) {
+        this.root = root;
+        this.layout = layout;
+        this.locks = locks ?? new NodeFileLocks(join(root, "locks"));
+    }
+    async load(key) {
+        const store = this.forKey(key);
+        return store.withCacheLock(async () => {
+            const token = deserializeToken((await store.readCache()).tokens[key]);
+            logger.debug("loaded file credential", {
+                credential: credentialId(key),
+                layout: this.layout,
+                token: tokenMetadata(token),
+            });
+            return token;
+        });
+    }
+    async prepareWrite() {
+        await ensureDirectory(this.root, 0o700);
+        logger.debug("prepared credential directory", { layout: this.layout });
+    }
+    async save(key, token) {
+        const store = this.forKey(key);
+        await store.withCacheLock(async () => {
+            const cache = await store.readCache();
+            cache.tokens[key] = serializeToken(token);
+            await store.writeCache(cache);
+            logger.debug("saved file credential", {
+                credential: credentialId(key),
+                layout: this.layout,
+                token: tokenMetadata(token),
+            });
+        });
+    }
+    async remove(key) {
+        const store = this.forKey(key);
+        await store.withCacheLock(async () => {
+            const cache = await store.readCache();
+            delete cache.tokens[key];
+            await store.writeCache(cache);
+            logger.debug("removed file credential", {
+                credential: credentialId(key),
+                layout: this.layout,
+            });
+        });
+    }
+    acquireLock(key, timeoutMs) {
+        return this.locks.acquire(this.layout === FileLayout.Single ? `${this.root}:refresh` : `${this.root}:${key}:refresh`, timeoutMs);
+    }
+    releaseLock(lease) {
+        return this.locks.release(lease);
+    }
+    name() {
+        return "file";
+    }
+    forKey(key) {
+        if (this.layout === FileLayout.Single)
+            return this;
+        const digest = createHash("sha256").update(key).digest("hex");
+        return new FileCredentialStore(join(this.root, digest), FileLayout.Single, this.locks);
+    }
+    async withCacheLock(action) {
+        await ensureDirectory(this.root, 0o700);
+        const lease = await this.locks.acquire(`${this.root}:cache`, 30_000);
+        try {
+            return await action();
+        }
+        finally {
+            await this.locks.release(lease);
+        }
+    }
+    async readCache() {
+        try {
+            const source = await readTextFile(join(this.root, "token-cache.json"));
+            const cache = source ? JSON.parse(source) : { version: 1, tokens: {} };
+            if (cache.version !== 1 || typeof cache.tokens !== "object" || !cache.tokens) {
+                throw new AuthError("storage", "Token cache must use version 1");
+            }
+            logger.debug("read token cache", {
+                exists: Boolean(source),
+                credentialCount: Object.keys(cache.tokens).length,
+            });
+            return cache;
+        }
+        catch (cause) {
+            if (cause instanceof AuthError)
+                throw cause;
+            throw new AuthError("storage", "Could not read Databricks token cache", { cause });
+        }
+    }
+    async writeCache(cache) {
+        try {
+            await atomicWriteTextFile(join(this.root, "token-cache.json"), `${JSON.stringify(cache, null, 2)}\n`, 0o600);
+            logger.debug("wrote token cache", { credentialCount: Object.keys(cache.tokens).length });
+        }
+        catch (cause) {
+            throw new AuthError("storage", "Could not write Databricks token cache", { cause });
+        }
+    }
+}
+async function ensureDirectory(path, mode) {
+    await mkdir(path, { recursive: true, mode });
+    await chmod(path, mode);
+}
+async function readTextFile(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (cause) {
+        if (cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    }
+}
+async function atomicWriteTextFile(path, content, mode) {
+    const parent = dirname(path);
+    await ensureDirectory(parent, 0o700);
+    const temporary = join(parent, `.${basename(path)}-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, content, { mode, flag: "wx" });
+        await chmod(temporary, mode);
+        await rename(temporary, path);
+    }
+    finally {
+        await unlink(temporary).catch((cause) => {
+            if (cause.code !== "ENOENT")
+                throw cause;
+        });
+    }
+}
+function serializeToken(token) {
+    return {
+        access_token: token.accessToken,
+        token_type: token.tokenType,
+        ...(token.refreshToken ? { refresh_token: token.refreshToken } : {}),
+        ...(token.expiry ? { expiry: token.expiry } : {}),
+        ...(token.scopes.length ? { scopes: token.scopes } : {}),
+    };
+}
+function deserializeToken(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const accessToken = stringValue(record.access_token ?? record.accessToken);
+    if (!accessToken)
+        return undefined;
+    return {
+        accessToken,
+        tokenType: stringValue(record.token_type ?? record.tokenType) ?? "Bearer",
+        ...(stringValue(record.refresh_token ?? record.refreshToken)
+            ? { refreshToken: stringValue(record.refresh_token ?? record.refreshToken) }
+            : {}),
+        ...(stringValue(record.expiry ?? record.expires_at)
+            ? { expiry: stringValue(record.expiry ?? record.expires_at) }
+            : {}),
+        scopes: Array.isArray(record.scopes)
+            ? record.scopes.filter((scope) => typeof scope === "string")
+            : [],
+    };
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-storage.js","sourceRoot":"","sources":["../../src/node-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\nimport { chmod, mkdir, readFile, rename, unlink, writeFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { basename, dirname, join } from \"node:path\";\n\nimport { acquireFileLock, type FileLockLease } from \"@dbx-tools/core/file-lock\";\n\nimport { authLogger, credentialId, tokenMetadata } from \"./_logging.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport type { CredentialStore, LockAdapter, Token } from \"./types.ts\";\nimport { FileLayout } from \"./types.ts\";\n\nconst logger = authLogger(\"file-storage\");\n\ninterface TokenCache {\n  version: number;\n  tokens: Record<string, unknown>;\n}\n\nclass NodeFileLocks implements LockAdapter {\n  private readonly leases = new Map<string, FileLockLease>();\n\n  constructor(private readonly lockDirectory: string) {}\n\n  async acquire(key: string, timeoutMs: number): Promise<string> {\n    logger.debug(\"waiting for file lock\", {\n      credential: credentialId(key),\n      timeoutMs,\n    });\n    const lease = await acquireFileLock(key, { dir: this.lockDirectory, timeoutMs });\n    const id = randomUUID();\n    this.leases.set(id, lease);\n    logger.debug(\"file lock acquired\", {\n      credential: credentialId(key),\n      backend: lease.backend,\n    });\n    return id;\n  }\n\n  async release(id: string): Promise<void> {\n    const lease = this.leases.get(id);\n    if (!lease) return;\n    this.leases.delete(id);\n    await lease.release();\n    logger.debug(\"file lock released\", { backend: lease.backend });\n  }\n}\n\n/** File-backed credential store preserving unrelated Databricks CLI entries. */\nexport class FileCredentialStore implements CredentialStore {\n  private readonly locks: LockAdapter;\n\n  constructor(\n    private readonly root = join(homedir(), \".databricks\"),\n    private readonly layout = FileLayout.Single,\n    locks?: LockAdapter,\n  ) {\n    this.locks = locks ?? new NodeFileLocks(join(root, \"locks\"));\n  }\n\n  async load(key: string): Promise<Token | undefined> {\n    const store = this.forKey(key);\n    return store.withCacheLock(async () => {\n      const token = deserializeToken((await store.readCache()).tokens[key]);\n      logger.debug(\"loaded file credential\", {\n        credential: credentialId(key),\n        layout: this.layout,\n        token: tokenMetadata(token),\n      });\n      return token;\n    });\n  }\n\n  async prepareWrite(): Promise<void> {\n    await ensureDirectory(this.root, 0o700);\n    logger.debug(\"prepared credential directory\", { layout: this.layout });\n  }\n\n  async save(key: string, token: Token): Promise<void> {\n    const store = this.forKey(key);\n    await store.withCacheLock(async () => {\n      const cache = await store.readCache();\n      cache.tokens[key] = serializeToken(token);\n      await store.writeCache(cache);\n      logger.debug(\"saved file credential\", {\n        credential: credentialId(key),\n        layout: this.layout,\n        token: tokenMetadata(token),\n      });\n    });\n  }\n\n  async remove(key: string): Promise<void> {\n    const store = this.forKey(key);\n    await store.withCacheLock(async () => {\n      const cache = await store.readCache();\n      delete cache.tokens[key];\n      await store.writeCache(cache);\n      logger.debug(\"removed file credential\", {\n        credential: credentialId(key),\n        layout: this.layout,\n      });\n    });\n  }\n\n  acquireLock(key: string, timeoutMs: number): Promise<string> {\n    return this.locks.acquire(\n      this.layout === FileLayout.Single ? `${this.root}:refresh` : `${this.root}:${key}:refresh`,\n      timeoutMs,\n    );\n  }\n\n  releaseLock(lease: string): Promise<void> {\n    return this.locks.release(lease);\n  }\n\n  name(): string {\n    return \"file\";\n  }\n\n  private forKey(key: string): FileCredentialStore {\n    if (this.layout === FileLayout.Single) return this;\n    const digest = createHash(\"sha256\").update(key).digest(\"hex\");\n    return new FileCredentialStore(join(this.root, digest), FileLayout.Single, this.locks);\n  }\n\n  private async withCacheLock<T>(action: () => Promise<T>): Promise<T> {\n    await ensureDirectory(this.root, 0o700);\n    const lease = await this.locks.acquire(`${this.root}:cache`, 30_000);\n    try {\n      return await action();\n    } finally {\n      await this.locks.release(lease);\n    }\n  }\n\n  private async readCache(): Promise<TokenCache> {\n    try {\n      const source = await readTextFile(join(this.root, \"token-cache.json\"));\n      const cache = source ? (JSON.parse(source) as TokenCache) : { version: 1, tokens: {} };\n      if (cache.version !== 1 || typeof cache.tokens !== \"object\" || !cache.tokens) {\n        throw new AuthError(\"storage\", \"Token cache must use version 1\");\n      }\n      logger.debug(\"read token cache\", {\n        exists: Boolean(source),\n        credentialCount: Object.keys(cache.tokens).length,\n      });\n      return cache;\n    } catch (cause) {\n      if (cause instanceof AuthError) throw cause;\n      throw new AuthError(\"storage\", \"Could not read Databricks token cache\", { cause });\n    }\n  }\n\n  private async writeCache(cache: TokenCache): Promise<void> {\n    try {\n      await atomicWriteTextFile(\n        join(this.root, \"token-cache.json\"),\n        `${JSON.stringify(cache, null, 2)}\\n`,\n        0o600,\n      );\n      logger.debug(\"wrote token cache\", { credentialCount: Object.keys(cache.tokens).length });\n    } catch (cause) {\n      throw new AuthError(\"storage\", \"Could not write Databricks token cache\", { cause });\n    }\n  }\n}\n\nasync function ensureDirectory(path: string, mode: number): Promise<void> {\n  await mkdir(path, { recursive: true, mode });\n  await chmod(path, mode);\n}\n\nasync function readTextFile(path: string): Promise<string | undefined> {\n  try {\n    return await readFile(path, \"utf8\");\n  } catch (cause) {\n    if ((cause as NodeJS.ErrnoException).code === \"ENOENT\") return undefined;\n    throw cause;\n  }\n}\n\nasync function atomicWriteTextFile(path: string, content: string, mode: number): Promise<void> {\n  const parent = dirname(path);\n  await ensureDirectory(parent, 0o700);\n  const temporary = join(parent, `.${basename(path)}-${randomUUID()}.tmp`);\n  try {\n    await writeFile(temporary, content, { mode, flag: \"wx\" });\n    await chmod(temporary, mode);\n    await rename(temporary, path);\n  } finally {\n    await unlink(temporary).catch((cause: NodeJS.ErrnoException) => {\n      if (cause.code !== \"ENOENT\") throw cause;\n    });\n  }\n}\n\nfunction serializeToken(token: Token): Record<string, unknown> {\n  return {\n    access_token: token.accessToken,\n    token_type: token.tokenType,\n    ...(token.refreshToken ? { refresh_token: token.refreshToken } : {}),\n    ...(token.expiry ? { expiry: token.expiry } : {}),\n    ...(token.scopes.length ? { scopes: token.scopes } : {}),\n  };\n}\n\nfunction deserializeToken(value: unknown): Token | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const record = value as Record<string, unknown>;\n  const accessToken = stringValue(record.access_token ?? record.accessToken);\n  if (!accessToken) return undefined;\n  return {\n    accessToken,\n    tokenType: stringValue(record.token_type ?? record.tokenType) ?? \"Bearer\",\n    ...(stringValue(record.refresh_token ?? record.refreshToken)\n      ? { refreshToken: stringValue(record.refresh_token ?? record.refreshToken) }\n      : {}),\n    ...(stringValue(record.expiry ?? record.expires_at)\n      ? { expiry: stringValue(record.expiry ?? record.expires_at) }\n      : {}),\n    scopes: Array.isArray(record.scopes)\n      ? record.scopes.filter((scope): scope is string => typeof scope === \"string\")\n      : [],\n  };\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.trim() ? value : undefined;\n}\n"]}

package/lib/src/personal-access-token.d.ts

@@ -0,0 +1,11 @@
+import type { Token, TokenProvider } from "./types.ts";
+/** Non-refreshing provider for a configured Databricks personal access token. */
+export declare class DatabricksPersonalAccessTokenProvider implements TokenProvider {
+    private readonly accessToken;
+    constructor(accessToken: string);
+    authenticate(): Promise<Token>;
+    login(): Promise<Token>;
+    refresh(): Promise<Token>;
+    canAuthenticateSilently(): boolean;
+    private token;
+}

package/lib/src/personal-access-token.js

@@ -0,0 +1,30 @@
+import { authLogger } from "./_logging.js";
+const logger = authLogger("pat");
+/** Non-refreshing provider for a configured Databricks personal access token. */
+export class DatabricksPersonalAccessTokenProvider {
+    accessToken;
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    authenticate() {
+        return Promise.resolve(this.token());
+    }
+    login() {
+        return Promise.resolve(this.token());
+    }
+    refresh() {
+        return Promise.resolve(this.token());
+    }
+    canAuthenticateSilently() {
+        return true;
+    }
+    token() {
+        logger.debug("using configured personal access token");
+        return {
+            accessToken: this.accessToken,
+            tokenType: "Bearer",
+            scopes: [],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/service-principal.d.ts

@@ -0,0 +1,24 @@
+import type { Token, TokenProvider } from "./types.ts";
+/** Client-credentials inputs and transport options for Databricks OAuth. */
+export interface DatabricksServicePrincipalConfig {
+    tokenEndpoint: string;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+    groupId?: string;
+    fetch?: typeof globalThis.fetch;
+    allowInsecureRequests?: boolean;
+}
+/** Databricks service-principal provider backed by client credentials. */
+export declare class DatabricksServicePrincipalProvider implements TokenProvider {
+    private readonly config;
+    private readonly authorizationServer;
+    private readonly client;
+    private readonly requestOptions;
+    constructor(config: DatabricksServicePrincipalConfig);
+    authenticate(): Promise<Token>;
+    login(): Promise<Token>;
+    refresh(): Promise<Token>;
+    canAuthenticateSilently(): boolean;
+    private acquire;
+}