@ai-ecoverse/slicc-kernel 1.13.0 → 1.15.0

package/dist/node.js

@@ -585,7 +585,8 @@ var ERRNO_BY_DOM_ERROR = {
   TypeMismatchError: "ENOTDIR",
   InvalidModificationError: "ENOTEMPTY",
   NoModificationAllowedError: "EBUSY",
-  TypeError: "EINVAL"
+  TypeError: "EINVAL",
+  NotAllowedError: "EACCES"
 };
 function translate(err, path) {
   if (typeof err?.code === "string") return err;
@@ -1168,9 +1169,28 @@ async function packages(fs, modules) {
   }
   return dirs;
 }
+async function pnpmGlobalRoots(fs, home) {
+  const roots = [];
+  const global = `${home}/global`;
+  for (const version of (await fs.readdir(global).catch(() => [])).sort()) {
+    for (const group of (await fs.readdir(`${global}/${version}`).catch(() => [])).sort()) {
+      const dir = `${global}/${version}/${group}`;
+      const st = await fs.lstat(dir).catch(() => void 0);
+      if (st?.isDirectory && await fs.exists(`${dir}/node_modules`))
+        roots.push(`${dir}/node_modules`);
+    }
+  }
+  return roots;
+}
+async function packagesIn(fs, roots) {
+  const dirs = [];
+  for (const root of typeof roots === "string" ? [roots] : roots)
+    dirs.push(...await packages(fs, root));
+  return dirs;
+}
 async function scanCommands(fs, modules) {
   const found = /* @__PURE__ */ new Map();
-  for (const pkg of await packages(fs, modules)) {
+  for (const pkg of await packagesIn(fs, modules)) {
     let manifest;
     try {
       manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
@@ -1189,7 +1209,7 @@ async function scanCommands(fs, modules) {
 }
 async function scanFilesystems(fs, modules) {
   const found = /* @__PURE__ */ new Map();
-  for (const pkg of await packages(fs, modules)) {
+  for (const pkg of await packagesIn(fs, modules)) {
     let manifest;
     try {
       manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
@@ -5891,6 +5911,157 @@ function serveFilesystem(port, handlers, capabilities = {}) {
   return { invalidate: (paths) => reply({ invalidate: paths }) };
 }
 
+// src/mount/fsa.ts
+var FSA_CAPABILITIES = { listingStats: true };
+var codeOf = (err) => err?.code;
+var denied = (err) => codeOf(err) === "EACCES" || err?.name === "NotAllowedError";
+function attrOf(st) {
+  return {
+    kind: st.isDirectory ? "directory" : st.isSymbolicLink ? "symlink" : "file",
+    size: st.size,
+    mtime: st.mtime.getTime(),
+    mode: st.mode,
+    ino: st.ino
+  };
+}
+function kernelFsHandlers(fs) {
+  const handles = /* @__PURE__ */ new Map();
+  let nextFh = 0;
+  const handle = (fh) => {
+    const found = handles.get(fh);
+    if (!found) throw fsError2("EBADF", `handle ${fh}`);
+    return found;
+  };
+  async function existing(path) {
+    try {
+      return await fs.stat(path);
+    } catch (err) {
+      if (codeOf(err) === "ENOENT") return void 0;
+      throw err;
+    }
+  }
+  return {
+    getattr: async (path) => attrOf(await fs.lstat(path)),
+    readdir: async (path) => (await fs.readdirStat(path)).flatMap(([name2, st]) => {
+      if (!st) return [];
+      const attr = attrOf(st);
+      return [{ name: name2, kind: attr.kind, attr }];
+    }),
+    async open(path, flags) {
+      const st = await existing(path);
+      if (st && flags.exclusive) throw fsError2("EEXIST", path);
+      if (st?.isDirectory && flags.write) throw fsError2("EISDIR", path);
+      if (!st && !flags.create) throw fsError2("ENOENT", path);
+      const data = st && !flags.truncate ? await fs.readFileBuffer(path) : new Uint8Array(0);
+      handles.set(++nextFh, { path, data, length: data.length, dirty: !st || flags.truncate });
+      return nextFh;
+    },
+    async read(fh, offset, size) {
+      const h = handle(fh);
+      return h.data.slice(offset, Math.min(h.length, offset + size));
+    },
+    async write(fh, offset, bytes) {
+      const h = handle(fh);
+      const end = offset + bytes.length;
+      if (end > h.data.length) {
+        const grown = new Uint8Array(Math.max(end, h.data.length * 2));
+        grown.set(h.data.subarray(0, h.length));
+        h.data = grown;
+      }
+      h.data.set(bytes, offset);
+      h.length = Math.max(h.length, end);
+      h.dirty = true;
+    },
+    async release(fh) {
+      const h = handle(fh);
+      handles.delete(fh);
+      if (h.dirty) await fs.writeFile(h.path, h.data.slice(0, h.length));
+    },
+    mkdir: (path) => fs.mkdir(path),
+    async rmdir(path) {
+      if (!(await fs.lstat(path)).isDirectory) throw fsError2("ENOTDIR", path);
+      if ((await fs.readdir(path)).length > 0) throw fsError2("ENOTEMPTY", path);
+      await fs.rm(path);
+    },
+    async unlink(path) {
+      if ((await fs.lstat(path)).isDirectory) throw fsError2("EISDIR", path);
+      await fs.rm(path);
+    },
+    rename: (from, to) => fs.rename(from, to),
+    symlink: (target, path) => fs.symlink(target, path),
+    readlink: (path) => fs.readlink(path),
+    async setattr(path, change) {
+      if (change.mode !== void 0) await fs.chmod(path, change.mode);
+      if (change.mtime !== void 0) {
+        await fs.utimes(path, new Date(change.mtime), new Date(change.mtime));
+      }
+    }
+  };
+}
+var EMPTY_ROOT = { kind: "directory", size: 0, mtime: 0, mode: 16749 };
+function granted(handle) {
+  if (!handle.queryPermission) return Promise.resolve(true);
+  return handle.queryPermission({ mode: "readwrite" }).then(
+    (state) => state === "granted",
+    () => false
+  );
+}
+function removableMedium(onLost, open = (handle) => new OpfsFs(handle)) {
+  let current;
+  const absent = () => fsError2("ENOMEDIUM", "No medium found");
+  function wrap(pick) {
+    return async (...args) => {
+      const medium = current;
+      if (!medium) throw absent();
+      try {
+        return await pick(medium.handlers)(...args);
+      } catch (err) {
+        if (!denied(err) || await granted(medium.handle)) throw err;
+        if (current === medium) {
+          current = void 0;
+          onLost(medium.handle);
+        }
+        throw absent();
+      }
+    };
+  }
+  const getattr = wrap((h) => h.getattr);
+  const readdir = wrap((h) => h.readdir);
+  return {
+    handlers: {
+      getattr: (path) => current || path !== "/" ? getattr(path) : Promise.resolve(EMPTY_ROOT),
+      readdir: (path) => current || path !== "/" ? readdir(path) : Promise.resolve([]),
+      open: wrap((h) => h.open),
+      read: wrap((h) => h.read),
+      write: wrap((h) => h.write),
+      release: wrap((h) => h.release),
+      mkdir: wrap((h) => h.mkdir),
+      rmdir: wrap((h) => h.rmdir),
+      unlink: wrap((h) => h.unlink),
+      rename: wrap((h) => h.rename),
+      symlink: wrap((h) => h.symlink),
+      readlink: wrap((h) => h.readlink),
+      setattr: wrap((h) => h.setattr)
+    },
+    present: () => current !== void 0,
+    insert(handle) {
+      current = { handle, handlers: kernelFsHandlers(open(handle)) };
+    },
+    eject() {
+      current = void 0;
+    }
+  };
+}
+
+// src/mount/media.ts
+function memoryMedia() {
+  const handles = /* @__PURE__ */ new Map();
+  return {
+    get: async (id) => handles.get(id),
+    put: async (id, handle) => void handles.set(id, handle)
+  };
+}
+
 // src/mount/connection.ts
 var DRIVER_TIMEOUT_MS = 3e4;
 function unref(timer) {
@@ -6034,14 +6205,16 @@ var MountTable = class {
     this.deps = deps;
   }
   list() {
-    return [...this.mounts.values()].map(({ type, source, target, options, state, error }) => ({
-      type,
-      source,
-      target,
-      options: { ...options },
-      state,
-      ...error ? { error } : {}
-    }));
+    return [...this.mounts.values()].map(
+      ({ type, source, target, options, state, error, present }) => ({
+        type,
+        source,
+        target,
+        options: { ...options },
+        state: state === "ok" && present?.() === false ? "nomedium" : state,
+        ...error ? { error } : {}
+      })
+    );
   }
   locate(path) {
     let best;
@@ -6112,7 +6285,8 @@ var MountTable = class {
       maxFile: options.maxfile !== void 0 ? parseSize(options.maxfile) : caps.maxFile ?? 0,
       attrs: /* @__PURE__ */ new Map(),
       lists: /* @__PURE__ */ new Map(),
-      dispose: () => opened2.dispose()
+      dispose: () => opened2.dispose(),
+      ...opened2.present ? { present: opened2.present } : {}
     };
     mounted = mount;
     this.mounts.set(target, mount);
@@ -6749,6 +6923,7 @@ function foreignImports(bytes) {
 }
 
 // src/launcher.ts
+var PNPM_HOME = "/home/.local/share/pnpm";
 var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
 var PACKAGE_ROOT = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//;
 var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
@@ -6838,8 +7013,13 @@ var Launcher = class {
   ca;
   transport;
   watchers = new FsWatchers();
+  pnpmHome;
   mounts;
   createDriverWorker;
+  media;
+  onMountPending;
+  removable = /* @__PURE__ */ new Map();
+  inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
   held = /* @__PURE__ */ new Set();
   nextPid = 1e3;
@@ -6854,6 +7034,9 @@ var Launcher = class {
     this.base = this.watchers.wrap(this.mounts.wrap(options.fs));
     this.createWorker = options.createWorker;
     this.createDriverWorker = options.createDriverWorker;
+    this.media = options.media ?? memoryMedia();
+    this.onMountPending = options.onMountPending;
+    this.pnpmHome = options.env?.PNPM_HOME ?? PNPM_HOME;
     this.modulesDir = options.modules ?? "/node_modules";
     this.env = { ...networkEnv(), ...options.env };
     this.ca = kernelCa(options.caStore ?? memoryCaStore());
@@ -6864,11 +7047,17 @@ var Launcher = class {
       ca: this.ca
     });
     this.fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
+    this.watchers.watch([this.modulesDir, this.pnpmHome], { recursive: true }, () => {
+      this.catalog = void 0;
+    });
   }
   commands() {
-    this.catalog ??= scanCommands(this.base, this.modulesDir);
+    this.catalog ??= this.roots().then((roots) => scanCommands(this.base, roots));
     return this.catalog;
   }
+  async roots() {
+    return [this.modulesDir, ...await pnpmGlobalRoots(this.base, this.pnpmHome)];
+  }
   async resolve(file, argv0, cwd) {
     const name2 = COMMAND2.exec(file)?.[1] ?? (file.includes("/") ? void 0 : file);
     if (name2 !== void 0) {
@@ -7110,7 +7299,8 @@ var Launcher = class {
     if (sig !== 0) handle.signal(sig);
     return true;
   }
-  async driver(type, _spec) {
+  async driver(type, spec) {
+    if (type === "fsa") return this.fsaDriver(spec);
     if (type === "tmpfs") {
       const { port1, port2 } = new MessageChannel();
       serveFilesystem(port2, tmpfs(), { symlinks: true, chmod: true, attrTtl: 0 });
@@ -7122,7 +7312,7 @@ var Launcher = class {
         }
       };
     }
-    const module = (await scanFilesystems(this.base, this.modulesDir)).get(type);
+    const module = (await scanFilesystems(this.base, await this.roots())).get(type);
     if (!module) throw fsError("ENODEV", `unknown file system type ${type}`);
     if (!this.createDriverWorker)
       throw fsError("ENODEV", `this kernel cannot start ${type} drivers`);
@@ -7151,8 +7341,47 @@ var Launcher = class {
       })
     };
   }
+  async fsaDriver(spec) {
+    const { target, source } = spec;
+    const ask = (handle) => this.onMountPending?.({ target, source, ...handle ? { handle } : {} });
+    const { port1, port2 } = new MessageChannel();
+    const medium = removableMedium((handle) => {
+      served.invalidate(true);
+      ask(handle);
+    });
+    const served = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
+    const id = source.slice("fsa:".length);
+    this.removable.set(target, { id, medium, served });
+    const stored = this.inserted.get(id) ?? await this.media.get(id);
+    if (stored && await granted(stored)) medium.insert(stored);
+    else ask(stored);
+    return {
+      port: port1,
+      present: () => medium.present(),
+      dispose: () => {
+        this.removable.delete(target);
+        port1.close();
+        port2.close();
+      }
+    };
+  }
   mount(spec) {
-    return this.mounts.mount(spec, this.fs);
+    if (spec.type !== "fsa" || spec.source.startsWith("fsa:"))
+      return this.mounts.mount(spec, this.fs);
+    return this.mounts.mount({ ...spec, source: `fsa:${crypto.randomUUID()}` }, this.fs);
+  }
+  async insert(target, handle, source) {
+    const at = normalizePath(target);
+    const slot = this.removable.get(at);
+    if (!slot) throw fsError("EINVAL", `${at} is not a removable mount`);
+    if (source !== void 0 && source !== `fsa:${slot.id}`) {
+      throw fsError("EINVAL", `${at} is no longer the drive ${source}`);
+    }
+    if (!await granted(handle)) throw fsError("EACCES", `${at}: no permission for this folder`);
+    this.inserted.set(slot.id, handle);
+    await this.media.put(slot.id, handle);
+    slot.medium.insert(handle);
+    slot.served.invalidate(true);
   }
   umount(target) {
     this.mounts.umount(target);
@@ -7162,7 +7391,14 @@ var Launcher = class {
     await writeCaFile(this.base, this.ca).catch(() => void 0);
   }
   environment(cwd, extra) {
-    return { PATH: "/usr/bin:/bin", HOME: "/home", ...this.env, PWD: cwd, ...extra };
+    return {
+      PATH: `/usr/bin:/bin:${this.pnpmHome}/bin`,
+      HOME: "/home",
+      PNPM_HOME: this.pnpmHome,
+      ...this.env,
+      PWD: cwd,
+      ...extra
+    };
   }
   async starting(argv, dir) {
     this.catalog = void 0;
@@ -7520,13 +7756,13 @@ async function holdLock(locks) {
   if (!locks) return { release() {
   } };
   const name2 = `slicc-kernel-client:${crypto.randomUUID()}`;
-  const granted = Promise.withResolvers();
+  const granted2 = Promise.withResolvers();
   const held = Promise.withResolvers();
   void locks.request(name2, () => {
-    granted.resolve();
+    granted2.resolve();
     return held.promise;
   });
-  await granted.promise;
+  await granted2.promise;
   return { name: name2, release: () => held.resolve() };
 }
 function concat6(chunks2) {