@dbx-tools/databricks 0.6.9 → 0.6.10

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

@@ -0,0 +1,67 @@
+/**
+ * Databricks path recognition and normalization for {@link DatabricksFileSystem}.
+ *
+ * Roots may be written as:
+ * - Unity Catalog volume: `/Volumes/catalog/schema/volume` (also accepts `/Volume/...`)
+ * - Three-part volume id: `catalog.schema.volume` → `/Volumes/catalog/schema/volume`
+ * - Home shorthand: `~` / `~/...` → `/Workspace/Users/<userName>/...`
+ * - Workspace tree: `/Workspace/...`, `/Users/...`, `/Repos/...`, `/Shared/...`
+ * - DBFS: `/dbfs/...`
+ *
+ * @module
+ */
+import type { WorkspaceClient } from "@databricks/sdk-experimental";
+import { posixPath } from "@dbx-tools/shared-fs";
+/** Which Databricks Files API serves an absolute path. */
+export type DatabricksFilesBackend = "workspace" | "volumes" | "dbfs";
+/** Options for synchronous {@link normalizeDatabricksRoot}. */
+export interface NormalizeDatabricksRootOptions {
+    /**
+     * Username used to expand `~` → `/Workspace/Users/<userName>`.
+     * Required when {@link root} is `~` or `~/...`. Prefer
+     * {@link resolveDatabricksRoot} when the name should come from the workspace
+     * client.
+     */
+    userName?: string;
+}
+/** Options for async {@link resolveDatabricksRoot}. */
+export interface ResolveDatabricksRootOptions {
+    /** Client used to resolve the current username for `~` expansion. */
+    client?: WorkspaceClient;
+}
+/** True when {@link input} is `~` or a path under `~/`. See {@link posixPath.isHomeRelativePath}. */
+export declare const isHomeRelativePath: typeof posixPath.isHomeRelativePath;
+/**
+ * Expand `~` / `~/...` to `/Workspace/Users/<userName>/...`.
+ * Non-home inputs are returned unchanged (POSIX separators only).
+ */
+export declare function expandHomePath(input: string, userName: string): string;
+/**
+ * Normalize a Databricks filesystem root to an absolute POSIX path.
+ *
+ * - `catalog.schema.volume` → `/Volumes/catalog/schema/volume`
+ * - `/Volume/...` → `/Volumes/...` (singular typo / shorthand)
+ * - `~` / `~/...` → `/Workspace/Users/<userName>/...` (needs {@link NormalizeDatabricksRootOptions.userName})
+ * - strips trailing slashes (except `/`)
+ *
+ * For `~` without a known username, use {@link resolveDatabricksRoot}.
+ */
+export declare function normalizeDatabricksRoot(root: string, options?: NormalizeDatabricksRootOptions): string;
+/**
+ * Like {@link normalizeDatabricksRoot}, but resolves `~` via
+ * {@link getCurrentUserName} (AppKit context user, else `currentUser.me()`).
+ */
+export declare function resolveDatabricksRoot(root: string, options?: ResolveDatabricksRootOptions): Promise<string>;
+/** True when {@link absolutePath} is served by the workspace objects API. */
+export declare function isWorkspaceFilesPath(absolutePath: string): boolean;
+/** True when {@link absolutePath} is a Unity Catalog volume path. */
+export declare function isVolumesPath(absolutePath: string): boolean;
+/** True when {@link absolutePath} is a DBFS path. */
+export declare function isDbfsPath(absolutePath: string): boolean;
+/**
+ * Pick the Databricks API backend for an absolute path.
+ *
+ * Volume three-part roots are normalized before this runs, so callers should
+ * pass paths from {@link normalizeDatabricksRoot} / {@link BaseFileSystem.resolvePath}.
+ */
+export declare function resolveDatabricksFilesBackend(absolutePath: string): DatabricksFilesBackend;

package/lib/src/databricks-path.js

