@dylanpiercey/work 0.0.119 → 0.0.121

package/lib/setup/doctor.mjs

@@ -46,7 +46,11 @@ export function setupPath(base = process.env.PATH || "") {
  * display (Settings rows, `work doctor`), never re-used to exec. */
 function tilde(p) {
   if (!p) return p;
-  return p === home ? "~" : p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
+  return p === home
+    ? "~"
+    : p.startsWith(home + path.sep)
+      ? "~" + p.slice(home.length)
+      : p;
 }
 
 /** Absolute path of `bin` on setupPath(), or null. */
@@ -65,8 +69,17 @@ function run(cmd, args, { timeout = 15_000 } = {}) {
     execFile(
       cmd,
       args,
-      { env: { ...process.env, PATH: setupPath() }, timeout, maxBuffer: 8 << 20 },
-      (err, stdout, stderr) => resolve({ ok: !err, stdout: String(stdout || ""), stderr: String(stderr || "") }),
+      {
+        env: { ...process.env, PATH: setupPath() },
+        timeout,
+        maxBuffer: 8 << 20,
+      },
+      (err, stdout, stderr) =>
+        resolve({
+          ok: !err,
+          stdout: String(stdout || ""),
+          stderr: String(stderr || ""),
+        }),
     );
   });
 }
@@ -81,7 +94,9 @@ export async function miseVersions() {
   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);
+      const active =
+        list.find((v) => v.installed && v.active) ||
+        list.find((v) => v.installed);
       if (active) out[name] = active.version;
     }
   } catch {}
@@ -92,7 +107,10 @@ export async function miseVersions() {
  * 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");
+  const file = path.join(
+    process.env.GH_CONFIG_DIR || path.join(home, ".config", "gh"),
+    "hosts.yml",
+  );
   let text = "";
   try {
     text = fs.readFileSync(file, "utf8");
@@ -130,7 +148,13 @@ export function discoverAgents() {
       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)))));
+      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;
       // Join against the PATH entry, not the realpath — tilde() matches on
       // $HOME, and on hosts where home is a symlink (/home → /var/home)
@@ -142,28 +166,65 @@ export function discoverAgents() {
         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) });
+      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 };
+      .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). */
 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]);
+  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];
+  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() };
+    : {
+        host,
+        isEnterprise,
+        authed: false,
+        error: /not logged in/i.test(text)
+          ? undefined
+          : text.trim().split("\n").pop(),
+      };
 }
 
 /**
@@ -173,7 +234,11 @@ async function githubHostStatus(host) {
  *   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 hostSet = new Set([
+    DEFAULT_GITHUB_HOST,
+    ...(opts.hosts || []),
+    ...ghKnownHosts(),
+  ]);
   const [versions, github] = await Promise.all([
     miseVersions(),
     Promise.all([...hostSet].map(githubHostStatus)),
@@ -205,7 +270,10 @@ export async function doctor(opts = {}) {
   return {
     ready: missing.length === 0,
     missing,
-    mise: { installed: versions !== null, path: tilde(which("mise")) || undefined },
+    mise: {
+      installed: versions !== null,
+      path: tilde(which("mise")) || undefined,
+    },
     tools,
     agents,
     github,
@@ -216,16 +284,24 @@ export async function doctor(opts = {}) {
 export function formatDoctor(d) {
   const mark = (ok) => (ok ? "✓" : "✗");
   const lines = [];
-  lines.push(`mise       ${mark(d.mise.installed)} ${d.mise.path || "not installed"}`);
+  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}`);
+    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"}`);
+    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(
+      `${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(", ")}`);

package/lib/setup/install.d.mts

@@ -1,14 +1,20 @@
 export interface RunOpts {
   log?: (line: string) => void;
-  interactive?: boolean;
   input?: string;
   env?: Record<string, string>;
   cwd?: string;
   timeout?: number;
 }
-export function runStreaming(cmd: string, args: string[], opts?: RunOpts): Promise<string[]>;
+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 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>;

package/lib/setup/install.mjs

@@ -10,17 +10,20 @@ 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. `cwd` matters for tools whose
- * scope is the directory they run in, such as project-scope skill installs.
+ * Run a command, streaming each output line to `log`. stdout/err are
+ * captured line by line and `input` (if any) is written to stdin before it
+ * closes. `cwd` matters for tools whose scope is the directory they run in,
+ * such as project-scope skill installs.
  */
