@dbx-tools/fs 0.6.10

package/README.md

@@ -0,0 +1,60 @@
+# `@dbx-tools/fs`
+
+Node local-disk `FileSystem` implementation of the `@dbx-tools/shared-fs`
+contract. Built on `BaseFileSystem`, so this package only owns host separator
+conversion (`toBackendPath`), Node I/O, symlink containment (`preparePath`), and
+errno mapping.
+
+Key features:
+
+- Contained-by-default path resolution under a configured root
+- `~` / `~/...` roots expand via `os.homedir()` (before `HOME`), then
+  Databricks App `/home/app`, then a created `./.home` (create failures skip)
+- Temp dirs via `os.tmpdir()` then `TMPDIR` / `TMP` / `TEMP`, else
+  `<home>/.tmp` (each candidate must pass a write/delete probe)
+- Read/write/append/copy/move plus mkdir/rmdir/readdir/stat/exists
+- Optional read-only mode
+- Native append / copy / rename via Node when available
+
+## Why use this over native Node `fs`
+
+Use this when callers should speak the portable `FileSystem` interface (the same
+surface FTP, object storage, or Databricks mounts can implement) rather than
+Node APIs directly. Reach for `node:fs` when you only need one-off local I/O.
+
+## Quick start
+
+```ts
+import { LocalFileSystem, localFS } from "@dbx-tools/fs";
+
+const local = new LocalFileSystem({ root: "./data" });
+await local.init();
+await local.writeFile("hello.txt", "hi");
+
+const home = localFS.homeFS("projects/data");
+const scratch = localFS.tmpFS("job-42");
+
+// A throwaway working directory no other run can collide with.
+const work = localFS.scratchFS("import-job");
+await work.init(); // only needed when handing the root to `node:fs` or a subprocess
+
+// Regenerate on every boot, but into ONE stable directory: the callback writes
+// into a scratch root that replaces the stable one only on success, so restarts
+// don't pile up directories and a failed rebuild keeps the last good tree.
+const tools = await localFS.rebuildFS("databricks-aitools", (scratch) => installInto(scratch.root));
+```
+
+## Module map
+
+| Export                             | Role                                                   |
+| ---------------------------------- | ------------------------------------------------------ |
+| `LocalFileSystem`                  | Local-disk `FileSystem<"local">`                       |
+| `LocalFileSystemOptions`           | Constructor options                                    |
+| `localFS.homeFS` / `localFS.tmpFS` | `LocalFileSystem` under resolved home / temp           |
+| `localFS.scratchFS`                | `tmpFS` on a `<prefix>-<id>` root unique per call      |
+| `localFS.rebuildFS`                | Rebuild a stable temp tree via an atomic scratch swap  |
+| `osPath.resolveLocalHome`          | Home: `homedir` → `HOME` → `/home/app` → `./.home`     |
+| `osPath.resolveLocalTemp`          | Temp: `tmpdir` → `TMPDIR`/`TMP`/`TEMP` → `<home>/.tmp` |
+| `localPath.expandLocalHomePath`    | Expand `~` against a home dir                          |
+
+Adjacent: `@dbx-tools/shared-fs` (`FileSystem` contract + `BaseFileSystem`).

package/index.ts

@@ -0,0 +1,12 @@
+// 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 localFS from "./src/local-fs.ts";
+export * as localPath from "./src/local-path.ts";
+export * as osPath from "./src/os-path.ts";
+export { LocalFileSystem } from "./src/local-fs.ts";
+export type { LocalFileSystemOptions, OsFileSystemOptions } from "./src/local-fs.ts";
+export { isHomeRelativePath } from "./src/local-path.ts";
+export { APP_HOME } from "./src/os-path.ts";
+export type { OsPaths, ResolveOsPathsOptions } from "./src/os-path.ts";

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * as localFS from "./src/local-fs.ts";
+export * as localPath from "./src/local-path.ts";
+export * as osPath from "./src/os-path.ts";
+export { LocalFileSystem } from "./src/local-fs.ts";
+export type { LocalFileSystemOptions, OsFileSystemOptions } from "./src/local-fs.ts";
+export { isHomeRelativePath } from "./src/local-path.ts";
+export { APP_HOME } from "./src/os-path.ts";
+export type { OsPaths, ResolveOsPathsOptions } from "./src/os-path.ts";

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 localFS from "./src/local-fs.js";
+export * as localPath from "./src/local-path.js";
+export * as osPath from "./src/os-path.js";
+export { LocalFileSystem } from "./src/local-fs.js";
+export { isHomeRelativePath } from "./src/local-path.js";
+export { APP_HOME } from "./src/os-path.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssT0FBTyxNQUFNLG1CQUFtQixDQUFDO0FBQzdDLE9BQU8sS0FBSyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxLQUFLLE1BQU0sTUFBTSxrQkFBa0IsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFcEQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDekQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0ICogYXMgbG9jYWxGUyBmcm9tIFwiLi9zcmMvbG9jYWwtZnMudHNcIjtcbmV4cG9ydCAqIGFzIGxvY2FsUGF0aCBmcm9tIFwiLi9zcmMvbG9jYWwtcGF0aC50c1wiO1xuZXhwb3J0ICogYXMgb3NQYXRoIGZyb20gXCIuL3NyYy9vcy1wYXRoLnRzXCI7XG5leHBvcnQgeyBMb2NhbEZpbGVTeXN0ZW0gfSBmcm9tIFwiLi9zcmMvbG9jYWwtZnMudHNcIjtcbmV4cG9ydCB0eXBlIHsgTG9jYWxGaWxlU3lzdGVtT3B0aW9ucywgT3NGaWxlU3lzdGVtT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9sb2NhbC1mcy50c1wiO1xuZXhwb3J0IHsgaXNIb21lUmVsYXRpdmVQYXRoIH0gZnJvbSBcIi4vc3JjL2xvY2FsLXBhdGgudHNcIjtcbmV4cG9ydCB7IEFQUF9IT01FIH0gZnJvbSBcIi4vc3JjL29zLXBhdGgudHNcIjtcbmV4cG9ydCB0eXBlIHsgT3NQYXRocywgUmVzb2x2ZU9zUGF0aHNPcHRpb25zIH0gZnJvbSBcIi4vc3JjL29zLXBhdGgudHNcIjtcbiJdfQ==

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

