@dbx-tools/fs 0.6.10

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

@@ -0,0 +1,23 @@
+/**
+ * Local host path helpers for {@link LocalFileSystem}.
+ *
+ * Home / temp directory resolution lives in {@link ./os-path.ts}; this module
+ * owns `~` expansion and root resolution against that home.
+ *
+ * @module
+ */
+import { posixPath } from "@dbx-tools/shared-fs";
+import { type ResolveOsPathsOptions } from "./os-path.ts";
+export { APP_HOME, clearOsPathsCache, resolveLocalHome, resolveLocalTemp, resolveOsPaths, type OsPaths, type ResolveOsPathsOptions, } from "./os-path.ts";
+/** True when {@link input} is `~` or a path under `~/`. See {@link posixPath.isHomeRelativePath}. */
+export declare const isHomeRelativePath: typeof posixPath.isHomeRelativePath;
+/**
+ * Expand `~` / `~/...` against {@link home}, joining with the HOST separator.
+ * Non-home inputs are returned trimmed and unchanged.
+ */
+export declare function expandLocalHomePath(input: string, home?: string): string;
+/**
+ * Resolve a local filesystem root: expand `~` when needed, then `path.resolve`
+ * (so relative roots still land under `process.cwd()`).
+ */
+export declare function resolveLocalRoot(root: string, options?: ResolveOsPathsOptions): string;

package/lib/src/local-path.js