@@ -0,0 +1,113 @@
+/**
+ * Databricks path recognition and normalization for {@link DatabricksFileSystem}.
+ *
+ * Roots may be written as:
+ * - Unity Catalog volume: `/Volumes/catalog/schema/volume` (also accepts `/Volume/...`)
+ * - Three-part volume id: `catalog.schema.volume` → `/Volumes/catalog/schema/volume`
+ * - Home shorthand: `~` / `~/...` → `/Workspace/Users/<userName>/...`
+ * - Workspace tree: `/Workspace/...`, `/Users/...`, `/Repos/...`, `/Shared/...`
+ * - DBFS: `/dbfs/...`
+ *
+ * @module
+ */
+import { posixPath } from "@dbx-tools/shared-fs";
+import { getCurrentUserName } from "./workspace.js";
+/** `catalog.schema.volume` (no slashes, exactly three dotted segments). */
+const VOLUME_THREE_PART = /^([^.\/\s]+)\.([^.\/\s]+)\.([^.\/\s]+)$/;
+/** True when {@link input} is `~` or a path under `~/`. See {@link posixPath.isHomeRelativePath}. */
+export const isHomeRelativePath = posixPath.isHomeRelativePath;
+/**
+ * Expand `~` / `~/...` to `/Workspace/Users/<userName>/...`.
+ * Non-home inputs are returned unchanged (POSIX separators only).
+ */
+export function expandHomePath(input, userName) {
+    const name = userName.trim();
+    if (!name) {
+        throw new TypeError("Databricks home expansion requires a non-empty userName");
+    }
+    if (!isHomeRelativePath(input)) {
+        return posixPath.toPosix(input.trim());
+    }
+    return posixPath.expandHome(input, `/Workspace/Users/${name}`);
+}
+/**
+ * Normalize a Databricks filesystem root to an absolute POSIX path.
+ *
+ * - `catalog.schema.volume` → `/Volumes/catalog/schema/volume`
+ * - `/Volume/...` → `/Volumes/...` (singular typo / shorthand)
+ * - `~` / `~/...` → `/Workspace/Users/<userName>/...` (needs {@link NormalizeDatabricksRootOptions.userName})
+ * - strips trailing slashes (except `/`)
+ *
+ * For `~` without a known username, use {@link resolveDatabricksRoot}.
+ */
+export function normalizeDatabricksRoot(root, options = {}) {
+    const trimmed = root.trim();
+    if (!trimmed) {
+        throw new TypeError("Databricks filesystem root cannot be empty");
+    }
+    if (isHomeRelativePath(trimmed)) {
+        if (!options.userName?.trim()) {
+            throw new TypeError(`Databricks home path "${root}" requires userName; use resolveDatabricksRoot() or pass userName`);
+        }
+        return posixPath.normalizeRoot(expandHomePath(trimmed, options.userName));
+    }
+    const threePart = VOLUME_THREE_PART.exec(trimmed);
+    if (threePart) {
+        return posixPath.normalizeRoot(`/Volumes/${threePart[1]}/${threePart[2]}/${threePart[3]}`);
+    }
+    let posix = posixPath.toPosix(trimmed);
+    if (posix === "/Volume" || posix.startsWith("/Volume/")) {
+        posix = `/Volumes${posix.slice("/Volume".length)}`;
+    }
+    if (!posixPath.isAbsolute(posix)) {
+        throw new TypeError(`Databricks filesystem root must be absolute, catalog.schema.volume, or ~, got: ${root}`);
+    }
+    return posixPath.normalizeRoot(posix);
+}
+/**
+ * Like {@link normalizeDatabricksRoot}, but resolves `~` via
+ * {@link getCurrentUserName} (AppKit context user, else `currentUser.me()`).
+ */
+export async function resolveDatabricksRoot(root, options = {}) {
+    if (!isHomeRelativePath(root)) {
+        return normalizeDatabricksRoot(root);
+    }
+    const userName = await getCurrentUserName(options.client);
+    return normalizeDatabricksRoot(root, { userName });
+}
+/** True when {@link absolutePath} is served by the workspace objects API. */
+export function isWorkspaceFilesPath(absolutePath) {
+    const p = posixPath.toPosix(absolutePath);
+    return (p === "/Workspace" ||
+        p.startsWith("/Workspace/") ||
+        p.startsWith("/Users/") ||
+        p.startsWith("/Repos/") ||
+        p.startsWith("/Shared/"));
+}
+/** True when {@link absolutePath} is a Unity Catalog volume path. */
+export function isVolumesPath(absolutePath) {
+    const p = posixPath.toPosix(absolutePath);
+    return p === "/Volumes" || p.startsWith("/Volumes/");
+}
+/** True when {@link absolutePath} is a DBFS path. */
+export function isDbfsPath(absolutePath) {
+    const p = posixPath.toPosix(absolutePath);
+    return p === "/dbfs" || p.startsWith("/dbfs/");
+}
+/**
+ * Pick the Databricks API backend for an absolute path.
+ *
+ * Volume three-part roots are normalized before this runs, so callers should
+ * pass paths from {@link normalizeDatabricksRoot} / {@link BaseFileSystem.resolvePath}.
+ */
+export function resolveDatabricksFilesBackend(absolutePath) {
+    if (isDbfsPath(absolutePath))
+        return "dbfs";
+    if (isWorkspaceFilesPath(absolutePath))
+        return "workspace";
+    if (isVolumesPath(absolutePath))
+        return "volumes";
+    // Default: UC Files API (covers unusual absolute roots under the workspace host).
+    return "volumes";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-path.js","sourceRoot":"","sources":["../../src/databricks-path.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks path recognition and normalization for {@link DatabricksFileSystem}.\n *\n * Roots may be written as:\n * - Unity Catalog volume: `/Volumes/catalog/schema/volume` (also accepts `/Volume/...`)\n * - Three-part volume id: `catalog.schema.volume` → `/Volumes/catalog/schema/volume`\n * - Home shorthand: `~` / `~/...` → `/Workspace/Users/<userName>/...`\n * - Workspace tree: `/Workspace/...`, `/Users/...`, `/Repos/...`, `/Shared/...`\n * - DBFS: `/dbfs/...`\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { posixPath } from \"@dbx-tools/shared-fs\";\nimport { getCurrentUserName } from \"./workspace.ts\";\n\n/** Which Databricks Files API serves an absolute path. */\nexport type DatabricksFilesBackend = \"workspace\" | \"volumes\" | \"dbfs\";\n\n/** `catalog.schema.volume` (no slashes, exactly three dotted segments). */\nconst VOLUME_THREE_PART = /^([^.\\/\\s]+)\\.([^.\\/\\s]+)\\.([^.\\/\\s]+)$/;\n\n/** Options for synchronous {@link normalizeDatabricksRoot}. */\nexport interface NormalizeDatabricksRootOptions {\n  /**\n   * Username used to expand `~` → `/Workspace/Users/<userName>`.\n   * Required when {@link root} is `~` or `~/...`. Prefer\n   * {@link resolveDatabricksRoot} when the name should come from the workspace\n   * client.\n   */\n  userName?: string;\n}\n\n/** Options for async {@link resolveDatabricksRoot}. */\nexport interface ResolveDatabricksRootOptions {\n  /** Client used to resolve the current username for `~` expansion. */\n  client?: WorkspaceClient;\n}\n\n/** True when {@link input} is `~` or a path under `~/`. See {@link posixPath.isHomeRelativePath}. */\nexport const isHomeRelativePath = posixPath.isHomeRelativePath;\n\n/**\n * Expand `~` / `~/...` to `/Workspace/Users/<userName>/...`.\n * Non-home inputs are returned unchanged (POSIX separators only).\n */\nexport function expandHomePath(input: string, userName: string): string {\n  const name = userName.trim();\n  if (!name) {\n    throw new TypeError(\"Databricks home expansion requires a non-empty userName\");\n  }\n  if (!isHomeRelativePath(input)) {\n    return posixPath.toPosix(input.trim());\n  }\n  return posixPath.expandHome(input, `/Workspace/Users/${name}`);\n}\n\n/**\n * Normalize a Databricks filesystem root to an absolute POSIX path.\n *\n * - `catalog.schema.volume` → `/Volumes/catalog/schema/volume`\n * - `/Volume/...` → `/Volumes/...` (singular typo / shorthand)\n * - `~` / `~/...` → `/Workspace/Users/<userName>/...` (needs {@link NormalizeDatabricksRootOptions.userName})\n * - strips trailing slashes (except `/`)\n *\n * For `~` without a known username, use {@link resolveDatabricksRoot}.\n */\nexport function normalizeDatabricksRoot(\n  root: string,\n  options: NormalizeDatabricksRootOptions = {},\n): string {\n  const trimmed = root.trim();\n  if (!trimmed) {\n    throw new TypeError(\"Databricks filesystem root cannot be empty\");\n  }\n\n  if (isHomeRelativePath(trimmed)) {\n    if (!options.userName?.trim()) {\n      throw new TypeError(\n        `Databricks home path \"${root}\" requires userName; use resolveDatabricksRoot() or pass userName`,\n      );\n    }\n    return posixPath.normalizeRoot(expandHomePath(trimmed, options.userName));\n  }\n\n  const threePart = VOLUME_THREE_PART.exec(trimmed);\n  if (threePart) {\n    return posixPath.normalizeRoot(`/Volumes/${threePart[1]}/${threePart[2]}/${threePart[3]}`);\n  }\n\n  let posix = posixPath.toPosix(trimmed);\n  if (posix === \"/Volume\" || posix.startsWith(\"/Volume/\")) {\n    posix = `/Volumes${posix.slice(\"/Volume\".length)}`;\n  }\n\n  if (!posixPath.isAbsolute(posix)) {\n    throw new TypeError(\n      `Databricks filesystem root must be absolute, catalog.schema.volume, or ~, got: ${root}`,\n    );\n  }\n\n  return posixPath.normalizeRoot(posix);\n}\n\n/**\n * Like {@link normalizeDatabricksRoot}, but resolves `~` via\n * {@link getCurrentUserName} (AppKit context user, else `currentUser.me()`).\n */\nexport async function resolveDatabricksRoot(\n  root: string,\n  options: ResolveDatabricksRootOptions = {},\n): Promise<string> {\n  if (!isHomeRelativePath(root)) {\n    return normalizeDatabricksRoot(root);\n  }\n  const userName = await getCurrentUserName(options.client);\n  return normalizeDatabricksRoot(root, { userName });\n}\n\n/** True when {@link absolutePath} is served by the workspace objects API. */\nexport function isWorkspaceFilesPath(absolutePath: string): boolean {\n  const p = posixPath.toPosix(absolutePath);\n  return (\n    p === \"/Workspace\" ||\n    p.startsWith(\"/Workspace/\") ||\n    p.startsWith(\"/Users/\") ||\n    p.startsWith(\"/Repos/\") ||\n    p.startsWith(\"/Shared/\")\n  );\n}\n\n/** True when {@link absolutePath} is a Unity Catalog volume path. */\nexport function isVolumesPath(absolutePath: string): boolean {\n  const p = posixPath.toPosix(absolutePath);\n  return p === \"/Volumes\" || p.startsWith(\"/Volumes/\");\n}\n\n/** True when {@link absolutePath} is a DBFS path. */\nexport function isDbfsPath(absolutePath: string): boolean {\n  const p = posixPath.toPosix(absolutePath);\n  return p === \"/dbfs\" || p.startsWith(\"/dbfs/\");\n}\n\n/**\n * Pick the Databricks API backend for an absolute path.\n *\n * Volume three-part roots are normalized before this runs, so callers should\n * pass paths from {@link normalizeDatabricksRoot} / {@link BaseFileSystem.resolvePath}.\n */\nexport function resolveDatabricksFilesBackend(absolutePath: string): DatabricksFilesBackend {\n  if (isDbfsPath(absolutePath)) return \"dbfs\";\n  if (isWorkspaceFilesPath(absolutePath)) return \"workspace\";\n  if (isVolumesPath(absolutePath)) return \"volumes\";\n  // Default: UC Files API (covers unusual absolute roots under the workspace host).\n  return \"volumes\";\n}\n"]}

