@dylanpiercey/work 0.0.47 → 0.0.48

package/lib/setup/catalog.d.mts

@@ -0,0 +1,22 @@
+export interface ToolSpec {
+  id: string;
+  label: string;
+  bin: string;
+  mise?: string;
+  required?: boolean;
+  system?: boolean;
+}
+export interface AgentSpec {
+  id: string;
+  label: string;
+  bins: string[];
+  install: { url: string; shell: "bash" | "sh" };
+}
+export const TOOLS: ToolSpec[];
+export const AGENTS: AgentSpec[];
+export const DEFAULT_GITHUB_HOST: string;
+export function toolById(id: string): ToolSpec | null;
+export function agentById(id: string): AgentSpec | null;
+export function parseAgentId(id: string): { family: AgentSpec; suffix: string } | null;
+export function agentCommand(id: string): string | null;
+export function agentLabel(id: string): string;

package/lib/setup/catalog.mjs

@@ -0,0 +1,72 @@
+// The one list of what a `work` machine should have. Consumed by
+// `work setup` / `work doctor` (bin/work.mjs, plain node) and by the server
+// (src/server/setup.ts) so the CLI, the installer, and the Settings page can
+// never disagree about what "ready" means. Keep it declarative: detection and
+// installation live in doctor.mjs / install.mjs, this file only describes.
+
+/** Machine tools. `required` ones gate readiness; the rest are the utilities
+ * agents reach for constantly (mirrors DylanPiercey/start). Static binaries via
+ * mise, except the system packages the installer provides (git, tmux). */
+export const TOOLS = [
+  { id: "git", label: "git", bin: "git", required: true, system: true },
+  { id: "tmux", label: "tmux", bin: "tmux", required: true, system: true, mise: "tmux" },
+  // The server itself runs on it — install.sh puts it there via mise.
+  { id: "node", label: "Node.js", bin: "node", mise: "node", required: true },
+  { id: "gh", label: "GitHub CLI", bin: "gh", mise: "gh", required: true },
+  { id: "ripgrep", label: "ripgrep", bin: "rg", mise: "ripgrep" },
+  { id: "fd", label: "fd", bin: "fd", mise: "fd" },
+  { id: "jq", label: "jq", bin: "jq", mise: "jq" },
+  { id: "delta", label: "delta", bin: "delta", mise: "delta" },
+  // ast-grep's short alias `sg` collides with coreutils setgroups — detect
+  // the long binary name.
+  { id: "ast-grep", label: "ast-grep", bin: "ast-grep", mise: "ast-grep" },
+  { id: "hyperfine", label: "hyperfine", bin: "hyperfine", mise: "hyperfine" },
+  { id: "fzf", label: "fzf", bin: "fzf", mise: "fzf" },
+  { id: "bottom", label: "bottom", bin: "btm", mise: "bottom" },
+  { id: "pnpm", label: "pnpm", bin: "pnpm", mise: "pnpm" },
+];
+
+/** Coding agent CLIs. Installed via each vendor's own installer (not npm) so
+ * self-update works. `bins` lists the executable names a family answers to;
+ * numeric suffixes (`claude1`) are discovered on top of these. */
+export const AGENTS = [
+  { id: "claude", label: "Claude", bins: ["claude"], install: { url: "https://claude.ai/install.sh", shell: "bash" } },
+  { id: "codex", label: "Codex", bins: ["codex"], install: { url: "https://chatgpt.com/codex/install.sh", shell: "sh" } },
+  { id: "copilot", label: "Copilot", bins: ["copilot"], install: { url: "https://gh.io/copilot-install", shell: "bash" } },
+  { id: "cursor", label: "Cursor", bins: ["cursor-agent"], install: { url: "https://cursor.com/install", shell: "bash" } },
+  { id: "grok", label: "Grok", bins: ["grok"], install: { url: "https://x.ai/cli/install.sh", shell: "bash" } },
+];
+
+export const DEFAULT_GITHUB_HOST = "github.com";
+
+export function toolById(id) {
+  return TOOLS.find((t) => t.id === id) || null;
+}
+
+export function agentById(id) {
+  return AGENTS.find((a) => a.id === id) || null;
+}
+
+/**
+ * Agent *instances* are the family id plus an optional numeric suffix —
+ * `claude`, `claude1`, `claude2` — one per binary on PATH (`claude1`,
+ * `cursor-agent2`, …). This is the canonical id everywhere: sessions,
+ * settings, usage rows (`~/.claude-2` reports as `claude2`), icons.
+ */
+export function parseAgentId(id) {
+  const m = /^([a-z]+?)(\d*)$/.exec(id || "");
+  const family = m && agentById(m[1]);
+  return family ? { family, suffix: m[2] } : null;
+}
+
+/** argv0 an instance id launches — the family's binary plus the suffix. */
+export function agentCommand(id) {
+  const parsed = parseAgentId(id);
+  return parsed ? `${parsed.family.bins[0]}${parsed.suffix}` : null;
+}
+
+/** "Claude" / "Claude 2". */
+export function agentLabel(id) {
+  const parsed = parseAgentId(id);
+  return parsed ? `${parsed.family.label}${parsed.suffix ? ` ${parsed.suffix}` : ""}` : id;
+}