-export function runStreaming(cmd, args, { log = () => {}, interactive = false, input, env, cwd, timeout = 15 * 60_000 } = {}) {
+export function runStreaming(
+  cmd,
+  args,
+  { log = () => {}, input, env, cwd, timeout = 15 * 60_000 } = {},
+) {
   return new Promise((resolve, reject) => {
     const child = spawn(cmd, args, {
       cwd,
-      stdio: interactive ? "inherit" : ["pipe", "pipe", "pipe"],
+      stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...env, PATH: setupPath() },
     });
     const lines = [];
@@ -29,7 +32,10 @@ export function runStreaming(cmd, args, { log = () => {}, interactive = false, i
       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();
+        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);
@@ -39,10 +45,8 @@ export function runStreaming(cmd, args, { log = () => {}, interactive = false, i
     };
     child.stdout?.on("data", onData);
     child.stderr?.on("data", onData);
-    if (child.stdin) {
-      if (input) child.stdin.write(input);
-      child.stdin.end();
-    }
+    if (input) child.stdin.write(input);
+    child.stdin.end();
     const timer = setTimeout(() => child.kill("SIGTERM"), timeout);
     child.on("error", (err) => {
       clearTimeout(timer);
@@ -52,7 +56,12 @@ export function runStreaming(cmd, args, { log = () => {}, interactive = false, i
       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]}` : ""}`));
+      else
+        reject(
+          new Error(
+            `${cmd} ${args.join(" ")} exited ${code}${lines.length ? `: ${lines[lines.length - 1]}` : ""}`,
+          ),
+        );
     });
   });
 }
@@ -62,7 +71,10 @@ export function runStreaming(cmd, args, { log = () => {}, interactive = false, i
  * 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) });
