@ai-ecoverse/slicc-kernel 1.108.4 → 1.109.0

package/dist/node.js

@@ -6435,7 +6435,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.108.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.109.0" : "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
@@ -6794,23 +6794,115 @@ function binfmtOf(binfmts, path) {
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
-// src/cron/clock.ts
-var systemCronClock = {
-  now: () => Date.now(),
-  sleep(until, signal) {
-    if (signal.aborted) return Promise.resolve();
-    return new Promise((resolve2) => {
-      const done4 = () => {
-        clearTimeout(timer);
-        signal.removeEventListener("abort", done4);
-        resolve2();
-      };
-      const timer = setTimeout(done4, Math.max(0, until - Date.now()));
-      timer.unref?.();
-      signal.addEventListener("abort", done4, { once: true });
-    });
-  }
+// src/cron/command.ts
+var CRONTAB_PATH = "/usr/bin/crontab";
+var CRONTAB_COMMAND = {
+  name: "crontab",
+  abi: "js",
+  glue: CRONTAB_PATH,
+  wasm: CRONTAB_PATH,
+  argv0: "crontab"
 };
+var CRONTAB_SOURCE = `export default async function crontab(ctx) {
+  const say = (fd, text) => ctx.write(fd, text).catch(() => undefined);
+  const usage = async () => {
+    await say(2, "usage: crontab [-u user] { -l | -r | -e | file | - }\\n");
+    return 1;
+  };
+  const args = ctx.argv.slice(1);
+  let user;
+  let action;
+  let file;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-u") {
+      user = args[++i];
+      if (user === undefined) return usage();
+    } else if (arg === "-l" || arg === "-r" || arg === "-e") {
+      if (action !== undefined) return usage();
+      action = arg.slice(1);
+    } else if (arg === "-" || !arg.startsWith("-")) {
+      if (file !== undefined) return usage();
+      file = arg;
+    } else return usage();
+  }
+  if ((action === undefined) === (file === undefined)) return usage();
+  const call = (c) => ctx.crontab(user === undefined ? c : { ...c, user });
+  const failed = async (answer) => {
+    await say(2, answer.error + "\\n");
+    return 1;
+  };
+  const decode = (bytes) => new TextDecoder().decode(bytes);
+  if (action === "l") {
+    const answer = await call({ action: "list" });
+    if (answer.error !== undefined) return failed(answer);
+    await say(1, answer.text);
+    return 0;
+  }
+  if (action === "r") {
+    const answer = await call({ action: "remove" });
+    return answer.error !== undefined ? failed(answer) : 0;
+  }
+  if (action === "e") return edit();
+  let text;
+  try {
+    if (file === "-") {
+      const parts = [];
+      for (;;) {
+        const chunk = await ctx.read(0);
+        if (chunk.length === 0) break;
+        parts.push(decode(chunk));
+      }
+      text = parts.join("");
+    } else text = decode(await ctx.fs.readFile(ctx.resolve(file)));
+  } catch (err) {
+    await say(2, "crontab: " + file + ": " + (err && err.code ? err.code : String(err)) + "\\n");
+    return 1;
+  }
+  const answer = await call({ action: "install", text });
+  return answer.error !== undefined ? failed(answer) : 0;
+
+  async function edit() {
+    const editor = ctx.env.VISUAL || ctx.env.EDITOR;
+    if (!editor) {
+      await say(2, "crontab: set VISUAL or EDITOR to edit, or install a file with crontab <file>\\n");
+      return 1;
+    }
+    const current = await call({ action: "list" });
+    const before = current.error === undefined ? current.text : "";
+    if (current.error !== undefined && !current.error.startsWith("no crontab for ")) return failed(current);
+    const tmp = "/tmp/crontab." + ctx.pid + "." + crypto.randomUUID();
+    try {
+      const file = await ctx.open(tmp, { write: true, create: true, exclusive: true, mode: 0o600 });
+      await file.write(0, new TextEncoder().encode(before));
+      await file.close();
+    } catch (err) {
+      await say(2, "crontab: " + tmp + ": " + (err && err.code ? err.code : String(err)) + "\\n");
+      return 1;
+    }
+    const child = await ctx.spawn({ argv: ["/bin/bash", "-c", editor + ' "$1"', "crontab", tmp] });
+    const ended = await ctx.wait(child.pid);
+    if (ended.status !== 0) {
+      await say(2, "crontab: the editor exited with status " + ended.status + ", crontab not changed\\n");
+      await ctx.fs.rm(tmp).catch(() => undefined);
+      return 1;
+    }
+    const after = decode(await ctx.fs.readFile(tmp));
+    if (after === before) {
+      await say(2, "crontab: no changes made to crontab\\n");
+      await ctx.fs.rm(tmp).catch(() => undefined);
+      return 0;
+    }
+    const answer = await call({ action: "install", text: after });
+    if (answer.error !== undefined) {
+      await say(2, answer.error + "\\ncrontab: your edit is kept in " + tmp + "\\n");
+      return 1;
+    }
+    await ctx.fs.rm(tmp).catch(() => undefined);
+    return 0;
+  }
+}
+`;
 
 // src/cron/schedule.ts
 var MISSED_CAP = 1e5;
@@ -7056,6 +7148,83 @@ function parseCrontab(text, path, system = false) {
   return { jobs, errors };
 }
 
+// src/cron/crontab.ts
+var CRONTAB_MAX = 256 * 1024;
+var ACTIONS = /* @__PURE__ */ new Set(["list", "remove", "install"]);
+function crontabCall(req) {
+  const { action, user, text } = req;
+  if (typeof action !== "string" || !ACTIONS.has(action)) return void 0;
+  if (user !== void 0 && typeof user !== "string") return void 0;
+  if (action === "install" && typeof text !== "string") return void 0;
+  return {
+    op: "proc-crontab",
+    action,
+    ...user !== void 0 ? { user } : {},
+    ...action === "install" ? { text } : {}
+  };
+}
+var Crontabs = class {
+  o;
+  constructor(options) {
+    this.o = options;
+  }
+  async request(cred, call) {
+    const caller = await this.o.lookup(cred.ruid);
+    if (!caller) return { error: `crontab: your uid ${cred.ruid} is not in /etc/passwd` };
+    let target = caller;
+    if (call.user !== void 0 && call.user !== caller.name) {
+      if (cred.euid !== 0) return { error: "crontab: must be privileged to use -u" };
+      const found = await this.o.lookup(call.user);
+      if (!found) return { error: `crontab: user ${call.user} unknown` };
+      target = found;
+    }
+    const path = `${SPOOL_DIR}/${target.name}`;
+    const none = { error: `no crontab for ${target.name}` };
+    const { fs } = this.o;
+    if (call.action === "install") return this.install(path, target, call.text);
+    if (!await fs.exists(path)) return none;
+    if (call.action === "list") return { text: await fs.readFile(path) };
+    await fs.rm(path);
+    return { text: "" };
+  }
+  async install(path, target, text) {
+    if (text.length > CRONTAB_MAX) return { error: "crontab: the table is too long" };
+    const { errors } = parseCrontab(text, path);
+    if (errors.length > 0) {
+      const lines2 = errors.map(({ line, message: message3 }) => `"-":${line}: ${message3}`);
+      return { error: ["crontab: errors in crontab file, cannot install", ...lines2].join("\n") };
+    }
+    const { fs, owners } = this.o;
+    if (!await fs.exists(SPOOL_DIR)) {
+      await fs.mkdir(SPOOL_DIR, { recursive: true });
+      if (owners) await fs.chown?.(SPOOL_DIR, { uid: 0, gid: 0, mode: 448, follow: false });
+    }
+    const fresh2 = `${SPOOL_DIR}/.${target.name}.${crypto.randomUUID()}.new`;
+    const owner = owners ? { uid: target.uid, gid: target.gid, mode: 384 } : void 0;
+    await fs.writeFile(fresh2, text, owner);
+    await fs.rename(fresh2, path);
+    return { text: "" };
+  }
+};
+
+// src/cron/clock.ts
+var systemCronClock = {
+  now: () => Date.now(),
+  sleep(until, signal) {
+    if (signal.aborted) return Promise.resolve();
+    return new Promise((resolve2) => {
+      const done4 = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done4);
+        resolve2();
+      };
+      const timer = setTimeout(done4, Math.max(0, until - Date.now()));
+      timer.unref?.();
+      signal.addEventListener("abort", done4, { once: true });
+    });
+  }
+};
+
 // src/cron/service.ts
 var CRON_DIR = "/var/spool/cron";
 var STAMP_PATH = `${CRON_DIR}/stamp`;
