@dylanpiercey/work 0.0.194 → 0.0.195

package/bin/work.mjs

@@ -696,68 +696,22 @@ function servicePath() {
   return setupPath(path.dirname(process.execPath));
 }
 
-/** Argv prefixes that keep the host awake while the server runs, best first.
- * A suspended host is a dead host: agents keep running in tmux, but the
- * machine stops answering, so remote sessions look hung until someone wakes
- * it by hand. The inhibitor lifts when the service stops.
- *
- * Linux offers two, because polkit gates them differently:
- *
- *   sleep:idle  also vetoes an explicit suspend, but
- *               org.freedesktop.login1.inhibit-block-sleep is
- *               allow_any=auth_admin_keep — permitted from a session, refused
- *               for a caller that has none. That is the lingering user
- *               manager at boot, so the service cannot rely on it.
- *   idle        org.freedesktop.login1.inhibit-block-idle is allow_any=yes,
- *               so this always works. It holds the system non-idle, which is
- *               what stops logind's IdleAction (and a desktop's idle-suspend)
- *               from ever firing.
- *
- * Idle alone is the honest target anyway — it matches `caffeinate -s`, and
- * declining to veto a suspend the user deliberately asked for is correct.
- * Taking the stronger one when it is allowed costs nothing, so try both. */
-function awakePrefixes() {
-  if (process.platform === "darwin")
-    return have("caffeinate") ? [["/usr/bin/caffeinate", "-s"]] : [];
-  if (process.platform === "linux" && have("systemd-inhibit"))
-    return ["sleep:idle", "idle"].map((what) => [
-      "systemd-inhibit",
-      `--what=${what}`,
-      "--who=work",
-      "--why=work server is running",
-      "--mode=block",
-    ]);
-  return [];
+/** Argv prefix that keeps a Mac awake while the server runs. A suspended
+ * host is a dead host: agents keep running in tmux, but the machine stops
+ * answering, so remote sessions look hung until someone wakes it by hand.
+ * On Linux the server holds a logind inhibitor itself (src/server/awake.ts,
+ * `WORK_AWAKE=1` in the unit): wrapping it in `systemd-inhibit` would close
+ * the listening socket work.socket hands over. */
+function awakePrefix() {
+  return process.platform === "darwin" && have("caffeinate")
+    ? ["/usr/bin/caffeinate", "-s"]
+    : [];
 }
 
-/** systemd's ExecStart for the linux unit, as one line.
- *
- * With no inhibitor this is just the argv. Otherwise it is a shell that tries
- * each candidate in turn and execs under the first one allowed, because
- * `systemd-inhibit` exits non-zero when polkit refuses — and since it is the
- * unit's ExecStart, that failure takes the whole service down with it. A
- * lingering manager at boot has no session, so the sleep block is refused
- * every time and `Restart=always` retries forever; the server would only come
- * up once someone logged in, defeating the unattended start
- * `loginctl enable-linger` exists to guarantee. Falling through to the
- * ungated idle block keeps the machine awake anyway, and running bare is
- * still better than not running. */
-function serviceExecStart(candidates, argv) {
-  // systemd splits on whitespace, so quote any argument containing it.
-  const unit = (parts) =>
-    parts.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ");
-  if (!candidates.length) return unit(argv);
-  const shq = (a) => `'${a.replace(/'/g, `'\\''`)}'`;
-  const cmd = argv.map(shq).join(" ");
-  // Each probe takes and drops an inhibitor around `true`; if that is allowed
-  // the real one will be too.
-  const script = candidates
-    .map((c) => {
-      const inh = c.map(shq).join(" ");
-      return `if ${inh} true 2>/dev/null; then exec ${inh} ${cmd}; fi; `;
-    })
-    .join("");
-  return `/bin/sh -c "${script}exec ${cmd}"`;
+/** An argv as one systemd ExecStart line: systemd splits on whitespace, so
+ * any argument containing it is quoted. */
+function unitCommand(argv) {
+  return argv.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ");
 }
 
 /** Where installService() writes the service definition — also the store we
@@ -892,6 +846,20 @@ function pidsListening(port) {
   return [...new Set(pids)];
 }
 
+/** Listeners on the port that are servers, not the service manager: with
+ * work.socket the port is held by systemd itself, which a leftover sweep
+ * must never signal. */
+function serverPidsListening(port) {
+  return pidsListening(port).filter((pid) => {
+    try {
+      return fs.readFileSync(`/proc/${pid}/comm`, "utf8").trim() !== "systemd";
+    } catch {
+      // No /proc (macOS): launchd holds no socket for work.
+      return true;
+    }
+  });
+}
+
 function workServerPids() {
   const out = spawnSync("ps", ["-ax", "-o", "pid=,command="], {
     encoding: "utf8",
@@ -953,13 +921,13 @@ function stopOldCopies(port) {
       stdio: "ignore",
     });
   }
-  const seen = new Set([...pidsListening(port), ...workServerPids()]);
+  const seen = new Set([...serverPidsListening(port), ...workServerPids()]);
   if (seen.size) {
     log(`stopping ${seen.size} leftover work process(es)`);
     killPids(seen, "SIGTERM");
     spawnSync("sleep", ["0.4"], { stdio: "ignore" });
   }
-  killPids(pidsListening(port), "SIGKILL");
+  killPids(serverPidsListening(port), "SIGKILL");
 }
 
 /** Wait for the service to answer before we tell anyone it is up. Both
@@ -992,10 +960,8 @@ function installService() {
   // PORT handling, so no awake prefix is layered on top.
   const execOverride = process.env.WORK_SERVICE_EXEC;
   const target = execOverride ? [execOverride] : [cliPath, "start"];
-  const awake = execOverride ? [] : awakePrefixes();
-  // launchd takes an argv, not a shell: caffeinate needs no authorisation, so
-  // the first candidate is simply used.
-  const startArgs = [...(awake[0] || []), ...target];
+  const awake = execOverride ? [] : awakePrefix();
+  const startArgs = [...awake, ...target];
   if (process.platform === "darwin") {
     const plist = serviceFile();
     fs.mkdirSync(path.dirname(plist), { recursive: true });
@@ -1076,11 +1042,32 @@ ${envXml}
     const envLines = Object.entries(serviceEnv())
       .map(([k, v]) => `Environment=${k}=${v}`)
       .join("\n");
-    const execStart = serviceExecStart(awake, target);
+    const execStart = unitCommand(target);
+    // The port is held by work.socket, not the server: a restart swaps the
+    // process behind a socket that never closes, so a connection made
+    // meanwhile waits instead of being refused (a reverse proxy took one
+    // refusal for the server being down, for half a minute).
+    const socketFile = path.join(unitDir, "work.socket");
+    const socketUnit = `[Unit]
+Description=work, agentic dev workspace GUI (its port, held across restarts)
+
+[Socket]
+ListenStream=${port}
+
+[Install]
+WantedBy=sockets.target
+`;
+    let socketChanged = true;
+    try {
+      socketChanged = fs.readFileSync(socketFile, "utf8") !== socketUnit;
+    } catch {}
+    fs.writeFileSync(socketFile, socketUnit);
     fs.writeFileSync(
       unitFile,
       `[Unit]
 Description=work, agentic dev workspace GUI
+Requires=work.socket
+After=work.socket
 # Keep retrying forever: hitting the default start limit parks the unit in
 # failed state, which is the manual-restart hole we are closing.
 StartLimitIntervalSec=0
@@ -1093,20 +1080,35 @@ ExecStart=${execStart}
 Restart=always
 RestartSec=2
 ${envLines}
-
+${execOverride ? "" : "Environment=WORK_AWAKE=1\n"}
 [Install]
 WantedBy=default.target
 `,
     );
     log("installing systemd user service");
     sh("systemctl", ["--user", "daemon-reload"]);
-    sh("systemctl", ["--user", "enable", "work.service"]);
+    sh("systemctl", ["--user", "enable", "work.socket", "work.service"]);
+    // Rebinding (a new port, or the first install) is the one restart that
+    // closes the port; otherwise the socket stays up and only the process
+    // behind it is replaced.
+    if (
+      socketChanged ||
+      spawnSync("systemctl", ["--user", "is-active", "--quiet", "work.socket"])
+        .status !== 0
+    ) {
+      spawnSync("systemctl", ["--user", "stop", "work.service"], {
+        stdio: "ignore",
+      });
+      sh("systemctl", ["--user", "restart", "work.socket"]);
+    }
     sh("systemctl", ["--user", "restart", "work.service"]);
     // Survive logout (best-effort; may need sudo on some systems).
     spawnSync("loginctl", ["enable-linger", os.userInfo().username], {
       stdio: "ignore",
     });
-    log("manage with: systemctl --user {status,restart,stop} work.service");
+    log(
+      "manage with: systemctl --user {status,restart} work.service   (stop: systemctl --user stop work.socket work.service)",
+    );
     return true;
   }