@skillcdn/console 0.1.24 → 0.3.1

package/src/cli/cli.ts

@@ -16,11 +16,12 @@ import {
   type RestClaim,
   type RestDecision,
   type RestMember,
+  type RestPackConnectStarted,
   type RestPerson,
   type RestSkillBrowse,
   type RestSkillFile,
   type RestSkillLoad,
-  type RestSkillPage,
+  type RestSkills,
   type RestTaskPatch,
 } from "../schemas.js";
 import {
@@ -28,7 +29,9 @@ import {
   type ColorName,
   GOAL_STATES,
   type GoalState,
+  PEOPLE_VISIBILITIES,
   PERSON_ROLES,
+  type PeopleVisibility,
   type PersonRole,
   PROJECT_ROLES,
   PROJECT_VISIBILITIES,
@@ -40,6 +43,7 @@ import {
   TASK_STATES,
   type TaskPriority,
   type TaskState,
+  WEEK_STARTS,
 } from "../vocabulary.js";
 import { loadWebRoot, type WebRoot, WebRootError } from "../web.js";
 import {
@@ -53,7 +57,7 @@ import {
   withLogin,
   withoutLogin,
 } from "./credentials.js";
-import type { DirectorySettings, DirectoryStore } from "./directory.js";
+import { type DirectorySettings, type DirectoryStore, THE_SENTENCE } from "./directory.js";
 import {
   formatAnswer,
   formatCategoryLine,
@@ -75,20 +79,34 @@ import {
   formatRules,
   formatRun,
   formatRunLine,
-  formatSkillBrowse,
-  formatSkillFile,
-  formatSkillFind,
-  formatSkillLoad,
-  formatSkills,
   formatTask,
   formatTaskLine,
   formatVersion,
   formatVersionLine,
   formatWork,
+  formatWorkspace,
+  moment,
+  setMomentZone,
 } from "./format.js";
 import { COMMAND_HELP, helpFor, ownSkillPath, usage } from "./help.js";
 import { describeInstall, type Install, updateCommandFor } from "./install.js";
 import type { NoticeStore } from "./notices.js";
+import {
+  bodyOfFile,
+  bodyOfFolder,
+  bodyOfSkill,
+  formatSkillBrowse,
+  formatSkillFile,
+  formatSkillFind,
+  formatSkillLoad,
+  formatSkills,
+  joinFile,
+  joinFolder,
+  joinSkill,
+  type PackSummary,
+  skillPathIn,
+  summaryOf,
+} from "./pack.js";
 import { createServeHandler, DEFAULT_SERVE_PORT, type Listen } from "./serve.js";
 
 // The `console` command (docs/specs/cli.md): the agent's side of the console. A thin client of
@@ -299,6 +317,14 @@ async function open(io: CliIo, values: Values): Promise<Session> {
     throw failed(wordsOf(resolved));
   }
   const { url, token } = resolved;
+  // Moments are printed in the workspace's time zone as the login kept it (ADR-0035); the
+  // environment's pair keeps nothing, and they stay as the API gives them.
+  setMomentZone(
+    resolved.via === "login"
+      ? credentials?.logins.find((kept) => kept.url === url && kept.account === resolved.account)
+          ?.timeZone
+      : undefined,
+  );
   const client = clientOf(io, url, token);
   const projectKey = async () =>
     text(values, "project") ?? io.env.CONSOLE_PROJECT ?? directory?.project;
@@ -473,18 +499,25 @@ async function personIdOf(
   return (await personOf(session, value)).id;
 }
 
-/** The person a login names, among the workspace's; the logins are as people sign in. */
+/**
+ * The person a login names, among the workspace's, found by their exact login as people sign in
+ * (ADR-0035): whom the console shows the person, and, for an owner of a project, anyone of the
+ * workspace, so that someone the People page does not show can still be listed.
+ */
 async function personOf(session: Session, login: string): Promise<RestPerson> {
-  const { items } = await session.client.people();
-  const found = items.find((person) => person.login.toLowerCase() === login.toLowerCase());
+  const found = await session.client.findPerson(login);
   if (found === undefined) {
     throw misuse(
-      `Nobody of the workspace is called ${login}. console people lists everyone, by login.`,
+      `Nobody of the workspace is called ${login}, or they are not yours to see. console people lists whom you see, by login.`,
     );
   }
   return found;
 }
 
+/** Who sees whom, as the command takes it: with a hyphen or an underscore. */
+const peopleVisibilityOf = (value: string): PeopleVisibility =>
+  wordOf(value.replaceAll("-", "_"), PEOPLE_VISIBILITIES, "who sees whom");
+
 /** One word of a vocabulary, or the refusal to understand. */
 function wordOf<T extends string>(value: string, words: readonly T[], what: string): T {
   const found = words.find((word) => word === value);
@@ -641,7 +674,14 @@ async function keep(
   }
   const next = withLogin(
     credentials,
-    { url, account: person.login, token, agent, since: new Date(io.now()).toISOString() },
+    {
+      url,
+      account: person.login,
+      token,
+      agent,
+      since: new Date(io.now()).toISOString(),
+      timeZone: me.workspace.timeZone ?? undefined,
+    },
     { default: asDefault },
   );
   const kept = await io.store.save(next);
@@ -815,6 +855,24 @@ function agentOf(env: CliIo["env"]): string | undefined {
   return undefined;
 }
 
+/**
+ * Keeps the workspace's time zone on the login the command used (ADR-0035), so that moments are
+ * printed in it from now on without asking; the environment's pair keeps nothing.
+ */
+async function rememberZone(io: CliIo, session: Session, zone: string | undefined): Promise<void> {
+  setMomentZone(zone);
+  if (session.via !== "login" || session.credentials === undefined) {
+    return;
+  }
+  const kept = session.credentials.logins.find(
+    (login) => login.url === session.url && login.account === session.account,
+  );
+  if (kept === undefined || kept.timeZone === zone) {
+    return;
+  }
+  await io.store.save(withLogin(session.credentials, { ...kept, timeZone: zone }));
+}
+
 const whoami: Command = async (args, io) => {
   const { values } = parse(args, {}, false);
   const session = await open(io, values);
@@ -823,6 +881,7 @@ const whoami: Command = async (args, io) => {
   if (person === null) {
     throw failed("The console does not know this token. Sign in again: console login");
   }
+  await rememberZone(io, session, me.workspace.timeZone ?? undefined);
   const key = await session.projectKey();
   const command = parseVersion(io.version);
   const server = parseVersion(me.console?.version);
@@ -903,12 +962,15 @@ const use: Command = async (args, io) => {
   const bound = pinUrl
     ? ` at ${session.url}${pinAccount && session.account !== undefined ? ` as ${session.account}` : ""}`
     : "";
-  answer(
-    io,
-    session,
-    project,
-    () =>
+  answer(io, session, project, () =>
+    [
       `Working in ${project.name} (${project.key})${bound} from this directory on: kept in ${kept}, which is meant to be committed in a private repository and left out of a public one. What its people ask of agents: console rules.`,
+      // Nothing sends an agent to the console until the checkout says so; the sentence is the
+      // skill's (references/the-sentence.md), printed here as `skillcdn use` prints its own.
+      "Then put this sentence into the checkout's agreement (AGENTS.md, or CLAUDE.md where that is the file agents read), as it is, so that every agent working here is sent to the console:",
+      "",
+      THE_SENTENCE,
+    ].join("\n"),
   );
   return EXIT.ok;
 };
@@ -1003,10 +1065,19 @@ const MAX_SKILL_PAGES = 64;
 /** How many results a search answers at most: what the deployment allows on one page. */
 const MAX_FIND_LIMIT = 25;
 
+/** The pack of the project as the console lists it, and what its reads are rendered at; none when the pack did not answer. */
+async function packOf(
+  project: ProjectClient,
+): Promise<{ readonly listing: RestSkills; readonly summary: PackSummary | undefined }> {
+  const listing = await project.skills();
+  return { listing, summary: summaryOf(listing) };
+}
+
 const skills: Command = async (args, io) => {
   const { values, positionals } = parse(args, {
     search: { type: "string" },
     limit: { type: "string" },
+    cursor: { type: "string" },
   });
   if (positionals.length > 1) {
     throw misuse("Say one folder: console skills [<folder>] [--search <words>]");
@@ -1016,8 +1087,11 @@ const skills: Command = async (args, io) => {
   const folder = given === undefined || given === "/" || given === "." ? undefined : given;
   const words = text(values, "search");
   const limit = text(values, "limit");
-  if (words === undefined && limit !== undefined) {
-    throw misuse("--limit goes with --search: console skills --search <words> [--limit <n>]");
+  const cursor = text(values, "cursor");
+  if (words === undefined && (limit !== undefined || cursor !== undefined)) {
+    throw misuse(
+      "--limit and --cursor go with --search: console skills --search <words> [--limit <n>] [--cursor <cursor>]",
+    );
   }
   const atMost = limit === undefined ? undefined : Number(limit);
   if (
@@ -1028,37 +1102,41 @@ const skills: Command = async (args, io) => {
   }
   const session = await open(io, values);
   const project = await session.project();
+  const { listing, summary } = await packOf(project);
+  // The pack as it stands; or why it does not answer, which a folder or a search would meet too.
+  if (summary === undefined || (words === undefined && given === undefined)) {
+    answer(io, session, listing, () => formatSkills(listing, io.skillsDir));
+    return EXIT.ok;
+  }
   if (words !== undefined) {
-    // One page of what the words find; more is said, and narrowed by the agent, not fetched.
-    const found = await project.skillFind(words, { path: folder, limit: atMost });
-    answer(io, session, found, () => formatSkillFind(found));
+    // One page of what the words find; more is said, and asked for with --cursor.
+    const found = await project.skillFind(words, { path: folder, limit: atMost, cursor });
+    answer(io, session, found, () => formatSkillFind(found, summary));
     return EXIT.ok;
   }
-  if (given !== undefined) {
-    // The folder whole: its pages until the end, as the deployment lists them.
-    const folders: NonNullable<RestSkillBrowse["folder"]>[] = [];
-    let cursor: string | undefined;
-    let last: RestSkillBrowse | undefined;
-    for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
-      last = await project.skillBrowse({ path: folder, cursor });
-      if (last.status !== "ready" || last.folder === null) {
-        break;
-      }
-      folders.push(last.folder);
-      if (last.folder.nextCursor === null) {
-        break;
-      }
-      cursor = last.folder.nextCursor;
+  // The folder whole: its pages until the end, as the pack lists them.
+  const pages: RestSkillBrowse[] = [];
+  let next: string | undefined;
+  let last: RestSkillBrowse | undefined;
+  for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
+    last = await project.skillBrowse({ path: folder, cursor: next });
+    if (last.read?.status !== "ready") {
+      break;
     }
-    if (last === undefined) {
-      throw failed("The folder could not be read.");
+    pages.push(last);
+    next = last.read.nextCursor ?? undefined;
+    if (next === undefined) {
+      break;
     }
-    const browsed = last;
-    answer(io, session, { ...browsed, folders }, () => formatSkillBrowse(browsed, folders));
-    return EXIT.ok;
   }
-  const found = await project.skills();
-  answer(io, session, found, () => formatSkills(found, io.skillsDir));
+  if (last === undefined) {
+    throw failed("The folder could not be read.");
+  }
+  const browsed = last;
+  const whole = joinFolder(pages, summary);
+  answer(io, session, { ...browsed, read: whole === undefined ? null : bodyOfFolder(whole) }, () =>
+    formatSkillBrowse(browsed, whole),
+  );
   return EXIT.ok;
 };
 
@@ -1074,84 +1152,73 @@ const skill: Command = async (args, io) => {
   }
   const session = await open(io, values);
   const project = await session.project();
+  const { listing, summary } = await packOf(project);
+  if (summary === undefined) {
+    answer(io, session, listing, () => formatSkills(listing, io.skillsDir));
+    return EXIT.ok;
+  }
   if (file !== undefined) {
-    // The file whole, page after page, as the console reads it from the deployment.
-    const parts: string[] = [];
+    // The file whole, page after page, as the console reads it from the pack.
+    const pages: RestSkillFile[] = [];
     let offset: number | undefined;
     let last: RestSkillFile | undefined;
-    for (let pages = 0; pages < MAX_SKILL_PAGES; pages += 1) {
+    for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
       last = await project.skillFile(file, offset === undefined ? {} : { offset });
-      if (last.status !== "ready" || last.file === null) {
+      if (last.read === null) {
         break;
       }
-      parts.push(last.file.content);
-      if (last.file.nextOffset === null) {
+      pages.push(last);
+      if (last.read.kind !== "file" || last.read.nextOffset === null) {
         break;
       }
-      offset = last.file.nextOffset;
+      offset = last.read.nextOffset;
     }
     if (last === undefined) {
       throw failed("The file could not be read.");
     }
-    const read = last;
-    const content = parts.join("");
-    answer(io, session, { ...read, content }, () => formatSkillFile(read, content));
+    const fileRead = last;
+    const whole = joinFile(pages, summary);
+    answer(io, session, { ...fileRead, read: whole === undefined ? null : bodyOfFile(whole) }, () =>
+      formatSkillFile(fileRead, whole),
+    );
     return EXIT.ok;
   }
-  const { path, pack } = skillPathOf(
+  const wanted = skillPathIn(
     theOne(
       positionals,
       "Say which skill: console skill <path of its SKILL.md>, or console skill --file <path> for a file of the pack",
     ),
+    listing.address,
   );
+  if ("error" in wanted) {
+    throw misuse(wanted.error);
+  }
   // The skill whole: its pages until complete, the rules first, as load_skill lays them out.
-  const pages: RestSkillPage[] = [];
+  const pages: RestSkillLoad[] = [];
   let cursor: string | undefined;
   let last: RestSkillLoad | undefined;
   for (let n = 0; n < MAX_SKILL_PAGES; n += 1) {
-    last = await project.skill(path, cursor);
-    if (last.status !== "ready" || last.skill === null) {
+    last = await project.skill(wanted.path, cursor);
+    if (last.read?.status !== "ready") {
       break;
     }
-    pages.push(last.skill);
-    if (last.skill.complete || last.skill.nextCursor === null) {
+    pages.push(last);
+    cursor = last.read.skill.nextCursor ?? undefined;
+    if (last.read.skill.complete === true || cursor === undefined) {
       break;
     }
-    cursor = last.skill.nextCursor;
   }
   if (last === undefined) {
     throw failed("The skill could not be read.");
   }
-  // A URI of another pack would read this pack's skill at the same path, or nothing: said instead.
-  if (pack !== undefined && last.address !== null && last.address !== pack) {
-    throw misuse(
-      `That URI is of another pack, ${pack}; this project's pack is at ${last.address}. Say the path of the SKILL.md, or a URI console skills lists.`,
-    );
-  }
   const loaded = last;
-  answer(io, session, { ...loaded, pages }, () => formatSkillLoad(loaded, pages));
+  const whole = joinSkill(pages, summary);
+  answer(io, session, { ...loaded, read: whole === undefined ? null : bodyOfSkill(whole) }, () =>
+    formatSkillLoad(loaded, whole),
+  );
   return EXIT.ok;
 };
 
-/**
- * A skill's path as given, or taken out of the URI `console skills` lists beside it
- * (`skill://gh/<owner>/<repo>/<path>`), with the pack the URI names, for the read to check.
- */
-function skillPathOf(given: string): { readonly path: string; readonly pack?: string } {
-  const uri = /^skill:\/\/(gh\/[^/]+\/[^/]+)\/(.+)$/.exec(given);
-  const named = uri?.[1];
-  const within = uri?.[2];
-  if (named !== undefined && within !== undefined) {
-    return { path: within, pack: `/${named}` };
-  }
-  if (given.startsWith("skill://")) {
-    throw misuse(
-      `Not a skill's URI the console knows: ${given}. Say the path of its SKILL.md from the repository's root, or the URI console skills lists.`,
-    );
-  }
-  return { path: given };
-}
-
 /** A version number given as a flag, or nothing; anything else is not understood. */
 function versionOf(given: string | undefined): number | undefined {
   if (given === undefined) {
@@ -1317,7 +1384,12 @@ const newTask: Command = async (args, io) => {
     ...(body === undefined ? {} : { body }),
     ...fields,
   });
-  answer(io, session, made, () => `Task #${made.number} written: ${made.title}\nid: ${made.id}`);
+  answer(
+    io,
+    session,
+    made,
+    () => `Task #${made.number} written: ${made.title}\ntask id: ${made.id}`,
+  );
   return EXIT.ok;
 };
 
@@ -1540,6 +1612,9 @@ const take: Command = async (args, io) => {
   answer(io, session, { run, task: taken, comments: comments.items, rules }, () =>
     [
       `Run ${run.id} began on #${found.number} ${found.title}, as "${run.agent}" for ${run.person.login}. The task is in progress and theirs.${tookOver}${elsewhere}`,
+      // The ids on a line of their own, each named: a run's and a task's begin alike, and a
+      // task has a number for people as well.
+      `run id: ${run.id}  task id: ${found.id}  (task #${found.number})`,
       "",
       formatTask(taken, undefined, undefined, comments.items),
       "",
@@ -1685,7 +1760,7 @@ const ask: Command = async (args, io) => {
   io.stdout(
     session.json
       ? `${JSON.stringify(raised, null, 2)}\n`
-      : `Decision ${raised.id} raised on run ${runId}; the run waits for a person.\n${formatOptions(raised)}\n`,
+      : `Decision ${raised.id} raised on run ${runId}; the run waits for a person.\ndecision id: ${raised.id}\n${formatOptions(raised)}\n`,
   );
   return settle(io, session, project, raised, seconds, true);
 };
@@ -1934,7 +2009,7 @@ const newGoal: Command = async (args, io) => {
     ...(startsOn === undefined ? {} : { startsOn }),
     ...(dueOn === undefined ? {} : { dueOn }),
   });
-  answer(io, session, made, () => `Goal set: ${made.title}\nid: ${made.id}`);
+  answer(io, session, made, () => `Goal set: ${made.title}\ngoal id: ${made.id}`);
   return EXIT.ok;
 };
 
@@ -2170,6 +2245,81 @@ const people: Command = async (args, io) => {
   return EXIT.ok;
 };
 
+// The workspace's settings (ADR-0035): read by everyone, changed by an administrator, themselves
+// on the Settings page or through their agent here (ADR-0021).
+const WORKSPACE_FLAGS =
+  "--people-visibility <everyone|shared-projects>, --week-start <auto|monday|sunday>, --time-zone <zone|none>";
+const WORKSPACE_USAGE = `Say what to do: console workspace  |  console workspace edit [${WORKSPACE_FLAGS.replaceAll(", ", "] [")}]  |  console workspace pack-token --connect|--stdin|--remove`;
+
+const workspace: Command = async (args, io) => {
+  const [verb, ...rest] = args;
+  if (verb === undefined || verb.startsWith("--")) {
+    const { values } = parse(args, {}, false);
+    const session = await open(io, values);
+    const me = await session.client.me();
+    await rememberZone(io, session, me.workspace.timeZone ?? undefined);
+    answer(io, session, me.workspace, () => formatWorkspace(me.workspace));
+    return EXIT.ok;
+  }
+  if (verb === "edit") {
+    const { values } = parse(
+      rest,
+      {
+        "people-visibility": { type: "string" },
+        "week-start": { type: "string" },
+        "time-zone": { type: "string" },
+      },
+      false,
+    );
+    const visibility = text(values, "people-visibility");
+    const weekStart = text(values, "week-start");
+    const zone = text(values, "time-zone");
+    if (visibility === undefined && weekStart === undefined && zone === undefined) {
+      throw misuse(`Say what to change: ${WORKSPACE_FLAGS}`);
+    }
+    const session = await open(io, values);
+    const changed = await session.client.updateWorkspace({
+      ...(visibility === undefined ? {} : { peopleVisibility: peopleVisibilityOf(visibility) }),
+      ...(weekStart === undefined
+        ? {}
+        : { weekStart: wordOf(weekStart, WEEK_STARTS, "a day the week begins on") }),
+      ...(zone === undefined ? {} : { timeZone: zone === "none" ? null : zone }),
+    });
+    await rememberZone(io, session, changed.timeZone ?? undefined);
+    answer(io, session, changed, () => formatWorkspace(changed));
+    return EXIT.ok;
+  }
+  if (verb === "pack-token") {
+    const { values, positionals } = parse(rest, PACK_TOKEN_FLAGS);
+    if (positionals.length > 0) {
+      throw misuse(
+        "The workspace's token names no project: console workspace pack-token --connect, --stdin or --remove",
+      );
+    }
+    const way = wayOf(values);
+    const session = await open(io, values);
+    const { client } = session;
+    return packToken(
+      io,
+      session,
+      way,
+      {
+        set: (token) => client.setWorkspacePackToken({ token }),
+        remove: () => client.removeWorkspacePackToken(),
+        connect: () => client.connectWorkspacePackToken(),
+        async standing() {
+          const state = await client.workspacePackTokenConnection();
+          return state.status === "connected"
+            ? { status: "connected", held: state.workspace }
+            : state;
+        },
+      },
+      formatWorkspace,
+    );
+  }
+  throw misuse(WORKSPACE_USAGE);
+};
+
 const PERSON_USAGE =
   "Say what to do: console person role <login> <admin|member>  |  person add <login> [--host gh|google]  |  person remove <login>  |  person deactivate <login>  |  person reactivate <login>";
 
@@ -2293,35 +2443,118 @@ const editProject: Command = async (args, io) => {
   return EXIT.ok;
 };
 
-/** The pack token (ADR-0028): read from standard input and never from an argument, so that no shell keeps it. */
-const projectPackToken: Command = async (args, io) => {
-  const { values, positionals } = parse(args, {
-    stdin: { type: "boolean" },
-    remove: { type: "boolean" },
-  });
-  const key = theOne(
-    positionals,
-    "Say which project: console project pack-token <key> --stdin, or console project pack-token <key> --remove",
-  );
-  if (on(values, "stdin") === on(values, "remove")) {
+/** How a pack's connection ended short of a token (ADR-0036), in words for the person. */
+const PACK_CONNECT_ENDED = {
+  expired: "The code expired before anyone approved it. Run the command again for a new one.",
+  declined: "The request was declined at SkillCDN, or the code was spent.",
+  refused:
+    "SkillCDN refused the request: the repository is not one the person may open, the pack is public and needs no token, or they hold as many tokens as one may.",
+} as const;
+
+/** How a SkillCDN token is to change, one of the three the flags name. */
+const wayOf = (values: Values): "connect" | "stdin" | "remove" => {
+  const ways = (["connect", "stdin", "remove"] as const).filter((way) => on(values, way));
+  const [way] = ways;
+  if (way === undefined || ways.length !== 1) {
     throw misuse(
-      "Say one of --stdin, which reads the token from standard input, and --remove, which takes it away.",
+      "Say one of --connect, which asks SkillCDN for a code a person approves; --stdin, which reads a token made by hand from standard input; and --remove, which takes the token away.",
     );
   }
-  const session = await open(io, values);
-  const project = session.client.project(key);
-  if (on(values, "remove")) {
-    const changed = await project.removePackToken();
-    answer(io, session, changed, () => formatProject(changed));
+  return way;
+};
+
+/** Whose SkillCDN token the command works: a project's, or the workspace's for the organization's pack. */
+interface TokenHolder<T> {
+  set(token: string): Promise<T>;
+  remove(): Promise<T>;
+  connect(): Promise<RestPackConnectStarted>;
+  standing(): Promise<
+    | { readonly status: "none" }
+    | { readonly status: "pending" }
+    | { readonly status: "ended"; readonly reason: keyof typeof PACK_CONNECT_ENDED }
+    | { readonly status: "connected"; readonly held: T }
+  >;
+}
+
+/**
+ * The SkillCDN token (ADR-0028): connected with a code a person approves at SkillCDN (ADR-0036),
+ * or read from standard input and never from an argument, so that no shell keeps it; or taken
+ * away. The same for a project's and for the workspace's.
+ */
+async function packToken<T>(
+  io: CliIo,
+  session: Session,
+  way: "connect" | "stdin" | "remove",
+  holder: TokenHolder<T>,
+  format: (held: T) => string,
+): Promise<number> {
+  if (way === "remove") {
+    const changed = await holder.remove();
+    answer(io, session, changed, () => format(changed));
     return EXIT.ok;
   }
+  if (way === "connect") {
+    const started = await holder.connect();
+    io.stdout(
+      `To connect the pack, a person who may open its repository opens ${started.url} signed in at SkillCDN, checks that the page shows the code ${started.code}, and approves; the console receives the SkillCDN token and keeps it sealed, shown to nobody.\nWaiting for that, until ${moment(started.expiresAt)}.\n`,
+    );
+    for (;;) {
+      await io.sleep(started.intervalSeconds * 1000);
+      const state = await holder.standing();
+      if (state.status === "pending") {
+        continue;
+      }
+      if (state.status === "connected") {
+        answer(io, session, state.held, () => `Connected.\n${format(state.held)}`);
+        return EXIT.ok;
+      }
+      if (state.status === "ended") {
+        throw failed(PACK_CONNECT_ENDED[state.reason]);
+      }
+      throw failed(
+        "The console no longer waits for the connection; run the command again for a new code.",
+      );
+    }
+  }
   const token = (await io.readStdin()).trim();
   if (token.length === 0) {
     throw failed("No token was given on standard input.");
   }
-  const changed = await project.setPackToken({ token });
-  answer(io, session, changed, () => formatProject(changed));
+  const changed = await holder.set(token);
+  answer(io, session, changed, () => format(changed));
   return EXIT.ok;
+}
+
+const PACK_TOKEN_FLAGS = {
+  connect: { type: "boolean" },
+  stdin: { type: "boolean" },
+  remove: { type: "boolean" },
+} as const;
+
+const projectPackToken: Command = async (args, io) => {
+  const { values, positionals } = parse(args, PACK_TOKEN_FLAGS);
+  const key = theOne(
+    positionals,
+    "Say which project: console project pack-token <key> --connect, --stdin or --remove",
+  );
+  const way = wayOf(values);
+  const session = await open(io, values);
+  const project = session.client.project(key);
+  return packToken(
+    io,
+    session,
+    way,
+    {
+      set: (token) => project.setPackToken({ token }),
+      remove: () => project.removePackToken(),
+      connect: () => project.connectPackToken(),
+      async standing() {
+        const state = await project.packTokenConnection();
+        return state.status === "connected" ? { status: "connected", held: state.project } : state;
+      },
+    },
+    formatProject,
+  );
 };
 
 const projectIcon: Command = async (args, io) => {
@@ -2548,6 +2781,7 @@ const COMMANDS: Readonly<Record<string, Command>> = {
   rules,
   people,
   person,
+  workspace,
   project,
   members,
   member,
@@ -2699,6 +2933,8 @@ function hintFor(error: ApiError, io: CliIo, seen: ConsoleSeen): string {
       return "The person is listed already. console member role <login> <owner|member> changes what they are.\n";
     case "member.not_found":
       return "The person is not listed in the project. console members lists those who are.\n";
+    case "member.open_project":
+      return "The project is open to the workspace, so everyone of it is a member already. console member add <login> --role owner lists an owner; console member role <login> member takes one back to member.\n";
     case "category.key_taken":
       return "A category has that key already. console categories lists them.\n";
     case "category.not_found":