@dylanpiercey/work 0.0.5 → 0.0.7

package/bin/work.mjs

@@ -107,15 +107,21 @@ async function setup() {
     }
   }
 
-  // One-shot cleanups between versions.
+  // One-shot cleanups between versions. Run them against the settings the
+  // service actually uses: migrate.mjs exits quietly when it finds no db, so
+  // an ambient environment missing WORK_DATA_DIR skips every sweep.
   const migrate = path.join(pkgRoot, "scripts", "migrate.mjs");
   if (fs.existsSync(migrate)) {
-    spawnSync(process.execPath, [migrate], { stdio: "inherit" });
+    spawnSync(process.execPath, [migrate], {
+      stdio: "inherit",
+      env: { ...process.env, ...serviceEnv() },
+    });
   }
 
   installService();
-  maybeTunnel();
-  log(`done — http://localhost:${appPort}`);
+  const port = serviceEnv().PORT;
+  maybeTunnel(port);
+  log(`done — http://localhost:${port}`);
 }
 
 async function update() {
@@ -139,18 +145,73 @@ function servicePath() {
   ].join(":");
 }
 
+/** Argv prefix that keeps the host 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. The
+ * inhibitor needs no privileges and lifts when the service stops — masking
+ * sleep.target is the stronger machine-wide version, but that wants sudo. */
+function awakePrefix() {
+  if (process.platform === "darwin")
+    return have("caffeinate") ? ["/usr/bin/caffeinate", "-s"] : [];
+  if (process.platform === "linux" && have("systemd-inhibit"))
+    return [
+      "systemd-inhibit",
+      "--what=sleep:idle",
+      "--who=work",
+      "--why=work server is running",
+      "--mode=block",
+    ];
+  return [];
+}
+
+/** Where installService() writes the service definition — also the store we
+ * read settings back out of, so there is no second config file to keep. */
+function serviceFile() {
+  return process.platform === "darwin"
+    ? path.join(os.homedir(), "Library/LaunchAgents/dev.work.app.plist")
+    : path.join(
+        process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+        "systemd/user/work.service",
+      );
+}
+
+/** WORK_* already baked into the installed service. `work update` re-runs
+ * setup from whatever shell the user happens to be in, so without this the
+ * first update silently resets the port, root and data dir to defaults —
+ * and a lost WORK_DATA_DIR points the server at an empty database, making
+ * every workspace look like it vanished. */
+function installedServiceEnv() {
+  const installed = {};
+  try {
+    const text = fs.readFileSync(serviceFile(), "utf8");
+    const re =
+      process.platform === "darwin"
+        ? /<key>(WORK_[A-Z_]+)<\/key>\s*<string>([^<]*)<\/string>/g
+        : /^Environment=(WORK_[A-Z_]+)=(.*)$/gm;
+    for (const [, key, value] of text.matchAll(re)) installed[key] = value;
+  } catch {}
+  return installed;
+}
+
 function serviceEnv() {
-  const env = { PATH: servicePath(), PORT: appPort };
-  for (const key of ["WORK_APP_PORT", "WORK_ROOT", "WORK_DATA_DIR", "WORK_ALLOWED_HOSTS", "WORK_BIND"]) {
-    if (process.env[key]) env[key] = process.env[key];
+  const env = { PATH: servicePath() };
+  const installed = installedServiceEnv();
+  for (const key of ["WORK_APP_PORT", "WORK_ROOT", "WORK_DATA_DIR", "WORK_ALLOWED_HOSTS"]) {
+    // `in` rather than a truthy check, so `WORK_ALLOWED_HOSTS= work setup`
+    // can deliberately clear a setting the installed service still carries.
+    const value = key in process.env ? process.env[key] : installed[key];
+    if (value) env[key] = value;
   }
+  // entry.ts prefers PORT, so carrying WORK_APP_PORT forward without this
+  // would leave the service on the default port anyway.
+  env.PORT = env.WORK_APP_PORT || appPort;
   return env;
 }
 
 function installService() {
   const cliPath = fileURLToPath(import.meta.url);
   if (process.platform === "darwin") {
-    const plist = path.join(os.homedir(), "Library/LaunchAgents/dev.work.app.plist");
+    const plist = serviceFile();
     fs.mkdirSync(path.dirname(plist), { recursive: true });
     fs.mkdirSync(path.join(os.homedir(), "Library/Logs"), { recursive: true });
     const envXml = Object.entries(serviceEnv())
@@ -164,7 +225,7 @@ function installService() {
 <dict>
   <key>Label</key><string>dev.work.app</string>
   <key>ProgramArguments</key>
-  <array><string>${process.execPath}</string><string>${cliPath}</string><string>start</string></array>
+  <array>${[...awakePrefix(), process.execPath, cliPath, "start"].map((a) => `<string>${a}</string>`).join("")}</array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
   <key>StandardOutPath</key><string>${os.homedir()}/Library/Logs/work.log</string>
@@ -192,22 +253,31 @@ ${envXml}
   }
 
   if (process.platform === "linux" && have("systemctl")) {
-    const unitDir = path.join(
-      process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
-      "systemd/user",
-    );
+    const unitFile = serviceFile();
+    const unitDir = path.dirname(unitFile);
     fs.mkdirSync(unitDir, { recursive: true });
     const envLines = Object.entries(serviceEnv())
       .map(([k, v]) => `Environment=${k}=${v}`)
       .join("\n");
+    // systemd splits ExecStart on whitespace, so quote the inhibitor's --why.
+    const execStart = [...awakePrefix(), process.execPath, cliPath, "start"]
+      .map((a) => (a.includes(" ") ? `"${a}"` : a))
+      .join(" ");
     fs.writeFileSync(
-      path.join(unitDir, "work.service"),
+      unitFile,
       `[Unit]
 Description=work — agentic dev workspace GUI
+# 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
 
 [Service]
-ExecStart=${process.execPath} ${cliPath} start
-Restart=on-failure
+ExecStart=${execStart}
+# always, not on-failure: a stray SIGTERM (an agent running \`pkill node\`) or a
+# clean exit looks like success to systemd and leaves the service down until
+# someone notices. Matches launchd's KeepAlive on the macOS side.
+Restart=always
+RestartSec=2
 ${envLines}
 
 [Install]
@@ -227,12 +297,12 @@ WantedBy=default.target
   warn("no service manager found — start manually with: work start");
 }
 
-function maybeTunnel() {
+function maybeTunnel(port = appPort) {
   if (yes || have("cloudflared")) return;
   console.log(`
 To reach work from your phone or other devices, put it behind something
 that terminates TLS and authenticates — e.g. a Cloudflare Tunnel with
 Access (https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/)
-pointing at http://localhost:${appPort}, or Tailscale. The server itself has
+pointing at http://localhost:${port}, or Tailscale. The server itself has
 no auth of its own.`);
 }