@ai-ecoverse/slicc-kernel 1.124.13 → 1.125.1

package/dist/node.js

@@ -930,7 +930,12 @@ function openPipe(capacity) {
         }
       },
       close: () => pipe.closeRead(),
-      poll: () => ({ readable: pipe.readReady, writable: false, hangup: pipe.writersGone }),
+      poll: () => ({
+        readable: pipe.readReady,
+        writable: false,
+        hangup: pipe.writersGone,
+        nread: pipe.buffered
+      }),
       changed: (signal) => pipe.changed(signal),
       identity: pipe
     }),
@@ -1718,7 +1723,8 @@ var KernelSocket = class _KernelSocket {
       readable: this.readShut || rx.readReady,
       writable: this.writeShut || tx.writeReady,
       hangup: rx.writersGone && tx.readersGone,
-      rdhup: rx.writersGone
+      rdhup: rx.writersGone,
+      nread: this.readShut ? 0 : rx.buffered
     };
   }
   changed(signal) {
@@ -1778,8 +1784,8 @@ var KernelSocket = class _KernelSocket {
     if (this.state !== "open") throw new KernelError("EINVAL");
     if (addr.family !== this.domain) throw new KernelError("EAFNOSUPPORT");
     this.failed = void 0;
-    const route = viaUplink && addr.family === "inet" ? this.net.uplinkFor(addr.host) : void 0;
-    if (route) return this.dial(addr, route);
+    const route2 = viaUplink && addr.family === "inet" ? this.net.uplinkFor(addr.host) : void 0;
+    if (route2) return this.dial(addr, route2);
     const target = this.net.target(addr, name2);
     if (!this.local) {
       if (addr.family === "inet") {
@@ -1835,9 +1841,9 @@ var KernelSocket = class _KernelSocket {
     }
   }
   switch;
-  connectSecure(addr, route, secure2) {
+  connectSecure(addr, route2, secure2) {
     if (this.state !== "open") throw new KernelError("EISCONN");
-    return this.dial(addr, route, secure2);
+    return this.dial(addr, route2, secure2);
   }
   upgradeSecure(make) {
     if (this.state !== "connected") throw new KernelError("ENOTCONN");
@@ -1845,7 +1851,7 @@ var KernelSocket = class _KernelSocket {
     if (this.switch.upgraded || this.writeShut || this.readShut) throw new KernelError("EINVAL");
     return this.switch.upgrade(make);
   }
-  dial(addr, route, secure2) {
+  dial(addr, route2, secure2) {
     this.state = "connecting";
     const abort = new AbortController();
     this.dialing = abort;
@@ -1853,13 +1859,13 @@ var KernelSocket = class _KernelSocket {
     const timer = setTimeout(() => {
       timedOut = true;
       abort.abort(new KernelError("ETIMEDOUT"));
-    }, route.timeoutMs ?? DIAL_TIMEOUT_MS);
+    }, route2.timeoutMs ?? DIAL_TIMEOUT_MS);
     const abandoned = new Promise((_, reject) => {
       abort.signal.addEventListener("abort", () => reject(abort.signal.reason), { once: true });
     });
     const { host, port } = addr;
     const dialled = new Promise(
-      (resolve2) => resolve2(route.uplink.dial({ network: "tcp", host, port, signal: abort.signal }))
+      (resolve2) => resolve2(route2.uplink.dial({ network: "tcp", host, port, signal: abort.signal }))
     );
     dialled.then(
       (conn) => abort.signal.aborted && conn.close(),
@@ -2008,14 +2014,14 @@ var LoopbackNet = class {
     if (!this.origins) throw new KernelError("ENETUNREACH");
     void this.origins(conn, origin).catch(() => conn.close());
   }
-  useUplink(route) {
-    this.route = route;
+  useUplink(route2) {
+    this.route = route2;
   }
   tlsClient;
   uplinkFor(host) {
-    const route = this.route;
-    if (!route) return void 0;
-    return this.destination(host) === "uplink" ? route : void 0;
+    const route2 = this.route;
+    if (!route2) return void 0;
+    return this.destination(host) === "uplink" ? route2 : void 0;
   }
   destination(host) {
     return (this.route?.routes ?? LOCAL_ONLY).classify(host);
@@ -7080,7 +7086,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.13" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.125.1" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9514,6 +9520,8 @@ async function physicalPathAsync(fs, path) {
 }
 
 // src/fs/watch.ts
+var WATCH_NOTES_LIMIT = 1e3;
+var baseOf2 = (path) => path.slice(path.lastIndexOf("/") + 1);
 var WATCH_BATCH_LIMIT = 1e3;
 var under3 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
 var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
@@ -9523,8 +9531,39 @@ function touches(watcher, changed) {
   );
 }
 var REALS_KEPT = 4096;
+function noted(watch, note) {
+  if (watch.ended) return;
+  if ("ended" in note) {
+    watch.notes.push(note);
+    watch.ended = true;
+    watch.wake?.();
+    return;
+  }
+  if (watch.overflowed) return;
+  if (watch.notes.length >= WATCH_NOTES_LIMIT) {
+    watch.overflowed = true;
+    watch.notes.push({ overflow: true });
+  } else watch.notes.push(note);
+  watch.wake?.();
+}
+function route(watch, type, path) {
+  for (const root of watch.roots) if (routed(watch, root, type, path)) return;
+}
+function routed(watch, root, type, path) {
+  if (path === root || type === "rename" && root !== "/" && under3(root, path)) {
+    noted(watch, { type, filename: baseOf2(root) });
+    if (type === "rename") noted(watch, { ended: true });
+    return true;
+  }
+  if (parentOf6(path) === root) noted(watch, { type, filename: baseOf2(path) });
+  else if (watch.recursive && under3(path, root)) {
+    noted(watch, { type, filename: path.slice(root === "/" ? 1 : root.length + 1) });
+  } else return false;
+  return true;
+}
 var FsWatchers = class {
   watchers = /* @__PURE__ */ new Set();
+  typed = /* @__PURE__ */ new Set();
   taps = [];
   reals = /* @__PURE__ */ new Map();
   reshapes = [];
@@ -9551,7 +9590,65 @@ var FsWatchers = class {
       this.watchers.delete(watcher);
     };
   }
+  typedWatch(root, recursive, alias) {
+    const main = normalizePath(root);
+    const other = alias === void 0 ? main : normalizePath(alias);
+    const watch = {
+      roots: other === main ? [main] : [main, other],
+      recursive,
+      notes: [],
+      overflowed: false,
+      ended: false,
+      wake: void 0
+    };
+    this.typed.add(watch);
+    const close = () => {
+      this.typed.delete(watch);
+      watch.ended = true;
+      watch.wake?.();
+    };
+    return {
+      close,
+      next: async (signal) => {
+        while (watch.notes.length === 0 && !watch.ended && !signal.aborted) {
+          await new Promise((resolve2) => {
+            const done4 = () => {
+              watch.wake = void 0;
+              signal.removeEventListener("abort", done4);
+              resolve2();
+            };
+            watch.wake = done4;
+            signal.addEventListener("abort", done4, { once: true });
+          });
+        }
+        const notes = watch.notes.splice(0);
+        watch.overflowed = false;
+        if (watch.ended) this.typed.delete(watch);
+        return notes.length === 0 && watch.ended ? [{ ended: true }] : notes;
+      }
+    };
+  }
+  covers(path) {
+    for (const watch of this.typed) {
+      for (const root of watch.roots) {
+        if (path === root || parentOf6(path) === root || watch.recursive && under3(path, root))
+          return true;
+      }
+    }
+    return false;
+  }
+  emit(type, paths) {
+    if (this.typed.size === 0) return;
+    for (const path of paths) {
+      const at = normalizePath(path);
+      for (const watch of [...this.typed]) route(watch, type, at);
+    }
+  }
   changed(...paths) {
+    this.report(paths);
+    this.emit("change", paths);
+  }
+  report(paths) {
     for (const tap of this.taps) tap(paths);
     for (const watcher of this.watchers) {
       for (const path of paths) {
@@ -9571,11 +9668,15 @@ var FsWatchers = class {
     watcher.notify(paths.length > WATCH_BATCH_LIMIT ? { overflow: true } : { paths });
   }
   wrap(fs) {
-    const after = (run2, changed) => async (...args) => {
+    const after = (run2, changed, type) => async (...args) => {
+      let done4 = false;
       try {
         await run2(...args);
+        done4 = true;
       } finally {
-        this.changed(...changed(...args));
+        const paths = changed(...args);
+        this.report(paths);
+        if (done4) this.emit(type, paths);
       }
     };
     const reals = this.reals;
@@ -9594,15 +9695,21 @@ var FsWatchers = class {
       reals.set(at, real);
       return real;
     };
-    const content = (run2) => async (...args) => {
+    const content = (run2, types) => async (...args) => {
+      const at = normalizePath(args[0]);
+      const fresh2 = this.covers(at) && !await fs.exists(at).catch(() => true);
+      let done4 = false;
       try {
         await run2(...args);
+        done4 = true;
       } finally {
-        const at = normalizePath(args[0]);
         const real = await realOf(at);
-        this.changed(...real === at ? [at] : [at, real]);
+        const paths = real === at ? [at] : [at, real];
+        this.report(paths);
+        if (done4) for (const type of types(fresh2)) this.emit(type, paths);
       }
     };
+    const written2 = (fresh2) => fresh2 ? ["rename", "change"] : ["change"];
     const reshaping = (run2) => async (...args) => {
       this.reshaped();
       try {
@@ -9612,8 +9719,8 @@ var FsWatchers = class {
       }
     };
     const overrides = {
-      writeFile: content(fs.writeFile.bind(fs)),
-      ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs)) } : {},
+      writeFile: content(fs.writeFile.bind(fs), written2),
+      ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs), () => ["rename"]) } : {},
       mkdir: async (path, options) => {
         const created3 = [];
         if (options?.recursive) {
@@ -9623,33 +9730,39 @@ var FsWatchers = class {
             if (created3.length > 0 || !await fs.exists(ancestor)) created3.push(ancestor);
           }
         }
+        const fresh2 = !options?.recursive || !(this.covers(path) && await fs.exists(path));
+        let done4 = false;
         try {
           await fs.mkdir(path, options);
+          done4 = true;
         } finally {
-          this.changed(...created3, path);
+          this.report([...created3, path]);
+          if (done4) this.emit("rename", fresh2 ? [...created3, path] : created3);
         }
       },
-      rm: reshaping(after(fs.rm.bind(fs), (path) => [path])),
-      rename: reshaping(after(fs.rename.bind(fs), (from, to) => [from, to])),
+      rm: reshaping(after(fs.rm.bind(fs), (path) => [path], "rename")),
+      rename: reshaping(after(fs.rename.bind(fs), (from, to) => [from, to], "rename")),
       link: reshaping(
         after(
           (from, to, follow2) => fs.link(from, to, follow2),
-          (_from, to) => [to]
+          (_from, to) => [to],
+          "rename"
         )
       ),
-      symlink: reshaping(after(fs.symlink.bind(fs), (_target, path) => [path])),
-      chmod: after(fs.chmod.bind(fs), (path) => [path]),
-      ...fs.chown ? { chown: after(fs.chown.bind(fs), (path) => [path]) } : {},
-      utimes: after(fs.utimes.bind(fs), (path) => [path]),
+      symlink: reshaping(after(fs.symlink.bind(fs), (_target, path) => [path], "rename")),
+      chmod: after(fs.chmod.bind(fs), (path) => [path], "change"),
+      ...fs.chown ? { chown: after(fs.chown.bind(fs), (path) => [path], "change") } : {},
+      utimes: after(fs.utimes.bind(fs), (path) => [path], "change"),
       lutimes: after(
         (path, atime, mtime) => lutimesOf(fs, path, atime, mtime),
-        (path) => [path]
+        (path) => [path],
+        "change"
       )
     };
     const ranged2 = rangedOps(fs);
     if (ranged2) {
-      overrides.pwrite = content(ranged2.pwrite);
-      overrides.truncate = content(ranged2.truncate);
+      overrides.pwrite = content(ranged2.pwrite, () => ["change"]);
+      overrides.truncate = content(ranged2.truncate, () => ["change"]);
     }
     return new Proxy(fs, {
       get(target, key, receiver) {
@@ -10257,7 +10370,8 @@ var FifoTable = class {
       poll: () => ({
         readable: reads && pipe.readReady,
         writable: writes && pipe.writeReady,
-        hangup: reads ? pipe.writersGone : pipe.readersGone
+        hangup: reads ? pipe.writersGone : pipe.readersGone,
+        ...reads ? { nread: pipe.buffered } : {}
       }),
       changed: (signal) => pipe.changed(signal)
     });
@@ -10656,8 +10770,8 @@ var MountTable = class {
         ...error ? { error } : {}
       })
     );
-    const noted = [...this.notes.values()].filter((note) => !this.mounts.has(note.target));
-    return [...mounted, ...noted.map((note) => ({ ...note, options: { ...note.options } }))];
+    const noted2 = [...this.notes.values()].filter((note) => !this.mounts.has(note.target));
+    return [...mounted, ...noted2.map((note) => ({ ...note, options: { ...note.options } }))];
   }
   listed() {
     return this.list().filter((entry) => !this.system.has(entry.target));
@@ -15968,7 +16082,8 @@ var KernelTty = class {
       poll: () => ({
         readable: this.readable.length > 0 || this.hungUp,
         writable: true,
-        hangup: this.hungUp
+        hangup: this.hungUp,
+        nread: this.readable.reduce((n, chunk2) => n + (chunk2?.length ?? 0), 0)
       }),
       changed: (signal) => this.changed(signal),
       close: () => {
@@ -16164,7 +16279,8 @@ var PtyPair = class {
       poll: () => ({
         readable: this.queue.length > 0 || this.slaveGone,
         writable: true,
-        hangup: this.slaveGone
+        hangup: this.slaveGone,
+        nread: this.queue.reduce((n, chunk2) => n + chunk2.length, 0)
       }),
       changed: (signal) => this.changed(signal),
       close: () => this.closeMaster(),
@@ -16446,13 +16562,17 @@ async function runChild(req, deps) {
 // src/kernel/select.ts
 function ready(fds, read, write) {
   const hangup = /* @__PURE__ */ new Set();
+  const nread = {};
   const pick = (list, dir) => list.filter((fd) => {
     const state = pollFile(fds.get(fd).file);
     if (state.hangup) hangup.add(fd);
-    return state[dir] || state.hangup;
+    const picked = state[dir] || state.hangup;
+    if (picked && dir === "readable" && state.nread !== void 0) nread[fd] = state.nread;
+    return picked;
   });
   const out = { read: pick(read, "readable"), write: pick(write, "writable") };
   if (hangup.size > 0) out.hangup = [...hangup];
+  if (Object.keys(nread).length > 0) out.nread = nread;
   return out;
 }
 function interruption(signal) {
@@ -17447,14 +17567,14 @@ async function connectSecure(proc, socket, host, port, req) {
   const servername = serverName(req.servername || host);
   if (isLoopbackHost(servername) || isLoopbackHost(host)) throw new KernelError("ENOTSUP");
   const address = await uplinkAddress(proc, host);
-  const route = proc.net.uplinkFor(address);
-  if (!route)
+  const route2 = proc.net.uplinkFor(address);
+  if (!route2)
     throw new KernelError("ENOTSUP", "TLS in the kernel needs a destination the uplink routes");
   const support = supportOf(proc.net);
   let info;
   const { make, abandon } = secure(await prepare(support, req, servername));
   try {
-    await socket.connectSecure({ family: "inet", host: address, port }, route, async (conn) => {
+    await socket.connectSecure({ family: "inet", host: address, port }, route2, async (conn) => {
       info = await conn.upgrade(make);
     });
   } finally {
@@ -18665,6 +18785,65 @@ function vfsFile(fs, opts, nodes) {
   });
 }
 
+// src/kernel/watch-ops.ts
+var WATCH_OPS = ["watch-open", "watch-next", "watch-close"];
+var WATCHING = new Set(WATCH_OPS);
+function isWatchSyscall(req) {
+  return WATCHING.has(req.op);
+}
+var WATCHES_MAX = 8192;
+var parentOf8 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+function visibleTo2(watch, root, visible) {
+  return {
+    close: () => watch.close(),
+    next: async (signal) => {
+      const notes = await watch.next(signal);
+      const seen = /* @__PURE__ */ new Map();
+      const shown = await Promise.all(
+        notes.map(async (note) => {
+          if (!("filename" in note) || !note.filename.includes("/")) return true;
+          const dir = parentOf8(`${root === "/" ? "" : root}/${note.filename}`);
+          if (!seen.has(dir)) seen.set(dir, visible(dir));
+          return seen.get(dir);
+        })
+      );
+      return notes.filter((_note, i) => shown[i]);
+    }
+  };
+}
+var ProcessWatches = class {
+  open = /* @__PURE__ */ new Map();
+  nextId = 1;
+  source;
+  constructor(source) {
+    this.source = source;
+  }
+  async syscall(req, cancelled) {
+    if (req.op === "watch-open") {
+      if (!this.source) throw new KernelError("ENOSYS");
+      if (this.open.size >= WATCHES_MAX) throw new KernelError("ENOSPC");
+      const watch2 = await this.source.open(req.path, req.recursive === true);
+      const id2 = this.nextId++;
+      this.open.set(id2, watch2);
+      return { ok: true, kind: "json", json: id2 };
+    }
+    const watch = this.open.get(req.id);
+    if (req.op === "watch-close") {
+      watch?.close();
+      this.open.delete(req.id);
+      return { ok: true, kind: "void" };
+    }
+    if (!watch) return { ok: true, kind: "json", json: [{ ended: true }] };
+    const notes = await watch.next(cancelled);
+    if (notes.some((note) => "ended" in note)) this.open.delete(req.id);
+    return { ok: true, kind: "json", json: notes };
+  }
+  closeAll() {
+    for (const watch of this.open.values()) watch.close();
+    this.open.clear();
+  }
+};
+
 // src/kernel/process.ts
 function aborted(signal) {
   return new Promise((_, reject) => {
@@ -18791,7 +18970,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   ...SEM_OPS,
   ...HTTP_OPS,
   ...PTY_OPS,
-  ...HOST_OPS
+  ...HOST_OPS,
+  ...WATCH_OPS
 ]);
 function isWasmSyscall(req) {
   const op = req.op;
@@ -18843,6 +19023,7 @@ function timeLeft(req, started) {
 }
 var WasmProcess = class {
   exited = false;
+  watches;
   children;
   deathSignals = /* @__PURE__ */ new Map();
   caught = 0;
@@ -18873,6 +19054,7 @@ var WasmProcess = class {
     this.pid = pid;
     this.fds = fds;
     this.options = options;
+    this.watches = new ProcessWatches(options.watches);
     this.inherited = options.ignored ?? 0;
     this.umask = options.umask ?? DEFAULT_UMASK2;
     this.cred = copyCred(options.cred ?? ROOT);
@@ -19130,6 +19312,7 @@ var WasmProcess = class {
         });
       }
       if (isHttpSyscall(req)) return await this.httpSyscall(req);
+      if (isWatchSyscall(req)) return await this.watches.syscall(req, cancelled);
       if (isHostSyscall(req)) {
         return await hostSyscall(req, {
           pid: this.pid,
@@ -20270,6 +20453,7 @@ var WasmProcess = class {
     this.options.locks?.release(this.pid);
     for (const owner of this.lockOwners) this.options.locks?.release(owner);
     this.asyncOps.close();
+    this.watches.closeAll();
     for (const [target, sig] of this.deathSignals) this.sendDeath(target, sig);
     this.deathSignals.clear();
     for (const pid of this.children.pids()) this.options.onReap?.(pid);
@@ -20531,6 +20715,7 @@ function processOptions(opts, header4, hooks, created3) {
     locks: opts.locks,
     fifos: opts.fifos,
     ...opts.sems ? { sems: opts.sems } : {},
+    watches: opts.watches,
     onReap: opts.onReap,
     resolver: opts.resolver,
     ...notifiers(header4),
@@ -25816,6 +26001,7 @@ var Launcher = class {
       locks: this.locks,
       fifos: this.fifos,
       sems: this.sems,
+      watches: this.watchSource(pid),
       resolver: this.resolver,
       onReap: (child) => this.reaped(child, pid),
       ...req.fork ? { fork: req.fork } : {},
@@ -26359,6 +26545,23 @@ var Launcher = class {
       mounts: this.mounts.list().map((entry) => entry.target).filter((target) => this.mounts.mounted(target) !== void 0)
     });
   }
+  watchSource(pid) {
+    return {
+      open: async (path, recursive) => {
+        const at = normalizePath(path);
+        const g = this.execGuard(this.credOf(pid), pid);
+        if (g) await readable(g, "watch", at);
+        const st = await this.fs.stat(at);
+        const real = await this.fs.realpath?.(at, true).catch(() => at) ?? at;
+        const watch = this.watchers.typedWatch(real, recursive && st.isDirectory, at);
+        if (!g || g.cred.euid === 0) return watch;
+        return visibleTo2(watch, real, async (dir) => {
+          const walked = await access(g.fs, g.cred, dir, R_OK | X_OK, { directory: true });
+          return walked.denied === void 0 && walked.missing !== true;
+        });
+      }
+    };
+  }
   watchFiles(paths, notify) {
     this.fileWatches ??= new FileWatches(this.watchers, this.rootFs);
     return this.fileWatches.watch(paths, notify);