@dylanpiercey/work 0.0.204 → 0.0.205

package/bin/work.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { doctor, formatDoctor, setupPath } from "../lib/setup/doctor.mjs";
 import { installTool } from "../lib/setup/install.mjs";
+import { dialHost, listenStream } from "../lib/setup/listen.mjs";
 import { commentMarkdown } from "../lib/review/markdown.mjs";
 import { formatInvite, parseInvite } from "../lib/share/manifest.mjs";
 import { duration, pctText } from "../lib/usage/format.mjs";
@@ -82,7 +83,7 @@ switch (command) {
     // definition; WORK_SERVICE_EXEC points it at a checkout's run-prod.sh.
     if (!installService()) {
       process.exitCode = 1;
-    } else if (await waitForServer(serviceEnv().PORT)) {
+    } else if (await waitForServer()) {
       log(`done — http://localhost:${serviceEnv().PORT}`);
     } else {
       warn(
@@ -91,6 +92,12 @@ switch (command) {
       process.exitCode = 1;
     }
     break;
+  case "migrate":
+    // The one-shot cleanups alone, against the service's settings (and the
+    // checkout's .env.local when WORK_SERVICE_EXEC names one). Used by
+    // scripts/update.sh ahead of setup-prod.sh.
+    process.exitCode = migrate();
+    break;
   case "doctor":
     await doctorCmd();
     break;
@@ -135,7 +142,7 @@ switch (command) {
     break;
   default:
     console.log(
-      `work ${pkg.version}\n\nusage: work <setup|install-service|doctor|start|update|usage|workspaces|workspace|repos|procs|review|export|restore|share|join|version> [--json]`,
+      `work ${pkg.version}\n\nusage: work <setup|install-service|migrate|doctor|start|update|usage|workspaces|workspace|repos|procs|review|export|restore|share|join|version> [--json]`,
     );
 }
 
@@ -190,10 +197,17 @@ async function usage() {
 
 // -- workspace read commands (HTTP to the running server) --------------------
 
+/** The running server as this machine reaches it: the service's port, at
+ * the address it listens on. */
+function serverUrl() {
+  const env = serviceEnv();
+  return `http://${dialHost(env.WORK_LISTEN)}:${env.PORT}`;
+}
+
 async function apiGet(path) {
   const port = serviceEnv().PORT;
   try {
-    const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+    const res = await fetch(`${serverUrl()}${path}`, {
       signal: AbortSignal.timeout(30_000),
     });
     if (!res.ok) die(`server answered ${res.status} for ${path}`);
@@ -362,14 +376,32 @@ async function reviewCmd() {
   const { comments = [] } = await apiGet(`/api/workspaces/${ws.id}/review`);
   if (jsonOut) return console.log(JSON.stringify(comments, null, 2));
   if (!comments.length) return console.log("no pending review comments");
-  console.log(commentMarkdown(comments, null));
+  console.log(commentMarkdown(comments, await reviewSections(ws.id, comments)));
+}
+
+/** The diff's sections, which say which lane or PR a comment's lines are
+ * on (by the head it stored) and what a removed line was removed from.
+ * Null when no comment stored a head or the diff cannot be had: those
+ * comments then read as the checkout's rather than failing the command. */
+async function reviewSections(wsId, comments) {
+  if (!comments.some((c) => c.head)) return null;
+  const port = serviceEnv().PORT;
+  try {
+    const res = await fetch(
+      `http://127.0.0.1:${port}/api/workspaces/${wsId}/diff`,
+      { signal: AbortSignal.timeout(60_000) },
+    );
+    return res.ok ? ((await res.json()).sections ?? null) : null;
+  } catch {
+    return null;
+  }
 }
 
 async function apiPost(path, body) {
   const port = serviceEnv().PORT;
   let res;
   try {
-    res = await fetch(`http://127.0.0.1:${port}${path}`, {
+    res = await fetch(`${serverUrl()}${path}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: body === undefined ? undefined : JSON.stringify(body),
@@ -428,8 +460,7 @@ async function exportCmd() {
       );
     }
   }
-  const port = serviceEnv().PORT;
-  const res = await fetch(`http://127.0.0.1:${port}/api/backup/export`);
+  const res = await fetch(`${serverUrl()}/api/backup/export`);
   if (!res.ok) die(`server answered ${res.status} for /api/backup/export`);
   const name =
     positional[0] ||
@@ -558,22 +589,13 @@ function until(iso) {
 async function setup() {
   await fix(await doctor());
 
-  // 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",
-      env: { ...process.env, ...serviceEnv() },
-    });
-  }
+  migrate();
 
   const running = installService();
   const port = serviceEnv().PORT;
   maybeTunnel(port);
   if (running) {
-    if (await waitForServer(port)) log(`done — http://localhost:${port}`);
+    if (await waitForServer()) log(`done — http://localhost:${port}`);
     else
       warn(
         `service started but nothing answered on port ${port} within 30s — check the logs`,
@@ -595,6 +617,22 @@ async function setup() {
   }
 }
 
+/** One-shot cleanups between versions (scripts/migrate.mjs), run 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. A checkout's .env.local sits under both, as it does when its run
+ * script starts the server. Returns the exit status. */
+function migrate() {
+  const script = path.join(pkgRoot, "scripts", "migrate.mjs");
+  if (!fs.existsSync(script)) return 0;
+  return (
+    spawnSync(process.execPath, [script], {
+      stdio: "inherit",
+      env: { ...checkoutEnvLocal(), ...process.env, ...serviceEnv() },
+    }).status ?? 1
+  );
+}
+
 /** The two packages in this tree that carry install scripts: node-pty builds
  * its native binding when there is no prebuild for the platform, and our own
  * postinstall marks the bundled spawn-helper executable. */
@@ -643,11 +681,16 @@ async function doctorCmd() {
     await fix(d);
     d = await doctor();
   }
-  if (args.includes("--json")) return console.log(JSON.stringify(d, null, 2));
-  console.log(formatDoctor(d));
-  const access = accessNote();
-  if (access) warn(access);
-  if (!d.ready) process.exit(1);
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(d, null, 2));
+  } else {
+    console.log(formatDoctor(d));
+    const access = accessNote();
+    if (access) warn(access);
+  }
+  // exitCode, not exit(): a pipe on macOS is written asynchronously, and
+  // exiting at once can cut the JSON short for whatever reads it.
+  if (!d.ready) process.exitCode = 1;
 }
 
 /** Said when the service listens beyond this machine with nothing declared
@@ -738,33 +781,114 @@ function serviceFile() {
       );
 }
 
+/** Whether an installed service with no WORK_LISTEN line was installed
+ * before the this-machine-only default. On Linux its shape tells: under the
+ * default, work.socket binds an address (`127.0.0.1:7171`), where an older
+ * service had no socket or bound a bare port. A launchd agent has no such
+ * tell. */
+function predatesListenDefault() {
+  if (!fs.existsSync(serviceFile())) return false;
+  if (process.platform === "darwin") return true;
+  try {
+    const socket = fs.readFileSync(
+      path.join(path.dirname(serviceFile()), "work.socket"),
+      "utf8",
+    );
+    return /^ListenStream=\d+\s*$/m.test(socket);
+  } catch {
+    return true;
+  }
+}
+
+/** One Environment= line systemd reads back as exactly this value. A value
+ * holding whitespace, a quote, `\` or `%` is quoted, with `\` and `"`
+ * escaped and `%` doubled, since systemd expands specifiers there: bare, a
+ * proxy URL's percent-encoded password, a root with a space or a host list
+ * written `a, b` is cut short or dropped whole. Any other value stays bare,
+ * the form an older CLI reads back (`work-source prod` runs the npm one),
+ * so a setting such a CLI carries is not lost to the quoting. */
+function unitEnvLine(key, value) {
+  const text = String(value);
+  if (!/[\s"'\\%]/.test(text)) return `Environment=${key}=${text}`;
+  const escaped = text.replace(/[\\"]/g, "\\$&").replace(/%/g, "%%");
+  return `Environment="${key}=${escaped}"`;
+}
+
+/** Text for a plist <string>: launchd reads it as XML. */
+function xmlText(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+const XML_ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+
 /** 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. */
-/** work.socket's ListenStream for WORK_LISTEN: this machine only unless
- * set, every interface for `0.0.0.0` / `::` / `*`, else that address. */
-function listenStream(listen, port) {
-  if (!listen) return `127.0.0.1:${port}`;
-  if (listen === "0.0.0.0" || listen === "::" || listen === "*")
-    return String(port);
-  return listen.includes(":") ? `[${listen}]:${port}` : `${listen}:${port}`;
-}
-
+ * every workspace look like it vanished. Values come back unescaped, or the
+ * next setup would write the escapes into the value itself. */
 function installedServiceEnv() {
   const installed = {};
+  let text;
   try {
-    const text = fs.readFileSync(serviceFile(), "utf8");
+    text = fs.readFileSync(serviceFile(), "utf8");
+  } catch {
+    return installed;
+  }
+  if (process.platform === "darwin") {
     const re =
-      process.platform === "darwin"
-        ? /<key>([A-Za-z_]+)<\/key>\s*<string>([^<]*)<\/string>/g
-        : /^Environment=([A-Za-z_]+)=(.*)$/gm;
-    for (const [, key, value] of text.matchAll(re)) installed[key] = value;
-  } catch {}
+      /<key>([A-Za-z_][A-Za-z0-9_]*)<\/key>\s*<string>([^<]*)<\/string>/g;
+    for (const [, key, value] of text.matchAll(re)) {
+      installed[key] = value.replace(
+        /&(amp|lt|gt|quot|apos);/g,
+        (_, name) => XML_ENTITIES[name],
+      );
+    }
+    return installed;
+  }
+  // unitEnvLine's quoted form, or an older service's bare `KEY=value`,
+  // which was never escaped either.
+  const re =
+    /^Environment=(?:"([A-Za-z_][A-Za-z0-9_]*)=((?:[^"\\]|\\.)*)"|([A-Za-z_][A-Za-z0-9_]*)=(.*))$/gm;
+  for (const [, qKey, qValue, key, value] of text.matchAll(re)) {
+    if (qKey) {
+      installed[qKey] = qValue.replace(/\\(.)|%%/g, (_, c) => c ?? "%");
+    } else {
+      installed[key] = value;
+    }
+  }
   return installed;
 }
 
+/** WORK_* from the .env.local of the checkout WORK_SERVICE_EXEC runs, read
+ * as scripts/env-local.sh reads it: that script exports them at start, under
+ * whatever the service sets. Never written into the service, which would
+ * shadow later edits of the file. */
+function checkoutEnvLocal() {
+  const exec = process.env.WORK_SERVICE_EXEC;
+  const out = {};
+  if (!exec) return out;
+  let text = "";
+  try {
+    text = fs.readFileSync(
+      path.join(path.dirname(path.dirname(exec)), ".env.local"),
+      "utf8",
+    );
+  } catch {
+    return out;
+  }
+  for (const line of text.split("\n")) {
+    const m = /^\s*(?:export\s+)?(WORK_[A-Za-z0-9_]*)=(.*)$/.exec(line);
+    if (!m) continue;
+    const quoted = /^"(.*)"$|^'(.*)'$/.exec(m[2]);
+    out[m[1]] ??= quoted ? (quoted[1] ?? quoted[2]) : m[2];
+  }
+  return out;
+}
+
 function serviceEnv() {
   // Network env worth carrying from the installing shell into the service.
   // (Declared here, not at module level: the command dispatch above runs
@@ -796,17 +920,23 @@ function serviceEnv() {
     const value = key in process.env ? process.env[key] : installed[key];
     if (value) env[key] = value;
   }
-  // A new install listens on this machine only. One installed before that
-  // default listened on every interface, and other machines (a phone, the
+  // A new install listens on this machine only, and its service says so, so
+  // that a missing line only ever means a service from before that default.
+  // Those listened on every interface, and other machines (a phone, the
   // proxy in front of it) may be reaching it that way: keep it listening,
   // so they get work's page naming the setting to add (server/access.ts)
   // rather than a connection that is simply refused.
-  if (!("WORK_LISTEN" in process.env) && !installed.WORK_LISTEN) {
-    if (fs.existsSync(serviceFile())) env.WORK_LISTEN = "0.0.0.0";
+  if (!env.WORK_LISTEN) {
+    env.WORK_LISTEN =
+      !("WORK_LISTEN" in process.env) && predatesListenDefault()
+        ? "0.0.0.0"
+        : "127.0.0.1";
   }
   // 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;
+  // would leave the service on the default port anyway. A checkout's run
+  // script serves the port its .env.local names, so the socket binds that
+  // one and setup waits on it.
+  env.PORT = env.WORK_APP_PORT || checkoutEnvLocal().WORK_APP_PORT || appPort;
   // A service starts with none of the shell's network environment. Behind a
   // corporate proxy or a private CA the server's own usage fetches would
   // fail while every CLI in a login-shell pane works, so carry those
@@ -838,16 +968,48 @@ function serviceEnv() {
 function isWorkServerCmd(cmd) {
   if (/\btmux\b/.test(cmd)) return false;
   if (/\bwork(\.mjs)?\s+(setup|update|version)\b/.test(cmd)) return false;
-  return (
+  if (
     /\bwork\.mjs\s+start(?:\s|$)/.test(cmd) ||
     /(?:^|[\s/])work\s+start(?:\s|$)/.test(cmd) ||
-    /run-prod\.sh/.test(cmd) ||
-    /run-local\.sh/.test(cmd) ||
     /--why=work server is running/.test(cmd) ||
-    /--why="work server is running"/.test(cmd) ||
-    (/@dylanpiercey\/work\//.test(cmd) && !/\bnpm\b/.test(cmd)) ||
-    /\/work\/(?:\S*\/)?(?:dist|\.run)\/index\.mjs/.test(cmd)
-  );
+    /--why="work server is running"/.test(cmd)
+  )
+    return true;
+  // A built server or run script, by the absolute path an interpreter was
+  // handed, inside this package or a checkout of it. A path alone says
+  // nothing: `dist/index.mjs` is most node builds' entry, workspaces live
+  // under ~/work, and an editor or pager may have a run script open — each
+  // a process of the user's that setup must not kill.
+  const argv = cmd.split(/\s+/);
+  return argv.some((arg, i) => {
+    if (
+      !/^\/.*\/(?:(?:dist|\.run)\/index\.mjs|scripts\/run-(?:prod|local)\.sh)$/.test(
+        arg,
+      )
+    )
+      return false;
+    const runner = argv
+      .slice(0, i)
+      .reverse()
+      .find((a) => !a.startsWith("-"));
+    if (runner && !/^(?:node|nodejs|bash|sh)$/.test(path.basename(runner)))
+      return false;
+    return inWorkPackage(arg);
+  });
+}
+
+/** Whether `file` lies in a package named as this one is: the nearest
+ * package.json above it that has a name. */
+function inWorkPackage(file) {
+  for (let dir = path.dirname(file); ; dir = path.dirname(dir)) {
+    try {
+      const { name } = JSON.parse(
+        fs.readFileSync(path.join(dir, "package.json"), "utf8"),
+      );
+      if (name) return name === pkg.name;
+    } catch {}
+    if (dir === path.dirname(dir)) return false;
+  }
 }
 
 function pidsListening(port) {
@@ -967,11 +1129,11 @@ function stopOldCopies(port) {
  * used to print at a port that answers a second or two later — which reads as
  * an update that broke the app. Any HTTP reply proves the server is serving;
  * the status the route returns is not this function's business. */
-async function waitForServer(port, timeoutMs = 30_000) {
+async function waitForServer(timeoutMs = 30_000) {
   const deadline = Date.now() + timeoutMs;
   for (;;) {
     try {
-      await fetch(`http://127.0.0.1:${port}/`, {
+      await fetch(`${serverUrl()}/`, {
         redirect: "manual",
         signal: AbortSignal.timeout(2000),
       });
@@ -998,13 +1160,8 @@ function installService() {
     const plist = serviceFile();
     fs.mkdirSync(path.dirname(plist), { recursive: true });
     fs.mkdirSync(path.join(os.homedir(), "Library/Logs"), { recursive: true });
-    const xml = (v) =>
-      String(v)
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
     const envXml = Object.entries(serviceEnv())
-      .map(([k, v]) => `    <key>${k}</key><string>${xml(v)}</string>`)
+      .map(([k, v]) => `    <key>${k}</key><string>${xmlText(v)}</string>`)
       .join("\n");
     fs.writeFileSync(
       plist,
@@ -1014,7 +1171,7 @@ function installService() {
 <dict>
   <key>Label</key><string>dev.work.app</string>
   <key>ProgramArguments</key>
-  <array>${startArgs.map((a) => `<string>${a}</string>`).join("")}</array>
+  <array>${startArgs.map((a) => `<string>${xmlText(a)}</string>`).join("")}</array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
   <key>StandardOutPath</key><string>${os.homedir()}/Library/Logs/work.log</string>
@@ -1072,7 +1229,7 @@ ${envXml}
     const unitDir = path.dirname(unitFile);
     fs.mkdirSync(unitDir, { recursive: true });
     const envLines = Object.entries(serviceEnv())
-      .map(([k, v]) => `Environment=${k}=${v}`)
+      .map(([k, v]) => unitEnvLine(k, v))
       .join("\n");
     const execStart = unitCommand(target);
     // The port is held by work.socket, not the server: a restart swaps the
@@ -1146,7 +1303,7 @@ WantedBy=default.target
 
   warn(
     execOverride
-      ? "no service manager found. Start manually with: scripts/run-prod.sh"
+      ? `no service manager found. Start manually with: ${execOverride}`
       : "no service manager found. Start manually with: work start",
   );
   return false;

package/dist/_CWyeRc54.js

@@ -0,0 +1,2 @@
+import { h as notifySessionsChanged } from "./_C_-lYJlp.js";
+export { notifySessionsChanged };