@@ -7232,7 +7401,7 @@ var CronService = class {
     }
     const names = await fs.readdir(SPOOL_DIR).catch(() => []);
     for (const name2 of names.sort()) {
-      if (name2.startsWith(".") || name2.endsWith("~") || name2.endsWith(".new")) continue;
+      if (name2.startsWith(".") || name2.endsWith("~")) continue;
       const path = `${SPOOL_DIR}/${name2}`;
       const account = await this.host.lookup(name2);
       if (!account) {
@@ -11391,12 +11560,11 @@ function attachSyncSabResponder(port, sab, token, opts) {
     if (disposed) return;
     const { status, payload } = encodeSabResult(result);
     drop(id2);
-    const entry = {
-      status,
-      payload,
-      timer: setTimeout(() => drop(id2), PENDING_TTL_MS)
-    };
-    pending.set(id2, entry);
+    const entry = { status, payload };
+    if (payload.byteLength > window.byteLength) {
+      entry.timer = setTimeout(() => drop(id2), PENDING_TTL_MS);
+      pending.set(id2, entry);
+    }
     publish(id2, entry, 0);
   }
   const handler = (event) => {
@@ -12106,6 +12274,8 @@ var AsyncRangedFile = class {
 
 // src/realm/sync-sab-bridge.ts
 var PATH_OPS = new Set(SYNC_FS_OPS);
+var SPIN_CORES = 4;
+var spinning = (globalThis.navigator?.hardwareConcurrency ?? 0) >= SPIN_CORES;
 
 // src/realm/live-vfs-fs.ts
 var EARLY_WHOLE_FILE = 64 * 1024;
@@ -16583,6 +16753,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-wait",
   "proc-captured",
   "proc-sudo",
+  "proc-crontab",
   "proc-run",
   "proc-exit",
   "proc-kill-self",
@@ -17772,8 +17943,17 @@ var WasmProcess = class {
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
       case "proc-sudo":
         return { ok: true, kind: "json", json: await this.sudo(req, cancelled) };
+      case "proc-crontab":
+        return { ok: true, kind: "json", json: await this.crontab(req) };
     }
   }
+  async crontab(req) {
+    const { crontab } = this.options;
+    if (!crontab) throw new KernelError("ENOSYS");
+    const call = crontabCall(req);
+    if (!call) throw new KernelError("EINVAL");
+    return crontab(call);
+  }
   signalSyscall(req) {
     if (req.op === "sig-inherited") {
       return { ok: true, kind: "json", json: this.inherited & ~this.caught };
@@ -18176,6 +18356,7 @@ function processOptions(opts, header4, hooks, created3) {
     ...opts.writesBack ? { writesBack: opts.writesBack } : {},
     processes: opts.processes,
     ...opts.sudo ? { sudo: opts.sudo } : {},
+    ...opts.crontab ? { crontab: opts.crontab } : {},
     openFiles: opts.openFiles,
     ...opts.nodes ? { nodes: opts.nodes } : {},
     mounts: opts.mounts,
@@ -21711,6 +21892,7 @@ var LAYOUT = [
   ["/usr", 493],
   ["/usr/local", 493]
 ];
+var IN_TREE = /* @__PURE__ */ new Set([SUDO_PATH, CRONTAB_PATH]);
 var LOAD_SAMPLE_MS = 5e3;
 var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
 var encoder8 = new TextEncoder();
@@ -21941,6 +22123,7 @@ var Launcher = class {
   boot = Date.now();
   bootId = crypto.randomUUID();
   cron;
+  crontabs;
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
@@ -22141,7 +22324,9 @@ var Launcher = class {
       found = this.trustedAppended().then(async (appended2) => {
         const tiers = await this.tiers(scope, appended2);
         return scanCommands(this.scanned, tiers, tiers.length - appended2.length);
-      }).then((commands) => this.refusals(commands).set(SUDO_COMMAND.name, SUDO_COMMAND));
+      }).then(
+        (commands) => this.refusals(commands).set(SUDO_COMMAND.name, SUDO_COMMAND).set(CRONTAB_COMMAND.name, CRONTAB_COMMAND)
+      );
       this.catalogs.set(scope, found);
     }
     return found;
@@ -22546,7 +22731,7 @@ var Launcher = class {
       const root = packageRootOf(at, roots) ?? PACKAGE_ROOT.exec(at)?.[1];
       if (root !== void 0) files.push(`${root}/package.json`);
     }
-    return [...new Set(files)].filter((path) => path !== "" && path !== SUDO_PATH);
+    return [...new Set(files)].filter((path) => path !== "" && !IN_TREE.has(path));
   }
   async unrunnable(file, cwd, scope) {
     const path = this.fs.resolvePath(cwd, file);
@@ -22686,6 +22871,9 @@ var Launcher = class {
     if (target.abi === "js" && target.wasm === SUDO_PATH) {
       return { abi: "js", glue: SUDO_SOURCE, path: SUDO_PATH };
     }
+    if (target.abi === "js" && target.wasm === CRONTAB_PATH) {
+      return { abi: "js", glue: CRONTAB_SOURCE, path: CRONTAB_PATH };
+    }
     if (target.abi === "js" && target.wasm === REFUSED_PATH) {
       return { abi: "js", glue: REFUSED_SOURCE, path: REFUSED_PATH };
     }
@@ -22841,6 +23029,7 @@ var Launcher = class {
         cpu: this.cpuTotal()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
+      crontab: (call) => this.crontab(pid, call),
       openFiles: this.openFiles,
       nodes: stack.nodes,
       held: this.held,
@@ -23059,6 +23248,14 @@ var Launcher = class {
     const threads = this.stateOf(pid) === "S" ? this.processes.get(pid)?.threads?.() : void 0;
     return threads ? { threads } : {};
   }
+  crontab(pid, call) {
+    this.crontabs ??= new Crontabs({
+      fs: this.fs,
+      owners: this.owners,
+      lookup: (user) => this.users.lookup(user)
+    });
+    return this.crontabs.request(this.credOf(pid), call);
+  }
   sudo(pid, call, signal) {
     const caller = {
       cred: this.credOf(pid),