@dylanpiercey/work 0.2.17 → 0.2.18

package/bin/cli/workspace.mjs

@@ -0,0 +1,184 @@
+// `work workspace create|archive|unarchive|delete`: making and putting
+// away workspaces from a terminal, as New and Manage do.
+import { follow, opId } from "./_progress.mjs";
+import { namesRepo, repoName } from "./_repo.mjs";
+
+/** Where the app shows a workspace: paths the terminal opens in the app,
+ * the same as `/w/…` links anywhere in its output. */
+const links = (ws) => ({
+  terminal: `/w/${ws.id}`,
+  review: `/w/${ws.id}/review`,
+  files: `/w/${ws.id}/files`,
+});
+
+function printWorkspace(ws, verb) {
+  console.log(`${verb} ${ws.name} (${ws.id})`);
+  console.log(`  path:      ${ws.display_path || ws.path}`);
+  console.log(`  branch:    ${ws.branch}`);
+  for (const r of ws.repos) {
+    console.log(
+      `  repo:      ${r.worktree}/  ${r.full_name}  (base ${r.base_branch})`,
+    );
+  }
+  const l = links(ws);
+  console.log(`  terminal:  ${l.terminal}`);
+  console.log(`  review:    ${l.review}`);
+}
+
+/** Whether a session of this shell runs in `ws`: archiving or deleting
+ * it stops the session the command runs in. Asked of the workspace's own
+ * session list, not the status snapshot, which is kept a few seconds. */
+async function runsHere(ctx, ws) {
+  const sid = process.env.WORK_SESSION_ID;
+  if (!sid) return false;
+  const sessions = await ctx.api.get(
+    `/api/workspaces/${encodeURIComponent(ws.id)}/sessions`,
+  );
+  return (sessions || []).some((s) => s.id === sid);
+}
+
+/** The workspace an archive/delete names: always by name or id, never the
+ * one the shell happens to be in. */
+async function named(ctx, verb) {
+  const [arg] = ctx.parse();
+  if (!arg)
+    ctx.die(
+      `name the workspace to ${verb}: work workspace ${verb} <name|id> (see: work workspaces)`,
+    );
+  return (await ctx.resolveWorkspace(arg)).ws;
+}
+
+/** Archive, unarchive or delete: the server's one action route. */
+async function act(ctx, ws, action) {
+  return follow(ctx, ws.id, () =>
+    ctx.api.post(`/api/workspaces/${encodeURIComponent(ws.id)}`, { action }),
+  );
+}
+
+/** @type {Array<{name: string, aliases?: string[], summary: string, help: string, run: (ctx: any) => Promise<void>}>} */
+export const commands = [
+  {
+    name: "workspace create",
+    summary: "make a workspace: work ws create <name> [repo…]",
+    help: `work workspace create <name> [repo…] [--base <repo>=<branch>] [--fork <repo>]
+  Make a workspace, as New does: a folder under the work root, a branch of
+  its own, and a worktree of each repo on it. A repo is owner/name,
+  host/owner/name (GitHub Enterprise) or a clone URL. Each is checked out
+  from its default branch unless --base names another (--base <branch>
+  alone when there is one repo); --fork forks it to your account first and
+  clones the fork. Clone and checkout progress goes to stderr. Prints the
+  workspace and its terminal and review links (--json: the workspace).
+  e.g. work ws create login-fix marko-js/marko --base marko=main`,
+    async run(ctx) {
+      const [name, ...specs] = ctx.parse(["--base", "--fork"]);
+      if (!name)
+        ctx.die("name the workspace: work workspace create <name> [repo…]");
+      const repos = specs.map((s) => {
+        const fullName = repoName(s);
+        if (!fullName)
+          ctx.die(
+            `not a repo: ${s} (owner/name, host/owner/name or a clone URL)`,
+          );
+        return { fullName };
+      });
+      for (const spec of ctx.flags("--base")) {
+        const eq = spec.indexOf("=");
+        const key = eq < 0 ? null : spec.slice(0, eq);
+        const branch = eq < 0 ? spec : spec.slice(eq + 1);
+        const target = key
+          ? repos.filter((r) => namesRepo(key, r.fullName))
+          : repos.length === 1
+            ? repos
+            : [];
+        if (target.length !== 1)
+          ctx.die(
+            key
+              ? `--base ${spec}: ${target.length ? "names more than one repo" : "names no repo given"}`
+              : "--base <branch> alone needs exactly one repo; name it: --base <repo>=<branch>",
+          );
+        target[0].baseBranch = branch;
+      }
+      for (const key of ctx.flags("--fork")) {
+        const target = repos.filter((r) => namesRepo(key, r.fullName));
+        if (target.length !== 1) ctx.die(`--fork ${key}: names no one repo`);
+        target[0].fork = true;
+      }
+      const op = opId();
+      const ws = await follow(ctx, op, () =>
+        ctx.api.post("/api/workspaces", { name, repos, opId: op }),
+      );
+      ctx.out({ ...ws, links: links(ws) }, () => printWorkspace(ws, "created"));
+    },
+  },
+  {
+    name: "workspace archive",
+    summary: "archive a workspace (stops its sessions; keeps its files)",
+    help: `work workspace archive <name|id> [--yes]
+  Archive a workspace, as the app's archive does: its sessions and
+  processes stop and it leaves the list; its folder, branches and review
+  stay, and work workspace unarchive brings it back. Archiving the
+  workspace this shell runs in stops this session too, so that needs --yes.`,
+    async run(ctx) {
+      const ws = await named(ctx, "archive");
+      if (ws.status === "archived") {
+        ctx.out({ id: ws.id, status: "archived" }, () =>
+          console.log(`${ws.name} is already archived`),
+        );
+        return;
+      }
+      if (!ctx.yes && (await runsHere(ctx, ws)))
+        ctx.die(
+          `${ws.name} is the workspace this shell runs in: archiving it stops this session. Pass --yes to go ahead`,
+        );
+      await act(ctx, ws, "archive");
+      ctx.out({ id: ws.id, status: "archived" }, () =>
+        console.log(
+          `archived ${ws.name} (work workspace unarchive ${ws.name} brings it back)`,
+        ),
+      );
+    },
+  },
+  {
+    name: "workspace unarchive",
+    aliases: ["workspace restore"],
+    summary: "bring an archived workspace back",
+    help: `work workspace unarchive <name|id>
+  Bring an archived workspace back into the list. One restored from a
+  backup that was never put on disk is cloned now, in the background (the
+  app shows how far it has got).`,
+    async run(ctx) {
+      const ws = await named(ctx, "unarchive");
+      if (ws.status === "active") {
+        ctx.out({ id: ws.id, status: "active" }, () =>
+          console.log(`${ws.name} is not archived`),
+        );
+        return;
+      }
+      await act(ctx, ws, "restore");
+      ctx.out({ id: ws.id, status: "active", links: links(ws) }, () =>
+        console.log(`unarchived ${ws.name}: ${links(ws).terminal}`),
+      );
+    },
+  },
+  {
+    name: "workspace delete",
+    summary: "delete a workspace and its files (--yes)",
+    help: `work workspace delete <name|id> --yes
+  Delete a workspace: its sessions and processes stop, its folder is
+  removed and its local branches are deleted — uncommitted and unpushed
+  work in it is lost. Branches already pushed, and their PRs, stay on
+  GitHub. Asks for --yes; archive instead to keep it.`,
+    async run(ctx) {
+      const ws = await named(ctx, "delete");
+      const here = await runsHere(ctx, ws);
+      if (!ctx.yes)
+        ctx.die(
+          `deleting ${ws.name} removes ${ws.display_path || ws.path} and its local branches; uncommitted and unpushed work is lost${here ? ", and this session stops (it runs there)" : ""}. Pass --yes to go ahead, or archive it instead`,
+        );
+      await act(ctx, ws, "delete");
+      ctx.out({ id: ws.id, deleted: true }, () =>
+        console.log(`deleted ${ws.name}`),
+      );
+    },
+  },
+];