fix(update): report failure when systemctl will not start the update timer (#282)

`moshcode update --timer --install` writes the systemd units, runs
`systemctl daemon-reload` and `systemctl enable --now`, then always
prints "checking on a schedule now" and exits 0 — even when the enable
fails. On a host without systemd (a container, WSL, macOS) or without
root, the timer never starts, so the tool promises an auto-update that
will never fire.

Two layers were dropping the failure:
- bin/moshcode.mjs wired `runner` to swallow execFile's error and always
  resolve { ok: true }, so selfUpdateCommand could never see a failure.
- selfUpdateCommand ignored the runner results entirely.

Surface execFile's error as { ok: !err }, and when daemon-reload or
enable reports ok:false, tell the user the timer is not scheduled yet
and exit 1 instead of claiming success. The existing tests already
inject runner: () => ({ ok: true }), so the { ok } contract is honored.

Co-authored-by: clawedassistant26 <307253840+clawedassistant26@users.noreply.github.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: clawedassistant26

bin/moshcode.mjs

@@ -417,7 +417,7 @@ async function main() {
           return results.filter((r) => !r.ok).length ? 1 : 0;
         },
         write: (path, body) => fsp.writeFile(path, body),
-        runner: (cmd2, args2) => new Promise((res) => execFile(cmd2, args2, () => res({ ok: true }))),
+        runner: (cmd2, args2) => new Promise((res) => execFile(cmd2, args2, (err) => res({ ok: !err }))),
       })) || 0;
       return;
     }

src/selfupdate.mjs

@@ -189,8 +189,16 @@ export async function selfUpdateCommand(args = [], out = console.log, deps = {})
       await write(`/etc/systemd/system/${name}`, body);
       out(`  wrote /etc/systemd/system/${name}`);
     }
-    await runner("systemctl", ["daemon-reload"]);
-    await runner("systemctl", ["enable", "--now", "moshcode-update.timer"]);
+    const reload = await runner("systemctl", ["daemon-reload"]);
+    const enable = await runner("systemctl", ["enable", "--now", "moshcode-update.timer"]);
+    // The units are on disk, but they only run if systemd actually took them.
+    // On a host without systemd (a container, WSL, macOS) or without root, the
+    // enable fails — and saying "checking on a schedule now" then would promise
+    // an auto-update that will never fire. Report the failure instead.
+    if (reload?.ok === false || enable?.ok === false) {
+      out("moshcode update: wrote the units but systemctl could not start the timer — it is not checking on a schedule yet. run `systemctl enable --now moshcode-update.timer` as root.");
+      return 1;
+    }
     out("checking on a schedule now. `systemctl list-timers moshcode-update` to see when.");
     return 0;
   }

test/selfupdate.test.mjs

@@ -148,6 +148,28 @@ test("control: a valid --interval still writes the units it always did", async (
   assert.match(lines.join("\n"), /checking on a schedule/);
 });
 
+// The units on disk mean nothing if systemd never took them. When `systemctl
+// enable --now` fails — no systemd (container/WSL/macOS) or no root — the
+// command must not claim it is "checking on a schedule now"; that would promise
+// an auto-update that never fires.
+test("--install reports failure when systemctl cannot start the timer", async () => {
+  const written = new Map();
+  const lines = [];
+  const code = await selfUpdateCommand(
+    ["--timer", "--interval", "1h", "--install"],
+    (l) => lines.push(l),
+    {
+      write: async (p, b) => written.set(p, b),
+      runner: async (cmd, args) => (cmd === "systemctl" && args[0] === "enable" ? { ok: false } : { ok: true }),
+    },
+  );
+
+  assert.equal(code, 1);
+  assert.equal(written.size, 2); // units were still written, we just did not lie about the timer
+  assert.doesNotMatch(lines.join("\n"), /checking on a schedule now/);
+  assert.match(lines.join("\n"), /systemctl could not start the timer/);
+});
+
 test("control: --timer with no --interval is still the default", async () => {
   const lines = [];
   assert.equal(await selfUpdateCommand(["--timer"], (l) => lines.push(l), {}), 0);