@dbx-tools/databricks 0.6.186 → 0.6.191

package/lib/src/cloud.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Best-effort geolocation of a host to the cloud provider and region it
+ * runs in. Resolves the host to its IP address(es) via DNS, then matches
+ * those addresses against the public IP-range feeds each hyperscaler
+ * publishes (AWS, Azure, GCP). Handy for placing a Databricks workspace
+ * URL, but works for any host.
+ *
+ * The range feeds are large and change slowly, so each provider's feed
+ * is cached for {@link RANGE_CACHE_TTL_MS} (24 hours) at two layers: an
+ * on-disk copy under the OS temp dir (survives process restarts, shared
+ * across processes) plus an in-process memoized parse. A provider whose
+ * feed fails to load is skipped rather than failing the whole lookup -
+ * the other providers still answer.
+ *
+ * Server-only: DNS resolution needs `node:dns` (via `./net.ts`), the
+ * disk cache needs `node:fs` / `node:os` / `node:path`, and the feeds
+ * are fetched with the global `fetch`.
+ *
+ * @module
+ */
+import { net } from "@dbx-tools/shared-core";
+/** How long a fetched provider IP-range feed is reused before refetch. */
+export declare const RANGE_CACHE_TTL_MS: number;
+/** Cloud hyperscaler a host resolves into. */
+export declare enum CloudProvider {
+    Aws = "aws",
+    Azure = "azure",
+    Gcp = "gcp"
+}
+/**
+ * Where a host lives: the {@link CloudProvider}, the provider-native
+ * `region` string (whatever the provider's feed calls it, e.g.
+ * `"us-east-1"` on AWS, `"eastus2"` on Azure, `"us-east1"` on GCP), the
+ * resolved `ip` that matched, and the `cidr` block it fell in.
+ */
+export interface CloudLocation {
+    provider: CloudProvider;
+    region: string;
+    ip: string;
+    cidr: string;
+}
+/** A parsed CIDR block tagged with the region it belongs to. */
+interface RegionCidr extends net.Cidr {
+    region: string;
+}
+/** One provider's parsed, region-tagged range table. */
+interface ProviderRanges {
+    provider: CloudProvider;
+    ranges: RegionCidr[];
+}
+/**
+ * Resolve `input`'s host to a {@link CloudLocation}, or `null` when the
+ * host can't be resolved or none of its IPs match a known cloud range.
+ * `input` is any {@link net.UrlLike} - a URL, a bare host, or a `{ url }`
+ * wrapper.
+ *
+ * The provider range feeds are cached for {@link RANGE_CACHE_TTL_MS}, so
+ * only the first call in a 24-hour window pays the fetch cost; the DNS
+ * lookup happens on every call.
+ *
+ * @example
+ * await resolveCloudLocation("https://adb-1234567890.7.azuredatabricks.net");
+ * // { provider: CloudProvider.Azure,
+ * //   region: "eastus2", ip: "...", cidr: "..." }
+ *
+ * await resolveCloudLocation("dbc-abc123.cloud.databricks.com");
+ * // { provider: CloudProvider.Aws,
+ * //   region: "us-west-2", ip: "...", cidr: "..." }
+ */
+export declare function resolveCloudLocation(input: net.UrlLike): Promise<CloudLocation | null>;
+/**
+ * Load every provider's region-tagged range table, each cached for
+ * {@link RANGE_CACHE_TTL_MS}. Providers are loaded in parallel and a
+ * feed that fails to fetch or parse is dropped (logged, not thrown) so
+ * a single flaky feed never sinks the whole lookup. Exposed for callers
+ * that want to match many IPs against one cached snapshot without a DNS
+ * step per address.
+ */
+export declare function loadProviderRanges(): Promise<ProviderRanges[]>;
+export {};

package/lib/src/cloud.js