@@ -0,0 +1,30 @@
+/**
+ * Local host path helpers for {@link LocalFileSystem}.
+ *
+ * Home / temp directory resolution lives in {@link ./os-path.ts}; this module
+ * owns `~` expansion and root resolution against that home.
+ *
+ * @module
+ */
+import path from "node:path";
+import { posixPath } from "@dbx-tools/shared-fs";
+import { resolveLocalHome } from "./os-path.js";
+export { APP_HOME, clearOsPathsCache, resolveLocalHome, resolveLocalTemp, resolveOsPaths, } from "./os-path.js";
+/** True when {@link input} is `~` or a path under `~/`. See {@link posixPath.isHomeRelativePath}. */
+export const isHomeRelativePath = posixPath.isHomeRelativePath;
+/**
+ * Expand `~` / `~/...` against {@link home}, joining with the HOST separator.
+ * Non-home inputs are returned trimmed and unchanged.
+ */
+export function expandLocalHomePath(input, home = resolveLocalHome()) {
+    return posixPath.expandHome(input, home, path.join);
+}
+/**
+ * Resolve a local filesystem root: expand `~` when needed, then `path.resolve`
+ * (so relative roots still land under `process.cwd()`).
+ */
+export function resolveLocalRoot(root, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    return path.resolve(cwd, expandLocalHomePath(root, resolveLocalHome(options)));
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+/**
+ * Resolve durable local home and temp directories for Node hosts.
+ *
+ * Home order (mkdir + write/delete probe; failure skips):
+ * 1. `os.homedir()`
+ * 2. `HOME` / `USERPROFILE`
+ * 3. `/home/app` when {@link databricks.isAppEnv}
+ * 4. `./.home` under cwd
+ *
+ * Temp order (same ensure/probe/skip):
+ * 1. `os.tmpdir()`
+ * 2. `TMPDIR` / `TMP` / `TEMP`
+ * 3. `.tmp` under the resolved home
+ *
+ * Both paths are memoized per resolved cwd (same idea as
+ * `@dbx-tools/core` `project` command caching): cwd is part of the key because
+ * the `./.home` / `<home>/.tmp` fallbacks depend on it.
+ *
+ * @module
+ */
+/** Databricks Apps container home when {@link databricks.isAppEnv}. */
+export declare const APP_HOME = "/home/app";
+/** Resolved home + temp for one cwd. */
+export interface OsPaths {
+    readonly home: string;
+    readonly tmp: string;
+}
+/** Injectable knobs for {@link resolveOsPaths} (mostly tests). */
+export interface ResolveOsPathsOptions {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    /** Defaults to `os.homedir`. */
+    homeDir?: () => string;
+    /** Defaults to `os.tmpdir`. */
+    tmpDir?: () => string;
+    /** App-env candidate; defaults to {@link APP_HOME}. */
+    appHome?: string;
+}
+/**
+ * Resolve home + temp for {@link cwd}, memoized when {@link cwd} is the process
+ * cwd (an explicit other cwd is computed fresh, matching core `project`
+ * caching).
+ */
+export declare function resolveOsPaths(options?: ResolveOsPathsOptions): OsPaths;
+/** {@link resolveOsPaths}.home */
+export declare function resolveLocalHome(options?: ResolveOsPathsOptions): string;
+/** {@link resolveOsPaths}.tmp */
+export declare function resolveLocalTemp(options?: ResolveOsPathsOptions): string;
+/** Drop memoized entries (tests). */
+export declare function clearOsPathsCache(): void;

package/lib/src/os-path.js

@@ -0,0 +1,143 @@
+/**
+ * Resolve durable local home and temp directories for Node hosts.
+ *
+ * Home order (mkdir + write/delete probe; failure skips):
+ * 1. `os.homedir()`
+ * 2. `HOME` / `USERPROFILE`
+ * 3. `/home/app` when {@link databricks.isAppEnv}
+ * 4. `./.home` under cwd
+ *
+ * Temp order (same ensure/probe/skip):
+ * 1. `os.tmpdir()`
+ * 2. `TMPDIR` / `TMP` / `TEMP`
+ * 3. `.tmp` under the resolved home
+ *
+ * Both paths are memoized per resolved cwd (same idea as
+ * `@dbx-tools/core` `project` command caching): cwd is part of the key because
+ * the `./.home` / `<home>/.tmp` fallbacks depend on it.
+ *
+ * @module
+ */
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { databricks } from "@dbx-tools/appkit";
+/** Databricks Apps container home when {@link databricks.isAppEnv}. */
+export const APP_HOME = "/home/app";
+/** Memoized {@link OsPaths} keyed by resolved cwd. */
+const osPathsCache = new Map();
+/**
+ * Resolve home + temp for {@link cwd}, memoized when {@link cwd} is the process
+ * cwd (an explicit other cwd is computed fresh, matching core `project`
+ * caching).
+ */
+export function resolveOsPaths(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const cacheEnabled = cwd === path.resolve(process.cwd());
+    if (cacheEnabled) {
+        const hit = osPathsCache.get(cwd);
+        if (hit)
+            return hit;
+    }
+    const env = options.env ?? process.env;
+    const home = resolveHome(env, cwd, options);
+    const tmp = resolveTemp(env, home, options);
+    const resolved = { home, tmp };
+    if (cacheEnabled)
+        osPathsCache.set(cwd, resolved);
+    return resolved;
+}
+/** {@link resolveOsPaths}.home */
+export function resolveLocalHome(options = {}) {
+    return resolveOsPaths(options).home;
+}
+/** {@link resolveOsPaths}.tmp */
+export function resolveLocalTemp(options = {}) {
+    return resolveOsPaths(options).tmp;
+}
+/** Drop memoized entries (tests). */
+export function clearOsPathsCache() {
+    osPathsCache.clear();
+}
+function resolveHome(env, cwd, options) {
+    const tried = new Set();
+    const candidates = [
+        tryCall(options.homeDir ?? homedir),
+        env.HOME?.trim(),
+        env.USERPROFILE?.trim(),
+        databricks.isAppEnv(env) ? (options.appHome ?? APP_HOME) : undefined,
+    ];
+    for (const candidate of candidates) {
+        if (!candidate || tried.has(candidate))
+            continue;
+        tried.add(candidate);
+        if (isUsableDir(candidate))
+            return candidate;
+    }
+    const fallback = path.resolve(cwd, ".home");
+    if (!isUsableDir(fallback)) {
+        throw new Error(`Unable to create a writable home directory at ${fallback}`);
+    }
+    return fallback;
+}
+function resolveTemp(env, home, options) {
+    const tried = new Set();
+    // os.tmpdir first, then the standard override env vars (Node checks
+    // TMPDIR/TMP/TEMP on POSIX and TEMP/TMP on Windows inside tmpdir itself;
+    // listing them again lets a failed create/write fall through to the next).
+    const candidates = [
+        tryCall(options.tmpDir ?? tmpdir),
+        env.TMPDIR?.trim(),
+        env.TMP?.trim(),
+        env.TEMP?.trim(),
+    ];
+    for (const candidate of candidates) {
+        if (!candidate || tried.has(candidate))
+            continue;
+        tried.add(candidate);
+        if (isUsableDir(candidate))
+            return candidate;
+    }
+    const fallback = path.join(home, ".tmp");
+    if (!isUsableDir(fallback)) {
+        throw new Error(`Unable to create a writable temp directory at ${fallback}`);
+    }
+    return fallback;
+}
+function tryCall(fn) {
+    try {
+        return fn().trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * True when {@link dir} can be created (if missing) and a probe file can be
+ * written then deleted. Read-only or otherwise unusable dirs return false.
+ */
+function isUsableDir(dir) {
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        return false;
+    }
+    const probe = path.join(dir, `.dbx-os-path-probe-${process.pid}-${process.hrtime.bigint()}`);
+    try {
+        writeFileSync(probe, "");
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            unlinkSync(probe);
+        }
+        catch {
+            // Probe cleanup is best-effort; usability already decided by the write.
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"os-path.js","sourceRoot":"","sources":["../../src/os-path.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Resolve durable local home and temp directories for Node hosts.\n *\n * Home order (mkdir + write/delete probe; failure skips):\n * 1. `os.homedir()`\n * 2. `HOME` / `USERPROFILE`\n * 3. `/home/app` when {@link databricks.isAppEnv}\n * 4. `./.home` under cwd\n *\n * Temp order (same ensure/probe/skip):\n * 1. `os.tmpdir()`\n * 2. `TMPDIR` / `TMP` / `TEMP`\n * 3. `.tmp` under the resolved home\n *\n * Both paths are memoized per resolved cwd (same idea as\n * `@dbx-tools/core` `project` command caching): cwd is part of the key because\n * the `./.home` / `<home>/.tmp` fallbacks depend on it.\n *\n * @module\n */\n\nimport { mkdirSync, unlinkSync, writeFileSync } from \"node:fs\";\nimport { homedir, tmpdir } from \"node:os\";\nimport path from \"node:path\";\nimport { databricks } from \"@dbx-tools/appkit\";\n\n/** Databricks Apps container home when {@link databricks.isAppEnv}. */\nexport const APP_HOME = \"/home/app\";\n\n/** Resolved home + temp for one cwd. */\nexport interface OsPaths {\n  readonly home: string;\n  readonly tmp: string;\n}\n\n/** Injectable knobs for {@link resolveOsPaths} (mostly tests). */\nexport interface ResolveOsPathsOptions {\n  env?: NodeJS.ProcessEnv;\n  cwd?: string;\n  /** Defaults to `os.homedir`. */\n  homeDir?: () => string;\n  /** Defaults to `os.tmpdir`. */\n  tmpDir?: () => string;\n  /** App-env candidate; defaults to {@link APP_HOME}. */\n  appHome?: string;\n}\n\n/** Memoized {@link OsPaths} keyed by resolved cwd. */\nconst osPathsCache = new Map<string, OsPaths>();\n\n/**\n * Resolve home + temp for {@link cwd}, memoized when {@link cwd} is the process\n * cwd (an explicit other cwd is computed fresh, matching core `project`\n * caching).\n */\nexport function resolveOsPaths(options: ResolveOsPathsOptions = {}): OsPaths {\n  const cwd = path.resolve(options.cwd ?? process.cwd());\n  const cacheEnabled = cwd === path.resolve(process.cwd());\n  if (cacheEnabled) {\n    const hit = osPathsCache.get(cwd);\n    if (hit) return hit;\n  }\n\n  const env = options.env ?? process.env;\n  const home = resolveHome(env, cwd, options);\n  const tmp = resolveTemp(env, home, options);\n  const resolved: OsPaths = { home, tmp };\n\n  if (cacheEnabled) osPathsCache.set(cwd, resolved);\n  return resolved;\n}\n\n/** {@link resolveOsPaths}.home */\nexport function resolveLocalHome(options: ResolveOsPathsOptions = {}): string {\n  return resolveOsPaths(options).home;\n}\n\n/** {@link resolveOsPaths}.tmp */\nexport function resolveLocalTemp(options: ResolveOsPathsOptions = {}): string {\n  return resolveOsPaths(options).tmp;\n}\n\n/** Drop memoized entries (tests). */\nexport function clearOsPathsCache(): void {\n  osPathsCache.clear();\n}\n\nfunction resolveHome(env: NodeJS.ProcessEnv, cwd: string, options: ResolveOsPathsOptions): string {\n  const tried = new Set<string>();\n  const candidates: Array<string | undefined> = [\n    tryCall(options.homeDir ?? homedir),\n    env.HOME?.trim(),\n    env.USERPROFILE?.trim(),\n    databricks.isAppEnv(env) ? (options.appHome ?? APP_HOME) : undefined,\n  ];\n\n  for (const candidate of candidates) {\n    if (!candidate || tried.has(candidate)) continue;\n    tried.add(candidate);\n    if (isUsableDir(candidate)) return candidate;\n  }\n\n  const fallback = path.resolve(cwd, \".home\");\n  if (!isUsableDir(fallback)) {\n    throw new Error(`Unable to create a writable home directory at ${fallback}`);\n  }\n  return fallback;\n}\n\nfunction resolveTemp(env: NodeJS.ProcessEnv, home: string, options: ResolveOsPathsOptions): string {\n  const tried = new Set<string>();\n  // os.tmpdir first, then the standard override env vars (Node checks\n  // TMPDIR/TMP/TEMP on POSIX and TEMP/TMP on Windows inside tmpdir itself;\n  // listing them again lets a failed create/write fall through to the next).\n  const candidates: Array<string | undefined> = [\n    tryCall(options.tmpDir ?? tmpdir),\n    env.TMPDIR?.trim(),\n    env.TMP?.trim(),\n    env.TEMP?.trim(),\n  ];\n\n  for (const candidate of candidates) {\n    if (!candidate || tried.has(candidate)) continue;\n    tried.add(candidate);\n    if (isUsableDir(candidate)) return candidate;\n  }\n\n  const fallback = path.join(home, \".tmp\");\n  if (!isUsableDir(fallback)) {\n    throw new Error(`Unable to create a writable temp directory at ${fallback}`);\n  }\n  return fallback;\n}\n\nfunction tryCall(fn: () => string): string | undefined {\n  try {\n    return fn().trim() || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * True when {@link dir} can be created (if missing) and a probe file can be\n * written then deleted. Read-only or otherwise unusable dirs return false.\n */\nfunction isUsableDir(dir: string): boolean {\n  try {\n    mkdirSync(dir, { recursive: true });\n  } catch {\n    return false;\n  }\n\n  const probe = path.join(dir, `.dbx-os-path-probe-${process.pid}-${process.hrtime.bigint()}`);\n  try {\n    writeFileSync(probe, \"\");\n    return true;\n  } catch {\n    return false;\n  } finally {\n    try {\n      unlinkSync(probe);\n    } catch {\n      // Probe cleanup is best-effort; usability already decided by the write.\n    }\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/local-fs.ts","../src/local-path.ts","../src/os-path.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@dbx-tools/fs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/node/fs"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "tsx": "^4.23.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@dbx-tools/appkit": "0.6.10",
+    "@dbx-tools/shared-core": "0.6.10",
+    "@dbx-tools/shared-fs": "0.6.10"
+  },
+  "main": "./lib/index.js",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.6.10",
+  "types": "./lib/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"pnpm exec projen\".",
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  }
+}