package/lib/src/workspace.d.ts

@@ -1,11 +1,31 @@
 /**
- * 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.
+ * Resolve the current Databricks workspace's URL, numeric id, and client from
+ * the active execution context (AppKit, when initialized), a default
+ * {@link WorkspaceClient}, or the environment. Server-only.
  *
  * @module
  */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
 import { net } from "@dbx-tools/shared-core";
+/**
+ * The AppKit execution-context workspace client when available, otherwise
+ * `undefined`. Never constructs a fallback client and never throws for a
+ * missing AppKit scope.
+ */
+export declare function tryGetWorkspaceClient(): WorkspaceClient | undefined;
+/**
+ * Resolve a {@link WorkspaceClient}: {@link tryGetWorkspaceClient} first, else
+ * a memoized default client from env / profile auth.
+ */
+export declare function getWorkspaceClient(): Promise<WorkspaceClient>;
+/**
+ * Current Databricks username for workspace home paths
+ * (`/Workspace/Users/<userName>`).
+ *
+ * Prefers `userName` on the AppKit execution context when set, otherwise
+ * calls `currentUser.me()` on {@link client} (or {@link getWorkspaceClient}).
+ */
+export declare function getCurrentUserName(client?: WorkspaceClient): Promise<string>;
 /**
  * Resolve the current workspace host as a `net.UrlBuilder`: the workspace
  * `Config` host first, then the `DATABRICKS_HOST` env var, else `undefined`.

package/lib/src/workspace.js

@@ -1,7 +1,7 @@
 /**
- * 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.
+ * Resolve the current Databricks workspace's URL, numeric id, and client from
+ * the active execution context (AppKit, when initialized), a default
+ * {@link WorkspaceClient}, or the environment. Server-only.
  *
  * @module
  */
