@ai-ecoverse/slicc-kernel 1.12.0 → 1.14.0

package/dist/node-driver-worker.js

@@ -0,0 +1,576 @@
+// src/node-driver-worker.ts
+import { parentPort } from "node:worker_threads";
+
+// src/kernel/net/remote-transport.ts
+var TransportError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+};
+var RemoteTransport = class {
+  traits;
+  port;
+  waiting = /* @__PURE__ */ new Map();
+  nextId = 0;
+  failure;
+  constructor(port, traits) {
+    this.port = port;
+    this.traits = traits;
+  }
+  receive(reply) {
+    const waiter = this.waiting.get(reply.nid);
+    if (!waiter) return;
+    this.waiting.delete(reply.nid);
+    if (reply.net === "error") {
+      waiter.reject(new TransportError(reply.message, reply.status, reply.code));
+    } else waiter.resolve(reply);
+  }
+  fail(error) {
+    this.failure = error;
+    for (const waiter of this.waiting.values()) waiter.reject(error);
+    this.waiting.clear();
+  }
+  ask(call) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      this.waiting.set(call.nid, { resolve, reject });
+      this.port.postMessage(call);
+    });
+  }
+  cancel(nid) {
+    const waiter = this.waiting.get(nid);
+    this.waiting.delete(nid);
+    waiter?.reject(new TransportError("the request was cancelled"));
+    this.port.postMessage({ net: "cancel", nid });
+  }
+  async fetch(request) {
+    const nid = ++this.nextId;
+    const { signal } = request;
+    signal.throwIfAborted();
+    let finished = false;
+    const abort = () => {
+      finished = true;
+      this.cancel(nid);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      signal.removeEventListener("abort", abort);
+    };
+    let head;
+    try {
+      head = await this.ask({
+        net: "fetch",
+        nid,
+        url: request.url,
+        method: request.method,
+        headers: request.headers,
+        ...request.body ? { body: request.body } : {}
+      });
+    } catch (e) {
+      finish();
+      throw e;
+    }
+    const { status, statusText, headers } = head;
+    const read = async () => {
+      if (finished) return void 0;
+      const reply = await this.ask({ net: "read", nid }).catch((e) => {
+        finish();
+        throw e;
+      });
+      if (reply.net === "chunk") return reply.bytes;
+      finish();
+      return void 0;
+    };
+    const cancel = async () => {
+      if (finished) return;
+      finish();
+      this.cancel(nid);
+    };
+    return {
+      status,
+      statusText,
+      headers,
+      cancel,
+      body: {
+        [Symbol.asyncIterator]: () => ({
+          next: async () => {
+            const bytes = await read();
+            return bytes ? { value: bytes, done: false } : { value: void 0, done: true };
+          },
+          return: async () => {
+            await cancel();
+            return { value: void 0, done: true };
+          }
+        })
+      }
+    };
+  }
+};
+
+// src/client/protocol.ts
+var PROTOCOL = [1, 2];
+function locksOf(scope = globalThis) {
+  const locks = scope.navigator?.locks;
+  return typeof locks?.request === "function" ? locks : void 0;
+}
+function versionError(theirs) {
+  const major = Array.isArray(theirs) ? theirs[0] : void 0;
+  if (major === PROTOCOL[0]) return void 0;
+  const named = typeof major === "number" ? `${major}.x` : "without a version";
+  return `slicc-kernel client protocol ${named} is not supported: this side speaks ${PROTOCOL.join(".")}`;
+}
+
+// src/client/attach.ts
+var KernelGoneError = class extends Error {
+  constructor(message = "the slicc-kernel this client was attached to is gone") {
+    super(message);
+    this.name = "KernelGoneError";
+  }
+};
+var KernelCallError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "KernelCallError";
+    this.code = code;
+  }
+};
+var encoder = new TextEncoder();
+var bytesOf = (data) => typeof data === "string" ? encoder.encode(data) : data;
+var UNAVAILABLE = {
+  manualRedirects: false,
+  encodedBodies: false,
+  maxRequestBody: 0,
+  unavailable: true
+};
+async function holdLock(locks) {
+  if (!locks) return { release() {
+  } };
+  const name = `slicc-kernel-client:${crypto.randomUUID()}`;
+  const granted = Promise.withResolvers();
+  const held = Promise.withResolvers();
+  void locks.request(name, () => {
+    granted.resolve();
+    return held.promise;
+  });
+  await granted.promise;
+  return { name, release: () => held.resolve() };
+}
+function concat(chunks) {
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let at = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, at);
+    at += chunk.length;
+  }
+  return out;
+}
+var Channel = class {
+  greeted = Promise.withResolvers();
+  ended = Promise.withResolvers();
+  remote;
+  failure;
+  pending = /* @__PURE__ */ new Map();
+  watching = /* @__PURE__ */ new Map();
+  protocol = PROTOCOL;
+  nextId = 0;
+  port;
+  release;
+  constructor(port, release) {
+    this.port = port;
+    this.release = release;
+    this.greeted.promise.catch(() => void 0);
+    port.addEventListener("message", (event) => this.receive(event.data));
+    port.addEventListener("close", () => this.end(new KernelGoneError()));
+    port.start?.();
+  }
+  post(message) {
+    if (!this.failure) this.port.postMessage(message);
+  }
+  end(error) {
+    if (this.failure) return;
+    this.failure = error;
+    this.greeted.reject(error);
+    this.remote?.fail(error);
+    for (const call of this.pending.values()) call.reject(error);
+    this.pending.clear();
+    this.release();
+    this.port.close?.();
+    this.ended.resolve(error);
+  }
+  request(call, handlers = {}) {
+    const id = ++this.nextId;
+    const { failure } = this;
+    if (failure) return { id, done: Promise.reject(failure) };
+    const done = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject, ...handlers });
+      this.port.postMessage({ ...call, id });
+    });
+    return { id, done };
+  }
+  call(call) {
+    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;
+    }
+    if (data.hello) {
+      this.greeted.resolve(data.hello);
+      return;
+    }
+    if (data.net !== void 0) {
+      this.remote?.receive(data);
+      return;
+    }
+    const reply = data;
+    const call = this.pending.get(reply.id);
+    if (!call) return;
+    if (reply.fd !== void 0) {
+      call.output?.(reply.fd, reply.bytes);
+      return;
+    }
+    if (reply.started !== void 0) {
+      call.started?.(reply.started);
+      return;
+    }
+    this.pending.delete(reply.id);
+    if (reply.error !== void 0) call.reject(new KernelCallError(reply.error, reply.code));
+    else call.resolve(reply.result);
+  }
+};
+async function spawnOn(channel, argv, opts) {
+  const { onStdout, onStderr, stdin, group: _, ...rest } = opts;
+  const started = Promise.withResolvers();
+  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf(stdin) } : {} };
+  const { done } = channel.request(
+    { op: "spawn", argv, options },
+    {
+      output: (fd, bytes) => (fd === 1 ? onStdout : onStderr)?.(bytes),
+      started: started.resolve
+    }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  return {
+    pid,
+    pgid: pid,
+    exited: done,
+    signal: async (name = "SIGTERM") => void await channel.call({ op: "kill", pid: -pid, signal: name })
+  };
+}
+async function runOn(channel, argv, opts) {
+  const { onStdout, onStderr, ...rest } = opts;
+  const chunks = { 1: [], 2: [] };
+  const live = { 1: new TextDecoder(), 2: new TextDecoder() };
+  const tee = (fd, on) => (bytes) => {
+    chunks[fd].push(bytes);
+    on?.(live[fd].decode(bytes, { stream: true }));
+  };
+  const child = await spawnOn(channel, argv, {
+    ...rest,
+    onStdout: tee(1, onStdout),
+    onStderr: tee(2, onStderr)
+  });
+  const status = await child.exited;
+  const text = (fd) => new TextDecoder().decode(concat(chunks[fd]));
+  return { pid: child.pid, status, stdout: text(1), stderr: text(2) };
+}
+async function terminalOn(channel, argv, opts) {
+  const { onData, ...options } = opts;
+  let listener = onData ?? null;
+  const backlog = [];
+  const started = Promise.withResolvers();
+  const { id, done } = channel.request(
+    { op: "open-terminal", argv, options },
+    {
+      output: (_fd, bytes) => listener ? listener(bytes) : backlog.push(bytes),
+      started: started.resolve
+    }
+  );
+  done.catch(started.reject);
+  const pid = await started.promise;
+  const send = (action) => void channel.call({ op: "terminal", terminal: id, ...action }).catch(() => void 0);
+  return {
+    pid,
+    exited: done,
+    get onData() {
+      return listener;
+    },
+    set onData(next) {
+      listener = next;
+      if (next) for (const bytes of backlog.splice(0)) next(bytes);
+    },
+    write: (data) => send({ action: "write", bytes: bytesOf(data) }),
+    resize: (cols, rows) => send({ action: "resize", cols, rows }),
+    signal: (name) => send({ action: "signal", signal: name }),
+    close: () => send({ action: "close" })
+  };
+}
+function fsOn(channel) {
+  const fs = (method, ...args) => channel.call({ op: "fs", method, args });
+  const done = async (method, ...args) => void await fs(method, ...args);
+  return {
+    readFile: (path) => fs("readFile", path),
+    readText: async (path) => new TextDecoder().decode(await fs("readFile", path)),
+    writeFile: (path, data) => done("writeFile", path, data),
+    stat: (path) => fs("stat", path),
+    lstat: (path) => fs("lstat", path),
+    readdir: (path) => fs("readdir", path),
+    mkdir: (path) => done("mkdir", path),
+    rm: (path, o = {}) => done("rm", path, o.force === true),
+    rename: (from, to) => done("rename", from, to),
+    realpath: (path) => fs("realpath", path),
+    symlink: (target, path) => done("symlink", target, path),
+    readlink: (path) => fs("readlink", 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: done2 } = channel.request({
+        op: "watch",
+        paths,
+        recursive: options.recursive === true
+      });
+      channel.watching.set(id, onChange);
+      try {
+        await done2;
+      } 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);
+        }
+      };
+    }
+  };
+}
+function since(channel, minor, what, run) {
+  if (channel.protocol[1] < minor) {
+    return Promise.reject(
+      new KernelCallError(
+        `this kernel speaks protocol ${channel.protocol.join(".")}, which has no ${what}`,
+        "ENOSYS"
+      )
+    );
+  }
+  return run();
+}
+async function greet(channel, lock, timeoutMs) {
+  channel.post({ hello: { protocol: PROTOCOL, ...lock ? { lock } : {} } });
+  const timer = setTimeout(
+    () => channel.end(
+      new KernelGoneError(`no slicc-kernel answered on this port within ${timeoutMs} ms`)
+    ),
+    timeoutMs
+  );
+  let hello;
+  try {
+    hello = await channel.greeted.promise;
+  } finally {
+    clearTimeout(timer);
+  }
+  const refused = hello.error ?? versionError(hello.protocol);
+  if (refused) {
+    const error = new Error(refused);
+    channel.end(error);
+    throw error;
+  }
+  return hello;
+}
+async function attachKernel(port, options = {}) {
+  const locks = options.locks === null ? void 0 : options.locks ?? locksOf();
+  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) },
+    hello.traits ?? UNAVAILABLE
+  );
+  channel.remote = transport;
+  return {
+    protocol: hello.protocol,
+    transport,
+    closed: channel.ended.promise,
+    spawn: (argv, opts = {}) => spawnOn(channel, argv, opts),
+    run: (argv, opts = {}) => runOn(channel, argv, opts),
+    openTerminal: (argv, opts = {}) => terminalOn(channel, argv, opts),
+    ps: () => channel.call({ op: "ps" }),
+    mount: (spec) => since(channel, 2, "mount", () => channel.call({ op: "mount", spec })),
+    umount: async (target) => void await since(channel, 2, "umount", () => channel.call({ op: "umount", target })),
+    mounts: () => since(channel, 2, "mounts", () => channel.call({ op: "mounts" })),
+    kill: async (pid, signal = "SIGTERM") => void await channel.call({ op: "kill", pid, signal }),
+    fetch: (req) => {
+      const { signal, ...rest } = req;
+      return transport.fetch({ ...rest, signal: signal ?? new AbortController().signal });
+    },
+    fs: fsOn(channel),
+    async close(o = {}) {
+      if (channel.failure) return;
+      await channel.call({ op: "detach", ...o.kill ? { kill: true } : {} }).catch(() => void 0);
+      channel.end(new KernelGoneError("this client is closed"));
+    }
+  };
+}
+
+// src/mount/protocol.ts
+var DRIVER_PROTOCOL = [1, 0];
+function driverVersionError(theirs) {
+  const major = Array.isArray(theirs) ? theirs[0] : void 0;
+  if (major === DRIVER_PROTOCOL[0]) return void 0;
+  const named = typeof major === "number" ? `${major}.x` : "without a version";
+  return `slicc-kernel driver protocol ${named} is not supported: this side speaks ${DRIVER_PROTOCOL.join(".")}`;
+}
+
+// src/mount/driver.ts
+function fsError(code, message = code) {
+  return Object.assign(new Error(message), { code });
+}
+async function dispatch(h, req) {
+  switch (req.op) {
+    case "getattr":
+      return h.getattr(req.path);
+    case "readdir":
+      return h.readdir(req.path);
+    case "open":
+      return h.open(req.path, {
+        write: req.write,
+        create: req.create,
+        truncate: req.truncate,
+        exclusive: req.exclusive
+      });
+    case "read":
+      return h.read(req.fh, req.offset, req.size);
+    case "write":
+      return h.write(req.fh, req.offset, req.bytes);
+    case "release":
+      return h.release(req.fh);
+    case "mkdir":
+      return h.mkdir(req.path);
+    case "rmdir":
+      return h.rmdir(req.path);
+    case "unlink":
+      return h.unlink(req.path);
+    case "rename":
+      return h.rename(req.from, req.to);
+    case "symlink":
+      if (!h.symlink) throw fsError("EPERM", "this file system has no symlinks");
+      return h.symlink(req.target, req.path);
+    case "readlink":
+      if (!h.readlink) throw fsError("EINVAL", `${req.path} is not a symlink`);
+      return h.readlink(req.path);
+    case "setattr":
+      return h.setattr?.(req.path, {
+        ...req.mode !== void 0 ? { mode: req.mode } : {},
+        ...req.mtime !== void 0 ? { mtime: req.mtime } : {}
+      });
+    case "statfs":
+      return h.statfs?.() ?? null;
+    default:
+      throw fsError("ENOSYS", `unknown driver op ${req.op}`);
+  }
+}
+function serveFilesystem(port, handlers, capabilities = {}) {
+  let open = false;
+  const reply = (message, transfer = []) => port.postMessage(message, transfer);
+  async function hello(message) {
+    const refused = driverVersionError(message.protocol);
+    if (refused) {
+      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused, errno: "EPROTO" } });
+      return;
+    }
+    try {
+      const refined = await handlers.mount?.(message.mount);
+      open = true;
+      reply({
+        hello: { protocol: DRIVER_PROTOCOL, capabilities: { ...capabilities, ...refined } }
+      });
+    } catch (err) {
+      const code = err?.code;
+      reply({
+        hello: {
+          protocol: DRIVER_PROTOCOL,
+          error: err instanceof Error ? err.message : String(err),
+          errno: typeof code === "string" ? code : "EIO"
+        }
+      });
+    }
+  }
+  port.addEventListener("message", (event) => {
+    const data = event.data;
+    if (data.hello) {
+      void hello(data.hello);
+      return;
+    }
+    if (!open) return;
+    dispatch(handlers, data).then(
+      (result) => {
+        if (result instanceof Uint8Array) {
+          const bytes = result.slice();
+          reply({ id: data.id, result: bytes }, [bytes.buffer]);
+        } else reply({ id: data.id, result: result ?? null });
+      },
+      (err) => {
+        const code = err?.code;
+        reply({
+          id: data.id,
+          errno: typeof code === "string" ? code : "EIO",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    );
+  });
+  port.start?.();
+  return { invalidate: (paths) => reply({ invalidate: paths }) };
+}
+
+// src/mount/host.ts
+async function hostDriver(start, load) {
+  try {
+    const factory = (await load(start.code)).default;
+    if (typeof factory !== "function") {
+      throw new Error("a slicc file system module must export a default function");
+    }
+    const client = await attachKernel(start.client, { locks: null });
+    const made = await factory({ fetch: (request) => client.fetch(request) });
+    serveFilesystem(start.driver, made.handlers, made.capabilities ?? {});
+  } catch (err) {
+    start.driver.postMessage({
+      hello: {
+        protocol: DRIVER_PROTOCOL,
+        error: `the driver did not start: ${err instanceof Error ? err.message : String(err)}`,
+        errno: "EIO"
+      }
+    });
+  }
+}
+
+// src/node-driver-worker.ts
+parentPort?.once(
+  "message",
+  (start) => hostDriver(
+    start,
+    (code) => import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`)
+  )
+);
+//# sourceMappingURL=node-driver-worker.js.map