@dylanpiercey/work 0.0.49 → 0.0.51

package/bin/work.mjs

@@ -6,7 +6,15 @@
 //   work start    run the server in the foreground
 //   work update   upgrade the npm package and refresh the service
 //   work usage    print agent plan/quota usage
+//   work workspaces           list workspaces (name, branch, sessions, ports)
+//   work workspace [id|name]  one workspace: repos, PRs, sessions, procs (default: the current one)
+//   work repos [id|name]      a workspace's repos with base branch and open PRs
+//   work procs [id|name]      a workspace's running processes and ports
 //   work version  print the installed version
+//
+// The read commands ask the running server (same data as the UI) and take
+// --json for machine-readable output — agents inside a workspace should
+// use them instead of poking at the filesystem or GitHub.
 import { execFileSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
@@ -37,6 +45,8 @@ const sh = (cmd, args, opts = {}) =>
 
 const [, , command = "help", ...args] = process.argv;
 const yes = args.includes("--yes") || args.includes("-y");
+const jsonOut = args.includes("--json");
+const positional = args.filter((a) => !a.startsWith("-"));
 
 switch (command) {
   case "start":
@@ -54,6 +64,19 @@ switch (command) {
   case "usage":
     await usage();
     break;
+  case "workspaces":
+    await workspacesCmd();
+    break;
+  case "workspace":
+  case "ws":
+    await workspaceCmd();
+    break;
+  case "repos":
+    await reposCmd();
+    break;
+  case "procs":
+    await procsCmd();
+    break;
   case "version":
   case "--version":
   case "-v":
@@ -61,7 +84,7 @@ switch (command) {
     break;
   default:
     console.log(
-      `work ${pkg.version}\n\nusage: work <setup|doctor|start|update|usage|version>`,
+      `work ${pkg.version}\n\nusage: work <setup|doctor|start|update|usage|workspaces|workspace|repos|procs|version> [--json]`,
     );
 }
 
@@ -117,6 +140,130 @@ async function usage() {
   }
 }
 
+// -- workspace read commands (HTTP to the running server) --------------------
+
+async function apiGet(path) {
+  const port = serviceEnv().PORT;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}${path}`, { signal: AbortSignal.timeout(30_000) });
+    if (!res.ok) die(`server answered ${res.status} for ${path}`);
+    return await res.json();
+  } catch (err) {
+    if (err?.message?.startsWith("server answered")) throw err;
+    die(`no work server on port ${port} — start one with: work start`);
+  }
+}
+
+/**
+ * The workspace a command means: an explicit id/name, else the one whose
+ * session this shell runs in (`WORK_SESSION_ID`, set on every pane), else
+ * the one whose directory contains the cwd. Agents call these from inside
+ * a workspace, so no argument is the common case.
+ */
+async function resolveWorkspace(arg) {
+  const [list, status] = await Promise.all([apiGet("/api/workspaces"), apiGet("/api/status")]);
+  let ws;
+  if (arg) {
+    ws = list.find((w) => w.id === arg || w.name === arg);
+    if (!ws) die(`no workspace named ${arg}`);
+  } else if (process.env.WORK_SESSION_ID) {
+    const sid = process.env.WORK_SESSION_ID;
+    ws = list.find((w) => (status[w.id]?.sessions || []).some((s) => s.id === sid));
+  }
+  if (!ws) {
+    // Compare real paths on both sides — /home may be a symlink to /var/home.
+    const cwd = fs.realpathSync(process.cwd());
+    const real = (p) => {
+      try {
+        return fs.realpathSync(p);
+      } catch {
+        return p;
+      }
+    };
+    ws = list.find((w) => {
+      const root = real(w.path);
+      return cwd === root || cwd.startsWith(root + path.sep);
+    });
+  }
+  if (!ws) die("not inside a workspace — pass its name or id (see: work workspaces)");
+  return { ws, status: status[ws.id] || { ports: [], repos: [], sessions: [] } };
+}
+
+function pad(s, n) {
+  return String(s ?? "").padEnd(n);
+}
+
+async function workspacesCmd() {
+  const [list, status] = await Promise.all([apiGet("/api/workspaces"), apiGet("/api/status")]);
+  const rows = list.map((w) => ({ ...w, ...(status[w.id] || {}) }));
+  if (jsonOut) return console.log(JSON.stringify(rows, null, 2));
+  if (!rows.length) return console.log("no workspaces — create one in the app");
+  const wName = Math.max(4, ...rows.map((w) => w.name.length));
+  console.log(`${pad("name", wName)}  ${pad("status", 8)}  ${pad("branch", 28)}  repos  agents  ports`);
+  for (const w of rows) {
+    const ports = (w.ports || []).map((p) => `:${p.port}`).join(" ");
+    console.log(
+      `${pad(w.name, wName)}  ${pad(w.status, 8)}  ${pad(w.branch, 28)}  ${pad(w.repos.length, 5)}  ${pad(w.agents ?? 0, 6)}  ${ports}`,
+    );
+  }
+}
+
+function prLine(pr) {
+  const state = pr.state === "MERGED" ? "merged" : pr.state === "CLOSED" ? "closed" : pr.isDraft ? "draft" : "open";
+  return `#${pr.number} ${state}  ${pr.title}  ${pr.url}`;
+}
+
+async function workspaceCmd() {
+  const { ws, status } = await resolveWorkspace(positional[0]);
+  const procs = await apiGet(`/api/workspaces/${ws.id}/procs`).catch(() => []);
+  const [sessions] = await Promise.all([apiGet(`/api/workspaces/${ws.id}/sessions`).catch(() => [])]);
+  const out = { ...ws, ports: status.ports, repos: mergeRepos(ws, status), sessions, procs };
+  if (jsonOut) return console.log(JSON.stringify(out, null, 2));
+  console.log(`${ws.name}  (${ws.status})`);
+  console.log(`  path:    ${ws.display_path || ws.path}`);
+  console.log(`  branch:  ${ws.branch}`);
+  console.log(`  repos:`);
+  for (const r of out.repos) {
+    console.log(`    ${r.worktree}/  ${r.full_name}  base:${r.base_branch}`);
+    for (const pr of r.prs || []) console.log(`      ${prLine(pr)}`);
+  }
+  if (sessions.length) {
+    console.log(`  sessions:`);
+    for (const s of sessions) {
+      const phase = s.state?.phase || (s.state?.alive ? "idle" : "off");
+      console.log(`    ${pad(s.agent, 10)} ${pad(phase, 8)} ${s.title || ""}`);
+    }
+  }
+  if (procs.length) {
+    console.log(`  running:`);
+    for (const p of procs) console.log(`    ${pad(p.pid, 7)} ${p.cmd}${p.ports?.length ? "  " + p.ports.map((x) => `:${x}`).join(" ") : ""}`);
+  }
+}
+
+/** Workspace repos joined with the status snapshot's PRs per repo. */
+function mergeRepos(ws, status) {
+  const byName = new Map((status.repos || []).map((r) => [r.full_name, r]));
+  return ws.repos.map((r) => ({ ...r, prs: byName.get(r.full_name)?.prs || [] }));
+}
+
+async function reposCmd() {
+  const { ws, status } = await resolveWorkspace(positional[0]);
+  const repos = mergeRepos(ws, status);
+  if (jsonOut) return console.log(JSON.stringify(repos, null, 2));
+  for (const r of repos) {
+    console.log(`${r.worktree}/  ${r.full_name}  base:${r.base_branch}${r.default_branch !== r.base_branch ? `  default:${r.default_branch}` : ""}`);
+    for (const pr of r.prs) console.log(`  ${prLine(pr)}`);
+  }
+}
+
+async function procsCmd() {
+  const { ws } = await resolveWorkspace(positional[0]);
+  const procs = await apiGet(`/api/workspaces/${ws.id}/procs`);
+  if (jsonOut) return console.log(JSON.stringify(procs, null, 2));
+  if (!procs.length) return console.log("nothing running");
+  for (const p of procs) console.log(`${pad(p.pid, 7)} ${p.cmd}${p.ports?.length ? "  " + p.ports.map((x) => `:${x}`).join(" ") : ""}`);
+}
+
 /** "4h" / "6d" — how long until an ISO timestamp. A reset already in the past
  * means the window turned over and this row hasn't refreshed since, so there
  * is no honest countdown to print. */
@@ -208,7 +355,7 @@ async function fix(d, { agents = "prompt" } = {}) {
     } else if (yes) {
       warn("gh is not authenticated — run `gh auth login` later");
     } else {
-      log("signing in to GitHub (PRs/clones)");
+      log("signing in to GitHub (PRs/clones) — open https://github.com/login/device in any browser and enter the code below; no browser is launched here");
       await authGithub("github.com", { interactive: true }).catch((err) => warn(err.message));
     }
   }