package/lib/setup/doctor.d.mts

@@ -0,0 +1,49 @@
+export interface DoctorTool {
+  id: string;
+  label: string;
+  required: boolean;
+  installed: boolean;
+  path?: string;
+  version?: string;
+  installable: boolean;
+  mise?: string;
+}
+export interface AgentInstance {
+  /** Canonical id: family + numeric suffix (`claude2`). */
+  id: string;
+  /** argv0 on PATH (`claude2`, `cursor-agent2`). */
+  command: string;
+  path: string;
+  suffix: string;
+}
+export interface DoctorAgent {
+  id: string;
+  label: string;
+  installed: boolean;
+  installable: boolean;
+  instances: AgentInstance[];
+}
+export interface GithubHostStatus {
+  host: string;
+  isEnterprise: boolean;
+  authed: boolean;
+  user?: string;
+  error?: string;
+}
+export interface Doctor {
+  ready: boolean;
+  missing: string[];
+  mise: { installed: boolean; path?: string };
+  tools: DoctorTool[];
+  agents: DoctorAgent[];
+  github: GithubHostStatus[];
+}
+export function setupPath(base?: string): string;
+export function which(bin: string): string | null;
+export function tilde(p: string): string;
+export function miseVersions(): Promise<Record<string, string> | null>;
+export function ghKnownHosts(): string[];
+export function discoverAgents(): DoctorAgent[];
+export function githubHostStatus(host: string): Promise<GithubHostStatus>;
+export function doctor(opts?: { hosts?: string[] }): Promise<Doctor>;
+export function formatDoctor(d: Doctor): string;

package/lib/setup/doctor.mjs