@@ -0,0 +1,154 @@
+/**
+ * Host-local {@link FileSystem} backed by Node's `node:fs/promises`.
+ *
+ * Extends {@link BaseFileSystem} so this module only owns Node I/O, host path
+ * conversion, and symlink containment. Portable behavior (encoding, recursion,
+ * parent creation, fallbacks, POSIX namespace paths) lives in `@dbx-tools/shared-fs`.
+ *
+ * @module
+ */
+import { BaseFileSystem, FileSystemError, type CopyOptions, type FileEntry, type FileStat, type WriteFileOptions } from "@dbx-tools/shared-fs";
+import { type ResolveOsPathsOptions } from "./os-path.ts";
+/** Options for {@link LocalFileSystem}. */
+export interface LocalFileSystemOptions {
+    /** Unique identifier. Defaults to a stable hash of the absolute root. */
+    id?: string;
+    /**
+     * Root directory on disk. Relative paths resolve against `process.cwd()`.
+     * `~` / `~/...` expand via `os.homedir()` (before `HOME`), App `/home/app`,
+     * or a created `./.home` (create failures skip).
+     * Stored on {@link LocalFileSystem.root} in POSIX form.
+     */
+    root: string;
+    /** Block all write operations. Defaults to false. */
+    readOnly?: boolean;
+    /**
+     * Keep every resolved path under {@link root}. Defaults to true.
+     * When false, absolute input paths are accepted as-is (no sandbox).
+     */
+    contained?: boolean;
+    /**
+     * Create {@link root} (and parents) during init. Defaults to true.
+     */
+    createRoot?: boolean;
+}
+/**
+ * Options for the factories that take their root FROM the OS
+ * ({@link homeFS} / {@link tmpFS} / {@link scratchFS}) rather than from the
+ * caller: {@link LocalFileSystemOptions} without `root`, plus the
+ * {@link resolveOsPaths} injectables.
+ */
+export type OsFileSystemOptions = Omit<LocalFileSystemOptions, "root"> & {
+    /** Forwarded to {@link resolveLocalHome} / {@link resolveLocalTemp}. */
+    os?: ResolveOsPathsOptions;
+};
+/**
+ * {@link FileSystem} implementation that stores files in a folder on the local
+ * machine.
+ *
+ * @example
+ * ```ts
+ * const fs = new LocalFileSystem({ root: "./data" });
+ * await fs.init();
+ * await fs.writeFile("hello.txt", "hi");
+ *
+ * const home = new LocalFileSystem({ root: "~/projects/data" });
+ * const scratch = tmpFS("my-job");
+ * const cache = homeFS(".cache/app");
+ * ```
+ */
+export declare class LocalFileSystem extends BaseFileSystem<"local"> {
+    private readonly contained;
+    /** Symlink-resolved host root, refreshed in {@link onInit}. */
+    private realRoot;
+    constructor(options: LocalFileSystemOptions);
+    protected toBackendPath(posixBackendPath: string): string;
+    protected createRootDirectory(): Promise<void>;
+    protected onInit(): Promise<void>;
+    resolvePath(inputPath: string): string;
+    /**
+     * When contained, resolve symlinks and ensure the real path still sits under
+     * {@link root}. Missing leaf paths are allowed when `allowMissing` is set so
+     * writes can create new files.
+     */
+    protected preparePath(resolvedPath: string, options?: {
+        allowMissing?: boolean;
+    }): Promise<string>;
+    /** Classify Node errno codes; {@link BaseFileSystem} wraps every primitive. */
+    protected mapError(err: unknown, filePath: string): FileSystemError;
+    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 isNotFoundError(error: unknown): boolean;
+    protected tryAppendFileAt(resolvedPath: string, content: Uint8Array): Promise<boolean>;
+    protected tryCopyFileAt(sourcePath: string, destinationPath: string, options: Required<CopyOptions>): Promise<boolean>;
+    protected tryMoveFileAt(sourcePath: string, destinationPath: string, options: Required<CopyOptions>): Promise<boolean>;
+}
+/**
+ * {@link LocalFileSystem} rooted under {@link resolveLocalHome}, with
+ * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped
+ * so the result stays under home).
+ *
+ * @example
+ * ```ts
+ * const cache = homeFS(".cache/my-app");
+ * await cache.writeFile("state.json", "{}");
+ * ```
+ */
+export declare function homeFS(relativeRoot?: string, options?: OsFileSystemOptions): LocalFileSystem;
+/**
+ * {@link LocalFileSystem} rooted under {@link resolveLocalTemp}, with
+ * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped
+ * so the result stays under temp).
+ *
+ * @example
+ * ```ts
+ * const scratch = tmpFS("job-42");
+ * await scratch.writeFile("out.bin", bytes);
+ * ```
+ */
+export declare function tmpFS(relativeRoot?: string, options?: OsFileSystemOptions): LocalFileSystem;
+/**
+ * {@link tmpFS} under a root that is unique per call (`<prefix>-<id>`), for a
+ * scratch area no other process or run can collide with.
+ *
+ * Prefer this over minting the id at the call site - it is the one place that
+ * decides what a throwaway working directory looks like.
+ *
+ * @example
+ * ```ts
+ * const scratch = scratchFS("remote-skills");
+ * await scratch.writeFile("SKILL.md", body);
+ * ```
+ */
+export declare function scratchFS(prefix: string, options?: OsFileSystemOptions): LocalFileSystem;
+/**
+ * Rebuild the STABLE temp tree named by {@link key}, every call.
+ *
+ * {@link materialize} writes into a throwaway {@link scratchFS} root; only on
+ * success does that root REPLACE the stable one. Two properties fall out of
+ * that ordering, and both are the reason to prefer this over writing into the
+ * stable path directly:
+ *
+ * - repeated runs reuse ONE directory instead of leaving a new scratch behind
+ *   on every boot, and
+ * - a reader never observes a half-written tree, and a failed rebuild leaves
+ *   the previous one intact.
+ *
+ * The swap is a `rename` within the same temp root, so it is atomic.
+ *
+ * @param key - Stable temp-relative path. May be nested (`"skills/abc123"`)
+ *   to give each input its own directory.
+ *
+ * @example
+ * ```ts
+ * const tools = await rebuildFS("databricks-aitools", (scratch) =>
+ *   installInto(scratch.root),
+ * );
+ * ```
+ */
+export declare function rebuildFS(key: string, materialize: (scratch: LocalFileSystem) => Promise<void>, options?: OsFileSystemOptions): Promise<LocalFileSystem>;

