@dylanpiercey/work 0.0.204 → 0.0.205

package/lib/review/markdown.mjs

@@ -64,8 +64,11 @@ export function commentMarkdown(comments, repos) {
 function commentBlock(c, n, repos) {
   let head = `## ${n}. ${placeOf(c)}`;
   if (c.side === "deletions") {
-    const base = (repos || []).find(
-      (r) => r.worktree === folderOf(c.worktree),
+    // The base of the section the line was removed in: a lane's or a PR's
+    // is not the checkout's.
+    const base = (
+      sectionOf(c, repos) ??
+      (repos || []).find((r) => r.worktree === folderOf(c.worktree))
     )?.base;
     head += base ? ` [removed from ${base}]` : " [removed]";
   }
@@ -88,24 +91,33 @@ function folderOf(worktree) {
   return worktree.split(/[@#]/)[0];
 }
 
-/** The branch a comment's lines are on when that is not the checkout's:
- * the lane or PR section it was made in (by id for older rows, else by
- * the head it stored), or a lane's topic when no section says more.
+/** The section a comment was made in: an older row names it outright; a
+ * newer one by the head it was made at — the first section at that head,
+ * so a lane still level with the checkout reads as the checkout, which it
+ * is.
  * @param {Comment} c
  * @param {Repo[] | null | undefined} repos */
-function branchOf(c, repos) {
+function sectionOf(c, repos) {
   const folder = folderOf(c.worktree);
   const list = repos || [];
-  // An older row names its section outright; a newer one by the head it
-  // was made at — the first section at that head, so a lane still level
-  // with the checkout reads as the checkout, which it is.
-  const section =
+  return (
     (c.worktree !== folder
       ? list.find((r) => r.id === c.worktree)
       : undefined) ??
     (c.head
       ? list.find((r) => r.worktree === folder && r.head === c.head)
-      : undefined);
+      : undefined)
+  );
+}
+
+/** The branch a comment's lines are on when that is not the checkout's:
+ * the lane or PR section it was made in (`sectionOf`), or a lane's topic
+ * when no section says more.
+ * @param {Comment} c
+ * @param {Repo[] | null | undefined} repos */
+function branchOf(c, repos) {
+  const folder = folderOf(c.worktree);
+  const section = sectionOf(c, repos);
   if (section && section.id && section.id !== folder) {
     const name = section.pr?.headRefName || section.headRef || section.branch;
     const pr = section.pr ? ` #${section.pr.number}` : "";

package/lib/setup/doctor.d.mts

@@ -32,6 +32,9 @@ export interface GithubHostStatus {
   /** Orgs whose SAML SSO this host's token still needs to authorize.
    * Populated by the server setup wrapper, not doctor.mjs itself. */
   sso?: { org: string; host: string; authorizeUrl: string }[];
+  /** gh itself has this host (its hosts.yml), so it is listed whatever
+   * Settings holds. Populated by the server setup wrapper. */
+  ghKnown?: boolean;
 }
 export interface Doctor {
   ready: boolean;
@@ -40,6 +43,8 @@ export interface Doctor {
   tools: DoctorTool[];
   agents: DoctorAgent[];
   github: GithubHostStatus[];
+  /** Whether the server can keep this Linux host awake; null elsewhere. */
+  awake: boolean | null;
 }
 export function setupPath(base?: string): string;
 export function which(bin: string): string | null;

package/lib/setup/doctor.mjs

@@ -290,6 +290,27 @@ async function githubHostStatus(host) {
       };
 }
 
+/** Whether the server can keep this Linux host awake (src/server/awake.ts
+ * holds the lock itself). Its last resort, an `idle` lock, is one polkit
+ * grants anyone, so failing that means nothing holds the host while work
+ * runs, and a suspend looks like the network dropping. Null off Linux, where
+ * caffeinate asks no one. */
+async function canStayAwake() {
+  if (process.platform !== "linux") return null;
+  const { ok } = await run(
+    "systemd-inhibit",
+    [
+      "--what=idle",
+      "--mode=block",
+      "--who=work",
+      "--why=work doctor probe",
+      "true",
+    ],
+    { timeout: 5000 },
+  );
+  return ok;
+}
+
 /**
  * Full readiness snapshot.
  *
@@ -302,9 +323,10 @@ export async function doctor(opts = {}) {
     ...(opts.hosts || []),
     ...ghKnownHosts(),
   ]);
-  const [versions, github] = await Promise.all([
+  const [versions, github, awake] = await Promise.all([
     miseVersions(),
     Promise.all([...hostSet].map(githubHostStatus)),
+    canStayAwake(),
   ]);
 
   const tools = TOOLS.map((t) => {
@@ -340,6 +362,7 @@ export async function doctor(opts = {}) {
     tools,
     agents,
     github,
+    awake,
   };
 }
 
@@ -366,6 +389,13 @@ export function formatDoctor(d) {
       `${a.label.padEnd(11)}${mark(a.installed)} ${a.installed ? a.instances.map((i) => `${i.command} (${i.path})`).join(", ") : "not installed"}`,
     );
   }
+  // Said only when nothing holds the host: not a readiness gate, since
+  // work runs either way, but the one place a headless host would say so.
+  if (d.awake === false) {
+    lines.push(
+      `sleep      ✗ nothing keeps this host awake: systemd-inhibit is missing or could not take a lock, so the host can suspend under work. Allow org.freedesktop.login1.inhibit-block-idle (a polkit rule), or keep the host up: sudo systemctl mask sleep.target suspend.target`,
+    );
+  }
   lines.push("");
   lines.push(d.ready ? "ready" : `not ready, missing: ${d.missing.join(", ")}`);
   return lines.join("\n");

package/lib/setup/install.mjs

@@ -2,7 +2,7 @@
 // Wraps mise, gh, and the vendors' own agent installers — never reimplements
 // them. Every command streams its output through `log` so a terminal and the
 // Settings page see the same lines. Plain node, no dependencies.
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -47,25 +47,84 @@ export function runStreaming(
     child.stderr?.on("data", onData);
     if (input) child.stdin.write(input);
     child.stdin.end();
-    const timer = setTimeout(() => child.kill("SIGTERM"), timeout);
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    child.on("close", (code) => {
+    let timedOut = false;
+    // The whole tree, not just the child: an installer's `curl` or a tool's
+    // forked worker outlives the shell that started it.
+    const timer = setTimeout(() => {
+      timedOut = true;
+      for (const pid of [...descendants(child.pid), child.pid]) {
+        try {
+          process.kill(pid, "SIGTERM");
+        } catch {}
+      }
+    }, timeout);
+    let drain;
+    let settled = false;
+    const settle = (code) => {
+      if (settled) return;
+      settled = true;
       clearTimeout(timer);
+      clearTimeout(drain);
+      child.stdout?.destroy();
+      child.stderr?.destroy();
       if (buf.trim()) onData("\n");
-      if (code === 0) resolve(lines);
+      if (code === 0 && !timedOut) resolve(lines);
       else
         reject(
           new Error(
-            `${cmd} ${args.join(" ")} exited ${code}${lines.length ? `: ${lines[lines.length - 1]}` : ""}`,
+            `${cmd} ${args.join(" ")} ${timedOut ? `timed out after ${Math.round(timeout / 1000)}s` : `exited ${code}`}${lines.length ? `: ${lines[lines.length - 1]}` : ""}`,
           ),
         );
+    };
+    child.on("error", (err) => {
+      settled = true;
+      clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", settle);
+    // `close` waits for every process holding the output pipes, and one the
+    // child left behind can hold them forever: a moment after the child
+    // itself exits is as long as its output is waited for. Callers hold
+    // locks across this call (mise, skills).
+    child.on("exit", (code) => {
+      drain = setTimeout(() => settle(code), 1000);
     });
   });
 }
 
+/** Every process under `pid`, read from one `ps` listing (Linux and macOS
+ * alike), so a timeout can stop the tree without moving the child into a
+ * process group of its own — which would also take it off the terminal a
+ * `work setup` runs in, and out of reach of that terminal's Ctrl-C. */
+function descendants(pid) {
+  if (!pid) return [];
+  let out = "";
+  try {
+    out = execFileSync("ps", ["-A", "-o", "pid=", "-o", "ppid="], {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+  } catch {
+    return [];
+  }
+  const children = new Map();
+  for (const line of out.split("\n")) {
+    const [child, parent] = line.trim().split(/\s+/).map(Number);
+    if (!child) continue;
+    if (!children.has(parent)) children.set(parent, []);
+    children.get(parent).push(child);
+  }
+  const found = [];
+  const walk = (p) => {
+    for (const c of children.get(p) || []) {
+      found.push(c);
+      walk(c);
+    }
+  };
+  walk(pid);
+  return found;
+}
+
 /** Fetch a vendor install script to a temp file and run it with `shell`.
  * Same effect as the documented `curl … | bash`, without piping a network
  * stream into a login shell: the URL is pinned in the catalog and the

package/lib/setup/listen.d.mts

@@ -0,0 +1,5 @@
+export function listenStream(
+  listen: string | undefined,
+  port: string | number,
+): string;
+export function dialHost(listen: string | undefined): string;

package/lib/setup/listen.mjs

@@ -0,0 +1,23 @@
+// Where work listens (WORK_LISTEN) and where this machine reaches it: one
+// rule for the CLI (the socket unit, its own requests to the server), the
+// server (the hooks it writes for panes and bare caches) and migrate.mjs.
+
+/** Addresses that mean every interface. */
+const EVERY = new Set(["0.0.0.0", "::", "*"]);
+
+/** work.socket's ListenStream for WORK_LISTEN: this machine only unless
+ * set, every interface for `0.0.0.0` / `::` / `*`, else that address. */
+export function listenStream(listen, port) {
+  if (!listen) return `127.0.0.1:${port}`;
+  if (EVERY.has(listen)) return String(port);
+  return listen.includes(":") ? `[${listen}]:${port}` : `${listen}:${port}`;
+}
+
+/** The host to dial the server at, for WORK_LISTEN: loopback when it
+ * listens on every interface or is unset, else the one address it listens
+ * on (a server bound to `::1` or a LAN address refuses 127.0.0.1), bracketed
+ * when IPv6 so it can go in a URL. */
+export function dialHost(listen) {
+  if (!listen || EVERY.has(listen)) return "127.0.0.1";
+  return listen.includes(":") ? `[${listen}]` : listen;
+}

package/lib/share/manifest.mjs

@@ -67,10 +67,15 @@ export function decodeRepo(entry) {
   } else return null;
   full = full.trim();
   if (!REPO_RE.test(full)) return null;
-  // A host is case-insensitive; the configured list is lowercase.
+  // A host is case-insensitive; the configured list is lowercase. And
+  // github.com's is never written: `github.com/o/r` kept as such is a
+  // second name for `o/r`, which everything keyed by full name tells apart.
   const parts = full.split("/");
-  if (parts.length === 3)
-    full = [parts[0].toLowerCase(), parts[1], parts[2]].join("/");
+  if (parts.length === 3) {
+    const host = parts[0].toLowerCase();
+    const name = `${parts[1]}/${parts[2]}`;
+    full = host === "github.com" ? name : `${host}/${name}`;
+  }
   if (base !== undefined && !BRANCH_RE.test(base)) return null;
   if (dir !== undefined && !DIR_RE.test(dir)) return null;
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dylanpiercey/work",
-  "version": "0.0.204",
+  "version": "0.0.205",
   "type": "module",
   "description": "Web GUI for agentic dev workspaces",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "dev": "marko-run dev src/entry.ts",
     "postinstall": "chmod +x node_modules/node-pty/prebuilds/*/spawn-helper node_modules/node-pty/build/Release/spawn-helper 2>/dev/null || true",
     "build": "node scripts/agents-catalog.mjs && marko-run build src/entry.ts",
-    "check": "node scripts/agents-catalog.mjs && mtc",
+    "check": "node scripts/agents-catalog.mjs && rm -f tsconfig.tsbuildinfo && mtc",
     "preview": "PORT=7171 node dist/index.mjs",
     "format": "prettier . -w",
     "format:check": "prettier --check ."
@@ -39,10 +39,10 @@
   },
   "devDependencies": {
     "@lobehub/icons-static-svg": "^1.95.1",
-    "@marko/run": "^0.11.12",
+    "@marko/run": "^0.11.13",
     "@marko/run-adapter-node": "^2.0.6",
     "@marko/type-check": "^3.2.1",
-    "@pierre/diffs": "1.4.3",
+    "@pierre/diffs": "1.5.1",
     "@pierre/trees": "1.0.0-beta.6",
     "@types/compression": "^1.8.1",
     "@types/node": "^26.6.2",
@@ -58,14 +58,14 @@
     "@xterm/xterm": "^6.0.0",
     "compression": "^1.8.2",
     "iconoir": "^7.12.1",
-    "marko": "^6.3.52",
+    "marko": "^6.3.56",
     "playwright": "^1.63.0",
     "prettier": "^3.9.9",
-    "prettier-plugin-marko": "^4.1.1",
+    "prettier-plugin-marko": "^4.1.3",
     "serve-static": "^2.2.1",
     "typescript": "^6.0.3",
     "valibot": "^1.5.0",
-    "vite": "^8.3.0",
+    "vite": "^8.3.1",
     "web-push": "^3.6.7",
     "ws": "^8.21.3"
   }