@@ -16,22 +16,59 @@ const WORKSPACE_ID_REGEX = /\d{10,20}/;
  * AppKit execution context to borrow a client from.
  */
 const getDefaultWorkspaceClient = functionModule.memoize(async () => new WorkspaceClient({}));
+/**
+ * The AppKit execution-context workspace client when available, otherwise
+ * `undefined`. Never constructs a fallback client and never throws for a
+ * missing AppKit scope.
+ */
+export function tryGetWorkspaceClient() {
+    return appkit.tryGetExecutionContext()?.client;
+}
+/**
+ * Resolve a {@link WorkspaceClient}: {@link tryGetWorkspaceClient} first, else
+ * a memoized default client from env / profile auth.
+ */
+export async function getWorkspaceClient() {
+    return tryGetWorkspaceClient() ?? (await getDefaultWorkspaceClient());
+}
 /**
  * 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
-        }
+    try {
+        return (await getWorkspaceClient()).config;
+    }
+    catch {
+        return undefined;
     }
-    return client?.config;
+}
+/**
+ * Current Databricks username for workspace home paths
+ * (`/Workspace/Users/<userName>`).
+ *
+ * Prefers `userName` on the AppKit execution context when set, otherwise
+ * calls `currentUser.me()` on {@link client} (or {@link getWorkspaceClient}).
+ */
+export async function getCurrentUserName(client) {
+    const contextUser = readContextUserName(appkit.tryGetExecutionContext());
+    if (contextUser)
+        return contextUser;
+    const resolved = client ?? (await getWorkspaceClient());
+    const me = await resolved.currentUser.me();
+    const userName = me.userName?.trim();
+    if (!userName) {
+        throw new Error("Databricks currentUser.me() did not return a userName");
+    }
+    return userName;
+}
+/** Best-effort `userName` off an AppKit execution context (shape varies by mode). */
+function readContextUserName(ctx) {
+    if (typeof ctx !== "object" || ctx === null || !("userName" in ctx))
+        return undefined;
+    const value = ctx.userName;
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 /**
  * Resolve the current workspace host as a `net.UrlBuilder`: the workspace
@@ -66,4 +103,4 @@ export async function getWorkspaceId(workspaceHost) {
     }
     return undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../src/workspace.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Resolve the current Databricks workspace's URL, numeric id, and client from\n * the active execution context (AppKit, when initialized), a default\n * {@link WorkspaceClient}, or the environment. Server-only.\n *\n * @module\n */\n\nimport { type Config, WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport { functionModule, net } from \"@dbx-tools/shared-core\";\n\n/** Databricks workspace ids are a 10-20 digit run embedded in the host. */\nconst WORKSPACE_ID_REGEX = /\\d{10,20}/;\n\n/**\n * Lazily-constructed default `WorkspaceClient` (env / profile auth), memoized so\n * construction happens at most once per process. Used only when there's no\n * AppKit execution context to borrow a client from.\n */\nconst getDefaultWorkspaceClient = functionModule.memoize(async () => new WorkspaceClient({}));\n\n/**\n * The AppKit execution-context workspace client when available, otherwise\n * `undefined`. Never constructs a fallback client and never throws for a\n * missing AppKit scope.\n */\nexport function tryGetWorkspaceClient(): WorkspaceClient | undefined {\n  return appkit.tryGetExecutionContext()?.client as WorkspaceClient | undefined;\n}\n\n/**\n * Resolve a {@link WorkspaceClient}: {@link tryGetWorkspaceClient} first, else\n * a memoized default client from env / profile auth.\n */\nexport async function getWorkspaceClient(): Promise<WorkspaceClient> {\n  return tryGetWorkspaceClient() ?? (await getDefaultWorkspaceClient());\n}\n\n/**\n * The active workspace `Config`: the AppKit execution-context client's config\n * when AppKit is initialized, else the default client's. Returns `undefined`\n * (never throws) when neither is available.\n */\nasync function getWorkspaceConfig(): Promise<Config | undefined> {\n  try {\n    return (await getWorkspaceClient()).config;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Current Databricks username for workspace home paths\n * (`/Workspace/Users/<userName>`).\n *\n * Prefers `userName` on the AppKit execution context when set, otherwise\n * calls `currentUser.me()` on {@link client} (or {@link getWorkspaceClient}).\n */\nexport async function getCurrentUserName(client?: WorkspaceClient): Promise<string> {\n  const contextUser = readContextUserName(appkit.tryGetExecutionContext());\n  if (contextUser) return contextUser;\n\n  const resolved = client ?? (await getWorkspaceClient());\n  const me = await resolved.currentUser.me();\n  const userName = me.userName?.trim();\n  if (!userName) {\n    throw new Error(\"Databricks currentUser.me() did not return a userName\");\n  }\n  return userName;\n}\n\n/** Best-effort `userName` off an AppKit execution context (shape varies by mode). */\nfunction readContextUserName(ctx: unknown): string | undefined {\n  if (typeof ctx !== \"object\" || ctx === null || !(\"userName\" in ctx)) return undefined;\n  const value = (ctx as { userName?: unknown }).userName;\n  return typeof value === \"string\" && value.trim() ? value.trim() : undefined;\n}\n\n/**\n * Resolve the current workspace host as a `net.UrlBuilder`: the workspace\n * `Config` host first, then the `DATABRICKS_HOST` env var, else `undefined`.\n */\nexport async function getWorkspaceUrl(): Promise<net.UrlBuilder | undefined> {\n  const config = await getWorkspaceConfig();\n  if (config) {\n    const configHost = net.urlBuilder(await config.getHost());\n    if (configHost) return configHost;\n  }\n  const databricksHost = net.urlBuilder(process.env.DATABRICKS_HOST);\n  if (databricksHost) return databricksHost;\n  return undefined;\n}\n\n/**\n * Resolve the numeric workspace id: the workspace `Config`'s `workspaceId`\n * first, else the 10-20 digit run of `workspaceHost` (defaulting to\n * {@link getWorkspaceUrl}'s host). `undefined` when neither yields an id.\n */\nexport async function getWorkspaceId(workspaceHost?: string): Promise<string | undefined> {\n  const workspaceId = (await getWorkspaceConfig())?.workspaceId;\n  if (workspaceId) return workspaceId;\n  workspaceHost = workspaceHost ?? (await getWorkspaceUrl())?.host;\n  if (workspaceHost) {\n    const match = workspaceHost.match(WORKSPACE_ID_REGEX)?.[0];\n    if (match) return match;\n  }\n  return undefined;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

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

package/package.json

@@ -12,16 +12,17 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/appkit": "0.6.9",
-    "@dbx-tools/shared-core": "0.6.9",
-    "@dbx-tools/core": "0.6.9"
+    "@dbx-tools/appkit": "0.6.10",
+    "@dbx-tools/shared-core": "0.6.10",
+    "@dbx-tools/core": "0.6.10",
+    "@dbx-tools/shared-fs": "0.6.10"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.6.9",
+  "version": "0.6.10",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {