@dbx-tools/databricks 0.3.44 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * as cloud from "./src/cloud.js";
+export * as net from "./src/net.js";
+export * as workspace from "./src/workspace.js";
+export { RANGE_CACHE_TTL_MS, CloudProvider, resolveCloudLocation, loadProviderRanges } from "./src/cloud.js";
+export type { CloudLocation } from "./src/cloud.js";
+export { getPublicIp, resolveHostIps } from "./src/net.js";
+export { getWorkspaceUrl, getWorkspaceId } from "./src/workspace.js";

package/lib/index.js

@@ -0,0 +1,10 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as cloud from "./src/cloud.js";
+export * as net from "./src/net.js";
+export * as workspace from "./src/workspace.js";
+export { RANGE_CACHE_TTL_MS, CloudProvider, resolveCloudLocation, loadProviderRanges } from "./src/cloud.js";
+export { getPublicIp, resolveHostIps } from "./src/net.js";
+export { getWorkspaceUrl, getWorkspaceId } from "./src/workspace.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssS0FBSyxNQUFNLGFBQWEsQ0FBQztBQUNyQyxPQUFPLEtBQUssR0FBRyxNQUFNLFdBQVcsQ0FBQztBQUNqQyxPQUFPLEtBQUssU0FBUyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxhQUFhLEVBQUUsb0JBQW9CLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFMUcsT0FBTyxFQUFFLFdBQVcsRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDeEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIGNsb3VkIGZyb20gXCIuL3NyYy9jbG91ZFwiO1xuZXhwb3J0ICogYXMgbmV0IGZyb20gXCIuL3NyYy9uZXRcIjtcbmV4cG9ydCAqIGFzIHdvcmtzcGFjZSBmcm9tIFwiLi9zcmMvd29ya3NwYWNlXCI7XG5leHBvcnQgeyBSQU5HRV9DQUNIRV9UVExfTVMsIENsb3VkUHJvdmlkZXIsIHJlc29sdmVDbG91ZExvY2F0aW9uLCBsb2FkUHJvdmlkZXJSYW5nZXMgfSBmcm9tIFwiLi9zcmMvY2xvdWRcIjtcbmV4cG9ydCB0eXBlIHsgQ2xvdWRMb2NhdGlvbiB9IGZyb20gXCIuL3NyYy9jbG91ZFwiO1xuZXhwb3J0IHsgZ2V0UHVibGljSXAsIHJlc29sdmVIb3N0SXBzIH0gZnJvbSBcIi4vc3JjL25ldFwiO1xuZXhwb3J0IHsgZ2V0V29ya3NwYWNlVXJsLCBnZXRXb3Jrc3BhY2VJZCB9IGZyb20gXCIuL3NyYy93b3Jrc3BhY2VcIjtcbiJdfQ==

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,230 @@
+/**
+ * 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, 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 });
+}
+async function fetchJson(url) {
+    const text = await fetchText(url);
+    return JSON.parse(text);
+}
+/**
+ * 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, log, net } from \"@dbx-tools/shared-core\";\nimport { resolveHostIps } from \"./net\";\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\nasync function fetchJson<T>(url: string): Promise<T> {\n  const text = await fetchText(url);\n  return JSON.parse(text) as T;\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/net.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Server-side networking helpers that need Node builtins, layered over the
+ * browser-safe URL / IP toolkit in `@dbx-tools/shared-core`'s `net` module: DNS
+ * resolution ({@link resolveHostIps}, `node:dns`) and public-IP discovery
+ * ({@link getPublicIp}).
+ *
+ * @module
+ */
+import { net } from "@dbx-tools/shared-core";
+/**
+ * This process's outbound public IP, cached for 5 minutes. Asks Cloudflare's
+ * `cdn-cgi/trace` first and falls back to ipify. Useful for allowlisting or for
+ * reasoning about egress from a Databricks App.
+ */
+export declare const getPublicIp: () => Promise<string>;
+/**
+ * Resolve the host of `input` to its IP address(es) via the OS resolver
+ * (`dns.lookup` with `all: true`, so both A and AAAA records are returned when
+ * the host is dual-stacked). Accepts any `net.UrlLike` - a bare hostname, a full
+ * URL, or a `{ url }` wrapper - and returns the deduplicated list of literal
+ * addresses. Never throws: an unparseable input, an IP-literal host (returned
+ * as-is without a DNS round-trip), or a resolution failure all yield the
+ * appropriate list or `[]`.
+ *
+ * `dns.lookup` (not `resolve4` / `resolve6`) is used so `/etc/hosts` and the
+ * platform resolver order are honored, matching what an outbound connection to
+ * the host would actually use.
+ */
+export declare function resolveHostIps(input: net.UrlLike): Promise<string[]>;

