@ai-ecoverse/slicc-kernel 1.108.5 → 1.110.0

package/dist/node.js

@@ -5975,14 +5975,14 @@ var WsReader = class {
   }
 };
 function switchingHead(accept2, protocol = "") {
-  const chosen = protocol ? `Sec-WebSocket-Protocol: ${protocol}\r
+  const chosen2 = protocol ? `Sec-WebSocket-Protocol: ${protocol}\r
 ` : "";
   return latin1Bytes(
     `HTTP/1.1 101 Switching Protocols\r
 Upgrade: websocket\r
 Connection: Upgrade\r
 Sec-WebSocket-Accept: ${accept2}\r
-${chosen}\r
+${chosen2}\r
 `
   );
 }
@@ -6435,7 +6435,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.108.5" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.110.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
@@ -6483,6 +6483,37 @@ function argsOf(pkg, raw) {
   if (!raw.every((arg) => typeof arg === "string")) return void 0;
   return raw.map((arg) => arg.replace(PACKAGE, pkg));
 }
+var warnedVariants = /* @__PURE__ */ new Set();
+function variantOf(pkg, raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const { env, wasm } = raw;
+  const path = inside(pkg, wasm);
+  if (!path || !env || typeof env !== "object" || Array.isArray(env)) return void 0;
+  const pairs = Object.entries(env);
+  if (pairs.length === 0) return void 0;
+  if (!pairs.every(([key, value2]) => ENV_KEY.test(key) && typeof value2 === "string")) {
+    return void 0;
+  }
+  return { env: Object.fromEntries(pairs), wasm: path };
+}
+function variantsOf(pkg, name2, raw) {
+  if (raw === void 0) return void 0;
+  const variants = Array.isArray(raw) ? raw.map((one) => variantOf(pkg, one)) : [void 0];
+  if (variants.every((one) => one !== void 0)) {
+    return variants.length > 0 ? variants : void 0;
+  }
+  const key = `${pkg}:${name2}:${JSON.stringify(raw)}`;
+  if (!warnedVariants.has(key)) {
+    warnedVariants.add(key);
+    console.warn(`slicc-kernel: ${pkg}: ${name2}: ignoring malformed "variants", running its wasm`);
+  }
+  return void 0;
+}
+function variantFor(variants, env) {
+  return variants?.find(
+    (one) => Object.entries(one.env).every(([key, value2]) => env[key] === value2)
+  )?.wasm;
+}
 function abiOf(raw, fallback) {
   const abi = raw ?? fallback;
   return abi === "emscripten" || abi === "wasi" || abi === "js" ? abi : void 0;
@@ -6516,6 +6547,7 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
   const glue = abi === "wasi" ? wasm : inside(pkg, raw.glue);
   if (!abi || !glue || !wasm) return void 0;
   const imports = abi === "wasi" ? inside(pkg, raw.imports) : void 0;
+  const variants = variantsOf(pkg, name2, raw.variants);
   return {
     name: name2,
     abi,
@@ -6527,7 +6559,8 @@ function commandOf(pkg, name2, raw, packageAbi, shared) {
     ...abi === "wasi" && raw.preopenRoot === true ? { preopenRoot: true } : {},
     ...args ? { args } : {},
     ...withEnv,
-    ...imports ? { imports } : {}
+    ...imports ? { imports } : {},
+    ...variants ? { variants } : {}
   };
 }
 function commandsOf(pkg, manifest) {
@@ -6794,23 +6827,116 @@ 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 stream = new TextDecoder();
+      const parts = [];
+      for (;;) {
+        const chunk = await ctx.read(0);
+        if (chunk.length === 0) break;
+        parts.push(stream.decode(chunk, { stream: true }));
+      }
+      text = parts.join("") + stream.decode();
+    } 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 +7182,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`;
@@ -7230,9 +7433,12 @@ var CronService = class {
       const account = await this.host.lookup(job.user);
       if (account) out.push({ source: "system", account, job });
     }
-    const names = await fs.readdir(SPOOL_DIR).catch(() => []);
+    const names = await fs.readdir(SPOOL_DIR).catch((err) => {
+      if (err?.code === "ENOENT") return [];
+      throw err;
+    });
     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) {
@@ -16584,6 +16790,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-wait",
   "proc-captured",
   "proc-sudo",
+  "proc-crontab",
   "proc-run",
   "proc-exit",
   "proc-kill-self",
@@ -17773,8 +17980,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 };
@@ -18177,6 +18393,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,
@@ -21712,6 +21929,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();
@@ -21810,9 +22028,18 @@ function targetOf(command) {
     ...command.env ? { env: command.env } : {},
     ...command.unset ? { unset: command.unset } : {},
     ...command.imports ? { imports: command.imports } : {},
-    ...command.preopenRoot ? { preopenRoot: true } : {}
+    ...command.preopenRoot ? { preopenRoot: true } : {},
+    ...command.variants ? { variants: command.variants } : {}
   };
 }
+function chosen(planned, env) {
+  const { target } = planned;
+  const wasm = variantFor(target.variants, env);
+  if (wasm === void 0) return planned;
+  const { asked: _asked, ...rest2 } = target;
+  const glue = target.abi === "wasi" ? wasm : target.glue;
+  return { ...planned, target: { ...rest2, wasm, glue } };
+}
 function withScriptEnv(target, command) {
   if (!command) return target;
   return {
@@ -21942,6 +22169,7 @@ var Launcher = class {
   boot = Date.now();
   bootId = crypto.randomUUID();
   cron;
+  crontabs;
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
@@ -22142,7 +22370,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;
@@ -22547,7 +22777,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);
@@ -22687,6 +22917,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 };
     }
@@ -22717,14 +22950,15 @@ var Launcher = class {
       ...target.preopenRoot ? { preopenRoot: true } : {}
     };
   }
-  async launch(planned, req) {
-    const { target, args } = planned;
+  async launch(asked, req) {
     const cwd = await physicalPathAsync(this.base, req.cwd);
     const seen = { ...req.env, HOSTNAME: this.hostname, cwd };
-    const env = { ...expandDefaults(target.env, seen), ...req.env };
-    for (const key of target.unset ?? []) delete env[key];
+    const env = { ...expandDefaults(asked.target.env, seen), ...req.env };
+    for (const key of asked.target.unset ?? []) delete env[key];
     delete env[TICKET_ENV];
     env.HOSTNAME = this.hostname;
+    const planned = chosen(asked, env);
+    const { target, args } = planned;
     let program;
     await this.pnpmReady();
     try {
@@ -22842,6 +23076,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,
@@ -23060,6 +23295,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),