@dylanpiercey/work 0.2.17 → 0.2.18

package/bin/cli/host.mjs

@@ -0,0 +1,142 @@
+// `work host` and `work gh login`: the GitHub hosts work clones from and
+// signs in to, as Settings → GitHub lists, adds and signs them in.
+import { follow } from "./_progress.mjs";
+
+function printHosts(hosts) {
+  if (!hosts.length) return console.log("no GitHub hosts");
+  const w = Math.max(4, ...hosts.map((h) => h.host.length));
+  for (const h of hosts) {
+    const state = h.unreachable
+      ? `can't be reached${h.error ? `: ${h.error}` : ""}`
+      : h.authed
+        ? `signed in${h.user ? ` as ${h.user}` : ""}`
+        : `not signed in (work gh login ${h.host})${h.error ? `: ${h.error}` : ""}`;
+    console.log(`${h.host.padEnd(w)}  ${state}`);
+    for (const s of h.sso || [])
+      console.log(`${"".padEnd(w)}  ${s.org} needs its SAML SSO authorized`);
+  }
+}
+
+/** A host name as gh and Settings take it: no scheme, no path. */
+function hostName(ctx, text) {
+  const h = String(text || "")
+    .trim()
+    .replace(/^https?:\/\//i, "")
+    .replace(/\/.*$/, "")
+    .toLowerCase();
+  if (!/^[a-z0-9.-]+\.[a-z0-9.-]+(?::\d+)?$/.test(h))
+    ctx.die(`not a host name: ${text} (e.g. github.example.com)`);
+  return h;
+}
+
+/** The device flow's two things the user acts on, from gh's own lines:
+ * the one-time code and the page to enter it on. */
+function deviceFlow(line, seen) {
+  const code = /\b([A-Z0-9]{4}-[A-Z0-9]{4})\b/.exec(line)?.[1];
+  const url = /(https?:\/\/\S+\/login\/device\S*)/.exec(line)?.[1];
+  if (code) seen.code ??= code;
+  if (url) seen.url ??= url;
+}
+
+/** @type {Array<{name: string, summary: string, help: string, run: (ctx: any) => Promise<void>}>} */
+export const commands = [
+  {
+    name: "host",
+    summary: "GitHub hosts: list | add | rm",
+    help: `work host [list] [--refresh]
+  The GitHub hosts work clones from (github.com and any Enterprise hosts),
+  whether each is signed in and as whom, or can't be reached (an Enterprise
+  host off its VPN). --refresh asks gh again rather than the app's last
+  reading (a sign-in made outside work).
+work host add <host>
+  Add a GitHub Enterprise host, as Settings → GitHub does: its repos join
+  the picker once signed in (work gh login <host>).
+work host rm <host>
+  Forget an Enterprise host (gh stays signed in to it).`,
+    async run(ctx) {
+      const [verb = "list", arg] = ctx.parse();
+      if (verb === "list") {
+        const setup = await ctx.api.get(
+          `/api/setup${ctx.has("--refresh") ? "?refresh" : ""}`,
+        );
+        return ctx.out(setup.github || [], printHosts);
+      }
+      if (verb === "add" || verb === "rm" || verb === "remove") {
+        if (!arg) ctx.die(`name the host: work host ${verb} <host>`);
+        const host = hostName(ctx, arg);
+        const setup = await ctx.api.post("/api/github/hosts", {
+          host,
+          remove: verb !== "add" || undefined,
+        });
+        const row = (setup.github || []).find((h) => h.host === host);
+        return ctx.out(row ?? { host, removed: verb !== "add" }, () =>
+          console.log(
+            verb === "add"
+              ? `added ${host}${row && !row.authed && !row.unreachable ? ` — sign in: work gh login ${host}` : row?.unreachable ? " — it can't be reached now (VPN?)" : ""}`
+              : `forgot ${host}`,
+          ),
+        );
+      }
+      ctx.die(`no host verb ${verb} (list, add, rm)`);
+    },
+  },
+  {
+    name: "gh login",
+    summary: "sign in to a GitHub host (device code)",
+    help: `work gh login [host]
+  Sign in to github.com, or an Enterprise host (added first if it is not
+  yet), with gh's device flow, as Settings → GitHub does: prints the
+  one-time code and the page to enter it on as soon as gh has them, then
+  waits until the sign-in is done in the browser. gh's own lines go to
+  stderr.`,
+    async run(ctx) {
+      const [arg] = ctx.parse();
+      const host = arg ? hostName(ctx, arg) : "github.com";
+      // Asked afresh: the app's last reading may predate a sign-out.
+      const before = await ctx.api.get("/api/setup?refresh");
+      const known = (before.github || []).find((h) => h.host === host);
+      if (known?.authed) {
+        ctx.out(known, () =>
+          console.log(
+            `already signed in to ${host}${known.user ? ` as ${known.user}` : ""}`,
+          ),
+        );
+        return;
+      }
+      if (!known && host !== "github.com") {
+        process.stderr.write(`  adding ${host}\n`);
+        await ctx.api.post("/api/github/hosts", { host });
+      }
+      const seen = {};
+      let told = false;
+      const setup = await follow(
+        ctx,
+        `setup:${host}`,
+        () =>
+          ctx.api.post(`/api/setup/${encodeURIComponent(host)}`, {
+            action: "auth",
+          }),
+        (line) => {
+          deviceFlow(line, seen);
+          // Said once both are known, while this still waits on the user:
+          // on stdout, or stderr under --json, where stdout is the JSON.
+          if (!told && seen.code && seen.url) {
+            told = true;
+            const say = `open ${seen.url} and enter the code ${seen.code}`;
+            if (ctx.json) process.stderr.write(`${say}\n`);
+            else console.log(say);
+          }
+        },
+      );
+      const row = (setup.github || []).find((h) => h.host === host);
+      ctx.out(row ?? { host }, () =>
+        console.log(
+          row?.authed
+            ? `signed in to ${host}${row.user ? ` as ${row.user}` : ""}`
+            : `not signed in to ${host}${row?.error ? `: ${row.error}` : ""}`,
+        ),
+      );
+      if (!row?.authed) process.exitCode = 1;
+    },
+  },
+];

package/bin/cli/lsp.mjs

@@ -0,0 +1,117 @@
+// `work lsp`: the language servers behind Review and Files' types and
+// errors, as Settings → Languages switches and installs them.
+import { follow } from "./_progress.mjs";
+
+function printList(list) {
+  console.log(
+    `language servers: ${list.on ? "on" : "off (work lsp on turns them on)"}`,
+  );
+  const rows = list.servers || [];
+  const w = Math.max(2, ...rows.map((s) => s.id.length));
+  for (const s of rows) {
+    const state = [
+      s.installed
+        ? `installed${s.version ? ` ${s.version}` : ""}`
+        : "not installed",
+      s.enabled ? null : "off",
+      s.running ? `${s.running} running` : null,
+    ]
+      .filter(Boolean)
+      .join(", ");
+    const exts = [...(s.extensions || []), ...(s.names || [])].join(" ");
+    console.log(
+      `${s.id.padEnd(w)}  ${s.label} — ${state}${exts ? `  (${exts})` : ""}`,
+    );
+  }
+}
+
+/** A server the list has, or the command dies naming where to look. */
+function server(ctx, list, id) {
+  if (!id) ctx.die("name the server: an id from work lsp list");
+  const hit = (list.servers || []).find((s) => s.id === id);
+  if (!hit) ctx.die(`no language server ${id} (see: work lsp list)`);
+  return hit;
+}
+
+/** @type {Array<{name: string, summary: string, help: string, run: (ctx: any) => Promise<void>}>} */
+export const commands = [
+  {
+    name: "lsp",
+    summary: "language servers: list | on | off | install | enable | disable",
+    help: `work lsp [list]
+  Whether language servers are on, and each one work knows: installed or
+  not, switched off or not, running copies, the file types it serves.
+work lsp on|off
+  Language servers for the whole app (off until switched on: nothing
+  starts or installs while off).
+work lsp install|update|remove <id>
+  Install, update or uninstall one server, as Settings does; the
+  installer's output goes to stderr.
+work lsp enable|disable <id>
+  Use or skip one installed server (disabling stops its running copies).`,
+    async run(ctx) {
+      const [verb = "list", id] = ctx.parse();
+      if (verb === "list") {
+        const list = await ctx.api.get("/api/lsp");
+        return ctx.out(list, printList);
+      }
+      if (verb === "on" || verb === "off") {
+        await ctx.api.post("/api/prefs", {
+          key: "lsp",
+          value: verb === "on" ? "1" : null,
+        });
+        return ctx.out({ on: verb === "on" }, () =>
+          console.log(`language servers ${verb}`),
+        );
+      }
+      if (verb === "install" || verb === "update" || verb === "remove") {
+        const list = await ctx.api.get("/api/lsp");
+        const s = server(ctx, list, id);
+        if (verb === "install" && s.installed) {
+          ctx.out({ id: s.id, installed: true }, () =>
+            console.log(
+              `${s.label} is already installed (work lsp update ${s.id} to update it)`,
+            ),
+          );
+          return;
+        }
+        if (verb !== "remove" && !s.installable)
+          ctx.die(
+            `${s.label} installs outside work${s.hint ? `: ${s.hint}` : ""}`,
+          );
+        const after = await follow(ctx, `lsp:${s.id}`, () =>
+          ctx.api.post(`/api/lsp/${encodeURIComponent(s.id)}`, {
+            action: verb,
+          }),
+        );
+        const now = (after.servers || []).find((x) => x.id === s.id);
+        if (!list.on && verb !== "remove")
+          ctx.warn("language servers are off: work lsp on to use it");
+        return ctx.out(now ?? { id: s.id }, () =>
+          console.log(
+            `${verb === "remove" ? "removed" : verb === "update" ? "updated" : "installed"} ${s.label}${now?.version ? ` ${now.version}` : ""}`,
+          ),
+        );
+      }
+      if (verb === "enable" || verb === "disable") {
+        const list = await ctx.api.get("/api/lsp");
+        const s = server(ctx, list, id);
+        await ctx.api.post("/api/prefs", {
+          key: "lsp-off",
+          change: { op: verb === "disable" ? "add" : "remove", item: s.id },
+        });
+        // Switched off, its copies stop now rather than at their idle end.
+        if (verb === "disable" && s.running)
+          await ctx.api.post(`/api/lsp/${encodeURIComponent(s.id)}`, {
+            action: "stop",
+          });
+        return ctx.out({ id: s.id, enabled: verb === "enable" }, () =>
+          console.log(`${s.label} ${verb}d`),
+        );
+      }
+      ctx.die(
+        `no lsp verb ${verb} (list, on, off, install, update, remove, enable, disable)`,
+      );
+    },
+  },
+];

package/bin/cli/notify.mjs

@@ -0,0 +1,53 @@
+import { resolveTarget, unresolved } from "./_target.mjs";
+
+/** `work notify`: an agent tells the user something — a toast on every
+ * open page, and a notification on their devices when the session's
+ * terminal is not on screen (Settings → Notifications, "An agent sends you
+ * a message"), past a few in ten minutes only shown. */
+export const commands = [
+  {
+    name: "notify",
+    summary: "tell the user something: a toast in the app and a push",
+    help: `work notify <message…> [--link <target>] [--title <t>] [--no-push] [--json]
+  Tell the user something: a toast on every open page of work and, unless
+  --no-push or the session's terminal is on screen, a notification on the
+  devices that have them on. From inside a session it is that session's;
+  elsewhere, the workspace's (the cwd's, or --workspace <id|name>).
+  --link   what the toast's Open (and a tap on the notification) opens: an
+           app page (/w/<id>/review?section=…), a URL (a dev server), or a
+           path in the workspace (src/a.ts:12, .share/shots/), which opens
+           in Files
+  --title  the notification's title in place of the session's name
+  At most one a second; past a few pushes in ten minutes the app still
+  shows it, only without a notification (the command says so).`,
+    async run(ctx) {
+      const words = ctx.parse(["--link", "--title", "--workspace"]);
+      const message = words.join(" ").trim();
+      if (!message)
+        ctx.die(
+          "say something: work notify <message…> (see: work help notify)",
+        );
+      const { ws } = await ctx.resolveWorkspace(ctx.flag("--workspace"));
+      const raw = ctx.flag("--link");
+      const target = raw ? await resolveTarget(ctx, ws, raw) : null;
+      if (raw && !target) ctx.die(unresolved(raw));
+      const res = await ctx.api.post(`/api/workspaces/${ws.id}/notices`, {
+        message,
+        ...(ctx.flag("--title") && { title: ctx.flag("--title") }),
+        ...(target && { link: target.link }),
+        ...(process.env.WORK_SESSION_ID && {
+          session: process.env.WORK_SESSION_ID,
+        }),
+        push: !ctx.has("--no-push"),
+      });
+      ctx.out(res, ({ push }) => {
+        console.log(
+          push.state === "sent"
+            ? `shown in the app, and pushed to ${push.devices} device${push.devices === 1 ? "" : "s"}`
+            : `shown in the app; not pushed: ${push.reason}`,
+        );
+        if (target) console.log(`link: ${target.link}`);
+      });
+    },
+  },
+];

package/bin/cli/open.mjs

@@ -0,0 +1,37 @@
+import { resolveTarget, unresolved } from "./_target.mjs";
+
+/** `work open`: an agent offers the user something to look at — a toast
+ * on every open page with an Open button; never a navigation of its own
+ * (the user may be typing), and no push (`work notify --link` is that). */
+export const commands = [
+  {
+    name: "open",
+    summary: "offer the user a file, folder or page to open in the app",
+    help: `work open <target> [--message <text>] [--json]
+  Offer the user something to look at: a toast on every open page of work
+  with an Open button (never a navigation by itself, and no notification:
+  work notify --link is that). Prints the link it offered.
+  <target>  a path in the workspace — a file (src/a.ts, src/a.ts:12) or a
+            folder (.share/shots/), opened in Files; an app page
+            (/w/<id>/review?section=<repo>@<topic>); or a URL (a dev server)
+  --message the toast's text in place of "Look at <target>"`,
+    async run(ctx) {
+      const [raw] = ctx.parse(["--message", "--workspace"]);
+      if (!raw) ctx.die("open what? work open <target> (see: work help open)");
+      const { ws } = await ctx.resolveWorkspace(ctx.flag("--workspace"));
+      const target = await resolveTarget(ctx, ws, raw);
+      if (!target) ctx.die(unresolved(raw));
+      const res = await ctx.api.post(`/api/workspaces/${ws.id}/notices`, {
+        message: ctx.flag("--message") || `Look at ${target.label}`,
+        link: target.link,
+        ...(process.env.WORK_SESSION_ID && {
+          session: process.env.WORK_SESSION_ID,
+        }),
+        push: false,
+      });
+      ctx.out({ ...target, notice: res.notice }, () =>
+        console.log(`offered in the app: ${target.link}`),
+      );
+    },
+  },
+];

package/bin/cli/repo.mjs

@@ -0,0 +1,98 @@
+// `work repo add|rm`: a workspace's repos from a terminal, as Manage's
+// Repos list adds and removes them.
+import { follow, opId } from "./_progress.mjs";
+import { repoName } from "./_repo.mjs";
+
+/** The workspace `--workspace` names, else the one this shell is in. */
+async function target(ctx) {
+  const arg = ctx.args.includes("--workspace")
+    ? ctx.flag("--workspace")
+    : undefined;
+  return (await ctx.resolveWorkspace(arg)).ws;
+}
+
+/** @type {Array<{name: string, summary: string, help: string, run: (ctx: any) => Promise<void>}>} */
+export const commands = [
+  {
+    name: "repo add",
+    summary: "add a repo to a workspace (clones it the first time)",
+    help: `work repo add <repo> [--base <branch>] [--fork] [--workspace <name|id>]
+  Add a repo to a workspace, as Manage does: a worktree of it on the
+  workspace's branch, from its default branch unless --base names another.
+  <repo> is owner/name, host/owner/name (GitHub Enterprise) or a clone URL;
+  --fork forks it to your account first and clones the fork. The workspace
+  is the one this shell runs in unless --workspace names another. Clone
+  progress goes to stderr. Prints where it landed (--json: the workspace).`,
+    async run(ctx) {
+      const [spec] = ctx.parse(["--base", "--workspace"]);
+      if (!spec) ctx.die("name the repo: work repo add <owner/name|clone URL>");
+      const fullName = repoName(spec);
+      if (!fullName)
+        ctx.die(
+          `not a repo: ${spec} (owner/name, host/owner/name or a clone URL)`,
+        );
+      const ws = await target(ctx);
+      const baseBranch = ctx.args.includes("--base")
+        ? ctx.flag("--base")
+        : undefined;
+      const op = opId();
+      const before = new Set(ws.repos.map((r) => r.worktree));
+      const updated = await follow(ctx, op, () =>
+        ctx.api.post(`/api/workspaces/${encodeURIComponent(ws.id)}/repos`, {
+          fullName,
+          baseBranch,
+          fork: ctx.has("--fork") || undefined,
+          opId: op,
+        }),
+      );
+      const added =
+        updated.repos.find((r) => !before.has(r.worktree)) ??
+        updated.repos.find((r) => r.full_name === fullName);
+      ctx.out(updated, () => {
+        if (!added) return console.log(`added ${fullName} to ${ws.name}`);
+        console.log(
+          `added ${added.full_name} to ${ws.name} as ${added.worktree}/ (base ${added.base_branch})`,
+        );
+        console.log(`  path: ${ws.display_path || ws.path}/${added.worktree}`);
+      });
+    },
+  },
+  {
+    name: "repo rm",
+    aliases: ["repo remove"],
+    summary: "remove a repo from a workspace (--yes)",
+    help: `work repo rm <worktree|owner/name> [--workspace <name|id>] --yes
+  Remove a repo from a workspace, as Manage does: its folder there is
+  deleted, with the workspace's local branches of it and its review
+  comments — uncommitted and unpushed work in it is lost; pushed branches
+  and their PRs stay on GitHub. Asks for --yes.`,
+    async run(ctx) {
+      const [spec] = ctx.parse(["--workspace"]);
+      if (!spec) ctx.die("name the repo: work repo rm <worktree> --yes");
+      const ws = await target(ctx);
+      const name = repoName(spec);
+      const repo = ws.repos.find(
+        (r) =>
+          r.worktree === spec.replace(/\/$/, "") ||
+          r.full_name === spec ||
+          (name && r.full_name === name),
+      );
+      if (!repo)
+        ctx.die(
+          `${ws.name} has no repo ${spec} (it has: ${ws.repos.map((r) => `${r.worktree}/`).join(", ") || "none"})`,
+        );
+      if (!ctx.yes)
+        ctx.die(
+          `removing ${repo.worktree}/ deletes ${ws.display_path || ws.path}/${repo.worktree} and ${ws.name}'s local branches of ${repo.full_name}; uncommitted and unpushed work there is lost. Pass --yes to go ahead`,
+        );
+      await follow(ctx, ws.id, () =>
+        ctx.api.del(
+          `/api/workspaces/${encodeURIComponent(ws.id)}/repos/${encodeURIComponent(repo.worktree)}`,
+        ),
+      );
+      ctx.out({ workspace: ws.id, removed: repo.worktree }, () =>
+        console.log(`removed ${repo.worktree}/ from ${ws.name}`),
+      );
+    },
+  },
+];

package/bin/cli/session.mjs

@@ -0,0 +1,167 @@
+// `work session`: which session this is (an agent's own pane, by
+// WORK_SESSION_ID), its name in the session list, and the workspace's
+// other sessions — starting one, sending it a prompt, closing it.
+
+/** More sessions than this in one workspace is an agent starting them in
+ * a loop, not a plan: past it, `new` wants --force. */
+const SESSION_CAP = 8;
+
+/** The session a command means: --session's, else this pane's own. */
+function sessionId(ctx) {
+  const id = ctx.flag("--session") || process.env.WORK_SESSION_ID;
+  if (!id)
+    ctx.die(
+      "not in a work session (WORK_SESSION_ID is unset): pass --session <id>",
+    );
+  return id;
+}
+
+/** The workspace's sessions with their state, this pane's marked. */
+async function sessionsOf(ctx, wsId) {
+  const me = process.env.WORK_SESSION_ID;
+  const list = await ctx.api.get(`/api/workspaces/${wsId}/sessions`);
+  return list.map((s) => ({
+    id: s.id,
+    agent: s.agent,
+    title: s.title || null,
+    phase: s.state?.phase || (s.state?.alive ? "idle" : "off"),
+    self: s.id === me,
+  }));
+}
+
+function sessionLine(ctx, s) {
+  return `${ctx.pad(s.id, 9)} ${ctx.pad(s.agent, 10)} ${ctx.pad(s.phase, 8)} ${s.title || ""}${s.self ? "  (this session)" : ""}`;
+}
+
+export const commands = [
+  {
+    name: "session",
+    summary: "this session and the workspace's others: title, new, send, kill",
+    help: `work session [--json]
+  This session (WORK_SESSION_ID): its id, agent, name, state, and the
+  workspace it is in (id, name, path) — what a link names (/w/<id>/…).
+work session list [id|name] [--json]
+  The workspace's sessions, this one marked.
+work session title "<name>" [--session <id>]
+  Name a session in the session list (empty clears it).
+work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"] [--workspace <id|name>] [--force]
+  Start a session (the default agent unless --agent; "shell" for a
+  terminal), name it, and hand it a first prompt. Past ${SESSION_CAP} sessions
+  in the workspace it wants --force.
+work session send <id> "<text>"
+  Type text into a session and press Enter, as the review's Send does.
+work session kill <id> --yes
+  Close a session and the process in it.`,
+    async run(ctx) {
+      const [verb, ...rest] = ctx.parse([
+        "--agent",
+        "--title",
+        "--prompt",
+        "--workspace",
+        "--session",
+      ]);
+      switch (verb) {
+        case undefined: {
+          const id = sessionId(ctx);
+          const { ws } = await ctx.resolveWorkspace();
+          const me = (await sessionsOf(ctx, ws.id)).find((s) => s.id === id);
+          if (!me) ctx.die(`no session ${id} in ${ws.name}`);
+          const out = {
+            ...me,
+            workspace: {
+              id: ws.id,
+              name: ws.name,
+              path: ws.path,
+              branch: ws.branch,
+            },
+          };
+          return ctx.out(out, (s) => {
+            console.log(
+              `${s.id}  ${s.agent}  ${s.phase}${s.title ? `  "${s.title}"` : ""}`,
+            );
+            console.log(
+              `workspace ${s.workspace.name} (${s.workspace.id})  ${s.workspace.path}`,
+            );
+          });
+        }
+        case "list": {
+          const { ws } = await ctx.resolveWorkspace(rest[0]);
+          const list = await sessionsOf(ctx, ws.id);
+          return ctx.out(list, (l) => {
+            if (!l.length) return console.log("no sessions");
+            for (const s of l) console.log(sessionLine(ctx, s));
+          });
+        }
+        case "title": {
+          const id = sessionId(ctx);
+          const title = rest.join(" ");
+          await ctx.api.patch(`/api/sessions/${id}`, { title });
+          return ctx.out({ id, title: title || null }, () =>
+            console.log(
+              title ? `named ${id} "${title}"` : `cleared ${id}'s name`,
+            ),
+          );
+        }
+        case "new": {
+          const { ws } = await ctx.resolveWorkspace(ctx.flag("--workspace"));
+          const existing = await sessionsOf(ctx, ws.id);
+          if (existing.length >= SESSION_CAP && !ctx.has("--force"))
+            ctx.die(
+              `${ws.name} already has ${existing.length} sessions: pass --force to start another`,
+            );
+          const agent = ctx.flag("--agent");
+          const created = await ctx.api.post(
+            `/api/workspaces/${ws.id}/sessions`,
+            agent ? { agent } : {},
+          );
+          const title = ctx.flag("--title");
+          if (title)
+            await ctx.api.patch(`/api/sessions/${created.id}`, { title });
+          const prompt = ctx.flag("--prompt");
+          // Sent, the session starts (detached) with it as its first
+          // prompt; otherwise it starts when someone opens it.
+          if (prompt)
+            await ctx.api.post(`/api/sessions/${created.id}/send`, {
+              text: prompt,
+            });
+          const out = {
+            id: created.id,
+            agent: created.agent,
+            title: title || null,
+            workspace: ws.id,
+            prompted: !!prompt,
+            href: `/w/${ws.id}?s=${created.id}`,
+          };
+          return ctx.out(out, (s) =>
+            console.log(
+              `started ${s.id} (${s.agent})${s.prompted ? " with its prompt" : ""}: [${s.title || s.agent}](${s.href})`,
+            ),
+          );
+        }
+        case "send": {
+          const [id, ...words] = rest;
+          const text = words.join(" ");
+          if (!id || !text) ctx.die('usage: work session send <id> "<text>"');
+          await ctx.api.post(`/api/sessions/${id}/send`, { text });
+          return ctx.out({ id, sent: true }, () =>
+            console.log(`sent to ${id}`),
+          );
+        }
+        case "kill": {
+          const [id] = rest;
+          if (!id) ctx.die("usage: work session kill <id> --yes");
+          if (!ctx.yes)
+            ctx.die(
+              `closing ${id} ends the process in it${id === process.env.WORK_SESSION_ID ? " — this session, the one running this command" : ""}: pass --yes`,
+            );
+          await ctx.api.del(`/api/sessions/${id}`);
+          return ctx.out({ id, killed: true }, () =>
+            console.log(`closed ${id}`),
+          );
+        }
+        default:
+          ctx.die(`no \`work session ${verb}\` (see: work help session)`);
+      }
+    },
+  },
+];