package/lib/src/local-fs.js

@@ -0,0 +1,330 @@
+/**
+ * Host-local {@link FileSystem} backed by Node's `node:fs/promises`.
+ *
+ * Extends {@link BaseFileSystem} so this module only owns Node I/O, host path
+ * conversion, and symlink containment. Portable behavior (encoding, recursion,
+ * parent creation, fallbacks, POSIX namespace paths) lives in `@dbx-tools/shared-fs`.
+ *
+ * @module
+ */
+import { appendFile, cp, lstat, mkdir, readdir, readFile, realpath, rename, rm, rmdir, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { hash } from "@dbx-tools/shared-core";
+import { BaseFileSystem, baseFS, FileSystemError, posixPath, } from "@dbx-tools/shared-fs";
+import { resolveLocalRoot } from "./local-path.js";
+import { resolveLocalHome, resolveLocalTemp } from "./os-path.js";
+/**
+ * {@link FileSystem} implementation that stores files in a folder on the local
+ * machine.
+ *
+ * @example
+ * ```ts
+ * const fs = new LocalFileSystem({ root: "./data" });
+ * await fs.init();
+ * await fs.writeFile("hello.txt", "hi");
+ *
+ * const home = new LocalFileSystem({ root: "~/projects/data" });
+ * const scratch = tmpFS("my-job");
+ * const cache = homeFS(".cache/app");
+ * ```
+ */
+export class LocalFileSystem extends BaseFileSystem {
+    contained;
+    /** Symlink-resolved host root, refreshed in {@link onInit}. */
+    realRoot;
+    constructor(options) {
+        const hostRoot = resolveLocalRoot(options.root);
+        const root = posixPath.normalizeRoot(posixPath.toPosix(hostRoot));
+        super({
+            id: options.id ?? `local-${hash.fnvHash(root)}`,
+            backend: "local",
+            root,
+            readOnly: options.readOnly,
+            createRoot: options.createRoot ?? true,
+        });
+        this.realRoot = this.toBackendPath(root);
+        this.contained = options.contained ?? true;
+    }
+    toBackendPath(posixBackendPath) {
+        return posixPath.toHost(posixBackendPath, path.sep);
+    }
+    async createRootDirectory() {
+        await mkdir(this.toBackendPath(this.root), { recursive: true });
+    }
+    async onInit() {
+        const hostRoot = this.toBackendPath(this.root);
+        if (!this.createRoot) {
+            const info = await lstat(hostRoot);
+            if (!info.isDirectory()) {
+                throw new FileSystemError("NOT_DIRECTORY", `Local filesystem root is not a directory: ${this.root}`, this.root);
+            }
+        }
+        // Canonicalize so containment checks survive OS root symlinks (e.g. /var -> /private/var).
+        this.realRoot = await realpath(hostRoot);
+    }
+    resolvePath(inputPath) {
+        if (!this.contained) {
+            const resolved = path.isAbsolute(inputPath)
+                ? path.resolve(inputPath)
+                : path.resolve(this.toBackendPath(this.root), inputPath);
+            return this.toBackendPath(posixPath.toPosix(resolved));
+        }
+        return super.resolvePath(inputPath);
+    }
+    /**
+     * When contained, resolve symlinks and ensure the real path still sits under
+     * {@link root}. Missing leaf paths are allowed when `allowMissing` is set so
+     * writes can create new files.
+     */
+    async preparePath(resolvedPath, options) {
+        if (!this.contained)
+            return resolvedPath;
+        try {
+            const real = await realpath(resolvedPath);
+            if (!isWithinHostRoot(this.realRoot, real)) {
+                throw new FileSystemError("PERMISSION_DENIED", "Path escapes the filesystem root", resolvedPath);
+            }
+            return resolvedPath;
+        }
+        catch (err) {
+            if (err instanceof FileSystemError)
+                throw err;
+            if (options?.allowMissing && isErrno(err, "ENOENT")) {
+                let cursor = path.dirname(resolvedPath);
+                while (cursor !== path.dirname(cursor)) {
+                    try {
+                        const real = await realpath(cursor);
+                        if (!isWithinHostRoot(this.realRoot, real)) {
+                            throw new FileSystemError("PERMISSION_DENIED", "Path escapes the filesystem root", resolvedPath);
+                        }
+                        return resolvedPath;
+                    }
+                    catch (inner) {
+                        if (inner instanceof FileSystemError)
+                            throw inner;
+                        if (!isErrno(inner, "ENOENT"))
+                            throw this.mapError(inner, resolvedPath);
+                        cursor = path.dirname(cursor);
+                    }
+                }
+                return resolvedPath;
+            }
+            throw this.mapError(err, resolvedPath);
+        }
+    }
+    /** Classify Node errno codes; {@link BaseFileSystem} wraps every primitive. */
+    mapError(err, filePath) {
+        return baseFS.mapFileSystemError(err, filePath, nodeErrorCode);
+    }
+    async readBytesAt(resolvedPath) {
+        const buffer = await readFile(resolvedPath);
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    async writeBytesAt(resolvedPath, content, options) {
+        await writeFile(resolvedPath, content, options.overwrite ? undefined : { flag: "wx" });
+    }
+    async deleteFileAt(resolvedPath) {
+        await rm(resolvedPath, { force: false });
+    }
+    async createDirectoryAt(resolvedPath) {
+        await mkdir(resolvedPath);
+    }
+    async removeDirectoryAt(resolvedPath) {
+        await rmdir(resolvedPath);
+    }
+    async listDirectoryAt(resolvedPath) {
+        const dirents = await readdir(resolvedPath, { withFileTypes: true });
+        const entries = [];
+        for (const dirent of dirents) {
+            const type = entryType(dirent);
+            let size;
+            if (type === "file" || type === "symbolic-link") {
+                try {
+                    size = (await lstat(path.join(resolvedPath, dirent.name))).size;
+                }
+                catch {
+                    // Race with concurrent deletes; omit size.
+                }
+            }
+            entries.push(size === undefined ? { name: dirent.name, type } : { name: dirent.name, type, size });
+        }
+        return entries;
+    }
+    async statAt(resolvedPath) {
+        const info = await lstat(resolvedPath);
+        return {
+            name: path.basename(resolvedPath) || path.basename(this.toBackendPath(this.root)),
+            type: entryType(info),
+            size: info.size,
+            createdAt: info.birthtime,
+            modifiedAt: info.mtime,
+            accessedAt: info.atime,
+        };
+    }
+    isNotFoundError(error) {
+        return ((error instanceof FileSystemError && error.code === "NOT_FOUND") || isErrno(error, "ENOENT"));
+    }
+    async tryAppendFileAt(resolvedPath, content) {
+        await appendFile(resolvedPath, content);
+        return true;
+    }
+    async tryCopyFileAt(sourcePath, destinationPath, options) {
+        await cp(sourcePath, destinationPath, {
+            recursive: true,
+            force: options.overwrite,
+            errorOnExist: !options.overwrite,
+        });
+        return true;
+    }
+    async tryMoveFileAt(sourcePath, destinationPath, options) {
+        try {
+            await rename(sourcePath, destinationPath);
+        }
+        catch (err) {
+            // Across devices `rename` cannot work; fall back to copy + remove. Any
+            // other failure propagates for the base class to map.
+            if (!isErrno(err, "EXDEV"))
+                throw err;
+            await cp(sourcePath, destinationPath, { recursive: true, force: options.overwrite });
+            await rm(sourcePath, { recursive: true, force: true });
+        }
+        return true;
+    }
+}
+/* ------------------------------ helpers ------------------------------ */
+function isWithinHostRoot(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function isErrno(err, code) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        err.code === code);
+}
+function entryType(entry) {
+    if (entry.isSymbolicLink())
+        return "symbolic-link";
+    if (entry.isDirectory())
+        return "directory";
+    if (entry.isFile())
+        return "file";
+    return "other";
+}
+/** Node errno -> portable {@link FileSystemErrorCode}. */
+const NODE_ERROR_CODES = {
+    ENOENT: "NOT_FOUND",
+    EEXIST: "ALREADY_EXISTS",
+    ENOTDIR: "NOT_DIRECTORY",
+    EISDIR: "IS_DIRECTORY",
+    ENOTEMPTY: "DIRECTORY_NOT_EMPTY",
+    EACCES: "PERMISSION_DENIED",
+    EPERM: "PERMISSION_DENIED",
+};
+function nodeErrorCode(err) {
+    const code = err?.code;
+    return code ? NODE_ERROR_CODES[code] : undefined;
+}
+/**
+ * {@link LocalFileSystem} rooted under {@link resolveLocalHome}, with
+ * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped
+ * so the result stays under home).
+ *
+ * @example
+ * ```ts
+ * const cache = homeFS(".cache/my-app");
+ * await cache.writeFile("state.json", "{}");
+ * ```
+ */
+export function homeFS(relativeRoot = ".", options = {}) {
+    const { os, ...fsOptions } = options;
+    return new LocalFileSystem({
+        ...fsOptions,
+        root: joinUnderBase(resolveLocalHome(os), relativeRoot),
+    });
+}
+/**
+ * {@link LocalFileSystem} rooted under {@link resolveLocalTemp}, with
+ * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped
+ * so the result stays under temp).
+ *
+ * @example
+ * ```ts
+ * const scratch = tmpFS("job-42");
+ * await scratch.writeFile("out.bin", bytes);
+ * ```
+ */
+export function tmpFS(relativeRoot = ".", options = {}) {
+    const { os, ...fsOptions } = options;
+    return new LocalFileSystem({
+        ...fsOptions,
+        root: joinUnderBase(resolveLocalTemp(os), relativeRoot),
+    });
+}
+/**
+ * {@link tmpFS} under a root that is unique per call (`<prefix>-<id>`), for a
+ * scratch area no other process or run can collide with.
+ *
+ * Prefer this over minting the id at the call site - it is the one place that
+ * decides what a throwaway working directory looks like.
+ *
+ * @example
+ * ```ts
+ * const scratch = scratchFS("remote-skills");
+ * await scratch.writeFile("SKILL.md", body);
+ * ```
+ */
+export function scratchFS(prefix, options = {}) {
+    return tmpFS(`${prefix}-${hash.id()}`, options);
+}
+/**
+ * Rebuild the STABLE temp tree named by {@link key}, every call.
+ *
+ * {@link materialize} writes into a throwaway {@link scratchFS} root; only on
+ * success does that root REPLACE the stable one. Two properties fall out of
+ * that ordering, and both are the reason to prefer this over writing into the
+ * stable path directly:
+ *
+ * - repeated runs reuse ONE directory instead of leaving a new scratch behind
+ *   on every boot, and
+ * - a reader never observes a half-written tree, and a failed rebuild leaves
+ *   the previous one intact.
+ *
+ * The swap is a `rename` within the same temp root, so it is atomic.
+ *
+ * @param key - Stable temp-relative path. May be nested (`"skills/abc123"`)
+ *   to give each input its own directory.
+ *
+ * @example
+ * ```ts
+ * const tools = await rebuildFS("databricks-aitools", (scratch) =>
+ *   installInto(scratch.root),
+ * );
+ * ```
+ */
+export async function rebuildFS(key, materialize, options = {}) {
+    const scratch = scratchFS(key, options);
+    await scratch.init();
+    try {
+        await materialize(scratch);
+    }
+    catch (err) {
+        await rm(scratch.root, { recursive: true, force: true }).catch(() => undefined);
+        throw err;
+    }
+    const stable = tmpFS(key, options);
+    const stableHost = path.resolve(stable.root);
+    await rm(stableHost, { recursive: true, force: true });
+    await mkdir(path.dirname(stableHost), { recursive: true });
+    await rename(path.resolve(scratch.root), stableHost);
+    return stable;
+}
+/**
+ * Join {@link relativeRoot} under {@link base}. Empty / `.` keeps {@link base};
+ * leading `~` or `/` is stripped so an absolute-looking input cannot escape.
+ */
+function joinUnderBase(base, relativeRoot) {
+    const rest = posixPath.toRelativeSegment(relativeRoot);
+    return rest ? path.resolve(base, rest) : base;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"local-fs.js","sourceRoot":"","sources":["../../src/local-fs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Host-local {@link FileSystem} backed by Node's `node:fs/promises`.\n *\n * Extends {@link BaseFileSystem} so this module only owns Node I/O, host path\n * conversion, and symlink containment. Portable behavior (encoding, recursion,\n * parent creation, fallbacks, POSIX namespace paths) lives in `@dbx-tools/shared-fs`.\n *\n * @module\n */\n\nimport {\n  appendFile,\n  cp,\n  lstat,\n  mkdir,\n  readdir,\n  readFile,\n  realpath,\n  rename,\n  rm,\n  rmdir,\n  writeFile,\n} from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { hash } from \"@dbx-tools/shared-core\";\nimport {\n  BaseFileSystem,\n  baseFS,\n  FileSystemError,\n  posixPath,\n  type CopyOptions,\n  type FileEntry,\n  type FileEntryType,\n  type FileStat,\n  type FileSystemErrorCode,\n  type WriteFileOptions,\n} from \"@dbx-tools/shared-fs\";\nimport { resolveLocalRoot } from \"./local-path.ts\";\nimport { resolveLocalHome, resolveLocalTemp, type ResolveOsPathsOptions } from \"./os-path.ts\";\n\n/** Options for {@link LocalFileSystem}. */\nexport interface LocalFileSystemOptions {\n  /** Unique identifier. Defaults to a stable hash of the absolute root. */\n  id?: string;\n\n  /**\n   * Root directory on disk. Relative paths resolve against `process.cwd()`.\n   * `~` / `~/...` expand via `os.homedir()` (before `HOME`), App `/home/app`,\n   * or a created `./.home` (create failures skip).\n   * Stored on {@link LocalFileSystem.root} in POSIX form.\n   */\n  root: string;\n\n  /** Block all write operations. Defaults to false. */\n  readOnly?: boolean;\n\n  /**\n   * Keep every resolved path under {@link root}. Defaults to true.\n   * When false, absolute input paths are accepted as-is (no sandbox).\n   */\n  contained?: boolean;\n\n  /**\n   * Create {@link root} (and parents) during init. Defaults to true.\n   */\n  createRoot?: boolean;\n}\n\n/**\n * Options for the factories that take their root FROM the OS\n * ({@link homeFS} / {@link tmpFS} / {@link scratchFS}) rather than from the\n * caller: {@link LocalFileSystemOptions} without `root`, plus the\n * {@link resolveOsPaths} injectables.\n */\nexport type OsFileSystemOptions = Omit<LocalFileSystemOptions, \"root\"> & {\n  /** Forwarded to {@link resolveLocalHome} / {@link resolveLocalTemp}. */\n  os?: ResolveOsPathsOptions;\n};\n\n/**\n * {@link FileSystem} implementation that stores files in a folder on the local\n * machine.\n *\n * @example\n * ```ts\n * const fs = new LocalFileSystem({ root: \"./data\" });\n * await fs.init();\n * await fs.writeFile(\"hello.txt\", \"hi\");\n *\n * const home = new LocalFileSystem({ root: \"~/projects/data\" });\n * const scratch = tmpFS(\"my-job\");\n * const cache = homeFS(\".cache/app\");\n * ```\n */\nexport class LocalFileSystem extends BaseFileSystem<\"local\"> {\n  private readonly contained: boolean;\n  /** Symlink-resolved host root, refreshed in {@link onInit}. */\n  private realRoot: string;\n\n  constructor(options: LocalFileSystemOptions) {\n    const hostRoot = resolveLocalRoot(options.root);\n    const root = posixPath.normalizeRoot(posixPath.toPosix(hostRoot));\n    super({\n      id: options.id ?? `local-${hash.fnvHash(root)}`,\n      backend: \"local\",\n      root,\n      readOnly: options.readOnly,\n      createRoot: options.createRoot ?? true,\n    });\n    this.realRoot = this.toBackendPath(root);\n    this.contained = options.contained ?? true;\n  }\n\n  protected override toBackendPath(posixBackendPath: string): string {\n    return posixPath.toHost(posixBackendPath, path.sep);\n  }\n\n  protected override async createRootDirectory(): Promise<void> {\n    await mkdir(this.toBackendPath(this.root), { recursive: true });\n  }\n\n  protected override async onInit(): Promise<void> {\n    const hostRoot = this.toBackendPath(this.root);\n    if (!this.createRoot) {\n      const info = await lstat(hostRoot);\n      if (!info.isDirectory()) {\n        throw new FileSystemError(\n          \"NOT_DIRECTORY\",\n          `Local filesystem root is not a directory: ${this.root}`,\n          this.root,\n        );\n      }\n    }\n    // Canonicalize so containment checks survive OS root symlinks (e.g. /var -> /private/var).\n    this.realRoot = await realpath(hostRoot);\n  }\n\n  override resolvePath(inputPath: string): string {\n    if (!this.contained) {\n      const resolved = path.isAbsolute(inputPath)\n        ? path.resolve(inputPath)\n        : path.resolve(this.toBackendPath(this.root), inputPath);\n      return this.toBackendPath(posixPath.toPosix(resolved));\n    }\n    return super.resolvePath(inputPath);\n  }\n\n  /**\n   * When contained, resolve symlinks and ensure the real path still sits under\n   * {@link root}. Missing leaf paths are allowed when `allowMissing` is set so\n   * writes can create new files.\n   */\n  protected override async preparePath(\n    resolvedPath: string,\n    options?: { allowMissing?: boolean },\n  ): Promise<string> {\n    if (!this.contained) return resolvedPath;\n    try {\n      const real = await realpath(resolvedPath);\n      if (!isWithinHostRoot(this.realRoot, real)) {\n        throw new FileSystemError(\n          \"PERMISSION_DENIED\",\n          \"Path escapes the filesystem root\",\n          resolvedPath,\n        );\n      }\n      return resolvedPath;\n    } catch (err) {\n      if (err instanceof FileSystemError) throw err;\n      if (options?.allowMissing && isErrno(err, \"ENOENT\")) {\n        let cursor = path.dirname(resolvedPath);\n        while (cursor !== path.dirname(cursor)) {\n          try {\n            const real = await realpath(cursor);\n            if (!isWithinHostRoot(this.realRoot, real)) {\n              throw new FileSystemError(\n                \"PERMISSION_DENIED\",\n                \"Path escapes the filesystem root\",\n                resolvedPath,\n              );\n            }\n            return resolvedPath;\n          } catch (inner) {\n            if (inner instanceof FileSystemError) throw inner;\n            if (!isErrno(inner, \"ENOENT\")) throw this.mapError(inner, resolvedPath);\n            cursor = path.dirname(cursor);\n          }\n        }\n        return resolvedPath;\n      }\n      throw this.mapError(err, resolvedPath);\n    }\n  }\n\n  /** Classify Node errno codes; {@link BaseFileSystem} wraps every primitive. */\n  protected override mapError(err: unknown, filePath: string): FileSystemError {\n    return baseFS.mapFileSystemError(err, filePath, nodeErrorCode);\n  }\n\n  protected override async readBytesAt(resolvedPath: string): Promise<Uint8Array> {\n    const buffer = await readFile(resolvedPath);\n    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);\n  }\n\n  protected override async writeBytesAt(\n    resolvedPath: string,\n    content: Uint8Array,\n    options: Required<WriteFileOptions>,\n  ): Promise<void> {\n    await writeFile(resolvedPath, content, options.overwrite ? undefined : { flag: \"wx\" });\n  }\n\n  protected override async deleteFileAt(resolvedPath: string): Promise<void> {\n    await rm(resolvedPath, { force: false });\n  }\n\n  protected override async createDirectoryAt(resolvedPath: string): Promise<void> {\n    await mkdir(resolvedPath);\n  }\n\n  protected override async removeDirectoryAt(resolvedPath: string): Promise<void> {\n    await rmdir(resolvedPath);\n  }\n\n  protected override async listDirectoryAt(resolvedPath: string): Promise<FileEntry[]> {\n    const dirents = await readdir(resolvedPath, { withFileTypes: true });\n    const entries: FileEntry[] = [];\n    for (const dirent of dirents) {\n      const type = entryType(dirent);\n      let size: number | undefined;\n      if (type === \"file\" || type === \"symbolic-link\") {\n        try {\n          size = (await lstat(path.join(resolvedPath, dirent.name))).size;\n        } catch {\n          // Race with concurrent deletes; omit size.\n        }\n      }\n      entries.push(\n        size === undefined ? { name: dirent.name, type } : { name: dirent.name, type, size },\n      );\n    }\n    return entries;\n  }\n\n  protected override async statAt(resolvedPath: string): Promise<Omit<FileStat, \"path\">> {\n    const info = await lstat(resolvedPath);\n    return {\n      name: path.basename(resolvedPath) || path.basename(this.toBackendPath(this.root)),\n      type: entryType(info),\n      size: info.size,\n      createdAt: info.birthtime,\n      modifiedAt: info.mtime,\n      accessedAt: info.atime,\n    };\n  }\n\n  protected override isNotFoundError(error: unknown): boolean {\n    return (\n      (error instanceof FileSystemError && error.code === \"NOT_FOUND\") || isErrno(error, \"ENOENT\")\n    );\n  }\n\n  protected override async tryAppendFileAt(\n    resolvedPath: string,\n    content: Uint8Array,\n  ): Promise<boolean> {\n    await appendFile(resolvedPath, content);\n    return true;\n  }\n\n  protected override async tryCopyFileAt(\n    sourcePath: string,\n    destinationPath: string,\n    options: Required<CopyOptions>,\n  ): Promise<boolean> {\n    await cp(sourcePath, destinationPath, {\n      recursive: true,\n      force: options.overwrite,\n      errorOnExist: !options.overwrite,\n    });\n    return true;\n  }\n\n  protected override async tryMoveFileAt(\n    sourcePath: string,\n    destinationPath: string,\n    options: Required<CopyOptions>,\n  ): Promise<boolean> {\n    try {\n      await rename(sourcePath, destinationPath);\n    } catch (err) {\n      // Across devices `rename` cannot work; fall back to copy + remove. Any\n      // other failure propagates for the base class to map.\n      if (!isErrno(err, \"EXDEV\")) throw err;\n      await cp(sourcePath, destinationPath, { recursive: true, force: options.overwrite });\n      await rm(sourcePath, { recursive: true, force: true });\n    }\n    return true;\n  }\n}\n\n/* ------------------------------ helpers ------------------------------ */\n\nfunction isWithinHostRoot(root: string, candidate: string): boolean {\n  const relative = path.relative(root, candidate);\n  return relative === \"\" || (!relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\n\nfunction isErrno(err: unknown, code: string): boolean {\n  return (\n    typeof err === \"object\" &&\n    err !== null &&\n    \"code\" in err &&\n    (err as NodeJS.ErrnoException).code === code\n  );\n}\n\nfunction entryType(entry: {\n  isFile(): boolean;\n  isDirectory(): boolean;\n  isSymbolicLink(): boolean;\n}): FileEntryType {\n  if (entry.isSymbolicLink()) return \"symbolic-link\";\n  if (entry.isDirectory()) return \"directory\";\n  if (entry.isFile()) return \"file\";\n  return \"other\";\n}\n\n/** Node errno -> portable {@link FileSystemErrorCode}. */\nconst NODE_ERROR_CODES: Readonly<Record<string, FileSystemErrorCode>> = {\n  ENOENT: \"NOT_FOUND\",\n  EEXIST: \"ALREADY_EXISTS\",\n  ENOTDIR: \"NOT_DIRECTORY\",\n  EISDIR: \"IS_DIRECTORY\",\n  ENOTEMPTY: \"DIRECTORY_NOT_EMPTY\",\n  EACCES: \"PERMISSION_DENIED\",\n  EPERM: \"PERMISSION_DENIED\",\n};\n\nfunction nodeErrorCode(err: unknown): FileSystemErrorCode | undefined {\n  const code = (err as NodeJS.ErrnoException | undefined)?.code;\n  return code ? NODE_ERROR_CODES[code] : undefined;\n}\n\n/**\n * {@link LocalFileSystem} rooted under {@link resolveLocalHome}, with\n * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped\n * so the result stays under home).\n *\n * @example\n * ```ts\n * const cache = homeFS(\".cache/my-app\");\n * await cache.writeFile(\"state.json\", \"{}\");\n * ```\n */\nexport function homeFS(\n  relativeRoot: string = \".\",\n  options: OsFileSystemOptions = {},\n): LocalFileSystem {\n  const { os, ...fsOptions } = options;\n  return new LocalFileSystem({\n    ...fsOptions,\n    root: joinUnderBase(resolveLocalHome(os), relativeRoot),\n  });\n}\n\n/**\n * {@link LocalFileSystem} rooted under {@link resolveLocalTemp}, with\n * {@link relativeRoot} joined as a relative path (leading `/` / `~` stripped\n * so the result stays under temp).\n *\n * @example\n * ```ts\n * const scratch = tmpFS(\"job-42\");\n * await scratch.writeFile(\"out.bin\", bytes);\n * ```\n */\nexport function tmpFS(\n  relativeRoot: string = \".\",\n  options: OsFileSystemOptions = {},\n): LocalFileSystem {\n  const { os, ...fsOptions } = options;\n  return new LocalFileSystem({\n    ...fsOptions,\n    root: joinUnderBase(resolveLocalTemp(os), relativeRoot),\n  });\n}\n\n/**\n * {@link tmpFS} under a root that is unique per call (`<prefix>-<id>`), for a\n * scratch area no other process or run can collide with.\n *\n * Prefer this over minting the id at the call site - it is the one place that\n * decides what a throwaway working directory looks like.\n *\n * @example\n * ```ts\n * const scratch = scratchFS(\"remote-skills\");\n * await scratch.writeFile(\"SKILL.md\", body);\n * ```\n */\nexport function scratchFS(prefix: string, options: OsFileSystemOptions = {}): LocalFileSystem {\n  return tmpFS(`${prefix}-${hash.id()}`, options);\n}\n\n/**\n * Rebuild the STABLE temp tree named by {@link key}, every call.\n *\n * {@link materialize} writes into a throwaway {@link scratchFS} root; only on\n * success does that root REPLACE the stable one. Two properties fall out of\n * that ordering, and both are the reason to prefer this over writing into the\n * stable path directly:\n *\n * - repeated runs reuse ONE directory instead of leaving a new scratch behind\n *   on every boot, and\n * - a reader never observes a half-written tree, and a failed rebuild leaves\n *   the previous one intact.\n *\n * The swap is a `rename` within the same temp root, so it is atomic.\n *\n * @param key - Stable temp-relative path. May be nested (`\"skills/abc123\"`)\n *   to give each input its own directory.\n *\n * @example\n * ```ts\n * const tools = await rebuildFS(\"databricks-aitools\", (scratch) =>\n *   installInto(scratch.root),\n * );\n * ```\n */\nexport async function rebuildFS(\n  key: string,\n  materialize: (scratch: LocalFileSystem) => Promise<void>,\n  options: OsFileSystemOptions = {},\n): Promise<LocalFileSystem> {\n  const scratch = scratchFS(key, options);\n  await scratch.init();\n\n  try {\n    await materialize(scratch);\n  } catch (err) {\n    await rm(scratch.root, { recursive: true, force: true }).catch(() => undefined);\n    throw err;\n  }\n\n  const stable = tmpFS(key, options);\n  const stableHost = path.resolve(stable.root);\n  await rm(stableHost, { recursive: true, force: true });\n  await mkdir(path.dirname(stableHost), { recursive: true });\n  await rename(path.resolve(scratch.root), stableHost);\n  return stable;\n}\n\n/**\n * Join {@link relativeRoot} under {@link base}. Empty / `.` keeps {@link base};\n * leading `~` or `/` is stripped so an absolute-looking input cannot escape.\n */\nfunction joinUnderBase(base: string, relativeRoot: string): string {\n  const rest = posixPath.toRelativeSegment(relativeRoot);\n  return rest ? path.resolve(base, rest) : base;\n}\n"]}