@archildata/just-bash 0.1.0

package/dist/index.mjs

@@ -0,0 +1,522 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ArchilFs.ts
+var ArchilFs_exports = {};
+__export(ArchilFs_exports, {
+  ArchilFs: () => ArchilFs
+});
+var ArchilFs;
+var init_ArchilFs = __esm({
+  "src/ArchilFs.ts"() {
+    "use strict";
+    ArchilFs = class {
+      client;
+      inodeCache;
+      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;
+        this.inodeCache = /* @__PURE__ */ new Map();
+        this.inodeCache.set("/", this.rootInodeId);
+      }
+      // ========================================================================
+      // 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 cachedInode = this.inodeCache.get(normalizedPath);
+        if (cachedInode !== void 0) {
+          const attributes2 = await this.client.getAttributes(cachedInode, this.user);
+          return { inodeId: cachedInode, attributes: attributes2 };
+        }
+        const parts = normalizedPath.split("/").filter((p) => p !== "");
+        let currentInodeId = this.rootInodeId;
+        let currentPath = "";
+        for (const part of parts) {
+          currentPath += "/" + part;
+          const cached = this.inodeCache.get(currentPath);
+          if (cached !== void 0) {
+            currentInodeId = cached;
+            continue;
+          }
+          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;
+          this.inodeCache.set(currentPath, currentInodeId);
+        }
+        const attributes = await this.client.getAttributes(currentInodeId, this.user);
+        return { inodeId: currentInodeId, attributes };
+      }
+      /**
+       * Resolve parent directory and get child name
+       */
+      async resolveParent(path) {
+        const normalizedPath = this.normalizePath(path);
+        const lastSlash = normalizedPath.lastIndexOf("/");
+        const parentPath = lastSlash === 0 ? "/" : normalizedPath.substring(0, lastSlash);
+        const name = normalizedPath.substring(lastSlash + 1);
+        const { inodeId: parentInodeId } = await this.resolve(parentPath);
+        return { parentInodeId, name };
+      }
+      /**
+       * Invalidate cache entries for a path and its descendants
+       */
+      invalidateCache(path) {
+        const normalizedPath = this.normalizePath(path);
+        for (const cachedPath of this.inodeCache.keys()) {
+          if (cachedPath === normalizedPath || cachedPath.startsWith(normalizedPath + "/")) {
+            this.inodeCache.delete(cachedPath);
+          }
+        }
+      }
+      /**
+       * Convert InodeAttributes to FsStat
+       */
+      toStat(attrs) {
+        const isFile = attrs.inodeType === "File";
+        const isDirectory = attrs.inodeType === "Directory";
+        const isSymlink = attrs.inodeType === "Symlink";
+        return {
+          isFile: () => isFile,
+          isDirectory: () => isDirectory,
+          isSymlink: () => isSymlink,
+          mode: attrs.mode,
+          size: Number(attrs.size),
+          mtimeMs: attrs.mtimeMs,
+          atimeMs: attrs.atimeMs,
+          ctimeMs: attrs.ctimeMs,
+          birthtimeMs: attrs.btimeMs
+        };
+      }
+      // ========================================================================
+      // IFileSystem Implementation - Read Operations
+      // ========================================================================
+      resolvePath(base, ...paths) {
+        let result = base;
+        for (const p of paths) {
+          if (p.startsWith("/")) {
+            result = p;
+          } else {
+            result = result.endsWith("/") ? result + p : result + "/" + p;
+          }
+        }
+        return this.normalizePath(result);
+      }
+      async readFile(path, encoding) {
+        const buffer = await this.readFileBuffer(path);
+        const decoder = new TextDecoder(encoding || "utf-8");
+        return decoder.decode(buffer);
+      }
+      async readFileBuffer(path) {
+        const { inodeId, attributes } = await this.resolve(path);
+        if (attributes.inodeType !== "File") {
+          throw new Error(`EISDIR: illegal operation on a directory, read '${path}'`);
+        }
+        const size = Number(attributes.size);
+        if (size === 0) {
+          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) {
+        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.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) {
+        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) {
+        const { attributes } = await this.resolve(path);
+        return this.toStat(attributes);
+      }
+      async exists(path) {
+        try {
+          await this.resolve(path);
+          return true;
+        } catch {
+          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) {
+        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+        let inodeId;
+        let isNewFile = false;
+        try {
+          const resolved = await this.resolve(path);
+          inodeId = resolved.inodeId;
+          if (resolved.attributes.inodeType !== "File") {
+            throw new Error(`EISDIR: illegal operation on a directory, write '${path}'`);
+          }
+          await this.client.checkout(inodeId, false, this.user);
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("EISDIR")) {
+            throw err;
+          }
+          const { parentInodeId, name } = await this.resolveParent(path);
+          const range = await this.client.reserveInodes(1);
+          inodeId = range.start;
+          const now = Date.now();
+          await this.client.conditionalCreate(
+            parentInodeId,
+            name,
+            inodeId,
+            {
+              inodeId: Number(inodeId),
+              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
+          );
+          this.inodeCache.set(this.normalizePath(path), inodeId);
+          isNewFile = true;
+        }
+        try {
+          await this.client.writeData(inodeId, 0, Buffer.from(data), this.user);
+        } finally {
+          if (!isNewFile) {
+            try {
+              await this.client.checkin(inodeId, this.user);
+            } catch {
+            }
+          }
+        }
+      }
+      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 range = await this.client.reserveInodes(1);
+        const inodeId = range.start;
+        const now = Date.now();
+        await this.client.conditionalCreate(
+          parentInodeId,
+          name,
+          inodeId,
+          {
+            inodeId: Number(inodeId),
+            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
+        );
+        this.inodeCache.set(this.normalizePath(path), inodeId);
+      }
+      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);
+        this.invalidateCache(path);
+      }
+      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 srcResolved = await this.resolve(src);
+        if (srcResolved.attributes.inodeType === "Directory") {
+          await this.cp(src, dest, { recursive: true });
+        } else {
+          const content = await this.readFileBuffer(src);
+          await this.writeFile(dest, content);
+        }
+        await this.rm(src, { recursive: true, force: true });
+      }
+      async symlink(target, path) {
+        const { parentInodeId, name } = await this.resolveParent(path);
+        const range = await this.client.reserveInodes(1);
+        const inodeId = range.start;
+        const now = Date.now();
+        await this.client.conditionalCreate(
+          parentInodeId,
+          name,
+          inodeId,
+          {
+            inodeId: Number(inodeId),
+            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
+        );
+        this.inodeCache.set(this.normalizePath(path), inodeId);
+      }
+      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) {
+        throw new Error(
+          "chmod not yet implemented. The archil-node bindings need to expose setattr for permission changes."
+        );
+      }
+      async utimes(path, atime, mtime) {
+        throw new Error(
+          "utimes not yet implemented. The archil-node bindings need to expose setattr for timestamp changes."
+        );
+      }
+      // ========================================================================
+      // 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;
+      }
+      /**
+       * Clear the inode cache
+       */
+      clearCache() {
+        this.inodeCache.clear();
+        this.inodeCache.set("/", this.rootInodeId);
+      }
+      /**
+       * Get cache statistics
+       */
+      getCacheStats() {
+        return {
+          size: this.inodeCache.size,
+          paths: Array.from(this.inodeCache.keys())
+        };
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_ArchilFs();
+function createArchilFs(client, options) {
+  const { ArchilFs: ArchilFs2 } = (init_ArchilFs(), __toCommonJS(ArchilFs_exports));
+  return new ArchilFs2(client, options);
+}
+export {
+  ArchilFs,
+  createArchilFs
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@archildata/just-bash",
+  "version": "0.1.0",
+  "description": "Archil filesystem adapter for just-bash",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "archil-shell": "./bin/shell.ts"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
+    "shell": "tsx bin/shell.ts"
+  },
+  "dependencies": {
+    "@archildata/client": "^0.1.0",
+    "debug": "^4.3.4",
+    "just-bash": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "keywords": [
+    "archil",
+    "just-bash",
+    "filesystem",
+    "bash",
+    "ai-agents"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/archil/archil-dataplane.git",
+    "directory": "packages/archil-just-bash"
+  }
+}