@outerlayer/cli 0.5.1 → 0.7.0

package/dist/chunk-7FTNIAHS.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { runnerUnit, UNIT_MARKER } from './chunk-FBTE2A2X.js';
+import { checkFit } from './chunk-OUUINEYB.js';
+import { builtinKind } from './chunk-DTXOJDEH.js';
+import { runnerDir } from './chunk-ZM2IMMYN.js';
+import { dirname } from 'path';
+import { spawnSync } from 'child_process';
+
+createRequire(import.meta.url);
+function withSystemd(conf) {
+  const lines = (conf ?? "").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  const boot = lines.findIndex((line) => line.trim() === "[boot]");
+  if (boot === -1) {
+    return { text: `${lines.length === 0 ? "" : `${lines.join("\n")}
+
+`}[boot]
+systemd=true
+`, changed: true };
+  }
+  let end = lines.findIndex((line, at) => at > boot && /^\s*\[/.test(line));
+  if (end === -1) end = lines.length;
+  const key = lines.findIndex((line, at) => at > boot && at < end && /^\s*systemd\s*=/.test(line));
+  if (key !== -1) {
+    if (/^\s*systemd\s*=\s*true\s*$/i.test(lines[key])) return { text: `${lines.join("\n")}
+`, changed: false };
+    lines[key] = "systemd=true";
+  } else {
+    lines.splice(boot + 1, 0, "systemd=true");
+  }
+  return { text: `${lines.join("\n")}
+`, changed: true };
+}
+function taskNameFor(unitName) {
+  return unitName;
+}
+function taskCommand(distro) {
+  return `wsl.exe -d ${distro} --exec sleep infinity`;
+}
+function realTaskScheduler(run = defaultRun) {
+  const message = (result) => (result.stderr.trim() || result.stdout.trim()).slice(0, 300);
+  return {
+    available: () => run(["/?"]).status === 0,
+    create: (name, command) => {
+      const result = run(["/Create", "/F", "/TN", name, "/SC", "ONLOGON", "/TR", command]);
+      return result.status === 0 ? { ok: true } : { ok: false, message: message(result) };
+    },
+    exists: (name) => run(["/Query", "/TN", name]).status === 0,
+    remove: (name) => {
+      const result = run(["/Delete", "/F", "/TN", name]);
+      return result.status === 0 ? { ok: true } : { ok: false, message: message(result) };
+    }
+  };
+}
+function defaultRun(args) {
+  const result = spawnSync("schtasks.exe", args, { encoding: "utf8", timeout: 3e4 });
+  return { status: result.error === void 0 ? result.status : null, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+
+// src/runner/service/install.ts
+var DEFAULT_UNIT_NAME = "outerlayer-runner";
+function unitPathFor(unitName = DEFAULT_UNIT_NAME) {
+  return `/etc/systemd/system/${unitName}.service`;
+}
+var outcome = (ok, state, lines, unit) => ({ ok, state, lines, ...unit === void 0 ? {} : { unit } });
+function asRoot(deps, lines, say, argv) {
+  say(`sudo systemctl ${argv.join(" ")}`);
+  const result = deps.systemd.systemctl(argv, { sudo: true });
+  if (result.status !== 0) lines.push(`sudo systemctl ${argv.join(" ")} failed with exit status ${result.status}`);
+  return result.status === 0;
+}
+function attempt(lines, step) {
+  try {
+    step();
+    return true;
+  } catch (err) {
+    lines.push(err instanceof Error ? err.message : String(err));
+    return false;
+  }
+}
+var OWN_HOOKS = "the hooks are the host's own executables, so the runner does not write a service for them: run `outerlayer runner install --service --print` to print the unit, and edit it for your hooks";
+function installService(request, deps) {
+  const unitName = request.unitName ?? DEFAULT_UNIT_NAME;
+  const unitPath = unitPathFor(unitName);
+  const lines = [];
+  const say = deps.say ?? ((line) => void lines.push(line));
+  const kind = builtinKind(request.hooks.provision);
+  const own = kind === "own" || builtinKind(request.hooks.cleanup) === "own";
+  const unit = runnerUnit({
+    user: request.user,
+    configDir: dirname(request.configPath),
+    execStart: request.execStart,
+    timeLimitMinutes: request.timeLimitMinutes,
+    docker: kind === "container" || kind === "vm" || builtinKind(request.hooks.cleanup) === "container" || builtinKind(request.hooks.cleanup) === "vm"
+  });
+  if (request.print === true) return outcome(true, "printed", [], unit);
+  if (own) return outcome(false, "refused", [OWN_HOOKS]);
+  if (deps.platform === "darwin" || deps.platform === "windows") {
+    return outcome(false, "refused", [
+      deps.platform === "darwin" ? "the runner on a Mac lives in a Linux VM, and its service is set up there: run `outerlayer runner init --vm`" : "the runner on Windows lives in WSL2: run this from a WSL2 shell"
+    ]);
+  }
+  if (!deps.systemd.running()) {
+    if (deps.platform === "wsl2" && deps.wslConf !== void 0) {
+      const merged = withSystemd(deps.wslConf.read());
+      if (merged.changed) {
+        say("sudo tee /etc/wsl.conf");
+        const wslConf = deps.wslConf;
+        if (!attempt(lines, () => wslConf.write(merged.text))) return outcome(false, "refused", lines);
+      }
+      lines.push(
+        "systemd is not running in this WSL2 distribution. `systemd=true` is " + (merged.changed ? "now" : "already") + " in /etc/wsl.conf; run `wsl --shutdown` once from Windows, then run this again. No service or scheduled task is set up until then"
+      );
+      return outcome(true, "needs-wsl-shutdown", lines);
+    }
+    return outcome(false, "refused", ["systemd was not found (/run/systemd/system is missing), so no service is set up. `--print` prints the unit for another service manager"]);
+  }
+  if (kind === "container" || kind === "vm") {
+    const fit = checkFit({ concurrency: request.concurrency, buildMemory: request.buildMemory, usableBytes: deps.usableMemoryBytes });
+    if (!fit.fits) return outcome(false, "refused", [`${fit.message}. Nothing is set up: lower runner.concurrency or runner.build.memory, then run this again`]);
+  }
+  const existing = deps.systemd.read(unitPath);
+  const write = () => {
+    say(`sudo tee ${unitPath}`);
+    return attempt(lines, () => deps.systemd.write(unitPath, unit));
+  };
+  const running = () => deps.systemd.systemctl(["is-enabled", unitName]).status === 0 && deps.systemd.systemctl(["is-active", unitName]).status === 0;
+  const ensureTask = () => {
+    if (deps.platform === "wsl2") lines.push(...ensureLoginTask(deps, unitName));
+  };
+  if (existing === unit) {
+    if (!running() && !asRoot(deps, lines, say, ["enable", "--now", unitName])) return outcome(false, "refused", lines);
+    lines.push(`the service ${unitName} is current: the unit already matches the config, so nothing was changed`);
+    ensureTask();
+    return outcome(true, "current", lines);
+  }
+  if (existing === void 0) {
+    if (!write()) return outcome(false, "refused", lines);
+    if (!asRoot(deps, lines, say, ["daemon-reload"]) || !asRoot(deps, lines, say, ["enable", "--now", unitName])) {
+      say(`sudo rm ${unitPath}`);
+      if (attempt(lines, () => deps.systemd.remove(unitPath))) deps.systemd.systemctl(["daemon-reload"], { sudo: true });
+      return outcome(false, "refused", lines);
+    }
+    lines.push(`installed and started the service ${unitName}: the runner starts at boot and after a crash`);
+    ensureTask();
+    return outcome(true, "installed", lines);
+  }
+  if (!existing.startsWith(UNIT_MARKER) && request.replace !== true) {
+    lines.push(`${unitPath} differs from what this command writes, and it was not written by it, so it was left alone. Pass --replace to replace it, or \`--print\` to compare`);
+    return outcome(false, "differs", lines);
+  }
+  if (!write()) return outcome(false, "refused", lines);
+  if (!asRoot(deps, lines, say, ["daemon-reload"])) return outcome(false, "refused", lines);
+  if ((!existing.startsWith(UNIT_MARKER) || !running()) && !asRoot(deps, lines, say, ["enable", "--now", unitName])) return outcome(false, "refused", lines);
+  ensureTask();
+  if (deps.buildsRunning(runnerDir(request.configPath))) {
+    lines.push(`rewrote ${unitPath}; a build is running, so the service was not restarted and the new unit applies at the next restart`);
+    return outcome(true, "pending-restart", lines);
+  }
+  if (!asRoot(deps, lines, say, ["restart", unitName])) return outcome(false, "refused", lines);
+  lines.push(`rewrote ${unitPath} and restarted the service ${unitName}`);
+  return outcome(true, "updated", lines);
+}
+function ensureLoginTask(deps, unitName) {
+  const tasks = deps.tasks;
+  const name = taskNameFor(unitName);
+  const command = taskCommand(deps.distro ?? "Ubuntu");
+  const manual = `from Windows, run: schtasks /Create /F /TN ${name} /SC ONLOGON /TR "${command}"`;
+  if (tasks === void 0 || !tasks.available()) {
+    return [`Windows interop is off, so the scheduled task that starts WSL2 at login was not made: ${manual}`];
+  }
+  if (tasks.exists(name)) return [`the scheduled task ${name} already starts WSL2 at login`];
+  const created = tasks.create(name, command);
+  return created.ok ? [`made the scheduled task ${name}: it starts WSL2 at login and keeps it running, so the service runs from login`] : [`the scheduled task ${name} was not made (${created.message ?? "schtasks.exe failed"}): ${manual}`];
+}
+function uninstallService(request, deps) {
+  const unitName = request.unitName ?? DEFAULT_UNIT_NAME;
+  const unitPath = unitPathFor(unitName);
+  const lines = [];
+  const say = deps.say ?? ((line) => void lines.push(line));
+  const taskName = taskNameFor(unitName);
+  const removeTask = () => {
+    if (deps.platform !== "wsl2" || deps.tasks === void 0 || !deps.tasks.available() || !deps.tasks.exists(taskName)) return;
+    const removed = deps.tasks.remove(taskName);
+    lines.push(removed.ok ? `removed the scheduled task ${taskName}` : `the scheduled task ${taskName} was not removed (${removed.message ?? "schtasks.exe failed"}): from Windows, run: schtasks /Delete /F /TN ${taskName}`);
+  };
+  const existing = deps.systemd.running() ? deps.systemd.read(unitPath) : void 0;
+  if (existing === void 0) {
+    removeTask();
+    lines.push(`no service ${unitName} is installed, so there is nothing to remove`);
+    return outcome(true, "absent", lines);
+  }
+  if (!existing.startsWith(UNIT_MARKER)) {
+    lines.push(`${unitPath} was not written by \`runner install --service\`, so it was left alone`);
+    return outcome(false, "differs", lines);
+  }
+  if (!asRoot(deps, lines, say, ["disable", "--now", unitName])) return outcome(false, "refused", lines);
+  say(`sudo rm ${unitPath}`);
+  if (!attempt(lines, () => deps.systemd.remove(unitPath))) return outcome(false, "refused", lines);
+  if (deps.systemd.read(unitPath) !== void 0) {
+    lines.push(`${unitPath} is still there after the remove, so the service ${unitName} was not removed`);
+    return outcome(false, "refused", lines);
+  }
+  if (!asRoot(deps, lines, say, ["daemon-reload"])) return outcome(false, "refused", lines);
+  removeTask();
+  lines.push(`removed the service ${unitName}`);
+  return outcome(true, "removed", lines);
+}
+
+export { DEFAULT_UNIT_NAME, installService, realTaskScheduler, uninstallService, unitPathFor };