@@ -0,0 +1,240 @@
+/**
+ * Best-effort geolocation of a host to the cloud provider and region it
+ * runs in. Resolves the host to its IP address(es) via DNS, then matches
+ * those addresses against the public IP-range feeds each hyperscaler
+ * publishes (AWS, Azure, GCP). Handy for placing a Databricks workspace
+ * URL, but works for any host.
+ *
+ * The range feeds are large and change slowly, so each provider's feed
+ * is cached for {@link RANGE_CACHE_TTL_MS} (24 hours) at two layers: an
+ * on-disk copy under the OS temp dir (survives process restarts, shared
+ * across processes) plus an in-process memoized parse. A provider whose
+ * feed fails to load is skipped rather than failing the whole lookup -
+ * the other providers still answer.
+ *
+ * Server-only: DNS resolution needs `node:dns` (via `./net.ts`), the
+ * disk cache needs `node:fs` / `node:os` / `node:path`, and the feeds
+ * are fetched with the global `fetch`.
+ *
+ * @module
+ */
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { file } from "@dbx-tools/core";
+import { error, functionModule, hash, http, json, log, net } from "@dbx-tools/shared-core";
+import { resolveHostIps } from "./net.js";
+const logger = log.logger("cloud");
+/** How long a fetched provider IP-range feed is reused before refetch. */
+export const RANGE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** AWS publishes a single stable, unauthenticated ranges feed. */
+const AWS_RANGES_URL = "https://ip-ranges.amazonaws.com/ip-ranges.json";
+/** GCP publishes a single stable, unauthenticated ranges feed. */
+const GCP_RANGES_URL = "https://www.gstatic.com/ipranges/cloud.json";
+/**
+ * Azure has no stable feed URL - the JSON download link (with a
+ * rotating date stamp) lives on this human-facing download page and
+ * must be scraped out. See {@link fetchAzureRanges}.
+ */
+const AZURE_DOWNLOAD_PAGE = "https://www.microsoft.com/en-us/download/details.aspx?id=56519";
+/** Regex that plucks the current `ServiceTags_Public_<date>.json` link off the Azure page. */
+const AZURE_JSON_LINK = /https:\/\/download\.microsoft\.com\/download\/[^"']*ServiceTags_Public_\d+\.json/;
+/** Cloud hyperscaler a host resolves into. */
+export var CloudProvider;
+(function (CloudProvider) {
+    CloudProvider["Aws"] = "aws";
+    CloudProvider["Azure"] = "azure";
+    CloudProvider["Gcp"] = "gcp";
+})(CloudProvider || (CloudProvider = {}));
+/**
+ * Resolve `input`'s host to a {@link CloudLocation}, or `null` when the
+ * host can't be resolved or none of its IPs match a known cloud range.
+ * `input` is any {@link net.UrlLike} - a URL, a bare host, or a `{ url }`
+ * wrapper.
+ *
+ * The provider range feeds are cached for {@link RANGE_CACHE_TTL_MS}, so
+ * only the first call in a 24-hour window pays the fetch cost; the DNS
+ * lookup happens on every call.
+ *
+ * @example
+ * await resolveCloudLocation("https://adb-1234567890.7.azuredatabricks.net");
+ * // { provider: CloudProvider.Azure,
+ * //   region: "eastus2", ip: "...", cidr: "..." }
+ *
+ * await resolveCloudLocation("dbc-abc123.cloud.databricks.com");
+ * // { provider: CloudProvider.Aws,
+ * //   region: "us-west-2", ip: "...", cidr: "..." }
+ */
+export async function resolveCloudLocation(input) {
+    const ips = await resolveHostIps(input);
+    if (ips.length === 0) {
+        logger.debug("no ips resolved", { input: String(input) });
+        return null;
+    }
+    const providers = await loadProviderRanges();
+    for (const ip of ips) {
+        const parsed = net.parseIp(ip);
+        if (!parsed)
+            continue;
+        for (const { provider, ranges } of providers) {
+            const match = net.findContainingCidr(parsed, ranges);
+            if (match) {
+                return { provider, region: match.region, ip, cidr: match.cidr };
+            }
+        }
+    }
+    logger.debug("no cloud range matched", { ips });
+    return null;
+}
+/**
+ * Load every provider's region-tagged range table, each cached for
+ * {@link RANGE_CACHE_TTL_MS}. Providers are loaded in parallel and a
+ * feed that fails to fetch or parse is dropped (logged, not thrown) so
+ * a single flaky feed never sinks the whole lookup. Exposed for callers
+ * that want to match many IPs against one cached snapshot without a DNS
+ * step per address.
+ */
+export async function loadProviderRanges() {
+    const settled = await Promise.allSettled([loadAwsRanges(), loadAzureRanges(), loadGcpRanges()]);
+    const out = [];
+    for (const result of settled) {
+        if (result.status === "fulfilled")
+            out.push(result.value);
+        else
+            logger.warn("provider range load failed", { error: error.errorMessage(result.reason) });
+    }
+    return out;
+}
+// ────────────────────────────────────────────────────────────────
+// Per-provider cached loaders
+// ────────────────────────────────────────────────────────────────
+const loadAwsRanges = functionModule.memoize(fetchAwsRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+const loadAzureRanges = functionModule.memoize(fetchAzureRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+const loadGcpRanges = functionModule.memoize(fetchGcpRanges, { ttlMs: RANGE_CACHE_TTL_MS });
+/**
+ * AWS `ip-ranges.json`: a flat list of IPv4 (`prefixes`) and IPv6
+ * (`ipv6_prefixes`) blocks, each already tagged with a `region` such
+ * as `"us-east-1"` (or `"GLOBAL"` for edge ranges).
+ */
+async function fetchAwsRanges() {
+    const feed = await fetchJson(AWS_RANGES_URL);
+    const ranges = [];
+    for (const entry of feed.prefixes ?? []) {
+        addRange(ranges, entry.ip_prefix, entry.region);
+    }
+    for (const entry of feed.ipv6_prefixes ?? []) {
+        addRange(ranges, entry.ipv6_prefix, entry.region);
+    }
+    logger.debug("loaded aws ranges", { count: ranges.length });
+    return { provider: CloudProvider.Aws, ranges };
+}
+/**
+ * GCP `cloud.json`: a list of blocks each carrying an `ipv4Prefix` or
+ * `ipv6Prefix` and a `scope` that is the region (`"us-east1"`) or
+ * `"global"` for non-regional ranges.
+ */
+async function fetchGcpRanges() {
+    const feed = await fetchJson(GCP_RANGES_URL);
+    const ranges = [];
+    for (const entry of feed.prefixes ?? []) {
+        addRange(ranges, entry.ipv4Prefix ?? entry.ipv6Prefix, entry.scope);
+    }
+    logger.debug("loaded gcp ranges", { count: ranges.length });
+    return { provider: CloudProvider.Gcp, ranges };
+}
+/**
+ * Azure service tags: Microsoft ships no stable feed URL, so scrape the
+ * current `ServiceTags_Public_<date>.json` link off the download page
+ * and fetch it. Only the regional `AzureCloud.<region>` aggregates
+ * (which have a non-empty `region`) are kept; the cloud-wide
+ * `AzureCloud` tag and per-service tags are ignored so an address maps
+ * cleanly to one region.
+ */
+async function fetchAzureRanges() {
+    const page = await fetchText(AZURE_DOWNLOAD_PAGE);
+    const jsonUrl = page.match(AZURE_JSON_LINK)?.[0];
+    if (!jsonUrl) {
+        throw new Error("could not find ServiceTags JSON link on Azure download page");
+    }
+    const feed = await fetchJson(jsonUrl);
+    const ranges = [];
+    for (const value of feed.values ?? []) {
+        const region = value.properties?.region;
+        if (!region || !value.name?.startsWith("AzureCloud."))
+            continue;
+        for (const prefix of value.properties?.addressPrefixes ?? []) {
+            addRange(ranges, prefix, region);
+        }
+    }
+    logger.debug("loaded azure ranges", { count: ranges.length });
+    return { provider: CloudProvider.Azure, ranges };
+}
+// ────────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────────
+/** Parse `cidr` and, when valid and `region` is set, push a tagged range. */
+function addRange(ranges, cidr, region) {
+    if (!cidr || !region)
+        return;
+    const parsed = net.parseCidr(cidr);
+    if (parsed)
+        ranges.push({ ...parsed, region });
+}
+/**
+ * Fetch and parse a provider feed. A parse failure names the URL rather than
+ * surfacing an opaque `Unexpected token` - the text may come from the on-disk
+ * cache, so "which feed" is the part worth knowing. {@link loadProviderRanges}
+ * turns the throw into a per-provider warning.
+ */
+async function fetchJson(url) {
+    const text = await fetchText(url);
+    const parsed = json.parse(text);
+    if (parsed === undefined) {
+        throw new Error(`range feed returned non-JSON content: ${url}`);
+    }
+    return parsed;
+}
+/**
+ * Fetch `url` as text with a 24h on-disk cache under the OS temp dir
+ * (keyed by an FNV hash of the URL). A fresh cache file is returned
+ * directly; a miss/expiry fetches, writes to a unique temp file, and
+ * atomically renames it into place so concurrent callers never observe
+ * a half-written cache entry.
+ */
+async function fetchText(url) {
+    const cacheDir = join(tmpdir(), "dbx-tools", "shared", "cloud");
+    const cacheDirCreated = await mkdir(cacheDir, { recursive: true });
+    const cachePath = join(cacheDir, `fetch-${hash.fnvHash(url)}.txt`);
+    const createdAt = cacheDirCreated ? undefined : await getCreated(cachePath);
+    if (createdAt) {
+        const expiresAt = new Date(createdAt.getTime() + RANGE_CACHE_TTL_MS);
+        if (expiresAt > new Date()) {
+            logger.debug("cached fetch hit", { url, cachePath });
+            return readFile(cachePath, "utf8");
+        }
+    }
+    let tempPath = join(cacheDir, `${hash.id()}.txt`);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw await http.createFetchError(response, url);
+        }
+        const responseText = await response.text();
+        await mkdir(dirname(tempPath), { recursive: true });
+        await writeFile(tempPath, responseText);
+        await rename(tempPath, cachePath);
+        logger.debug("cached fetch load", { url, cachePath });
+        tempPath = null;
+        return responseText;
+    }
+    finally {
+        if (tempPath) {
+            await unlink(tempPath);
+        }
+    }
+}
+/** Birth time of `path`, or `undefined` when it doesn't exist yet. */
+async function getCreated(path) {
+    return (await file.statSync(path))?.birthtime;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud.js","sourceRoot":"","sources":["../../src/cloud.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Best-effort geolocation of a host to the cloud provider and region it\n * runs in. Resolves the host to its IP address(es) via DNS, then matches\n * those addresses against the public IP-range feeds each hyperscaler\n * publishes (AWS, Azure, GCP). Handy for placing a Databricks workspace\n * URL, but works for any host.\n *\n * The range feeds are large and change slowly, so each provider's feed\n * is cached for {@link RANGE_CACHE_TTL_MS} (24 hours) at two layers: an\n * on-disk copy under the OS temp dir (survives process restarts, shared\n * across processes) plus an in-process memoized parse. A provider whose\n * feed fails to load is skipped rather than failing the whole lookup -\n * the other providers still answer.\n *\n * Server-only: DNS resolution needs `node:dns` (via `./net.ts`), the\n * disk cache needs `node:fs` / `node:os` / `node:path`, and the feeds\n * are fetched with the global `fetch`.\n *\n * @module\n */\n\nimport { mkdir, readFile, rename, unlink, writeFile } from \"node:fs/promises\";\nimport { tmpdir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\n\nimport { file } from \"@dbx-tools/core\";\nimport { error, functionModule, hash, http, json, log, net } from \"@dbx-tools/shared-core\";\nimport { resolveHostIps } from \"./net.ts\";\n\nconst logger = log.logger(\"cloud\");\n\n/** How long a fetched provider IP-range feed is reused before refetch. */\nexport const RANGE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;\n\n/** AWS publishes a single stable, unauthenticated ranges feed. */\nconst AWS_RANGES_URL = \"https://ip-ranges.amazonaws.com/ip-ranges.json\";\n/** GCP publishes a single stable, unauthenticated ranges feed. */\nconst GCP_RANGES_URL = \"https://www.gstatic.com/ipranges/cloud.json\";\n/**\n * Azure has no stable feed URL - the JSON download link (with a\n * rotating date stamp) lives on this human-facing download page and\n * must be scraped out. See {@link fetchAzureRanges}.\n */\nconst AZURE_DOWNLOAD_PAGE = \"https://www.microsoft.com/en-us/download/details.aspx?id=56519\";\n/** Regex that plucks the current `ServiceTags_Public_<date>.json` link off the Azure page. */\nconst AZURE_JSON_LINK =\n  /https:\\/\\/download\\.microsoft\\.com\\/download\\/[^\"']*ServiceTags_Public_\\d+\\.json/;\n\n/** Cloud hyperscaler a host resolves into. */\nexport enum CloudProvider {\n  Aws = \"aws\",\n  Azure = \"azure\",\n  Gcp = \"gcp\",\n}\n\n/**\n * Where a host lives: the {@link CloudProvider}, the provider-native\n * `region` string (whatever the provider's feed calls it, e.g.\n * `\"us-east-1\"` on AWS, `\"eastus2\"` on Azure, `\"us-east1\"` on GCP), the\n * resolved `ip` that matched, and the `cidr` block it fell in.\n */\nexport interface CloudLocation {\n  provider: CloudProvider;\n  region: string;\n  ip: string;\n  cidr: string;\n}\n\n/** A parsed CIDR block tagged with the region it belongs to. */\ninterface RegionCidr extends net.Cidr {\n  region: string;\n}\n\n/** One provider's parsed, region-tagged range table. */\ninterface ProviderRanges {\n  provider: CloudProvider;\n  ranges: RegionCidr[];\n}\n\n/**\n * Resolve `input`'s host to a {@link CloudLocation}, or `null` when the\n * host can't be resolved or none of its IPs match a known cloud range.\n * `input` is any {@link net.UrlLike} - a URL, a bare host, or a `{ url }`\n * wrapper.\n *\n * The provider range feeds are cached for {@link RANGE_CACHE_TTL_MS}, so\n * only the first call in a 24-hour window pays the fetch cost; the DNS\n * lookup happens on every call.\n *\n * @example\n * await resolveCloudLocation(\"https://adb-1234567890.7.azuredatabricks.net\");\n * // { provider: CloudProvider.Azure,\n * //   region: \"eastus2\", ip: \"...\", cidr: \"...\" }\n *\n * await resolveCloudLocation(\"dbc-abc123.cloud.databricks.com\");\n * // { provider: CloudProvider.Aws,\n * //   region: \"us-west-2\", ip: \"...\", cidr: \"...\" }\n */\nexport async function resolveCloudLocation(input: net.UrlLike): Promise<CloudLocation | null> {\n  const ips = await resolveHostIps(input);\n  if (ips.length === 0) {\n    logger.debug(\"no ips resolved\", { input: String(input) });\n    return null;\n  }\n  const providers = await loadProviderRanges();\n  for (const ip of ips) {\n    const parsed = net.parseIp(ip);\n    if (!parsed) continue;\n    for (const { provider, ranges } of providers) {\n      const match = net.findContainingCidr(parsed, ranges);\n      if (match) {\n        return { provider, region: match.region, ip, cidr: match.cidr };\n      }\n    }\n  }\n  logger.debug(\"no cloud range matched\", { ips });\n  return null;\n}\n\n/**\n * Load every provider's region-tagged range table, each cached for\n * {@link RANGE_CACHE_TTL_MS}. Providers are loaded in parallel and a\n * feed that fails to fetch or parse is dropped (logged, not thrown) so\n * a single flaky feed never sinks the whole lookup. Exposed for callers\n * that want to match many IPs against one cached snapshot without a DNS\n * step per address.\n */\nexport async function loadProviderRanges(): Promise<ProviderRanges[]> {\n  const settled = await Promise.allSettled([loadAwsRanges(), loadAzureRanges(), loadGcpRanges()]);\n  const out: ProviderRanges[] = [];\n  for (const result of settled) {\n    if (result.status === \"fulfilled\") out.push(result.value);\n    else logger.warn(\"provider range load failed\", { error: error.errorMessage(result.reason) });\n  }\n  return out;\n}\n\n// ────────────────────────────────────────────────────────────────\n// Per-provider cached loaders\n// ────────────────────────────────────────────────────────────────\n\nconst loadAwsRanges = functionModule.memoize(fetchAwsRanges, { ttlMs: RANGE_CACHE_TTL_MS });\nconst loadAzureRanges = functionModule.memoize(fetchAzureRanges, { ttlMs: RANGE_CACHE_TTL_MS });\nconst loadGcpRanges = functionModule.memoize(fetchGcpRanges, { ttlMs: RANGE_CACHE_TTL_MS });\n\n// ────────────────────────────────────────────────────────────────\n// Provider feed fetch + parse\n// ────────────────────────────────────────────────────────────────\n\ninterface AwsFeed {\n  prefixes?: { ip_prefix?: string; region?: string }[];\n  ipv6_prefixes?: { ipv6_prefix?: string; region?: string }[];\n}\n\n/**\n * AWS `ip-ranges.json`: a flat list of IPv4 (`prefixes`) and IPv6\n * (`ipv6_prefixes`) blocks, each already tagged with a `region` such\n * as `\"us-east-1\"` (or `\"GLOBAL\"` for edge ranges).\n */\nasync function fetchAwsRanges(): Promise<ProviderRanges> {\n  const feed = await fetchJson<AwsFeed>(AWS_RANGES_URL);\n  const ranges: RegionCidr[] = [];\n  for (const entry of feed.prefixes ?? []) {\n    addRange(ranges, entry.ip_prefix, entry.region);\n  }\n  for (const entry of feed.ipv6_prefixes ?? []) {\n    addRange(ranges, entry.ipv6_prefix, entry.region);\n  }\n  logger.debug(\"loaded aws ranges\", { count: ranges.length });\n  return { provider: CloudProvider.Aws, ranges };\n}\n\ninterface GcpFeed {\n  prefixes?: { ipv4Prefix?: string; ipv6Prefix?: string; scope?: string }[];\n}\n\n/**\n * GCP `cloud.json`: a list of blocks each carrying an `ipv4Prefix` or\n * `ipv6Prefix` and a `scope` that is the region (`\"us-east1\"`) or\n * `\"global\"` for non-regional ranges.\n */\nasync function fetchGcpRanges(): Promise<ProviderRanges> {\n  const feed = await fetchJson<GcpFeed>(GCP_RANGES_URL);\n  const ranges: RegionCidr[] = [];\n  for (const entry of feed.prefixes ?? []) {\n    addRange(ranges, entry.ipv4Prefix ?? entry.ipv6Prefix, entry.scope);\n  }\n  logger.debug(\"loaded gcp ranges\", { count: ranges.length });\n  return { provider: CloudProvider.Gcp, ranges };\n}\n\ninterface AzureFeed {\n  values?: {\n    name?: string;\n    properties?: { region?: string; addressPrefixes?: string[] };\n  }[];\n}\n\n/**\n * Azure service tags: Microsoft ships no stable feed URL, so scrape the\n * current `ServiceTags_Public_<date>.json` link off the download page\n * and fetch it. Only the regional `AzureCloud.<region>` aggregates\n * (which have a non-empty `region`) are kept; the cloud-wide\n * `AzureCloud` tag and per-service tags are ignored so an address maps\n * cleanly to one region.\n */\nasync function fetchAzureRanges(): Promise<ProviderRanges> {\n  const page = await fetchText(AZURE_DOWNLOAD_PAGE);\n  const jsonUrl = page.match(AZURE_JSON_LINK)?.[0];\n  if (!jsonUrl) {\n    throw new Error(\"could not find ServiceTags JSON link on Azure download page\");\n  }\n  const feed = await fetchJson<AzureFeed>(jsonUrl);\n  const ranges: RegionCidr[] = [];\n  for (const value of feed.values ?? []) {\n    const region = value.properties?.region;\n    if (!region || !value.name?.startsWith(\"AzureCloud.\")) continue;\n    for (const prefix of value.properties?.addressPrefixes ?? []) {\n      addRange(ranges, prefix, region);\n    }\n  }\n  logger.debug(\"loaded azure ranges\", { count: ranges.length });\n  return { provider: CloudProvider.Azure, ranges };\n}\n\n// ────────────────────────────────────────────────────────────────\n// Helpers\n// ────────────────────────────────────────────────────────────────\n\n/** Parse `cidr` and, when valid and `region` is set, push a tagged range. */\nfunction addRange(ranges: RegionCidr[], cidr?: string, region?: string): void {\n  if (!cidr || !region) return;\n  const parsed = net.parseCidr(cidr);\n  if (parsed) ranges.push({ ...parsed, region });\n}\n\n/**\n * Fetch and parse a provider feed. A parse failure names the URL rather than\n * surfacing an opaque `Unexpected token` - the text may come from the on-disk\n * cache, so \"which feed\" is the part worth knowing. {@link loadProviderRanges}\n * turns the throw into a per-provider warning.\n */\nasync function fetchJson<T>(url: string): Promise<T> {\n  const text = await fetchText(url);\n  const parsed = json.parse<T>(text);\n  if (parsed === undefined) {\n    throw new Error(`range feed returned non-JSON content: ${url}`);\n  }\n  return parsed;\n}\n\n/**\n * Fetch `url` as text with a 24h on-disk cache under the OS temp dir\n * (keyed by an FNV hash of the URL). A fresh cache file is returned\n * directly; a miss/expiry fetches, writes to a unique temp file, and\n * atomically renames it into place so concurrent callers never observe\n * a half-written cache entry.\n */\nasync function fetchText(url: string): Promise<string> {\n  const cacheDir = join(tmpdir(), \"dbx-tools\", \"shared\", \"cloud\");\n  const cacheDirCreated = await mkdir(cacheDir, { recursive: true });\n  const cachePath = join(cacheDir, `fetch-${hash.fnvHash(url)}.txt`);\n  const createdAt = cacheDirCreated ? undefined : await getCreated(cachePath);\n  if (createdAt) {\n    const expiresAt = new Date(createdAt.getTime() + RANGE_CACHE_TTL_MS);\n    if (expiresAt > new Date()) {\n      logger.debug(\"cached fetch hit\", { url, cachePath });\n      return readFile(cachePath, \"utf8\");\n    }\n  }\n  let tempPath: string | null = join(cacheDir, `${hash.id()}.txt`);\n  try {\n    const response = await fetch(url);\n    if (!response.ok) {\n      throw await http.createFetchError(response, url);\n    }\n    const responseText = await response.text();\n    await mkdir(dirname(tempPath), { recursive: true });\n    await writeFile(tempPath, responseText);\n\n    await rename(tempPath, cachePath);\n    logger.debug(\"cached fetch load\", { url, cachePath });\n    tempPath = null;\n    return responseText;\n  } finally {\n    if (tempPath) {\n      await unlink(tempPath);\n    }\n  }\n}\n\n/** Birth time of `path`, or `undefined` when it doesn't exist yet. */\nasync function getCreated(path: string): Promise<Date | undefined> {\n  return (await file.statSync(path))?.birthtime;\n}\n"]}