@@ -0,0 +1,203 @@
+// Readiness probe for a `work` machine — the single truth behind `work
+// doctor`, `work setup`, GET /api/setup, and the Settings page. Pure
+// detection: nothing here installs or writes. Plain node, no dependencies.
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { AGENTS, DEFAULT_GITHUB_HOST, TOOLS } from "./catalog.mjs";
+
+const home = os.homedir();
+
+/** PATH the service runs with (no login shell) plus the current one, so a
+ * probe from the server sees the same binaries a probe from a terminal does. */
+export function setupPath(base = process.env.PATH || "") {
+  const extra = [
+    `${home}/.local/share/mise/shims`,
+    `${home}/.local/bin`,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+  ];
+  const seen = new Set();
+  return [...base.split(path.delimiter), ...extra]
+    .filter((p) => p && !seen.has(p) && seen.add(p))
+    .join(path.delimiter);
+}
+
+/** `~/…` for anything under the home directory — every path here is for
+ * display (Settings rows, `work doctor`), never re-used to exec. */
+export function tilde(p) {
+  if (!p) return p;
+  return p === home ? "~" : p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
+}
+
+/** Absolute path of `bin` on setupPath(), or null. */
+export function which(bin) {
+  for (const dir of setupPath().split(path.delimiter)) {
+    const full = path.join(dir, bin);
+    try {
+      if (fs.statSync(full).isFile()) return full;
+    } catch {}
+  }
+  return null;
+}
+
+function run(cmd, args, { timeout = 15_000 } = {}) {
+  return new Promise((resolve) => {
+    execFile(
+      cmd,
+      args,
+      { env: { ...process.env, PATH: setupPath() }, timeout, maxBuffer: 8 << 20 },
+      (err, stdout, stderr) => resolve({ ok: !err, stdout: String(stdout || ""), stderr: String(stderr || "") }),
+    );
+  });
+}
+
+/** Versions of every mise-managed tool (global + any active config), keyed
+ * by short name. Local and fast; `mise outdated` (network) is a separate,
+ * on-demand call in the server. */
+export async function miseVersions() {
+  if (!which("mise")) return null;
+  const { ok, stdout } = await run("mise", ["ls", "--json"]);
+  if (!ok) return {};
+  const out = {};
+  try {
+    for (const [name, list] of Object.entries(JSON.parse(stdout))) {
+      const active = list.find((v) => v.installed && v.active) || list.find((v) => v.installed);
+      if (active) out[name] = active.version;
+    }
+  } catch {}
+  return out;
+}
+
+/** Hosts `gh` knows about (~/.config/gh/hosts.yml top-level keys) — the
+ * source of truth for "which GitHub hosts has this machine signed in to",
+ * merged with whatever the caller has configured. */
+export function ghKnownHosts() {
+  const file = path.join(process.env.GH_CONFIG_DIR || path.join(home, ".config", "gh"), "hosts.yml");
+  let text = "";
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  return [...text.matchAll(/^([A-Za-z0-9.-]+):\s*$/gm)].map((m) => m[1]);
+}
+
+/**
+ * Every agent CLI instance on PATH, per family: the plain binary and any
+ * numeric-suffixed siblings (`claude1`, `cursor-agent2`). Sync — a PATH
+ * scan is cheap and the boot handler needs it without awaiting. First hit
+ * on PATH wins per name, like the shell.
+ */
+export function discoverAgents() {
+  const dirs = setupPath().split(path.delimiter);
+  const seen = new Map();
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const hit = AGENTS.find((a) => a.bins.some((b) => name === b || (name.startsWith(b) && /^\d+$/.test(name.slice(b.length)))));
+      if (!hit || seen.has(name)) continue;
+      const full = path.join(dir, name);
+      try {
+        if (!fs.statSync(full).isFile()) continue;
+      } catch {
+        continue;
+      }
+      const bin = hit.bins.find((b) => name.startsWith(b));
+      seen.set(name, { family: hit, id: `${hit.id}${name.slice(bin.length)}`, command: name, path: tilde(full) });
+    }
+  }
+  return AGENTS.map((a) => {
+    const instances = [...seen.values()]
+      .filter((i) => i.family === a)
+      .map(({ id, command, path: p }) => ({ id, command, path: p, suffix: id.slice(a.id.length) }))
+      .sort((x, y) => (x.suffix === "" ? -1 : y.suffix === "" ? 1 : Number(x.suffix) - Number(y.suffix)));
+    return { id: a.id, label: a.label, installed: instances.length > 0, installable: true, instances };
+  });
+}
+
+/** Auth status for one host via gh (which owns the tokens). */
+export async function githubHostStatus(host) {
+  const isEnterprise = host !== DEFAULT_GITHUB_HOST;
+  if (!which("gh")) return { host, isEnterprise, authed: false, error: "gh not installed" };
+  const { ok, stdout, stderr } = await run("gh", ["auth", "status", "--hostname", host]);
+  const text = stdout + stderr;
+  const user = text.match(/account (\S+)/)?.[1] || text.match(/Logged in to \S+ as (\S+)/)?.[1];
+  return ok
+    ? { host, isEnterprise, authed: true, user }
+    : { host, isEnterprise, authed: false, error: /not logged in/i.test(text) ? undefined : text.trim().split("\n").pop() };
+}
+
+/**
+ * Full readiness snapshot.
+ *
+ * @param {{ hosts?: string[] }} [opts] configured GitHub hosts (settings);
+ *   github.com and any host gh is already signed in to are always included.
+ */
+export async function doctor(opts = {}) {
+  const hostSet = new Set([DEFAULT_GITHUB_HOST, ...(opts.hosts || []), ...ghKnownHosts()]);
+  const [versions, github] = await Promise.all([
+    miseVersions(),
+    Promise.all([...hostSet].map(githubHostStatus)),
+  ]);
+
+  const tools = TOOLS.map((t) => {
+    const found = which(t.bin);
+    return {
+      id: t.id,
+      label: t.label,
+      required: !!t.required,
+      installed: !!found,
+      path: tilde(found) || undefined,
+      version: (t.mise && versions && versions[t.mise]) || undefined,
+      // Installable when mise can provide it (system packages come from the
+      // installer / package manager, not from here).
+      installable: !!(t.mise && versions !== null),
+      mise: t.mise,
+    };
+  });
+
+  const agents = discoverAgents();
+
+  const missing = [];
+  for (const t of tools) if (t.required && !t.installed) missing.push(t.id);
+  if (!github.some((h) => h.authed)) missing.push("github-auth");
+  if (!agents.some((a) => a.installed)) missing.push("agent");
+
+  return {
+    ready: missing.length === 0,
+    missing,
+    mise: { installed: versions !== null, path: tilde(which("mise")) || undefined },
+    tools,
+    agents,
+    github,
+  };
+}
+
+/** Human summary for `work doctor` / logs. */
+export function formatDoctor(d) {
+  const mark = (ok) => (ok ? "✓" : "✗");
+  const lines = [];
+  lines.push(`mise       ${mark(d.mise.installed)} ${d.mise.path || "not installed"}`);
+  for (const t of d.tools) {
+    const tag = t.required ? "" : "  (optional)";
+    lines.push(`${t.label.padEnd(11)}${mark(t.installed)} ${t.installed ? (t.version ? `v${t.version}  ` : "") + (t.path || "") : "missing"}${tag}`);
+  }
+  for (const h of d.github) {
+    lines.push(`${h.host.padEnd(11)}${mark(h.authed)} ${h.authed ? `signed in${h.user ? ` as ${h.user}` : ""}` : h.error || "not signed in"}`);
+  }
+  for (const a of d.agents) {
+    lines.push(`${a.label.padEnd(11)}${mark(a.installed)} ${a.installed ? a.instances.map((i) => `${i.command} (${i.path})`).join(", ") : "not installed"}`);
+  }
+  lines.push("");
+  lines.push(d.ready ? "ready" : `not ready — missing: ${d.missing.join(", ")}`);
+  return lines.join("\n");
+}

