@ai-ecoverse/slicc-kernel 1.9.0 → 1.11.0

package/dist/node.js

@@ -252,7 +252,7 @@ function serveTransport(peer, transport) {
 }
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 0];
+var PROTOCOL = [1, 1];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -345,6 +345,7 @@ function serveClient(port, host) {
   let state = "new";
   const terminals = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Set();
+  const watches = /* @__PURE__ */ new Map();
   let net;
   const ended = Promise.withResolvers();
   const send = (message2, transfer = []) => {
@@ -356,6 +357,8 @@ function serveClient(port, host) {
     send({ bye });
     state = "closed";
     net?.close();
+    for (const unwatch of watches.values()) unwatch();
+    watches.clear();
     for (const session of terminals.values()) session.close();
     terminals.clear();
     const pids = [...groups];
@@ -449,6 +452,19 @@ function serveClient(port, host) {
           throw new Error(`unknown file system call ${req.method}`);
         }
         return fsCall(l.fs, req.method, req.args);
+      case "watch": {
+        const unwatch = l.watchers.watch(
+          req.paths,
+          { recursive: req.recursive },
+          (change) => send({ watch: req.id, change })
+        );
+        watches.set(req.id, unwatch);
+        return { result: req.id };
+      }
+      case "unwatch":
+        watches.get(req.watch)?.();
+        watches.delete(req.watch);
+        return { result: true };
       case "detach":
         return { result: true };
       default:
@@ -1269,6 +1285,89 @@ function withCommandDirs(fs, names) {
   };
 }
 
+// src/fs/watch.ts
+var WATCH_BATCH_LIMIT = 1e3;
+var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
+var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+function touches(watcher, changed) {
+  return watcher.paths.some(
+    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf3(changed) === watched)
+  );
+}
+var FsWatchers = class {
+  watchers = /* @__PURE__ */ new Set();
+  watch(paths, options, notify) {
+    const watcher = {
+      paths: paths.map(normalizePath),
+      recursive: options.recursive === true,
+      notify,
+      pending: /* @__PURE__ */ new Set(),
+      scheduled: false
+    };
+    this.watchers.add(watcher);
+    return () => {
+      this.watchers.delete(watcher);
+    };
+  }
+  changed(...paths) {
+    for (const watcher of this.watchers) {
+      for (const path of paths) {
+        const changed = normalizePath(path);
+        if (touches(watcher, changed)) watcher.pending.add(changed);
+      }
+      if (watcher.pending.size === 0 || watcher.scheduled) continue;
+      watcher.scheduled = true;
+      setTimeout(() => this.flush(watcher), 0);
+    }
+  }
+  flush(watcher) {
+    watcher.scheduled = false;
+    const paths = [...watcher.pending];
+    watcher.pending.clear();
+    if (!this.watchers.has(watcher)) return;
+    watcher.notify(paths.length > WATCH_BATCH_LIMIT ? { overflow: true } : { paths });
+  }
+  wrap(fs) {
+    const after = (run2, changed) => async (...args) => {
+      try {
+        await run2(...args);
+      } finally {
+        this.changed(...changed(...args));
+      }
+    };
+    const overrides = {
+      writeFile: after(fs.writeFile.bind(fs), (path) => [path]),
+      mkdir: async (path, options) => {
+        const created = [];
+        if (options?.recursive) {
+          const parts = normalizePath(path).split("/").filter(Boolean);
+          for (let at = 1; at < parts.length; at++) {
+            const ancestor = `/${parts.slice(0, at).join("/")}`;
+            if (created.length > 0 || !await fs.exists(ancestor)) created.push(ancestor);
+          }
+        }
+        try {
+          await fs.mkdir(path, options);
+        } finally {
+          this.changed(...created, path);
+        }
+      },
+      rm: after(fs.rm.bind(fs), (path) => [path]),
+      rename: after(fs.rename.bind(fs), (from, to) => [from, to]),
+      symlink: after(fs.symlink.bind(fs), (_target, path) => [path]),
+      chmod: after(fs.chmod.bind(fs), (path) => [path]),
+      utimes: after(fs.utimes.bind(fs), (path) => [path])
+    };
+    return new Proxy(fs, {
+      get(target, key, receiver) {
+        if (Object.hasOwn(overrides, key)) return overrides[key];
+        const value = Reflect.get(target, key, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+    });
+  }
+};
+
 // src/kernel/pipe.ts
 var PIPE_CAPACITY = 64 * 1024;
 var PipeError = class extends Error {
@@ -5866,11 +5965,12 @@ var Launcher = class {
   net = new LoopbackNet();
   ca;
   transport;
+  watchers = new FsWatchers();
   nextPid = 1e3;
   boot = Date.now();
   terminals = 0;
   constructor(options) {
-    this.base = options.fs;
+    this.base = this.watchers.wrap(options.fs);
     this.createWorker = options.createWorker;
     this.modulesDir = options.modules ?? "/node_modules";
     this.env = { ...networkEnv(), ...options.env };
@@ -5881,7 +5981,7 @@ var Launcher = class {
       engine: kernelTlsEngine(packageTlsEngine(options.fs, this.modulesDir)),
       ca: this.ca
     });
-    this.fs = withCommandDirs(options.fs, async () => new Set((await this.commands()).keys()));
+    this.fs = withCommandDirs(this.base, async () => new Set((await this.commands()).keys()));
   }
   commands() {
     this.catalog ??= scanCommands(this.base, this.modulesDir);
@@ -6510,6 +6610,8 @@ var Channel = class {
   remote;
   failure;
   pending = /* @__PURE__ */ new Map();
+  watching = /* @__PURE__ */ new Map();
+  protocol = PROTOCOL;
   nextId = 0;
   port;
   release;
@@ -6549,6 +6651,10 @@ var Channel = class {
     return this.request(call).done;
   }
   receive(data) {
+    if (data.watch !== void 0) {
+      this.watching.get(data.watch)?.(data.change);
+      return;
+    }
     if (data.bye !== void 0) {
       this.end(new KernelGoneError(data.bye));
       return;
@@ -6661,7 +6767,33 @@ function fsOn(channel) {
     realpath: (path) => fs("realpath", path),
     symlink: (target, path) => done4("symlink", target, path),
     readlink: (path) => fs("readlink", path),
-    exists: (path) => fs("exists", path)
+    exists: (path) => fs("exists", path),
+    async watch(paths, options, onChange) {
+      if (channel.protocol[1] < 1) {
+        throw new KernelCallError(
+          `this kernel speaks protocol ${channel.protocol.join(".")}, which has no watch`,
+          "ENOSYS"
+        );
+      }
+      const { id, done: done5 } = channel.request({
+        op: "watch",
+        paths,
+        recursive: options.recursive === true
+      });
+      channel.watching.set(id, onChange);
+      try {
+        await done5;
+      } catch (error) {
+        channel.watching.delete(id);
+        throw error;
+      }
+      return {
+        close: () => {
+          if (!channel.watching.delete(id)) return;
+          void channel.call({ op: "unwatch", watch: id }).catch(() => void 0);
+        }
+      };
+    }
   };
 }
 async function greet(channel, lock, timeoutMs) {
@@ -6691,6 +6823,7 @@ async function attachKernel(port, options = {}) {
   const own = await holdLock(locks);
   const channel = new Channel(port, own.release);
   const hello = await greet(channel, own.name, options.timeoutMs ?? 1e4);
+  channel.protocol = hello.protocol;
   if (hello.lock && locks) void locks.request(hello.lock, () => channel.end(new KernelGoneError()));
   const transport = new RemoteTransport(
     { postMessage: (call) => channel.post(call) },