@ai-ecoverse/slicc-kernel 1.59.1 → 1.60.1

package/dist/node.js

@@ -1774,6 +1774,29 @@ function userEnv(account, system) {
     PATH: `${pnpm}/bin:/usr/local/bin:/usr/bin:/bin`
   };
 }
+function groupsOf(groups, names) {
+  return names.map((g) => {
+    const row = groups.find((r) => r.name === g);
+    if (!row) throw fsError("ENOENT", `no group ${g}`);
+    return row;
+  });
+}
+function homeModeOf(mode) {
+  if (mode === void 0) return void 0;
+  if (!Number.isInteger(mode) || mode < 0 || mode > 4095) {
+    throw fsError("EINVAL", `not a mode: ${String(mode)}`);
+  }
+  return mode;
+}
+function joined(name2, rows) {
+  let changed = false;
+  for (const g of rows) {
+    if (g.members.includes(name2)) continue;
+    g.members.push(name2);
+    changed = true;
+  }
+  return changed;
+}
 function homeGroupOf(groups, name2) {
   if (name2 === void 0) return void 0;
   const found = groups.find((g) => g.name === name2);
@@ -1789,14 +1812,14 @@ var UserDb = class {
     this.fs = fs;
     this.owners = owners;
   }
-  async stampHome(row, shared) {
+  async stampHome(row, shared, homeMode) {
     const home = this.fs.resolvePath("/", row.home);
     if (!this.owners || !this.fs.chown || !HOME_DIR.test(home)) return;
     if (!await this.realDir(home)) return;
     const gid = shared?.gid ?? row.gid;
     await this.fs.chown(home, { uid: row.uid, gid, follow: false, kind: "adopt" });
     const scoop = row.name.startsWith("scoop-");
-    await this.fs.chmod(home, shared ? 1512 : scoop ? 488 : 448);
+    await this.fs.chmod(home, homeMode ?? (shared ? 1512 : scoop ? 488 : 448));
     const pnpm = `${home}/.local/share/pnpm`;
     if (await this.realDir(pnpm)) await this.fs.chmod(pnpm, scoop ? 488 : 448);
   }
@@ -1910,31 +1933,33 @@ var UserDb = class {
       const groups = parsed(group);
       const found = users.find((r) => r.name === name2);
       const shared = homeGroupOf(groups, options.homeGroup);
+      const homeMode = homeModeOf(options.homeMode);
       if (found) {
+        const more = groupsOf(groups, options.groups ?? []);
+        if (more.some((g) => g.gid === found.gid)) {
+          throw fsError("EINVAL", `a user is no member of its own group ${name2}`);
+        }
         if (found.uid >= FIRST_UID && found.uid <= LAST_UID) {
           await this.provision(found);
-          await this.stampHome(found, shared);
+          await this.stampHome(found, shared, homeMode);
         }
+        if (joined(name2, more)) await this.fs.writeFile(GROUP, formatGroup(group));
         remember();
         return this.account(found, groups);
       }
       const home = homeOf(options.home ?? `/home/${name2}`);
-      const extra = [USERS_GROUP, ...options.groups ?? []].map((g) => {
-        const row2 = groups.find((r) => r.name === g);
-        if (!row2) throw fsError("ENOENT", `no group ${g}`);
-        return row2;
-      });
+      const extra = groupsOf(groups, [USERS_GROUP, ...options.groups ?? []]);
       if (groups.some((r) => r.name === name2)) throw fsError("EEXIST", `group ${name2} exists`);
       const uid = freeId(users, groups);
       const row = { name: name2, uid, gid: uid, gecos: name2, home, shell: "/bin/bash" };
-      for (const g of extra) if (!g.members.includes(name2)) g.members.push(name2);
+      joined(name2, extra);
       group.push({ name: name2, gid: uid, members: [] });
       passwd.push(row);
       const fresh = !await this.fs.exists(home);
       await this.fs.mkdir(home, { recursive: true });
       try {
         await this.provision(row);
-        await this.stampHome(row, shared);
+        await this.stampHome(row, shared, homeMode);
         await this.fs.mkdir("/etc", { recursive: true });
         await this.commit(formatPasswd(passwd), formatGroup(group));
       } catch (err) {
@@ -1945,6 +1970,31 @@ var UserDb = class {
       return this.account(row, parsed(group));
     });
   }
+  async groups() {
+    const { group } = await this.tables();
+    return parsed(group).map(({ name: name2, gid, members }) => ({ name: name2, gid, members: [...members] }));
+  }
+  addMember(group, user) {
+    return this.member(group, user, true);
+  }
+  removeMember(group, user) {
+    return this.member(group, user, false);
+  }
+  member(name2, user, on) {
+    return this.serial(async () => {
+      const { passwd, group } = await this.tables();
+      const row = parsed(group).find((g) => g.name === name2);
+      if (!row) throw fsError("ENOENT", `no group ${String(name2)}`);
+      const who = parsed(passwd).find((u) => u.name === user);
+      if (!who) throw fsError("ENOENT", `no user ${String(user)}`);
+      if (who.gid === row.gid) throw fsError("EINVAL", `${name2} is the own group of ${user}`);
+      if (row.members.includes(user) !== on) {
+        row.members = on ? [...row.members, user] : row.members.filter((m) => m !== user);
+        await this.fs.writeFile(GROUP, formatGroup(group));
+      }
+      return { name: row.name, gid: row.gid, members: [...row.members] };
+    });
+  }
   remove(name2, options = {}) {
     return this.serial(async () => {
       const { passwd, group } = await this.tables();
@@ -2470,10 +2520,31 @@ var ERRNO_BY_DOM_ERROR = {
   TypeError: "EINVAL",
   NotAllowedError: "EACCES"
 };
-function translate(err, path) {
+var reported = /* @__PURE__ */ new Set();
+function translate(err, path, op = "lookup", mapped = true) {
   if (typeof err?.code === "string") return err;
-  const name2 = err?.name;
-  return fsError(typeof name2 === "string" && ERRNO_BY_DOM_ERROR[name2] || "EIO", path);
+  const raw = err?.name;
+  const name2 = typeof raw === "string" ? raw : "Error";
+  const code = mapped && ERRNO_BY_DOM_ERROR[name2] || "EIO";
+  const error = Object.assign(fsError(code, path), { domName: name2, op, cause: err });
+  if (code !== "EIO") return error;
+  const detail = err?.message;
+  error.message += ` (OPFS ${op}: ${name2}${typeof detail === "string" && detail ? `: ${detail}` : ""})`;
+  if (!reported.has(`${name2}/${op}`)) {
+    reported.add(`${name2}/${op}`);
+    console.warn(
+      `slicc-kernel: ${error.message}, reported as EIO; logged once per error and operation`
+    );
+  }
+  return error;
+}
+var META_OPS = ["get", "update", "move", "remove", "links", "under", "all"];
+function sidecar(meta) {
+  const pathOf = ([first]) => [first, "/"].flat().find((p) => typeof p === "string");
+  const guarded = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
+    throw translate(err, pathOf(args), "sidecar", false);
+  });
+  return Object.fromEntries(META_OPS.map((op) => [op, guarded(op)]));
 }
 function missing(err) {
   const code = err?.code;
@@ -2558,7 +2629,7 @@ var OpfsFs = class {
   owners = false;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
-    this.meta = meta;
+    this.meta = sidecar(meta);
     this.ranged = options.ranged === true;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     if (this.channel) {
@@ -2863,7 +2934,8 @@ var OpfsFs = class {
       } catch (err) {
         const name2 = err?.name;
         const again = name2 === "NotReadableError" || locks && LOCKED.has(name2);
-        if (!again || attempt >= READ_ATTEMPTS) throw translate(err, path);
+        if (!again || attempt >= READ_ATTEMPTS)
+          throw translate(err, path, locks ? "write" : "read");
         await new Promise((resolve) => setTimeout(resolve, attempt * 10));
       }
     }
@@ -2905,9 +2977,15 @@ var OpfsFs = class {
       true
     );
     return {
-      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }),
-      truncate: (size) => writable.truncate(size),
-      close: () => writable.close()
+      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }).catch((err) => {
+        throw translate(err, path, "write", false);
+      }),
+      truncate: (size) => writable.truncate(size).catch((err) => {
+        throw translate(err, path, "write", false);
+      }),
+      close: () => writable.close().catch((err) => {
+        throw translate(err, path, "commit", false);
+      })
     };
   }
   async readFile(path) {
@@ -2942,9 +3020,13 @@ var OpfsFs = class {
     const [file, existed, target] = await this.fileFor(path);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
-    const writable = await file.createWritable();
-    await writable.write(content);
-    await writable.close();
+    try {
+      const writable = await file.createWritable();
+      await writable.write(content);
+      await writable.close();
+    } catch (err) {
+      throw translate(err, path, "commit", false);
+    }
   }
   async listing(path) {
     const found = await this.locate(path, true);
@@ -3220,6 +3302,49 @@ var OpfsFs = class {
     return removed;
   }
 };
+var READS = [
+  "stat",
+  "lstat",
+  "exists",
+  "readFile",
+  "readFileBuffer",
+  "pread",
+  "readdir",
+  "readdirStat",
+  "readlink",
+  "realpath"
+];
+var WRITES = [
+  "writeFile",
+  "pwrite",
+  "truncate",
+  "writeSession",
+  "mkdir",
+  "rm",
+  "link",
+  "rename",
+  "symlink",
+  "chmod",
+  "utimes",
+  "lutimes",
+  "chown"
+];
+for (const [names, op] of [
+  [READS, "read"],
+  [WRITES, "write"]
+]) {
+  for (const name2 of names) {
+    const proto = OpfsFs.prototype;
+    const inner = proto[name2];
+    proto[name2] = async function(...args) {
+      try {
+        return await inner.apply(this, args);
+      } catch (err) {
+        throw translate(err, String(args[0]), op, false);
+      }
+    };
+  }
+}
 
 // src/fs/unlinked.ts
 var UNLINKED_DIR = ".slicc-unlinked";
@@ -11041,9 +11166,9 @@ var Dying = class {
   clear() {
     clearTimeout(this.timer);
   }
-  status(reported) {
+  status(reported2) {
     if (this.ending) return [this.ending.code, this.ending.sig];
-    return [typeof reported === "number" ? reported : CRASHED, void 0];
+    return [typeof reported2 === "number" ? reported2 : CRASHED, void 0];
   }
 };
 function killThread(thread, caught, sig) {
@@ -14831,10 +14956,10 @@ var ByteSource = class {
   async more() {
     const { done: done4, value } = await this.reader.read();
     if (done4) return false;
-    const joined = new Uint8Array(this.buffered.length + value.length);
-    joined.set(this.buffered);
-    joined.set(value, this.buffered.length);
-    this.buffered = joined;
+    const joined2 = new Uint8Array(this.buffered.length + value.length);
+    joined2.set(this.buffered);
+    joined2.set(value, this.buffered.length);
+    this.buffered = joined2;
     return true;
   }
   async until(marker) {
@@ -15522,6 +15647,11 @@ async function createNodeKernel(options = {}) {
       remove: (name2, options2) => guard(() => launcher.users.remove(name2, options2)),
       list: () => guard(() => launcher.users.list())
     },
+    groups: {
+      list: () => guard(() => launcher.users.groups()),
+      addMember: (group, user) => guard(() => launcher.users.addMember(group, user)),
+      removeMember: (group, user) => guard(() => launcher.users.removeMember(group, user))
+    },
     async connect({ user } = {}) {
       if (terminated) throw new Error(TERMINATED);
       if (user !== void 0 && !await launcher.users.lookup(user)) {