@archildata/just-bash 0.1.0

package/dist/index.cjs

@@ -0,0 +1,532 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ArchilFs.ts
+var ArchilFs_exports = {};
+__export(ArchilFs_exports, {
+  ArchilFs: () => ArchilFs
+});
+var import_debug, debug, ArchilFs;
+var init_ArchilFs = __esm({
+  "src/ArchilFs.ts"() {
+    "use strict";
+    import_debug = __toESM(require("debug"), 1);
+    debug = (0, import_debug.default)("archil:fs");
+    ArchilFs = class {
+      client;
+      user;
+      rootInodeId = 1;
+      /**
+       * Create a new ArchilFs adapter
+       *
+       * @param client - Connected ArchilClient instance
+       * @param options - Optional configuration
+       * @param options.user - Unix user context for permission checks
+       */
+      constructor(client, options) {
+        this.client = client;
+        this.user = options?.user;
+      }
+      // ========================================================================
+      // Path Resolution
+      // ========================================================================
+      /**
+       * Normalize a path (remove . and .., ensure leading /)
+       */
+      normalizePath(path) {
+        if (!path || path === "") {
+          return "/";
+        }
+        if (!path.startsWith("/")) {
+          path = "/" + path;
+        }
+        const parts = path.split("/").filter((p) => p !== "" && p !== ".");
+        const result = [];
+        for (const part of parts) {
+          if (part === "..") {
+            result.pop();
+          } else {
+            result.push(part);
+          }
+        }
+        return "/" + result.join("/");
+      }
+      /**
+       * Resolve a path to its inode ID, walking the directory tree
+       */
+      async resolve(path) {
+        const normalizedPath = this.normalizePath(path);
+        const parts = normalizedPath.split("/").filter((p) => p !== "");
+        let currentInodeId = this.rootInodeId;
+        for (const part of parts) {
+          const response = await this.client.lookupInode(currentInodeId, part, this.user);
+          if (response.inodeId === -1) {
+            throw new Error(`ENOENT: no such file or directory, '${path}'`);
+          }
+          currentInodeId = response.inodeId;
+        }
+        const attributes = await this.client.getAttributes(currentInodeId, this.user);
+        return { inodeId: currentInodeId, attributes };
+      }
+      /**
+       * Resolve parent directory and get child name
+       */
+      async resolveParent(path) {
+        debug("resolveParent raw path=%j (bytes: %o)", path, Buffer.from(path));
+        const normalizedPath = this.normalizePath(path);
+        const lastSlash = normalizedPath.lastIndexOf("/");
+        const parentPath = lastSlash === 0 ? "/" : normalizedPath.substring(0, lastSlash);
+        const name = normalizedPath.substring(lastSlash + 1);
+        debug("resolveParent extracted name=%j (bytes: %o)", name, Buffer.from(name));
+        const { inodeId: parentInodeId } = await this.resolve(parentPath);
+        return { parentInodeId, name };
+      }
+      /**
+       * Convert InodeAttributes to FsStat
+       */
+      toStat(attrs) {
+        return {
+          isFile: attrs.inodeType === "File",
+          isDirectory: attrs.inodeType === "Directory",
+          isSymlink: attrs.inodeType === "Symlink",
+          mode: attrs.mode,
+          size: Number(attrs.size),
+          mtime: new Date(attrs.mtimeMs)
+        };
+      }
+      // ========================================================================
+      // IFileSystem Implementation - Read Operations
+      // ========================================================================
+      resolvePath(base, ...paths) {
+        debug("resolvePath base=%s paths=%o", base, paths);
+        let result = base;
+        for (const p of paths) {
+          if (p.startsWith("/")) {
+            result = p;
+          } else {
+            result = result.endsWith("/") ? result + p : result + "/" + p;
+          }
+        }
+        const normalized = this.normalizePath(result);
+        debug("resolvePath result=%s", normalized);
+        return normalized;
+      }
+      async readFile(path, encoding) {
+        debug("readFile path=%s encoding=%s", path, encoding);
+        try {
+          const buffer = await this.readFileBuffer(path);
+          debug("readFile got buffer length=%d", buffer.length);
+          const decoderEncoding = encoding === "binary" ? "latin1" : encoding || "utf-8";
+          debug("readFile using decoder encoding=%s", decoderEncoding);
+          const decoder = new TextDecoder(decoderEncoding);
+          const result = decoder.decode(buffer);
+          debug("readFile decoded to string length=%d", result.length);
+          return result;
+        } catch (err) {
+          debug("readFile FAILED: %O", err);
+          throw err;
+        }
+      }
+      async readFileBuffer(path) {
+        debug("readFileBuffer path=%s", path);
+        const { inodeId, attributes } = await this.resolve(path);
+        debug("readFileBuffer resolved inodeId=%d type=%s size=%d", inodeId, attributes.inodeType, attributes.size);
+        if (attributes.inodeType !== "File") {
+          throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+        }
+        const size = Number(attributes.size);
+        if (size === 0) {
+          debug("readFileBuffer file is empty, returning empty buffer");
+          return new Uint8Array(0);
+        }
+        const MAX_CHUNK = 4 * 1024 * 1024;
+        if (size <= MAX_CHUNK) {
+          const buffer = await this.client.readInode(inodeId, 0, size, this.user);
+          return new Uint8Array(buffer);
+        }
+        const result = new Uint8Array(size);
+        let offset = 0;
+        while (offset < size) {
+          const chunkSize = Math.min(MAX_CHUNK, size - offset);
+          const chunk = await this.client.readInode(inodeId, offset, chunkSize, this.user);
+          result.set(new Uint8Array(chunk), offset);
+          offset += chunkSize;
+        }
+        return result;
+      }
+      async readdir(path) {
+        debug("readdir path=%s", path);
+        const { inodeId, attributes } = await this.resolve(path);
+        if (attributes.inodeType !== "Directory") {
+          throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+        }
+        const entries = await this.client.readDirectory(inodeId, void 0, void 0, this.user);
+        for (const e of entries) {
+          debug("readdir entry name=%j (bytes: %o)", e.name, Buffer.from(e.name));
+        }
+        return entries.map((e) => e.name).filter((name) => name !== "." && name !== "..");
+      }
+      async readdirWithFileTypes(path) {
+        const { inodeId, attributes } = await this.resolve(path);
+        if (attributes.inodeType !== "Directory") {
+          throw new Error(`ENOTDIR: not a directory, scandir '${path}'`);
+        }
+        const entries = await this.client.readDirectory(inodeId, void 0, void 0, this.user);
+        return entries.filter((e) => e.name !== "." && e.name !== "..").map((e) => ({
+          name: e.name,
+          isFile: e.inodeType === "File",
+          isDirectory: e.inodeType === "Directory",
+          isSymlink: e.inodeType === "Symlink"
+        }));
+      }
+      async stat(path) {
+        debug("stat path=%s", path);
+        const { attributes } = await this.resolve(path);
+        if (attributes.inodeType === "Symlink" && attributes.symlinkTarget) {
+          const targetPath = attributes.symlinkTarget.startsWith("/") ? attributes.symlinkTarget : this.resolvePath(path, "..", attributes.symlinkTarget);
+          return this.stat(targetPath);
+        }
+        return this.toStat(attributes);
+      }
+      async lstat(path) {
+        debug("lstat path=%s", path);
+        const { attributes } = await this.resolve(path);
+        return this.toStat(attributes);
+      }
+      async exists(path) {
+        debug("exists path=%s", path);
+        try {
+          await this.resolve(path);
+          debug("exists path=%s -> true", path);
+          return true;
+        } catch {
+          debug("exists path=%s -> false", path);
+          return false;
+        }
+      }
+      async readlink(path) {
+        const { attributes } = await this.resolve(path);
+        if (attributes.inodeType !== "Symlink") {
+          throw new Error(`EINVAL: invalid argument, readlink '${path}'`);
+        }
+        return attributes.symlinkTarget || "";
+      }
+      async realpath(path) {
+        const normalizedPath = this.normalizePath(path);
+        const parts = normalizedPath.split("/").filter((p) => p !== "");
+        let resolvedPath = "/";
+        let currentInodeId = this.rootInodeId;
+        for (const part of parts) {
+          const response = await this.client.lookupInode(currentInodeId, part, this.user);
+          if (response.inodeId === -1) {
+            throw new Error(`ENOENT: no such file or directory, realpath '${path}'`);
+          }
+          const attrs = response.attributes;
+          if (attrs.inodeType === "Symlink" && attrs.symlinkTarget) {
+            const targetPath = attrs.symlinkTarget.startsWith("/") ? attrs.symlinkTarget : this.resolvePath(resolvedPath, attrs.symlinkTarget);
+            const resolved = await this.realpath(targetPath);
+            resolvedPath = resolved;
+            const { inodeId } = await this.resolve(resolved);
+            currentInodeId = inodeId;
+          } else {
+            resolvedPath = resolvedPath === "/" ? "/" + part : resolvedPath + "/" + part;
+            currentInodeId = response.inodeId;
+          }
+        }
+        return resolvedPath;
+      }
+      // ========================================================================
+      // IFileSystem Implementation - Write Operations
+      // ========================================================================
+      async writeFile(path, content) {
+        debug("writeFile path=%s contentLength=%d", path, content.length);
+        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+        let inodeId;
+        try {
+          const resolved = await this.resolve(path);
+          inodeId = resolved.inodeId;
+          debug("writeFile resolved existing file path=%s inodeId=%d", path, inodeId);
+          if (resolved.attributes.inodeType !== "File") {
+            throw new Error(`EISDIR: illegal operation on a directory, write '${path}'`);
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("EISDIR")) {
+            throw err;
+          }
+          debug("writeFile file doesn't exist, creating: %s", path);
+          const { parentInodeId, name } = await this.resolveParent(path);
+          debug("writeFile resolved parent parentInodeId=%d name=%s", parentInodeId, name);
+          const now = Date.now();
+          debug("writeFile calling create parent=%d name=%s", parentInodeId, name);
+          try {
+            inodeId = await this.client.create(
+              parentInodeId,
+              name,
+              {
+                inodeId: 0,
+                // Will be assigned by the filesystem
+                inodeType: "File",
+                size: 0,
+                uid: this.user?.uid ?? 0,
+                gid: this.user?.gid ?? 0,
+                mode: 420,
+                nlink: 1,
+                ctimeMs: now,
+                atimeMs: now,
+                mtimeMs: now,
+                btimeMs: now,
+                rdev: void 0,
+                symlinkTarget: void 0
+              },
+              this.user
+            );
+            debug("writeFile create succeeded inodeId=%d", inodeId);
+          } catch (createErr) {
+            debug("writeFile create FAILED: %O", createErr);
+            throw createErr;
+          }
+        }
+        debug("writeFile writing %d bytes to inodeId=%d", data.length, inodeId);
+        await this.client.writeData(inodeId, 0, Buffer.from(data), this.user);
+        debug("writeFile write succeeded");
+      }
+      async appendFile(path, content) {
+        let existing;
+        try {
+          existing = await this.readFileBuffer(path);
+        } catch {
+          existing = new Uint8Array(0);
+        }
+        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+        const combined = new Uint8Array(existing.length + data.length);
+        combined.set(existing, 0);
+        combined.set(data, existing.length);
+        await this.writeFile(path, combined);
+      }
+      async mkdir(path, options) {
+        const normalizedPath = this.normalizePath(path);
+        if (options?.recursive) {
+          const parts = normalizedPath.split("/").filter((p) => p !== "");
+          let currentPath = "";
+          for (const part of parts) {
+            currentPath += "/" + part;
+            const exists = await this.exists(currentPath);
+            if (exists) {
+              continue;
+            }
+            await this.mkdirSingle(currentPath);
+          }
+        } else {
+          await this.mkdirSingle(normalizedPath);
+        }
+      }
+      async mkdirSingle(path) {
+        const { parentInodeId, name } = await this.resolveParent(path);
+        const now = Date.now();
+        await this.client.create(
+          parentInodeId,
+          name,
+          {
+            inodeId: 0,
+            // Will be assigned by the filesystem
+            inodeType: "Directory",
+            size: 4096,
+            uid: this.user?.uid ?? 0,
+            gid: this.user?.gid ?? 0,
+            mode: 493,
+            nlink: 2,
+            ctimeMs: now,
+            atimeMs: now,
+            mtimeMs: now,
+            btimeMs: now,
+            rdev: void 0,
+            symlinkTarget: void 0
+          },
+          this.user
+        );
+      }
+      async rm(path, options) {
+        let resolved;
+        try {
+          resolved = await this.resolve(path);
+        } catch {
+          if (options?.force) {
+            return;
+          }
+          throw new Error(`ENOENT: no such file or directory, rm '${path}'`);
+        }
+        if (resolved.attributes.inodeType === "Directory") {
+          if (!options?.recursive) {
+            throw new Error(`EISDIR: illegal operation on a directory, rm '${path}'`);
+          }
+          const entries = await this.readdir(path);
+          for (const entry of entries) {
+            await this.rm(this.resolvePath(path, entry), options);
+          }
+        }
+        const { parentInodeId, name } = await this.resolveParent(path);
+        await this.client.unlink(parentInodeId, name, this.user);
+      }
+      async cp(src, dest, options) {
+        const srcResolved = await this.resolve(src);
+        if (srcResolved.attributes.inodeType === "Directory") {
+          if (!options?.recursive) {
+            throw new Error(`EISDIR: illegal operation on a directory, cp '${src}'`);
+          }
+          await this.mkdir(dest, { recursive: true });
+          const entries = await this.readdir(src);
+          for (const entry of entries) {
+            await this.cp(
+              this.resolvePath(src, entry),
+              this.resolvePath(dest, entry),
+              options
+            );
+          }
+        } else {
+          const content = await this.readFileBuffer(src);
+          await this.writeFile(dest, content);
+        }
+      }
+      async mv(src, dest) {
+        const { parentInodeId: srcParentInodeId, name: srcName } = await this.resolveParent(src);
+        const { parentInodeId: destParentInodeId, name: destName } = await this.resolveParent(dest);
+        await this.client.rename(
+          srcParentInodeId,
+          srcName,
+          destParentInodeId,
+          destName,
+          this.user
+        );
+      }
+      async symlink(target, path) {
+        const { parentInodeId, name } = await this.resolveParent(path);
+        const now = Date.now();
+        await this.client.create(
+          parentInodeId,
+          name,
+          {
+            inodeId: 0,
+            // Will be assigned by the filesystem
+            inodeType: "Symlink",
+            size: target.length,
+            uid: this.user?.uid ?? 0,
+            gid: this.user?.gid ?? 0,
+            mode: 511,
+            nlink: 1,
+            ctimeMs: now,
+            atimeMs: now,
+            mtimeMs: now,
+            btimeMs: now,
+            rdev: void 0,
+            symlinkTarget: target
+          },
+          this.user
+        );
+      }
+      async link(existingPath, newPath) {
+        throw new Error(
+          "Hard link operations not yet implemented. The archil-node bindings need to expose link for hard links."
+        );
+      }
+      async chmod(path, mode) {
+        const { inodeId } = await this.resolve(path);
+        await this.client.setattr(
+          inodeId,
+          { mode },
+          this.user ?? { uid: 0, gid: 0 }
+        );
+      }
+      async utimes(path, atime, mtime) {
+        debug("utimes path=%s atime=%d mtime=%d", path, atime, mtime);
+        const { inodeId } = await this.resolve(path);
+        debug("utimes resolved path=%s inodeId=%d", path, inodeId);
+        const atimeMs = atime === -1 ? -1 : Math.floor(atime * 1e3);
+        const mtimeMs = mtime === -1 ? -1 : Math.floor(mtime * 1e3);
+        debug("utimes calling setattr inodeId=%d atimeMs=%d mtimeMs=%d", inodeId, atimeMs, mtimeMs);
+        await this.client.setattr(
+          inodeId,
+          { atimeMs, mtimeMs },
+          this.user ?? { uid: 0, gid: 0 }
+        );
+        debug("utimes setattr succeeded inodeId=%d", inodeId);
+      }
+      // ========================================================================
+      // Utility Methods
+      // ========================================================================
+      async getAllPaths() {
+        const paths = [];
+        const walk = async (dirPath) => {
+          paths.push(dirPath);
+          try {
+            const entries = await this.readdirWithFileTypes(dirPath);
+            for (const entry of entries) {
+              const fullPath = this.resolvePath(dirPath, entry.name);
+              if (entry.isDirectory) {
+                await walk(fullPath);
+              } else {
+                paths.push(fullPath);
+              }
+            }
+          } catch {
+          }
+        };
+        await walk("/");
+        return paths;
+      }
+      /**
+       * Resolve a path to its inode ID (public wrapper for delegation operations)
+       */
+      async resolveInodeId(path) {
+        const { inodeId } = await this.resolve(path);
+        return inodeId;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArchilFs: () => ArchilFs,
+  createArchilFs: () => createArchilFs
+});
+module.exports = __toCommonJS(index_exports);
+init_ArchilFs();
+function createArchilFs(client, options) {
+  const { ArchilFs: ArchilFs2 } = (init_ArchilFs(), __toCommonJS(ArchilFs_exports));
+  return new ArchilFs2(client, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArchilFs,
+  createArchilFs
+});

package/dist/index.d.cts

@@ -0,0 +1,171 @@
+import * as _archildata_client from '@archildata/client';
+import { ArchilClient, UnixUser } from '@archildata/client';
+
+/**
+ * Archil filesystem adapter for just-bash
+ *
+ * Implements the IFileSystem interface from just-bash using the ArchilClient
+ * from @archildata/client for direct protocol access to Archil distributed filesystems.
+ */
+
+type BufferEncoding = "utf8" | "utf-8" | "ascii" | "binary" | "base64" | "hex" | "latin1";
+type FileContent = string | Uint8Array;
+interface FsStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+    mode: number;
+    size: number;
+    mtime: Date;
+}
+interface DirentEntry {
+    name: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymlink: boolean;
+}
+interface IFileSystem {
+    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes?(path: string): Promise<DirentEntry[]>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    exists(path: string): Promise<boolean>;
+    readlink(path: string): Promise<string>;
+    realpath(path: string): Promise<string>;
+    writeFile(path: string, content: FileContent): Promise<void>;
+    appendFile(path: string, content: FileContent): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    symlink(target: string, path: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+    utimes(path: string, atime: number, mtime: number): Promise<void>;
+    resolvePath(base: string, ...paths: string[]): string;
+    getAllPaths?(): Promise<string[]>;
+}
+/**
+ * ArchilFs implements the just-bash IFileSystem interface using Archil protocol.
+ *
+ * This adapter provides:
+ * - Path-to-inode resolution
+ * - Full filesystem operations via Archil protocol
+ * - Optional user context for permission checks
+ *
+ * @example
+ * ```typescript
+ * import { ArchilClient } from '@archildata/client';
+ * import { ArchilFs } from '@archildata/just-bash';
+ *
+ * const client = await ArchilClient.connect({
+ *   region: 'aws-us-east-1',
+ *   diskName: 'myaccount/mydisk',
+ *   authToken: 'adt_xxx',
+ * });
+ *
+ * const fs = new ArchilFs(client);
+ *
+ * // Use with just-bash
+ * import { Bash } from 'just-bash';
+ * const bash = new Bash({ fs });
+ * await bash.run('ls -la /');
+ * ```
+ */
+declare class ArchilFs implements IFileSystem {
+    private client;
+    private user?;
+    private rootInodeId;
+    /**
+     * Create a new ArchilFs adapter
+     *
+     * @param client - Connected ArchilClient instance
+     * @param options - Optional configuration
+     * @param options.user - Unix user context for permission checks
+     */
+    constructor(client: ArchilClient, options?: {
+        user?: UnixUser;
+    });
+    /**
+     * Normalize a path (remove . and .., ensure leading /)
+     */
+    private normalizePath;
+    /**
+     * Resolve a path to its inode ID, walking the directory tree
+     */
+    private resolve;
+    /**
+     * Resolve parent directory and get child name
+     */
+    private resolveParent;
+    /**
+     * Convert InodeAttributes to FsStat
+     */
+    private toStat;
+    resolvePath(base: string, ...paths: string[]): string;
+    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    stat(path: string): Promise<FsStat>;
+    lstat(path: string): Promise<FsStat>;
+    exists(path: string): Promise<boolean>;
+    readlink(path: string): Promise<string>;
+    realpath(path: string): Promise<string>;
+    writeFile(path: string, content: FileContent): Promise<void>;
+    appendFile(path: string, content: FileContent): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    private mkdirSingle;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    symlink(target: string, path: string): Promise<void>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+    utimes(path: string, atime: number, mtime: number): Promise<void>;
+    getAllPaths(): Promise<string[]>;
+    /**
+     * Resolve a path to its inode ID (public wrapper for delegation operations)
+     */
+    resolveInodeId(path: string): Promise<number>;
+}
+
+/**
+ * Create an ArchilFs instance from an existing client
+ *
+ * This is a convenience function for creating the filesystem adapter.
+ *
+ * @param client - Connected ArchilClient instance
+ * @param options - Optional configuration
+ * @returns Configured ArchilFs instance
+ *
+ * @example
+ * ```typescript
+ * import { ArchilClient } from '@archildata/client';
+ * import { createArchilFs } from '@archildata/just-bash';
+ *
+ * const client = await ArchilClient.connectAuthenticated({...});
+ * const fs = createArchilFs(client, { user: { uid: 1000, gid: 1000 } });
+ * ```
+ */
+declare function createArchilFs(client: _archildata_client.ArchilClient, options?: {
+    user?: _archildata_client.UnixUser;
+}): ArchilFs;
+
+export { ArchilFs, type BufferEncoding, type DirentEntry, type FileContent, type FsStat, type IFileSystem, createArchilFs };