@ai-ecoverse/slicc-kernel 1.59.1 → 1.60.0

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();
@@ -14831,10 +14881,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 +15572,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)) {