@qodalis/cli-files 2.0.0-beta.13 → 2.0.0-beta.14

package/public-api.js

@@ -6,7 +6,7 @@ var cliCore = require('@qodalis/cli-core');
 var IFileSystemService_TOKEN = "cli-file-system-service";
 
 // src/lib/version.ts
-var LIBRARY_VERSION = "2.0.0-beta.13";
+var LIBRARY_VERSION = "2.0.0-beta.14";
 var API_VERSION = 2;
 
 // src/lib/processors/cli-ls-command-processor.ts
@@ -472,6 +472,14 @@ var CliMvCommandProcessor = class {
     return raw.split(/\s+/).filter((t) => t && !t.startsWith("--") && !t.startsWith("-"));
   }
 };
+function readableChildren(fs, path) {
+  try {
+    return fs.listDirectory(path);
+  } catch (e) {
+    if (cliCore.isCliAccessDeniedError(e)) return null;
+    throw e;
+  }
+}
 var CliTreeCommandProcessor = class {
   constructor() {
     this.command = "tree";
@@ -518,7 +526,8 @@ var CliTreeCommandProcessor = class {
         )
       );
       const counts = { dirs: 0, files: 0 };
-      this.printTree(node, "", true, 0, maxDepth, context, counts);
+      this.fs = fs;
+      this.printTree(node, "", true, 0, maxDepth, context, counts, resolvedPath);
       context.writer.writeln();
       context.writer.writeln(
         `${counts.dirs} directories, ${counts.files} files`
@@ -527,11 +536,15 @@ var CliTreeCommandProcessor = class {
       context.writer.writeError(e.message);
     }
   }
-  printTree(node, prefix, isRoot, depth, maxDepth, context, counts) {
-    if (!node.children || depth >= maxDepth) {
+  printTree(node, prefix, isRoot, depth, maxDepth, context, counts, path = "/") {
+    if (depth >= maxDepth) {
       return;
     }
-    const children = [...node.children].sort((a, b) => {
+    const visible = this.fs ? readableChildren(this.fs, path) : node.children;
+    if (!visible) {
+      return;
+    }
+    const children = [...visible].sort((a, b) => {
       if (a.type !== b.type) {
         return a.type === "directory" ? -1 : 1;
       }
@@ -556,7 +569,8 @@ var CliTreeCommandProcessor = class {
           depth + 1,
           maxDepth,
           context,
-          counts
+          counts,
+          path === "/" ? `/${child.name}` : `${path}/${child.name}`
         );
       } else {
         counts.files++;
@@ -846,6 +860,7 @@ var CliFindCommandProcessor = class {
       const resolvedBase = fs.resolvePath(searchPath);
       const nameRegex = namePattern ? this.globToRegex(namePattern) : null;
       const results = [];
+      this.fs = fs;
       this.walk(
         node,
         resolvedBase,
@@ -873,8 +888,9 @@ var CliFindCommandProcessor = class {
     return new RegExp(`^${regexStr}$`, "i");
   }
   walk(node, currentPath, depth, maxDepth, nameRegex, typeFilter, results) {
-    if (!node.children) return;
-    for (const child of node.children) {
+    const children = this.fs ? readableChildren(this.fs, currentPath) : node.children;
+    if (!children) return;
+    for (const child of children) {
       const childPath = currentPath === "/" ? `/${child.name}` : `${currentPath}/${child.name}`;
       let matches = true;
       if (nameRegex && !nameRegex.test(child.name)) {
@@ -1105,8 +1121,9 @@ var CliGrepCommandProcessor = class {
     };
   }
   collectFiles(fs, basePath, node, result) {
-    if (!node.children) return;
-    for (const child of node.children) {
+    const children = readableChildren(fs, basePath);
+    if (!children) return;
+    for (const child of children) {
       const childPath = basePath === "/" ? `/${child.name}` : `${basePath}/${child.name}`;
       if (child.type === "file") {
         result.push(childPath);
@@ -2065,6 +2082,10 @@ var CliStatCommandProcessor = class {
     }
     for (const path of paths) {
       const resolved = fs.resolvePath(path);
+      if (fs.canTraverse && !fs.canTraverse(resolved)) {
+        context.writer.writeError(`stat: cannot stat '${path}': Permission denied`);
+        continue;
+      }
       const node = fs.getNode(resolved);
       if (!node) {
         context.writer.writeError(
@@ -2333,6 +2354,10 @@ var CliDuCommandProcessor = class {
     }
     for (const path of paths) {
       const resolved = fs.resolvePath(path);
+      if (fs.canTraverse && !fs.canTraverse(resolved)) {
+        context.writer.writeError(`du: cannot access '${path}': Permission denied`);
+        continue;
+      }
       const node = fs.getNode(resolved);
       if (!node) {
         context.writer.writeError(
@@ -2346,6 +2371,7 @@ var CliDuCommandProcessor = class {
         );
       } else {
         const entries = [];
+        this.fs = fs;
         this.collectSizes(node, resolved, 0, maxDepth, summaryOnly, entries);
         for (const entry of entries) {
           context.writer.writeln(
@@ -2368,8 +2394,9 @@ var CliDuCommandProcessor = class {
       return node.size;
     }
     let total = 0;
-    if (node.children) {
-      for (const child of node.children) {
+    const children = this.fs ? readableChildren(this.fs, path) : node.children;
+    if (children) {
+      for (const child of children) {
         const childPath = path === "/" ? `/${child.name}` : `${path}/${child.name}`;
         total += this.collectSizes(
           child,
@@ -3832,14 +3859,14 @@ function substituteVariables(input, variables) {
   );
   return result;
 }
-
-// src/lib/services/indexed-db-file-system.service.ts
 var DB_NAME = "qodalis-cli-filesystem";
 var STORE_NAME = "filesystem";
 var ROOT_KEY = "root";
 var CWD_KEY = "cwd";
 var HOME_KEY = "home";
 var DEFAULT_HOME = "/";
+var SYSTEM_OWNERSHIP = { uid: "root", gid: "admin" };
+var ANONYMOUS_OWNERSHIP = { uid: "nobody", gid: "nogroup" };
 function createSeedFileSystem() {
   const now = Date.now();
   return {
@@ -3887,6 +3914,88 @@ var IndexedDbFileSystemService = class {
     this.homePath = DEFAULT_HOME;
     this.currentUid = null;
     this.currentGroups = [];
+    this.systemDepth = 0;
+  }
+  // --- Access control ---
+  setAccessPolicy(policy) {
+    this.accessPolicy = policy;
+  }
+  runAsSystem(fn) {
+    this.systemDepth++;
+    try {
+      return fn();
+    } finally {
+      this.systemDepth--;
+    }
+  }
+  reassignOwner(fromUid, toUid) {
+    const from = fromUid.toLowerCase();
+    if (!from || !toUid) return 0;
+    let changed = 0;
+    const visit = (node) => {
+      if (node.ownership && node.ownership.uid.toLowerCase() === from) {
+        node.ownership = { ...node.ownership, uid: toUid };
+        changed++;
+      }
+      node.children?.forEach(visit);
+    };
+    visit(this.root);
+    return changed;
+  }
+  canTraverse(path) {
+    try {
+      this.assertTraverse(this.resolvePath(path), "stat", path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  get enforcing() {
+    return !!this.accessPolicy && this.systemDepth === 0;
+  }
+  deny(op, path, reason = "Permission denied") {
+    throw new cliCore.CliAccessDeniedError(`${op}: ${path}: ${reason}`);
+  }
+  /** `x` on every existing directory on the way to `resolved` (excluding the target). */
+  assertTraverse(resolved, op, display) {
+    if (!this.enforcing) return;
+    const parts = resolved.split("/").filter(Boolean);
+    let current = this.root;
+    for (let i = 0; i < parts.length; i++) {
+      if (!current || current.type !== "directory") return;
+      if (!this.accessPolicy.canAccess(current, "execute")) this.deny(op, display);
+      current = current.children?.find((c) => c.name === parts[i]);
+    }
+  }
+  assertAccess(node, action, op, display) {
+    if (this.enforcing && !this.accessPolicy.canAccess(node, action)) this.deny(op, display);
+  }
+  /** Recursive delete: every directory inside must allow removing its entries (`w` + `x`, readable). */
+  assertRemovableTree(dir, dirPath, display) {
+    if (!this.enforcing) return;
+    this.assertAccess(dir, "read", "rm", display);
+    this.assertAccess(dir, "execute", "rm", display);
+    if ((dir.children?.length ?? 0) > 0) this.assertAccess(dir, "write", "rm", display);
+    for (const child of dir.children ?? []) {
+      if (child.type === "directory") this.assertRemovableTree(child, `${dirPath}/${child.name}`, display);
+    }
+  }
+  /** Copying reads everything it copies: `r` on every file, `r` + `x` on every directory. */
+  assertReadableTree(node, display) {
+    if (!this.enforcing) return;
+    this.assertAccess(node, "read", "cp", display);
+    if (node.type !== "directory") return;
+    this.assertAccess(node, "execute", "cp", display);
+    for (const child of node.children ?? []) {
+      this.assertReadableTree(child, `${display.replace(/\/+$/, "")}/${child.name}`);
+    }
+  }
+  /** Creating/removing entries needs `w` and `x` on the containing directory. */
+  assertModifyDir(dir, dirPath, op, display) {
+    if (!this.enforcing) return;
+    this.assertTraverse(dirPath, op, display);
+    this.assertAccess(dir, "execute", op, display);
+    this.assertAccess(dir, "write", op, display);
   }
   // --- User context ---
   setCurrentUser(uid, groups) {
@@ -3894,7 +4003,9 @@ var IndexedDbFileSystemService = class {
     this.currentGroups = groups;
   }
   getDefaultOwnership() {
-    if (!this.currentUid) return void 0;
+    if (!this.currentUid) {
+      return this.accessPolicy ? { ...ANONYMOUS_OWNERSHIP } : void 0;
+    }
     return {
       uid: this.currentUid,
       gid: this.currentGroups[0] || "users"
@@ -3913,6 +4024,8 @@ var IndexedDbFileSystemService = class {
     if (node.type !== "directory") {
       throw new Error(`cd: ${path}: Not a directory`);
     }
+    this.assertTraverse(resolved, "cd", path);
+    this.assertAccess(node, "execute", "cd", path);
     this.cwd = resolved;
   }
   getHomePath() {
@@ -3969,6 +4082,8 @@ var IndexedDbFileSystemService = class {
     if (node.type !== "directory") {
       throw new Error(`ls: ${path}: Not a directory`);
     }
+    this.assertTraverse(this.resolvePath(path), "ls", path);
+    this.assertAccess(node, "read", "ls", path);
     return node.children || [];
   }
   readFile(path) {
@@ -3979,6 +4094,8 @@ var IndexedDbFileSystemService = class {
     if (node.type === "directory") {
       throw new Error(`cat: ${path}: Is a directory`);
     }
+    this.assertTraverse(this.resolvePath(path), "cat", path);
+    this.assertAccess(node, "read", "cat", path);
     return node.content ?? "";
   }
   exists(path) {
@@ -4003,6 +4120,10 @@ var IndexedDbFileSystemService = class {
         }
         let child = current.children.find((c) => c.name === part);
         if (!child) {
+          if (this.enforcing) {
+            this.assertAccess(current, "execute", "mkdir", path);
+            this.assertAccess(current, "write", "mkdir", path);
+          }
           const now = Date.now();
           child = {
             name: part,
@@ -4018,6 +4139,8 @@ var IndexedDbFileSystemService = class {
           current.modifiedAt = now;
         } else if (child.type !== "directory") {
           throw new Error(`mkdir: ${part}: Not a directory`);
+        } else {
+          this.assertAccess(child, "execute", "mkdir", path);
         }
         current = child;
       }
@@ -4036,6 +4159,7 @@ var IndexedDbFileSystemService = class {
       if (parent.children?.find((c) => c.name === dirName)) {
         throw new Error(`mkdir: ${path}: File exists`);
       }
+      this.assertModifyDir(parent, parentPath, "mkdir", path);
       const now = Date.now();
       if (!parent.children) {
         parent.children = [];
@@ -4070,6 +4194,12 @@ var IndexedDbFileSystemService = class {
     }
     const existing = parent.children?.find((c) => c.name === fileName);
     const now = Date.now();
+    if (existing) {
+      this.assertTraverse(resolved, "touch", path);
+      this.assertAccess(existing, "write", "touch", path);
+    } else {
+      this.assertModifyDir(parent, parentPath, "touch", path);
+    }
     if (existing) {
       existing.modifiedAt = now;
     } else {
@@ -4096,6 +4226,8 @@ var IndexedDbFileSystemService = class {
       if (node.type === "directory") {
         throw new Error(`write: ${path}: Is a directory`);
       }
+      this.assertTraverse(resolved, "write", path);
+      this.assertAccess(node, "write", "write", path);
       const now = Date.now();
       node.content = append ? (node.content ?? "") + content : content;
       node.size = new Blob([node.content]).size;
@@ -4124,6 +4256,8 @@ var IndexedDbFileSystemService = class {
     if (target.type === "directory" && !recursive) {
       throw new Error(`rm: ${path}: Is a directory`);
     }
+    this.assertModifyDir(parent, parentPath, "rm", path);
+    if (target.type === "directory") this.assertRemovableTree(target, resolved, path);
     parent.children.splice(index, 1);
     parent.modifiedAt = Date.now();
   }
@@ -4138,10 +4272,13 @@ var IndexedDbFileSystemService = class {
         `cp: -r not specified; omitting directory '${src}'`
       );
     }
+    this.assertTraverse(srcResolved, "cp", src);
+    this.assertReadableTree(srcNode, src);
     const destResolved = this.resolvePath(dest);
     const destNode = this.getNode(destResolved);
     if (destNode && destNode.type === "directory") {
-      const clone = this.cloneNode(srcNode);
+      this.assertModifyDir(destNode, destResolved, "cp", dest);
+      const clone = this.ownedByCurrentUser(this.cloneNode(srcNode));
       if (!destNode.children) {
         destNode.children = [];
       }
@@ -4161,7 +4298,8 @@ var IndexedDbFileSystemService = class {
       if (!parent || parent.type !== "directory") {
         throw new Error(`cp: ${parentPath}: No such file or directory`);
       }
-      const clone = this.cloneNode(srcNode);
+      this.assertModifyDir(parent, parentPath, "cp", dest);
+      const clone = this.ownedByCurrentUser(this.cloneNode(srcNode));
       clone.name = newName;
       if (!parent.children) {
         parent.children = [];
@@ -4193,10 +4331,12 @@ var IndexedDbFileSystemService = class {
     if (!srcParent || !srcParent.children) {
       throw new Error(`mv: ${src}: No such file or directory`);
     }
+    this.assertModifyDir(srcParent, srcParentPath, "mv", src);
     const srcIndex = srcParent.children.findIndex(
       (c) => c.name === srcNode.name
     );
     if (destNode && destNode.type === "directory") {
+      this.assertModifyDir(destNode, destResolved, "mv", dest);
       if (!destNode.children) {
         destNode.children = [];
       }
@@ -4219,6 +4359,7 @@ var IndexedDbFileSystemService = class {
           `mv: ${destParentPath}: No such file or directory`
         );
       }
+      this.assertModifyDir(destParent, destParentPath, "mv", dest);
       srcParent.children.splice(srcIndex, 1);
       srcNode.name = newName;
       if (!destParent.children) {
@@ -4242,6 +4383,9 @@ var IndexedDbFileSystemService = class {
     if (!node) {
       throw new Error(`chmod: ${path}: No such file or directory`);
     }
+    if (this.enforcing && !this.accessPolicy.canChangeOwnership(node)) {
+      this.deny("chmod", path, "Operation not permitted");
+    }
     node.permissions = permissions;
   }
   chown(path, ownership) {
@@ -4250,6 +4394,9 @@ var IndexedDbFileSystemService = class {
     if (!node) {
       throw new Error(`chown: ${path}: No such file or directory`);
     }
+    if (this.enforcing && !this.accessPolicy.canChangeOwnership(node, ownership)) {
+      this.deny("chown", path, "Operation not permitted");
+    }
     node.ownership = ownership;
   }
   // --- Persistence ---
@@ -4291,6 +4438,18 @@ var IndexedDbFileSystemService = class {
     }
   }
   // --- Private helpers ---
+  /** A copy belongs to whoever made it (like `cp` without `-p`) */
+  ownedByCurrentUser(node) {
+    const owner = this.getDefaultOwnership();
+    if (owner) {
+      const apply = (n) => {
+        n.ownership = { ...owner };
+        n.children?.forEach(apply);
+      };
+      apply(node);
+    }
+    return node;
+  }
   cloneNode(node) {
     const now = Date.now();
     const clone = {
@@ -4965,6 +5124,115 @@ var VirtualFsFileTransferService = class {
     return this._browserService.uploadFromBrowser(accept);
   }
 };
+var CliFilesPermissions = {
+  /** Bypass all file permission checks */
+  Admin: "files:admin",
+  /** chmod/chown files you do not own */
+  Chown: "files:chown"
+};
+var HOME_DIR_PERMISSIONS = "rwxr-x---";
+function authorization(context) {
+  try {
+    return context.services.get(cliCore.ICliAuthorizationService_TOKEN);
+  } catch {
+    return void 0;
+  }
+}
+function createFileAccessPolicy(context) {
+  return {
+    // Nodes without an owner (system seed, legacy data) belong to root:admin
+    canAccess: (node, action) => cliCore.cliCanAccess(
+      context,
+      node.ownership ? node : { ...node, ownership: SYSTEM_OWNERSHIP },
+      action,
+      [CliFilesPermissions.Admin]
+    ),
+    canChangeOwnership: (node, newOwnership) => {
+      const auth = authorization(context);
+      if (!auth) return true;
+      if (auth.can(CliFilesPermissions.Admin) || auth.can(CliFilesPermissions.Chown)) return true;
+      const principal = auth.getPrincipal();
+      if (!principal) return false;
+      const owns = !!node.ownership && (node.ownership.uid === principal.name || node.ownership.uid === principal.id);
+      const keepsOwner = !newOwnership || newOwnership.uid === node.ownership?.uid || newOwnership.uid === principal.name;
+      return owns && keepsOwner;
+    }
+  };
+}
+function followUserSession(context, fs) {
+  let sessions;
+  try {
+    sessions = context.services.get(cliCore.ICliUserSessionService_TOKEN);
+  } catch {
+    sessions = void 0;
+  }
+  if (!sessions) return void 0;
+  let previousUser = null;
+  return sessions.getUserSession().subscribe((session) => {
+    if (!session?.user) {
+      fs.setCurrentUser("", []);
+      if (previousUser !== null || !canEnter(fs, fs.getCurrentDirectory())) {
+        try {
+          fs.setCurrentDirectory("/");
+          void fs.persist();
+        } catch {
+        }
+      }
+      previousUser = null;
+      return;
+    }
+    const user = session.user;
+    fs.setCurrentUser(user.name, user.groups ?? []);
+    if (user.homeDir) {
+      const home = user.homeDir;
+      const system = (fn) => fs.runAsSystem ? fs.runAsSystem(fn) : fn();
+      if (!fs.exists(home)) {
+        system(() => {
+          fs.createDirectory(home, true);
+          if (home !== "/") {
+            fs.chown(home, { uid: user.name, gid: user.groups?.[0] ?? "users" });
+            fs.chmod(home, HOME_DIR_PERMISSIONS);
+          }
+        });
+        void fs.persist();
+      }
+      fs.setHomePath(home);
+      if (previousUser !== user.id) {
+        try {
+          fs.setCurrentDirectory(home);
+        } catch {
+        }
+      }
+    }
+    previousUser = user.id;
+  });
+}
+function canEnter(fs, path) {
+  try {
+    fs.setCurrentDirectory(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function followUserAccounts(context, fs) {
+  let events;
+  try {
+    events = context.services.get(cliCore.ICliUserEventService_TOKEN);
+  } catch {
+    events = void 0;
+  }
+  if (!events || !fs.reassignOwner) return void 0;
+  return events.events$.subscribe((event) => {
+    let changed = 0;
+    if (event.type === "user_updated" && event.previousName && event.previousName !== event.user?.name) {
+      changed = fs.reassignOwner(event.previousName, event.user.name);
+    } else if (event.type === "user_deleted" && event.user?.name) {
+      changed = fs.reassignOwner(event.user.name, SYSTEM_OWNERSHIP.uid);
+    }
+    if (changed > 0) void fs.persist().catch(() => void 0);
+  });
+}
 
 // src/lib/completion/file-path-completion-provider.ts
 var FILE_COMMANDS = /* @__PURE__ */ new Set([
@@ -5159,6 +5427,10 @@ var filesModule = {
     new CliShCommandProcessor(),
     new CliUploadCommandProcessor()
   ],
+  permissions: [
+    { name: CliFilesPermissions.Admin, description: "Bypass file permission checks" },
+    { name: CliFilesPermissions.Chown, description: "chmod/chown files owned by others" }
+  ],
   services: [
     {
       provide: IFileSystemService_TOKEN,
@@ -5230,13 +5502,26 @@ var filesModule = {
       });
     }
   },
+  async onAfterBoot(context) {
+    const fs = context.services.getRequired(IFileSystemService_TOKEN);
+    fs.setAccessPolicy?.(createFileAccessPolicy(context));
+    this._sessionSubscription?.unsubscribe();
+    this._sessionSubscription = followUserSession(context, fs);
+    this._accountsSubscription?.unsubscribe();
+    this._accountsSubscription = followUserAccounts(context, fs);
+  },
   async onDestroy(_context) {
     const sub = this._dragDropSubscription;
     sub?.unsubscribe();
     this._dragDropSubscription = void 0;
+    this._sessionSubscription?.unsubscribe();
+    this._sessionSubscription = void 0;
+    this._accountsSubscription?.unsubscribe();
+    this._accountsSubscription = void 0;
   }
 };
 
+exports.ANONYMOUS_OWNERSHIP = ANONYMOUS_OWNERSHIP;
 exports.CliAwkCommandProcessor = CliAwkCommandProcessor;
 exports.CliBasenameCommandProcessor = CliBasenameCommandProcessor;
 exports.CliCatCommandProcessor = CliCatCommandProcessor;
@@ -5249,6 +5534,7 @@ exports.CliDiffCommandProcessor = CliDiffCommandProcessor;
 exports.CliDirnameCommandProcessor = CliDirnameCommandProcessor;
 exports.CliDuCommandProcessor = CliDuCommandProcessor;
 exports.CliEchoCommandProcessor = CliEchoCommandProcessor;
+exports.CliFilesPermissions = CliFilesPermissions;
 exports.CliFindCommandProcessor = CliFindCommandProcessor;
 exports.CliGrepCommandProcessor = CliGrepCommandProcessor;
 exports.CliHeadCommandProcessor = CliHeadCommandProcessor;
@@ -5274,11 +5560,16 @@ exports.CliUniqCommandProcessor = CliUniqCommandProcessor;
 exports.CliWcCommandProcessor = CliWcCommandProcessor;
 exports.CliXargsCommandProcessor = CliXargsCommandProcessor;
 exports.FilePathCompletionProvider = FilePathCompletionProvider;
+exports.HOME_DIR_PERMISSIONS = HOME_DIR_PERMISSIONS;
 exports.IFileSystemService_TOKEN = IFileSystemService_TOKEN;
 exports.IndexedDbFileSystemService = IndexedDbFileSystemService;
+exports.SYSTEM_OWNERSHIP = SYSTEM_OWNERSHIP;
 exports.ServerFileSystemService = ServerFileSystemService;
 exports.VirtualFsFileTransferService = VirtualFsFileTransferService;
+exports.createFileAccessPolicy = createFileAccessPolicy;
 exports.executeScript = executeScript;
 exports.filesModule = filesModule;
+exports.followUserAccounts = followUserAccounts;
+exports.followUserSession = followUserSession;
 //# sourceMappingURL=public-api.js.map
 //# sourceMappingURL=public-api.js.map