@dylanpiercey/work 0.2.41 → 0.2.43

package/bin/cli/stack.mjs

@@ -8,26 +8,40 @@ function recipe(branch) {
 
 Stack only when the user asks, or when a change of several hundred lines
 splits into parts each worth merging alone; never a layer per commit.
+A stack is a convention, plain branches and PRs: each layer is cut from
+the one below and its PR is based on it, which is how GitHub and work's
+review both read a stack.
 
-- The working branch (${branch}) stays the top; cut layers below it, bottom
-  first, as ${branch}-<layer>:
-    gh stack init --base <base> <layers…> ${branch}
-  (after \`gh stack unstack --local\` if a stack exists).
+- The working branch (${branch}) stays the top; cut layers below it from
+  its own commits, bottom first, as ${branch}-<layer>, each with its PR's
+  base as gh reads it:
+    git branch ${branch}-<layer> <its last commit>
+    git config branch.${branch}-<layer>.gh-merge-base <layer below, else base>
+- The user reviews it here a layer at a time, bottom first: link each as
+  [<layer>](/w/<id>/review?section=<repo>@<layer>) (\`work branches\`
+  lists them).
 - Never check a layer out. Edit one by \`git commit --fixup <sha>\` on the
-  top, then:
+  top, then (every layer moves with the commits it holds):
     GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash --update-refs origin/<base>
-- \`gh stack sync\` / \`gh stack rebase\` switch branches: run them in topic
-  worktrees only. Leave the local <base> gh-stack keeps as trunk.
-- Merge a layer with \`gh stack merge <pr> --squash\` or on the web
-  (\`gh pr merge\` refuses it), then, on the top:
-    old=$(git rev-parse origin/${branch})
+  A base that moved is \`git rebase --update-refs origin/<base>\` alike.
+- Nothing goes up front. Push a layer and open its PR only when the user
+  says it is ready, after reviewing it, bottom first and never past a
+  layer still local (a PR's base must be on GitHub):
+    git push origin ${branch}-<layer>
+    gh pr create --head ${branch}-<layer> --base <layer below, else base>
+  The top goes last, its PR based on the last layer (one already open:
+  \`gh pr edit --base\`). After a rebase, force-push only what is pushed:
+    git push --force-with-lease --atomic origin <pushed branches…>
+- Land bottom first, deleting the merged branch so GitHub moves the PR
+  above onto <base> (on the web, delete it after merging):
+    cut=$(git rev-parse ${branch}-<layer>)
+    gh pr merge <pr> --squash --delete-branch
+  then, on the top, move the rest onto the squash, and force-push what of
+  it is pushed:
     git fetch
-    git branch -f <layer> origin/<layer>     # for each remaining layer
-    git branch -D <merged-layer>
-    git rebase --onto origin/${branch} $old
-- Once the top merges: \`gh stack unstack --local\`.
-- Link a layer for review as [<layer>](/w/<id>/review?section=<repo>@<layer>);
-  \`work branches\` lists every layer with its link.`;
+    git rebase --update-refs --onto origin/<base> $cut
+    git config branch.<layer above>.gh-merge-base <base>   # not the top's
+- A lane stacks the same way, in its worktree, its branch the top.`;
 }
 
 export const commands = [
@@ -35,9 +49,9 @@ export const commands = [
     name: "stack",
     summary: "how to stack branches in this workspace (prints the recipe)",
     help: `work stack [id|name]
-  Prints how to stack branches with gh-stack here, with the workspace's
-  branch filled in: when to, cutting layers, editing one without checking
-  it out, merging a layer and rebasing the rest.`,
+  Prints how to stack branches here, as plain branches and PRs, with the
+  workspace's branch filled in: when to, cutting layers, editing one
+  without checking it out, merging a layer and rebasing the rest.`,
     async run(ctx) {
       let branch = "<workspace-branch>";
       try {

package/bin/cli/topic.mjs

@@ -84,7 +84,7 @@ function mergeBases(dir) {
  * copy. This workspace's own branches (it, and the topics one stacks on)
  * go by the local one: they may never be pushed, and here is where they
  * move. Any other (the repo's base) goes by origin's: a bare cache's local
- * copy of it is as old as the clone, or as gh-stack's trunk. */
+ * copy of it is as old as the clone. */
 function baseRef(dir, name, ws, foreign) {
   const local = has(dir, `refs/heads/${name}`) ? name : null;
   const remote = has(dir, `refs/remotes/origin/${name}`)

package/bin/work.mjs

@@ -76,6 +76,7 @@ import {
   applyPlan,
   dropText,
   firewallProbe,
+  programOf,
   serviceNode,
 } from "../lib/setup/firewall.mjs";
 import { installTool, repairGhHelpers } from "../lib/setup/install.mjs";
@@ -958,6 +959,7 @@ function allowScriptsArgs() {
 
 async function update() {
   log("updating @dylanpiercey/work");
+  const before = serviceCli();
   // `--prefer-online`: npm serves `latest` from a cached packument for a
   // few minutes after a publish, so an update right behind a release
   // reinstalled the version already running.
@@ -974,8 +976,19 @@ async function update() {
     ],
     { stdio },
   );
-  // Re-exec the (possibly new) CLI to finish with fresh code.
-  sh("work", [
+  // Finish with the CLI that npm just installed, found where that npm
+  // installs, never `work` by name: the npm and the `work` first on PATH
+  // can be two nodes' (a Homebrew npm ahead of mise's shims), and the
+  // other install's setup points the service back at itself, so every
+  // update left the service on the old release.
+  const root = execFileSync("npm", ["root", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", 2],
+  }).trim();
+  const cli = path.join(root, "@dylanpiercey", "work", "bin", "work.mjs");
+  if (!fs.existsSync(cli))
+    die(`npm installed into ${root}, but there is no ${cli}`);
+  sh(cli, [
     "setup",
     ...(yes ? ["--yes"] : []),
     ...args.filter((a) =>
@@ -991,6 +1004,21 @@ async function update() {
     ...flagValues("--allow-host").flatMap((h) => ["--allow-host", h]),
     ...flagValues("--disallow-host").flatMap((h) => ["--disallow-host", h]),
   ]);
+  // The service now runs what npm updated; an install it or this shell ran
+  // before is left behind at its old release.
+  const now = realpathOr(cli);
+  const left = new Map();
+  for (const [w, was] of [
+    [before, "the service ran"],
+    [installAt(fileURLToPath(import.meta.url)), "`work` here ran"],
+  ]) {
+    if (w?.prefix && w.real !== now && !left.has(w.real))
+      left.set(
+        w.real,
+        `${was} ${tilde(w.path)} (${w.version}), not the install npm updated (${tilde(cli)}); remove it: ${removeHint(w)}`,
+      );
+  }
+  for (const note of left.values()) warn(note);
 }
 
 /** Machine readiness from lib/setup — the same probe the Settings page runs. */
@@ -1015,38 +1043,39 @@ async function doctorCmd() {
 }
 
 /**
- * This `work`, every other one on PATH (the first is what `work` runs),
- * each with its version, and the version the running service reports
- * (null when none answers). A package manager's global left behind — a
- * Homebrew node's under mise's — shadows the one kept up to date, and the
- * doctor it runs is then old code describing a machine it no longer knows.
+ * This `work`, every other one on PATH (the first is what `work` runs) or
+ * on the service's, each with the install it runs and its version, and the
+ * service: the CLI its definition runs and the release the running one
+ * reports. A package manager's global left behind — a Homebrew node's
+ * under mise's — shadows the one kept up to date, and the doctor it runs is
+ * then old code describing a machine it no longer knows.
  */
 async function workInstalls() {
-  const self = realpathOr(fileURLToPath(import.meta.url));
+  const self = installAt(fileURLToPath(import.meta.url));
+  const shell = (process.env.PATH || "").split(path.delimiter);
+  const servicePath = (installedServiceEnv().PATH || "").split(path.delimiter);
   const onPath = [];
   const seen = new Set();
-  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+  for (const dir of new Set([...shell, ...servicePath])) {
     if (!dir) continue;
-    const file = path.join(dir, "work");
-    let real;
-    try {
-      if (!fs.statSync(file).isFile()) continue;
-      real = fs.realpathSync(file);
-    } catch {
-      continue;
-    }
-    if (seen.has(real)) continue;
-    seen.add(real);
-    onPath.push({ path: file, real, version: installVersion(real, file) });
-  }
-  let service = null;
+    const w = workOnPath(path.join(dir, "work"));
+    if (!w || seen.has(w.real)) continue;
+    seen.add(w.real);
+    onPath.push(shell.includes(dir) ? w : { ...w, servicePath: true });
+  }
+  // A service that answers without a version is from before /api/boot
+  // carried one: older than any CLI that asks.
+  const service = { answered: false, version: null, cli: serviceCli() };
   try {
     const res = await fetch(`${serverUrl()}/api/boot`, {
       signal: AbortSignal.timeout(2000),
     });
-    if (res.ok) service = (await res.json()).version ?? null;
+    if (res.ok) {
+      service.version = (await res.json()).version ?? null;
+      service.answered = true;
+    }
   } catch {}
-  return { self: { path: self, version: pkg.version }, onPath, service };
+  return { self, onPath, service };
 }
 
 function realpathOr(file) {
@@ -1057,28 +1086,118 @@ function realpathOr(file) {
   }
 }
 
-/** An install's version: an npm global's bin links into the package, whose
- * package.json says; a shim (mise's) is asked. */
-function installVersion(real, file) {
+/** The package of work a file is part of, read from its package.json and
+ * never by running anything: `prefix` is the npm prefix whose global it
+ * is, null for a checkout. */
+function installAt(file) {
+  const real = realpathOr(file);
   let dir = path.dirname(real);
   for (let i = 0; i < 3; i++) {
     try {
       const p = JSON.parse(fs.readFileSync(path.join(dir, "package.json")));
-      if (p.name === "@dylanpiercey/work") return p.version ?? null;
+      if (p.name === "@dylanpiercey/work") {
+        const prefix = /^(.*)\/lib\/node_modules\/@dylanpiercey\/work$/.exec(
+          dir,
+        )?.[1];
+        return {
+          path: file,
+          real,
+          version: p.version ?? null,
+          prefix: prefix ?? null,
+        };
+      }
     } catch {}
     dir = path.dirname(dir);
   }
+  return null;
+}
+
+/** Version managers whose shims stand in for `work`. A shim is the
+ * manager's own binary (mise links every shim to itself) or a script that
+ * hands off to it, so neither its path nor its target is the install: the
+ * manager's `which` names that. A global uninstalled from one of its
+ * nodes leaves the shim until a reshim. */
+function versionManagers() {
+  return [
+    {
+      id: "mise",
+      shim: (file, real) => path.basename(real) === "mise",
+      which: (real) => [real, ["which", "work"]],
+      installs: /\/mise\/installs\/node\//,
+      reshim: "mise reshim",
+    },
+    {
+      id: "asdf",
+      shim: (file) => /\/\.asdf\/shims$/.test(path.dirname(file)),
+      which: () => ["asdf", ["which", "work"]],
+      installs: /\/\.asdf\/installs\/nodejs\//,
+      reshim: "asdf reshim nodejs",
+    },
+    {
+      id: "nodenv",
+      shim: (file) => /\/\.nodenv\/shims$/.test(path.dirname(file)),
+      which: () => ["nodenv", ["which", "work"]],
+      installs: /\/\.nodenv\/versions\//,
+      reshim: "nodenv rehash",
+    },
+  ];
+}
+
+/** The install a `work` on PATH runs: an npm global's bin links into the
+ * package, a shim's is the one its manager names, and anything else is
+ * asked its version. */
+function workOnPath(file) {
+  try {
+    if (!fs.statSync(file).isFile()) return null;
+  } catch {
+    return null;
+  }
+  const own = installAt(file);
+  if (own) return own;
+  const real = realpathOr(file);
+  const manager = versionManagers().find((m) => m.shim(file, real));
+  if (manager) {
+    const [bin, argv] = manager.which(real);
+    const out = spawnSync(bin, argv, { encoding: "utf8", timeout: 5000 });
+    const target = out.status === 0 && out.stdout.trim();
+    const w = target && installAt(target);
+    if (w) return { ...w, path: file, manager: manager.id };
+  }
   const out = spawnSync(file, ["version"], { encoding: "utf8", timeout: 5000 });
-  return /^\d+\.\d+\.\d+\S*/.exec((out.stdout || "").trim())?.[0] ?? null;
+  const version = /^\d+\.\d+\.\d+\S*/.exec((out.stdout || "").trim())?.[0];
+  return { path: file, real, version: version ?? null, prefix: null };
+}
+
+/** The work the service definition runs (`[caffeinate -s] <cli> start`,
+ * or a checkout's run script under work-source local): the first program
+ * in its argv that is part of a work package. */
+function serviceCli() {
+  let text;
+  try {
+    text = fs.readFileSync(serviceFile(), "utf8");
+  } catch {
+    return null;
+  }
+  for (const arg of programOf(text)) {
+    const w = path.isAbsolute(arg) && installAt(arg);
+    if (w) return w;
+  }
+  return null;
 }
 
-/** How to remove an install: the npm beside the node whose global it is. */
-function removeHint(real) {
-  const m =
-    /^(.*)\/lib\/node_modules\/@dylanpiercey\/work\/bin\/work\.mjs$/.exec(real);
-  return m
-    ? `${m[1]}/bin/npm uninstall -g @dylanpiercey/work`
-    : `remove ${real}`;
+/** How to remove an npm global of work: npm's uninstall at the prefix it
+ * is in (named: the npm first on PATH may be another node's, whose own
+ * prefix holds some other install), then its version manager's reshim.
+ * Null for anything else, which is not this CLI's to remove. */
+function removeHint(w) {
+  if (!w.prefix) return null;
+  const manager = versionManagers().find(
+    (m) => m.id === w.manager || m.installs.test(`${w.prefix}/`),
+  );
+  const prefix = /^[\w@%+=:,./-]+$/.test(w.prefix)
+    ? w.prefix
+    : `'${w.prefix.replace(/'/g, `'\\''`)}'`;
+  return `npm uninstall -g --prefix ${prefix} @dylanpiercey/work${manager ? ` && ${manager.reshim}` : ""}`;
 }
 
 function newest(versions) {
@@ -1090,23 +1209,56 @@ function newest(versions) {
   }, null);
 }
 
-/** The doctor's warnings about which `work` this is. */
+/** The doctor's warnings about which `work` this is and which the service
+ * runs. */
 function installNotes({ self, onPath, service }) {
   const notes = [];
-  if (service && service !== self.version) {
-    const theirs = onPath.find((w) => w.version === service);
+  const runs = service.cli;
+  // The newest install here is the one to keep: an update installs it,
+  // and whatever else is here was left behind, the service's included.
+  const current = newest([self.version, ...onPath.map((w) => w.version)]);
+  const behind = (v) => v !== current && newest([v, current]) === current;
+  const keep = [...onPath.filter((w) => !w.servicePath), self].find(
+    (w) => w.prefix && w.version === current,
+  );
+  // `setup` from the install kept points the service at it, unless the
+  // service runs a checkout (work-source local), which setup would undo.
+  const move =
+    keep &&
+    runs?.prefix &&
+    `\`${keep === onPath[0] ? "work" : keep.path} setup\``;
+  if (service.answered && service.version !== self.version) {
+    const theirs = runs ?? onPath.find((w) => w.version === service.version);
+    notes.push(
+      `this work is ${self.version} (${tilde(self.path)}), but the running service is ${service.version ?? "older (it does not report its version)"}, so what this doctor says is an older or newer release's${theirs ? `: the service's is ${tilde(theirs.path)}` : ""}${move && behind(service.version) ? `; run ${move} to move it to ${current}` : ""}`,
+    );
+  } else if (!service.answered && runs && runs.version !== self.version) {
     notes.push(
-      `this work is ${self.version} (${tilde(self.path)}), but the running service is ${service}, so what this doctor says is an older or newer release's${theirs ? `: the service's is ${tilde(theirs.path)}` : ""}`,
+      `the service is set to run ${tilde(runs.path)} (${runs.version ?? "unknown version"}), not this work (${self.version}, ${tilde(self.path)})${move && behind(runs.version) ? `; run ${move} to move it to ${current}` : ""}`,
     );
   }
   if (onPath.length > 1) {
-    // A stray is one at another release than the service's (or, with no
-    // service answering, than the newest here).
-    const current = service ?? newest(onPath.map((w) => w.version));
-    const lines = onPath.map(
-      (w, i) =>
-        `  ${tilde(w.path)} → ${w.version ?? "unknown version"}${i === 0 ? "  (what \`work\` runs)" : ""}${w.version === current ? "" : `\n      remove: ${removeHint(w.real)}`}`,
-    );
+    const lines = onPath.map((w, i) => {
+      const tags = [
+        i === 0 && !w.servicePath && "what `work` runs",
+        w.servicePath && "on the service's PATH",
+        w.real === runs?.real && "the service's",
+      ].filter(Boolean);
+      const hint = removeHint(w);
+      // The service's own install goes only once the service is off it:
+      // removed first, it would stop the service.
+      const fix =
+        w.version === current
+          ? ""
+          : !hint
+            ? "not an npm global: remove it the way it was installed"
+            : w.real !== runs?.real
+              ? `remove: ${hint}`
+              : move
+                ? `remove, once ${move} has moved the service off it: ${hint}`
+                : "";
+      return `  ${tilde(w.path)} → ${w.version ?? "unknown version"}${tags.length ? `  (${tags.join(", ")})` : ""}${fix ? `\n      ${fix}` : ""}`;
+    });
     notes.push(`more than one work is on PATH:\n${lines.join("\n")}`);
   }
   return notes;

package/dist/_BKkT73fv.js

@@ -0,0 +1,2 @@
+import { J as notifySessionsChanged } from "./_Cv5RrCSW.js";
+export { notifySessionsChanged };

package/dist/_BviTiVOB.js

@@ -0,0 +1,2 @@
+import { f as teamsOf } from "./_DuwPQCOE.js";
+export { teamsOf };

package/dist/{_DuADlWik.js → _Cv5RrCSW.js}

@@ -1129,11 +1129,6 @@ var TOOLS = [
 		mise: "gh",
 		required: true
 	},
-	{
-		id: "gh-stack",
-		label: "gh stack",
-		ghExtension: "github/gh-stack"
-	},
 	{
 		id: "ripgrep",
 		label: "ripgrep",
@@ -2321,19 +2316,6 @@ async function canStayAwake() {
 	], { timeout: 5e3 });
 	return ok;
 }
-/** gh's extensions, repo → version (`gh extension list`: name, repo,
-* version by tabs). Null without gh, which is what installs them. */
-async function ghExtensions() {
-	if (!which("gh")) return null;
-	const { ok, stdout } = await run("gh", ["extension", "list"]);
-	if (!ok) return /* @__PURE__ */ new Map();
-	const out = /* @__PURE__ */ new Map();
-	for (const line of stdout.split("\n")) {
-		const [, repo, version = ""] = line.split("	");
-		if (repo) out.set(repo.trim(), version.trim().replace(/^v/, ""));
-	}
-	return out;
-}
 function parseJson(text) {
 	try {
 		return JSON.parse(text);
@@ -2386,11 +2368,10 @@ async function doctor(opts = {}) {
 		...opts.hosts || [],
 		...ghKnownHosts()
 	]);
-	const [versions, github, awake, extensions, helpers, tailscale, firewall] = await Promise.all([
+	const [versions, github, awake, helpers, tailscale, firewall] = await Promise.all([
 		miseVersions(),
 		Promise.all([...hostSet].map(githubHostStatus)),
 		canStayAwake(),
-		ghExtensions(),
 		staleGhHelpers(),
 		tailscaleProbe(opts),
 		opts.firewall !== void 0 ? opts.firewall : firewallProbe({
@@ -2401,17 +2382,6 @@ async function doctor(opts = {}) {
 		})
 	]);
 	const tools = TOOLS.map((t) => {
-		if (t.ghExtension) {
-			const version = extensions?.get(t.ghExtension);
-			return {
-				id: t.id,
-				label: t.label,
-				required: !!t.required,
-				installed: version !== void 0,
-				version: version || void 0,
-				installable: extensions !== null
-			};
-		}
 		const found = which(t.bin);
 		return {
 			id: t.id,
@@ -9508,7 +9478,7 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_DDikKLG_.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_BKkT73fv.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -14839,15 +14809,6 @@ async function installMise(opts = {}) {
 	await runRemoteScript("https://mise.run", "sh", opts);
 	if (!which("mise")) throw new Error("mise install finished but binary not found");
 }
-/** A catalog tool that is a gh extension: gh, not mise, owns it. The name
-* gh's upgrade and remove take is the repo's less its `gh-`. */
-function ghExtension(idOrName) {
-	const repo = toolById(idOrName)?.ghExtension;
-	return repo ? {
-		repo,
-		name: repo.slice(repo.indexOf("/") + 1).replace(/^gh-/, "")
-	} : null;
-}
 function miseName(idOrName) {
 	const t = toolById(idOrName);
 	if (t && !t.mise) throw new Error(`${t.label} is a system package. Install it with the system package manager`);
@@ -14856,16 +14817,6 @@ function miseName(idOrName) {
 /** `mise use -g name@version` — installs (or re-pins) a global tool. Accepts
 * catalog ids or any mise registry short name (Settings search). */
 async function installTool(idOrName, { version = "latest", ...opts } = {}) {
-	const ext = ghExtension(idOrName);
-	if (ext) {
-		opts.log?.(`gh extension install ${ext.repo}`);
-		await runStreaming("gh", [
-			"extension",
-			"install",
-			ext.repo
-		], opts);
-		return;
-	}
 	await installMise(opts);
 	const name = miseName(idOrName);
 	opts.log?.(`mise use -g ${name}@${version}`);
@@ -14879,16 +14830,6 @@ async function installTool(idOrName, { version = "latest", ...opts } = {}) {
 /** Move to the newest release and rewrite the global pin to match
 * (`--bump`), so an exact pin such as `1.5.0` updates too. */
 async function updateTool(idOrName, opts = {}) {
-	const ext = ghExtension(idOrName);
-	if (ext) {
-		opts.log?.(`gh extension upgrade ${ext.name}`);
-		await runStreaming("gh", [
-			"extension",
-			"upgrade",
-			ext.name
-		], opts);
-		return;
-	}
 	const name = miseName(idOrName);
 	opts.log?.(`mise upgrade --bump ${name}`);
 	await runStreaming("mise", [
@@ -14902,16 +14843,6 @@ async function updateTool(idOrName, opts = {}) {
 async function removeTool(idOrName, opts = {}) {
 	const t = toolById(idOrName);
 	if (t?.required) throw new Error(`${t.label} is required`);
-	const ext = ghExtension(idOrName);
-	if (ext) {
-		opts.log?.(`gh extension remove ${ext.name}`);
-		await runStreaming("gh", [
-			"extension",
-			"remove",
-			ext.name
-		], opts);
-		return;
-	}
 	const name = miseName(idOrName);
 	opts.log?.(`mise unuse -g ${name}`);
 	await runStreaming("mise", [
@@ -17645,7 +17576,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_ENqPMLjD.js");
+		const { teamsOf } = await import("./_BviTiVOB.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({