package/lib/setup/install.d.mts

@@ -0,0 +1,14 @@
+export interface RunOpts {
+  log?: (line: string) => void;
+  interactive?: boolean;
+  input?: string;
+  env?: Record<string, string>;
+  timeout?: number;
+}
+export function runStreaming(cmd: string, args: string[], opts?: RunOpts): Promise<string[]>;
+export function installMise(opts?: RunOpts): Promise<void>;
+export function installTool(idOrName: string, opts?: RunOpts & { version?: string }): Promise<void>;
+export function updateTool(idOrName: string, opts?: RunOpts): Promise<void>;
+export function removeTool(idOrName: string, opts?: RunOpts): Promise<void>;
+export function installAgent(id: string, opts?: RunOpts): Promise<void>;
+export function authGithub(host: string, opts?: RunOpts): Promise<string[]>;

package/lib/setup/install.mjs

@@ -0,0 +1,135 @@
+// Installers behind `work setup`, `work doctor --fix`, and POST /api/setup.
+// 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 fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { agentById, toolById } from "./catalog.mjs";
+import { setupPath, which } from "./doctor.mjs";
+
+/**
+ * Run a command, streaming each output line to `log`.
+ * `interactive` hands the terminal over (CLI prompts such as gh's device
+ * flow); otherwise stdout/err are captured line by line and `input` (if
+ * any) is written to stdin before it closes.
+ */
+export function runStreaming(cmd, args, { log = () => {}, interactive = false, input, env, timeout = 15 * 60_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: interactive ? "inherit" : ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env, PATH: setupPath() },
+    });
+    const lines = [];
+    let buf = "";
+    const onData = (chunk) => {
+      buf += String(chunk);
+      let i;
+      while ((i = buf.search(/\r?\n/)) >= 0) {
+        const line = buf.slice(0, i).replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").trimEnd();
+        buf = buf.slice(i + (buf[i] === "\r" ? 2 : 1));
+        if (line) {
+          lines.push(line);
+          log(line);
+        }
+      }
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    if (child.stdin) {
+      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) => {
+      clearTimeout(timer);
+      if (buf.trim()) onData("\n");
+      if (code === 0) resolve(lines);
+      else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}${lines.length ? `: ${lines[lines.length - 1]}` : ""}`));
+    });
+  });
+}
+
+/** 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
+ * script runs in the setup PATH, not the user's rc. */
+async function runRemoteScript(url, shell, opts) {
+  const res = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(60_000) });
+  if (!res.ok) throw new Error(`${url} → ${res.status}`);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "work-install-"));
+  const file = path.join(dir, "install.sh");
+  fs.writeFileSync(file, await res.text(), { mode: 0o700 });
+  try {
+    return await runStreaming(shell, [file], opts);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export async function installMise(opts = {}) {
+  if (which("mise")) return;
+  opts.log?.("installing mise");
+  await runRemoteScript("https://mise.run", "sh", opts);
+  if (!which("mise")) throw new Error("mise install finished but binary not found");
+}
+
+function miseName(idOrName) {
+  const t = toolById(idOrName);
+  if (t && !t.mise) throw new Error(`${t.label} is a system package — install it with your package manager`);
+  return t ? t.mise : idOrName;
+}
+
+/** `mise use -g name@version` — installs (or re-pins) a global tool. Accepts
+ * catalog ids or any mise registry short name (Settings search). */
+export async function installTool(idOrName, { version = "latest", ...opts } = {}) {
+  await installMise(opts);
+  const name = miseName(idOrName);
+  opts.log?.(`mise use -g ${name}@${version}`);
+  await runStreaming("mise", ["use", "-g", "-y", `${name}@${version}`], 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. */
+export async function updateTool(idOrName, opts = {}) {
+  const name = miseName(idOrName);
+  opts.log?.(`mise upgrade --bump ${name}`);
+  await runStreaming("mise", ["upgrade", "--bump", "-y", name], opts);
+}
+
+/** Drop the global pin and prune its installs. Required tools cannot go. */
+export async function removeTool(idOrName, opts = {}) {
+  const t = toolById(idOrName);
+  if (t?.required) throw new Error(`${t.label} is required`);
+  const name = miseName(idOrName);
+  opts.log?.(`mise unuse -g ${name}`);
+  await runStreaming("mise", ["unuse", "-g", name], opts);
+  await runStreaming("mise", ["prune", "-y", name], opts).catch(() => {});
+}
+
+export async function installAgent(id, opts = {}) {
+  const a = agentById(id);
+  if (!a) throw new Error(`unknown agent: ${id}`);
+  opts.log?.(`installing ${a.label} (${a.install.url})`);
+  await runRemoteScript(a.install.url, a.install.shell, opts);
+  if (!a.bins.some((b) => which(b))) throw new Error(`${a.label} installer finished but ${a.bins[0]} is not on PATH`);
+}
+
+/**
+ * Sign in to a GitHub host with gh's browser device flow.
+ * Interactive (CLI): gh owns the terminal. Otherwise (server) we press Enter
+ * for it and stop it launching a browser, so the one-time code and URL flow
+ * out through `log` for the UI to show — gh keeps polling until the user
+ * finishes in their own browser.
+ */
+export async function authGithub(host, { interactive = false, ...opts } = {}) {
+  if (!which("gh")) throw new Error("gh is not installed");
+  const args = ["auth", "login", "--hostname", host, "--web", "--git-protocol", "https"];
+  if (interactive) return runStreaming("gh", args, { ...opts, interactive: true });
+  return runStreaming("gh", args, { ...opts, input: "\n", env: { BROWSER: "true", GH_PROMPT_DISABLED: "1" } });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dylanpiercey/work",
-  "version": "0.0.47",
+  "version": "0.0.48",
   "type": "module",
   "description": "Web GUI for agentic dev workspaces",
   "license": "MIT",
@@ -14,6 +14,7 @@
   "files": [
     "dist",
     "bin",
+    "lib",
     "install.sh",
     "scripts/migrate.mjs"
   ],

package/dist/_CV5G1-Sr.js

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