+  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");
@@ -78,18 +90,25 @@ 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");
+  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 the system package manager`);
+  if (t && !t.mise)
+    throw new Error(
+      `${t.label} is a system package. Install it with the system 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 } = {}) {
+export async function installTool(
+  idOrName,
+  { version = "latest", ...opts } = {},
+) {
   await installMise(opts);
   const name = miseName(idOrName);
   opts.log?.(`mise use -g ${name}@${version}`);
@@ -119,39 +138,49 @@ export async function installAgent(id, opts = {}) {
   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`);
+  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, never opening a
- * browser: `work` usually runs on a remote box, so gh's attempt to launch
- * one only produces "Failed opening a web browser" noise. Interactive (CLI)
- * lets gh own the terminal (it prints the code + URL and polls); otherwise
- * (server) we press Enter for it and the 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 } = {}) {
+/** Shared gh device flow: sign in / refresh without opening a browser.
+ * `work` usually runs on a remote box, so gh's attempt to launch one only
+ * produces "Failed opening a web browser" noise. Server-side we press Enter
+ * for gh and the code and URL flow out through `log` for the UI to show —
+ * gh keeps polling until the user finishes in their own browser
+ * (BROWSER=true suppresses the launch attempt; GH_PROMPT_DISABLED stops the
+ * prompt waiting on stdin we already fed). */
+async function ghDeviceFlow(host, args, opts = {}) {
   if (!which("gh")) throw new Error("gh is not installed");
-  const args = ["auth", "login", "--hostname", host, "--web", "--git-protocol", "https"];
-  const env = { ...opts.env, BROWSER: "true" };
-  if (interactive) return runStreaming("gh", args, { ...opts, env, interactive: true });
-  return runStreaming("gh", args, { ...opts, input: "\n", env: { ...env, GH_PROMPT_DISABLED: "1" } });
+  return runStreaming("gh", args, {
+    ...opts,
+    input: "\n",
+    env: { ...opts.env, BROWSER: "true", GH_PROMPT_DISABLED: "1" },
+  });
+}
+
+/** Sign a GitHub host in with gh's device flow — see ghDeviceFlow. */
+export async function authGithub(host, opts = {}) {
+  return ghDeviceFlow(
+    host,
+    ["auth", "login", "--hostname", host, "--web", "--git-protocol", "https"],
+    opts,
+  );
 }
 
 /** Re-authorize an existing gh login (device flow). Needed after an org
  * enables SAML: visiting the X-GitHub-SSO link only signs the browser into
  * the IdP, while `auth refresh` re-issues the OAuth token with org SSO. */
-export async function refreshGithub(host, { interactive = false, ...opts } = {}) {
-  if (!which("gh")) throw new Error("gh is not installed");
-  const args = ["auth", "refresh", "--hostname", host];
-  const env = { ...opts.env, BROWSER: "true" };
-  if (interactive) return runStreaming("gh", args, { ...opts, env, interactive: true });
-  return runStreaming("gh", args, { ...opts, input: "\n", env: { ...env, GH_PROMPT_DISABLED: "1" } });
+export async function refreshGithub(host, opts = {}) {
+  return ghDeviceFlow(host, ["auth", "refresh", "--hostname", host], opts);
 }
 
 /** Sign out of a GitHub host (drops gh's token; the host stays listed). */
 export async function logoutGithub(host, opts = {}) {
   if (!which("gh")) throw new Error("gh is not installed");
-  return runStreaming("gh", ["auth", "logout", "--hostname", host], { ...opts, env: { GH_PROMPT_DISABLED: "1" } });
+  return runStreaming("gh", ["auth", "logout", "--hostname", host], {
+    ...opts,
+    env: { GH_PROMPT_DISABLED: "1" },
+  });
 }

package/lib/share/manifest.d.mts

@@ -0,0 +1,27 @@
+export interface RepoRow {
+  full_name: string;
+  worktree: string;
+  base_branch: string;
+  default_branch: string;
+}
+
+/** `owner/name`, `owner/name@base`, or `{ repo, dir?, base? }`. */
+export type RepoEntry = string | { repo: string; dir?: string; base?: string };
+
+export interface Invite {
+  name: string;
+  branch: string;
+  /** `[host/]owner/name` per repo. */
+  repos: string[];
+}
+
+/** A repo row as the manifest writes it. */
+export function encodeRepo(r: RepoRow): RepoEntry;
+/** The row for a manifest entry (or an older object form); null if not one.
+ * `base_branch`/`default_branch` are empty when the file did not pin them. */
+export function decodeRepo(entry: unknown): RepoRow | null;
+/** The pastable invite for a workspace (Manage's copy button, `work share`). */
+export function formatInvite(ws: Invite): string;
+/** Parse an invite, or a one-workspace backup. Throws with a reason a
+ * person can act on. */
+export function parseInvite(text: string): Invite;

package/lib/share/manifest.mjs

@@ -0,0 +1,144 @@
+// The backup manifest's workspace entry is the one shape a workspace has
+// outside the database: what `work export` writes, what Manage's copy
+// button puts on the clipboard, what New → Join and `work join` read. An
+// invite is that entry without the machine-specific parts (id, created,
+// archived). Plain ESM with no dependencies, shared by the browser, the
+// server and the CLI so there is exactly one format:
+//
+//   {
+//    "name": "persisted pages",
+//    "branch": "dpiercey-ws-persisted-pages-xh8764",
+//    "repos": ["marko-js/marko", "DylanPiercey/persisted-pages-scratch"]
+//   }
+//
+// A repo is `owner/name` (`host/owner/name` off github.com), `owner/name@base`
+// when the workspace's base is not the remote's default branch, and an
+// object `{ repo, dir?, base? }` only when its directory is not the repo's
+// name. A join ignores the base — the shared branch is the base.
+
+const BRANCH_RE = /^[\w./+@-]+$/;
+// `owner/name`, or `host/owner/name` — a host has a dot in it.
+const REPO_RE = /^(?:[\w-]+(?:\.[\w-]+)+\/)?[\w.-]+\/[\w.-]+$/;
+// One path segment: a repo's directory in the workspace.
+const DIR_RE = /^(?!\.{1,2}$)[\w.-]+$/;
+
+/**
+ * @typedef {{ full_name: string, worktree: string, base_branch: string, default_branch: string }} RepoRow
+ * @typedef {string | { repo: string, dir?: string, base?: string }} RepoEntry
+ */
+
+/** @param {RepoRow} r @returns {RepoEntry} */
+export function encodeRepo(r) {
+  const base = r.base_branch !== r.default_branch ? r.base_branch : undefined;
+  // `@` in the base would split wrong on the way back: object form then.
+  if (r.worktree === r.full_name.split("/").at(-1) && !base?.includes("@")) {
+    return base ? `${r.full_name}@${base}` : r.full_name;
+  }
+  const dir = r.worktree !== r.full_name.split("/").at(-1);
+  return {
+    repo: r.full_name,
+    ...(dir && { dir: r.worktree }),
+    ...(base && { base }),
+  };
+}
+
+/**
+ * The row for an entry, or null when it is not one. The remote's default
+ * branch is never in the file: `base_branch`/`default_branch` come back
+ * empty when not pinned and the server fills them from the clone.
+ * @param {unknown} entry @returns {RepoRow | null}
+ */
+export function decodeRepo(entry) {
+  let full = "";
+  let dir;
+  let base;
+  if (typeof entry === "string") {
+    const at = entry.lastIndexOf("@");
+    full = at > 0 ? entry.slice(0, at) : entry;
+    base = at > 0 ? entry.slice(at + 1) : undefined;
+  } else if (entry && typeof entry === "object") {
+    const o = /** @type {Record<string, unknown>} */ (entry);
+    // Format-1 rows and API shapes spell the name differently.
+    full = String(o.repo ?? o.full_name ?? o.fullName ?? "");
+    dir = typeof o.dir === "string" ? o.dir : undefined;
+    if (typeof o.worktree === "string") dir = o.worktree;
+    base = typeof o.base === "string" ? o.base : undefined;
+    if (typeof o.base_branch === "string") base = o.base_branch;
+  } else return null;
+  full = full.trim();
+  if (!REPO_RE.test(full)) return null;
+  // A host is case-insensitive; the configured list is lowercase.
+  const parts = full.split("/");
+  if (parts.length === 3)
+    full = [parts[0].toLowerCase(), parts[1], parts[2]].join("/");
+  if (base !== undefined && !BRANCH_RE.test(base)) return null;
+  if (dir !== undefined && !DIR_RE.test(dir)) return null;
+  return {
+    full_name: full,
+    worktree: dir || full.split("/").at(-1),
+    base_branch: base || "",
+    default_branch:
+      entry &&
+      typeof entry === "object" &&
+      typeof entry.default_branch === "string"
+        ? entry.default_branch
+        : base || "",
+  };
+}
+
+/**
+ * The invite for a workspace: its manifest entry, pared to what a join
+ * needs. Repos carry no base — the joiner's base is the branch.
+ * @param {{ name: string, branch: string, repos: string[] }} ws
+ * @returns {string}
+ */
+export function formatInvite(ws) {
+  return (
+    JSON.stringify(
+      { name: ws.name, branch: ws.branch, repos: ws.repos },
+      null,
+      1,
+    ) + "\n"
+  );
+}
+
+/**
+ * Read an invite: a workspace entry, or a whole backup that holds one
+ * workspace. Throws with a reason a person can act on.
+ * @param {string} text
+ * @returns {{ name: string, branch: string, repos: string[] }}
+ */
+export function parseInvite(text) {
+  const raw = String(text ?? "").trim();
+  if (!raw) throw new Error("paste a workspace invite");
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    throw new Error("not an invite (expected JSON)");
+  }
+  if (!obj || typeof obj !== "object") throw new Error("not an invite");
+  if (Array.isArray(obj.workspaces)) {
+    if (obj.workspaces.length !== 1)
+      throw new Error(
+        obj.workspaces.length
+          ? "this is a whole backup — restore it from Settings, or paste one workspace entry"
+          : "this backup holds no workspaces",
+      );
+    obj = obj.workspaces[0];
+    if (!obj || typeof obj !== "object") throw new Error("not an invite");
+  }
+  const branch = String(obj.branch ?? "").trim();
+  if (!branch) throw new Error("the invite has no branch");
+  if (!BRANCH_RE.test(branch)) throw new Error(`not a branch name: ${branch}`);
+  const entries = Array.isArray(obj.repos) ? obj.repos : [];
+  const repos = [];
+  for (const e of entries) {
+    const r = decodeRepo(e);
+    if (!r) throw new Error(`not a repo: ${JSON.stringify(e)}`);
+    if (!repos.includes(r.full_name)) repos.push(r.full_name);
+  }
+  if (!repos.length) throw new Error("the invite lists no repos");
+  const name = String(obj.name ?? "").trim();
+  return { name: name || branch, branch, repos };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dylanpiercey/work",
-  "version": "0.0.119",
+  "version": "0.0.121",
   "type": "module",
   "description": "Web GUI for agentic dev workspaces",
   "license": "MIT",
@@ -29,7 +29,9 @@
     "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",
-    "preview": "PORT=7171 node dist/index.mjs"
+    "preview": "PORT=7171 node dist/index.mjs",
+    "format": "prettier . -w",
+    "format:check": "prettier --check ."
   },
   "dependencies": {
     "node-pty": "^1.1.0"
@@ -56,6 +58,8 @@
     "iconoir": "^7.12.1",
     "marko": "^6.3.43",
     "playwright": "^1.62.1",
+    "prettier": "^3.9.6",
+    "prettier-plugin-marko": "^4.1.0",
     "serve-static": "^2.2.1",
     "typescript": "^6.0.3",
     "valibot": "^1.4.2",