package/lib/src/databricks-fs.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Databricks {@link FileSystem} backed by {@link WorkspaceClient}.
+ *
+ * Extends {@link BaseFileSystem}. Routes I/O by absolute path:
+ * - `/Workspace`, `/Users`, `/Repos`, `/Shared` → workspace objects API
+ * - `/Volumes/...` (or `catalog.schema.volume` roots) → Unity Catalog Files API
+ * - `/dbfs/...` → DBFS API
+ *
+ * Every primitive picks its API through {@link DatabricksFileSystem.dispatch}
+ * rather than re-branching by hand, and error normalization is inherited from
+ * {@link BaseFileSystem}, so a primitive here is just the SDK call.
+ *
+ * @module
+ */
+import { BaseFileSystem, type CopyOptions, type FileEntry, type FileStat, type WriteFileOptions } from "@dbx-tools/shared-fs";
+import { type WorkspaceClient } from "./workspace.ts";
+/** Options for {@link DatabricksFileSystem}. */
+export interface DatabricksFileSystemOptions {
+    /** Unique identifier. Defaults to a stable hash of the normalized root. */
+    id?: string;
+    /**
+     * Filesystem root. Accepts:
+     * - `/Volumes/catalog/schema/volume` (also `/Volume/...`)
+     * - `catalog.schema.volume`
+     * - `~` / `~/...` → `/Workspace/Users/<userName>/...` (needs {@link userName},
+     *   or use {@link DatabricksFileSystem.create})
+     * - `/Workspace/...`, `/Users/...`, `/Repos/...`, `/Shared/...`
+     * - `/dbfs/...`
+     */
+    root: string;
+    /**
+     * Username for expanding `~`. When omitted and {@link root} is home-relative,
+     * prefer {@link DatabricksFileSystem.create} which resolves it via
+     * `getCurrentUserName`.
+     */
+    userName?: string;
+    /**
+     * Databricks workspace client. Defaults to `tryGetWorkspaceClient()`, otherwise
+     * a default {@link WorkspaceClient} from env / profile auth.
+     */
+    client?: WorkspaceClient;
+    /** Block all write operations. Defaults to false. */
+    readOnly?: boolean;
+    /**
+     * Create {@link root} (and parents) during init. Defaults to false (volume
+     * and workspace roots are usually provisioned out of band).
+     */
+    createRoot?: boolean;
+}
+/**
+ * {@link FileSystem} implementation over Databricks workspace files, UC
+ * volumes, and DBFS.
+ *
+ * @example
+ * ```ts
+ * const fs = new DatabricksFileSystem({ root: "main.default.assets" });
+ * await fs.writeFile("notes/hello.txt", "hi");
+ *
+ * const home = await DatabricksFileSystem.create({ root: "~" });
+ * const listing = await home.readdir(".");
+ * ```
+ */
+export declare class DatabricksFileSystem extends BaseFileSystem<"databricks"> {
+    private client;
+    private readonly clientOption;
+    constructor(options: DatabricksFileSystemOptions);
+    /**
+     * Construct a {@link DatabricksFileSystem}, resolving `~` roots via the
+     * workspace current user when needed.
+     */
+    static create(options: DatabricksFileSystemOptions): Promise<DatabricksFileSystem>;
+    protected onInit(): Promise<void>;
+    /** Run the handler for `absolutePath`'s Databricks API with the live client. */
+    private dispatch;
+    protected createRootDirectory(): Promise<void>;
+    protected readBytesAt(resolvedPath: string): Promise<Uint8Array>;
+    protected writeBytesAt(resolvedPath: string, content: Uint8Array, options: Required<WriteFileOptions>): Promise<void>;
+    protected deleteFileAt(resolvedPath: string): Promise<void>;
+    protected createDirectoryAt(resolvedPath: string): Promise<void>;
+    protected removeDirectoryAt(resolvedPath: string): Promise<void>;
+    protected listDirectoryAt(resolvedPath: string): Promise<FileEntry[]>;
+    protected statAt(resolvedPath: string): Promise<Omit<FileStat, "path">>;
+    protected tryMoveFileAt(sourcePath: string, destinationPath: string, _options: Required<CopyOptions>): Promise<boolean>;
+    /**
+     * UC `createDirectory` is single-level, so walk the path creating each level
+     * below the volume itself. A level that already exists is not an error.
+     */
+    private createVolumeDirectories;
+    /** Stat a UC path: file metadata first, then a directory probe. */
+    private statVolumePath;
+    private readDbfsFile;
+    private writeDbfsFile;
+}