package/lib/src/net.js

@@ -0,0 +1,68 @@
+/**
+ * Server-side networking helpers that need Node builtins, layered over the
+ * browser-safe URL / IP toolkit in `@dbx-tools/shared-core`'s `net` module: DNS
+ * resolution ({@link resolveHostIps}, `node:dns`) and public-IP discovery
+ * ({@link getPublicIp}).
+ *
+ * @module
+ */
+import { lookup } from "node:dns/promises";
+import { functionModule, http, net } from "@dbx-tools/shared-core";
+/**
+ * This process's outbound public IP, cached for 5 minutes. Asks Cloudflare's
+ * `cdn-cgi/trace` first and falls back to ipify. Useful for allowlisting or for
+ * reasoning about egress from a Databricks App.
+ */
+export const getPublicIp = functionModule.memoize(async () => {
+    const cloudflareResponse = await fetch("https://cloudflare.com/cdn-cgi/trace");
+    if (cloudflareResponse.ok) {
+        const trace = await cloudflareResponse.text();
+        const ipKey = "ip=";
+        const ip = trace
+            .split("\n")
+            .map((line) => line.trim())
+            .find((line) => line.startsWith(ipKey))
+            ?.slice(ipKey.length);
+        if (ip)
+            return ip;
+    }
+    const ipifyResponse = await fetch("https://api.ipify.org?format=json");
+    if (!ipifyResponse.ok) {
+        throw await http.createFetchError(ipifyResponse);
+    }
+    const ipifyData = (await ipifyResponse.json());
+    const ip = ipifyData?.ip;
+    if (ip)
+        return ip;
+    throw new Error("Could not determine public IP");
+}, { ttlMs: 1000 * 60 * 5 });
+/**
+ * Resolve the host of `input` to its IP address(es) via the OS resolver
+ * (`dns.lookup` with `all: true`, so both A and AAAA records are returned when
+ * the host is dual-stacked). Accepts any `net.UrlLike` - a bare hostname, a full
+ * URL, or a `{ url }` wrapper - and returns the deduplicated list of literal
+ * addresses. Never throws: an unparseable input, an IP-literal host (returned
+ * as-is without a DNS round-trip), or a resolution failure all yield the
+ * appropriate list or `[]`.
+ *
+ * `dns.lookup` (not `resolve4` / `resolve6`) is used so `/etc/hosts` and the
+ * platform resolver order are honored, matching what an outbound connection to
+ * the host would actually use.
+ */
+export async function resolveHostIps(input) {
+    const host = net.urlBuilder(input)?.hostname;
+    if (!host)
+        return [];
+    // WHATWG `URL.hostname` brackets IPv6 literals; strip before parsing.
+    const literal = net.parseIp(host.replace(/^\[|\]$/g, ""));
+    if (literal)
+        return [host.replace(/^\[|\]$/g, "")];
+    try {
+        const results = await lookup(host, { all: true });
+        return [...new Set(results.map((r) => r.address))];
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/workspace.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Resolve the current Databricks workspace's URL and numeric id from the active
+ * execution context (AppKit, when initialized), a default `WorkspaceClient`, or
+ * the environment. Server-only.
+ *
+ * @module
+ */
+import { net } from "@dbx-tools/shared-core";
+/**
+ * Resolve the current workspace host as a `net.UrlBuilder`: the workspace
+ * `Config` host first, then the `DATABRICKS_HOST` env var, else `undefined`.
+ */
+export declare function getWorkspaceUrl(): Promise<net.UrlBuilder | undefined>;
+/**
+ * Resolve the numeric workspace id: the workspace `Config`'s `workspaceId`
+ * first, else the 10-20 digit run of `workspaceHost` (defaulting to
+ * {@link getWorkspaceUrl}'s host). `undefined` when neither yields an id.
+ */
+export declare function getWorkspaceId(workspaceHost?: string): Promise<string | undefined>;

package/lib/src/workspace.js

@@ -0,0 +1,69 @@
+/**
+ * Resolve the current Databricks workspace's URL and numeric id from the active
+ * execution context (AppKit, when initialized), a default `WorkspaceClient`, or
+ * the environment. Server-only.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import { appkit } from "@dbx-tools/appkit";
+import { functionModule, net } from "@dbx-tools/shared-core";
+/** Databricks workspace ids are a 10-20 digit run embedded in the host. */
+const WORKSPACE_ID_REGEX = /\d{10,20}/;
+/**
+ * Lazily-constructed default `WorkspaceClient` (env / profile auth), memoized so
+ * construction happens at most once per process. Used only when there's no
+ * AppKit execution context to borrow a client from.
+ */
+const getDefaultWorkspaceClient = functionModule.memoize(async () => new WorkspaceClient({}));
+/**
+ * The active workspace `Config`: the AppKit execution-context client's config
+ * when AppKit is initialized, else the default client's. Returns `undefined`
+ * (never throws) when neither is available.
+ */
+async function getWorkspaceConfig() {
+    let client = appkit.tryGetExecutionContext()?.client;
+    if (!client) {
+        try {
+            client = await getDefaultWorkspaceClient();
+        }
+        catch {
+            // no client available; fall back to the environment
+        }
+    }
+    return client?.config;
+}
+/**
+ * Resolve the current workspace host as a `net.UrlBuilder`: the workspace
+ * `Config` host first, then the `DATABRICKS_HOST` env var, else `undefined`.
+ */
+export async function getWorkspaceUrl() {
+    const config = await getWorkspaceConfig();
+    if (config) {
+        const configHost = net.urlBuilder(await config.getHost());
+        if (configHost)
+            return configHost;
+    }
+    const databricksHost = net.urlBuilder(process.env.DATABRICKS_HOST);
+    if (databricksHost)
+        return databricksHost;
+    return undefined;
+}
+/**
+ * Resolve the numeric workspace id: the workspace `Config`'s `workspaceId`
+ * first, else the 10-20 digit run of `workspaceHost` (defaulting to
+ * {@link getWorkspaceUrl}'s host). `undefined` when neither yields an id.
+ */
+export async function getWorkspaceId(workspaceHost) {
+    const workspaceId = (await getWorkspaceConfig())?.workspaceId;
+    if (workspaceId)
+        return workspaceId;
+    workspaceHost = workspaceHost ?? (await getWorkspaceUrl())?.host;
+    if (workspaceHost) {
+        const match = workspaceHost.match(WORKSPACE_ID_REGEX)?.[0];
+        if (match)
+            return match;
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/cloud.ts","../src/net.ts","../src/workspace.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -12,25 +12,29 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/core": "0.3.44",
-    "@dbx-tools/appkit": "0.3.44",
-    "@dbx-tools/shared-core": "0.3.44"
+    "@dbx-tools/core": "0.4.0",
+    "@dbx-tools/appkit": "0.4.0",
+    "@dbx-tools/shared-core": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [