@monster-orange/den 0.4.14 → 0.4.16

package/src/shared/agents/conversations.ts

@@ -32,6 +32,16 @@ export interface RuntimeConversation {
   lastAt: string;
   /** The folder it ran in. */
   cwd: string;
+  /**
+   * AG-17.1c: the model its last answer came from (the last assistant
+   * record's `message.model`), so Bring in keeps it. Absent when unknown.
+   */
+  model?: string;
+  /**
+   * AG-17.1c: the MCP servers its tools came from (`mcp__<server>__<tool>`
+   * tool calls in the ends read), sorted. Absent when none.
+   */
+  mcp?: string[];
 }
 
 /** Bytes read at each end of a transcript. */
@@ -114,22 +124,63 @@ function promptText(rec: Record<string, unknown>): string | null {
   return cleanName(text);
 }
 
-/** A transcript's cwd and title, from its two ends. */
+/** A model name as a transcript records it: short, printable, not synthetic. */
+const MODEL_RE = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/;
+/** An MCP tool's name: `mcp__<server>__<tool>`. */
+const MCP_TOOL_RE = /^mcp__([A-Za-z0-9_.-]+?)__[A-Za-z0-9_.-]+$/;
+
+/** An assistant record's tool calls' names. */
+function toolNames(rec: Record<string, unknown>): string[] {
+  const content = (rec.message as { content?: unknown } | undefined)?.content;
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((c) => {
+    const b = c as { type?: unknown; name?: unknown };
+    return b?.type === "tool_use" && typeof b.name === "string" ? [b.name] : [];
+  });
+}
+
+/** A transcript's summary from its two ends (AG-17.1, AG-17.1c). */
+export interface TranscriptSummary {
+  cwd: string | null;
+  title: string | null;
+  /** The last assistant record's model, or null. */
+  model: string | null;
+  /** The MCP servers its tool calls name, sorted. */
+  mcp: string[];
+}
+
+/** A transcript's cwd, title, last model and MCP servers, from its two ends. */
 export function transcriptSummary(
   file: string,
   bytes = ENDS_BYTES,
-): { cwd: string | null; title: string | null } {
+): TranscriptSummary {
   const { head, tail } = readEnds(file, bytes);
   let cwd: string | null = null;
   let prompt: string | null = null;
   let title: string | null = null;
+  let model: string | null = null;
+  const mcp = new Set<string>();
   const titleIn = (line: string) => {
     if (!line.includes("custom-title")) return;
     const r = parse(line);
     if (r?.type === "custom-title") title = cleanName(r.customTitle) ?? title;
   };
+  // AG-17.1c: the last answer's model, and the MCP servers its tools came from.
+  const assistantIn = (line: string) => {
+    if (!line.includes('"assistant"')) return;
+    const r = parse(line);
+    if (r?.type !== "assistant") return;
+    const m = (r.message as { model?: unknown } | undefined)?.model;
+    if (typeof m === "string" && MODEL_RE.test(m) && m !== "<synthetic>")
+      model = m;
+    for (const n of toolNames(r)) {
+      const hit = MCP_TOOL_RE.exec(n);
+      if (hit) mcp.add(hit[1]);
+    }
+  };
   for (const line of head) {
     titleIn(line);
+    assistantIn(line);
     if (cwd && prompt) continue;
     if (!line.includes('"cwd"') && !line.includes('"user"')) continue;
     const r = parse(line);
@@ -138,8 +189,73 @@ export function transcriptSummary(
       cwd = r.cwd;
     prompt ??= promptText(r);
   }
-  for (const line of tail) titleIn(line);
-  return { cwd, title: title ?? prompt };
+  for (const line of tail) {
+    titleIn(line);
+    assistantIn(line);
+  }
+  return { cwd, title: title ?? prompt, model, mcp: [...mcp].sort() };
+}
+
+/** Written this recently, a turn whose last record is an answer is still going. */
+export const TURN_QUIET_MS = 5_000;
+
+/**
+ * AG-18: whether a conversation's turn is still going, from its tail: the
+ * last user or assistant record. An answer that ended (`end_turn`, a stop
+ * sequence, the token limit) is idle; a tool call, or a prompt or tool
+ * result with no answer yet, is busy; an answer with no stop reason is busy
+ * until the file has been quiet TURN_QUIET_MS. An interrupted turn is idle.
+ * No transcript: idle (nothing was asked yet).
+ */
+export function transcriptBusy(
+  file: string | null,
+  now = Date.now(),
+  bytes = ENDS_BYTES,
+): boolean {
+  if (!file) return false;
+  let mtime: number;
+  try {
+    mtime = fs.statSync(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  const { head, tail } = readEnds(file, bytes);
+  const lines = tail.length ? [...head, ...tail] : head;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.includes('"user"') && !line.includes('"assistant"')) continue;
+    const r = parse(line);
+    if (!r || r.isSidechain === true || r.isMeta === true) continue;
+    if (r.type === "assistant") {
+      const msg = r.message as { stop_reason?: unknown } | undefined;
+      const stop = msg?.stop_reason;
+      if (stop === "tool_use" || toolNames(r).length) return true;
+      if (
+        stop === "end_turn" ||
+        stop === "stop_sequence" ||
+        stop === "max_tokens"
+      )
+        return false;
+      return now - mtime < TURN_QUIET_MS;
+    }
+    if (r.type === "user") {
+      const content = (r.message as { content?: unknown } | undefined)?.content;
+      const text =
+        typeof content === "string"
+          ? content
+          : Array.isArray(content)
+            ? ((
+                content.find(
+                  (c) => (c as { type?: unknown })?.type === "text",
+                ) as { text?: unknown } | undefined
+              )?.text ?? "")
+            : "";
+      if (typeof text === "string" && text.startsWith("[Request interrupted"))
+        return false;
+      return true;
+    }
+  }
+  return false;
 }
 
 /** A folder's absolute forms: as given and its real path. */
@@ -159,13 +275,25 @@ function forms(dir: string): string[] {
  * newest first, at most MAX_CONVERSATIONS. Never throws: a history it
  * can't read is no conversations.
  */
+/**
+ * Where a workspace's conversations ran (AG-17.1): in or under one of
+ * `under`, or exactly in one of `exact` (a shared repos root: its other
+ * subfolders are other workspaces' or no repo's).
+ */
+export interface ConversationScope {
+  under: string[];
+  exact?: string[];
+}
+
 export function claudeConversations(
-  folder: string,
+  scope: string | ConversationScope,
   env: NodeJS.ProcessEnv = process.env,
 ): RuntimeConversation[] {
+  const sc = typeof scope === "string" ? { under: [scope] } : scope;
   const root = claudeProjectsDir(env);
-  const dirs = forms(folder);
-  const slugs = dirs.map(claudeSlug);
+  const dirs = sc.under.flatMap(forms);
+  const exact = (sc.exact ?? []).flatMap(forms);
+  const slugs = [...dirs, ...exact].map(claudeSlug);
   let projects: string[];
   try {
     projects = fs.readdirSync(root);
@@ -208,18 +336,37 @@ export function claudeConversations(
       continue;
     }
     const cwd = s.cwd;
-    if (!cwd || !dirs.some((d) => within(cwd, d))) continue;
+    // Filtered before the cap, so others' conversations never crowd out
+    // this workspace's.
+    if (
+      !cwd ||
+      !(
+        dirs.some((d) => within(cwd, d)) ||
+        exact.some((d) => path.resolve(cwd) === d)
+      )
+    )
+      continue;
     seen.add(f.id);
     out.push({
       id: f.id,
       title: s.title,
       lastAt: new Date(f.mtimeMs).toISOString(),
       cwd,
+      ...(s.model ? { model: s.model } : {}),
+      ...(s.mcp.length ? { mcp: s.mcp } : {}),
     });
   }
   return out;
 }
 
+/** Whether a conversation that ran in `cwd` is in `scope` (AG-17.1). */
+export function inScope(cwd: string, scope: ConversationScope): boolean {
+  return (
+    scope.under.flatMap(forms).some((d) => within(cwd, d)) ||
+    (scope.exact ?? []).flatMap(forms).some((d) => path.resolve(cwd) === d)
+  );
+}
+
 /** Whether a conversation last written at `lastAt` is still open elsewhere. */
 export function openElsewhere(lastAt: string, now = Date.now()): boolean {
   const t = Date.parse(lastAt);

package/src/shared/agents/den-claude.ts

@@ -70,7 +70,11 @@ import { catalogFind } from "./catalog-runtime.js";
 import { locateRuntime, type RuntimeFind } from "./runtime-search.js";
 import { claudeProjectsDir } from "../usage/paths.js";
 import { cleanName, transcriptTitle } from "./transcript-follow.js";
-import { claudeConversations } from "./conversations.js";
+import {
+  claudeConversations,
+  transcriptBusy,
+  transcriptSummary,
+} from "./conversations.js";
 
 /**
  * `/rename "x"` keeps the quotes in customTitle: one matching pair around
@@ -490,13 +494,31 @@ export const denClaude: Runtime = {
     return transcriptFile(token, env) !== null;
   },
   // AG-17.1: its transcripts for the folder (conversations.ts).
-  listSessions(cwd, env = process.env) {
+  listSessions(scope, env = process.env) {
     try {
-      return claudeConversations(cwd, env);
+      return claudeConversations(scope, env);
     } catch {
       return [];
     }
   },
+  // AG-17.1: the folder a conversation ran in (only the ends of its file),
+  // so a foreign one is refused by name.
+  conversationCwd(token, env = process.env) {
+    try {
+      const file = transcriptFile(token, env);
+      return file ? transcriptSummary(file).cwd : null;
+    } catch {
+      return null;
+    }
+  },
+  // AG-18: mid-turn, from its transcript's tail (never the whole file).
+  turnBusy(token, env = process.env) {
+    try {
+      return transcriptBusy(transcriptFile(token, env));
+    } catch {
+      return false;
+    }
+  },
   // AG-4b, unofficial (catalog sessionName): `/rename` appends a
   // {"type":"custom-title","customTitle":…} record to the transcript; the
   // latest one, read on from the last ask (never the whole file), less one

package/src/shared/agents/records.ts

@@ -103,6 +103,25 @@ export interface AgentRecord {
    * the list tags it. Start fresh and Relaunch keep the choices.
    */
   overrides?: Override[];
+  /**
+   * AG-18: each persona change, oldest first: from, to, when, and who (a
+   * person's sign-in, or "cli").
+   */
+  personaChanges?: PersonaChange[];
+  /**
+   * AG-18: a persona change waiting for this agent's turn to end. The wait
+   * lives in the server's memory, so a restart drops it; the upkeep at
+   * start clears this and audits the cancel (cancelStalePersonaChanges).
+   */
+  pendingPersona?: { to: string; since: string; by?: string };
+}
+
+/** One persona change of an agent (AG-18). */
+export interface PersonaChange {
+  from: string;
+  to: string;
+  at: string;
+  by?: string;
 }
 
 /** A setting a session can override for one launch (AG-10.9). */
@@ -166,6 +185,24 @@ export interface AgentUsage {
 /** An agent id: the same rules as a workspace or session name. */
 export const AGENT_ID_RE = WORKSPACE_NAME_RE;
 
+/**
+ * AG-10.10b: the agent id a Name gives, so the name works in the CLI too:
+ * lowercase, spaces to "-", only id characters, at most 64. Null when
+ * nothing of it is left ("!!!"). The page's nameSlug is the same rule.
+ */
+export function nameSlug(name: string): string | null {
+  const s = name
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9._-]/g, "")
+    .replace(/-{2,}/g, "-")
+    .replace(/^[^a-z0-9]+/, "")
+    .slice(0, 64)
+    .replace(/[-._]+$/, "");
+  return s && AGENT_ID_RE.test(s) ? s : null;
+}
+
 export function agentsDir(stateDir: string): string {
   return path.join(stateDir, "agents");
 }

package/src/shared/agents/runtime.ts

@@ -201,7 +201,17 @@ export interface Runtime {
    * transcript). Each id is one `resume` continues. None: this runtime
    * can't bring one in yet. Must never throw.
    */
-  listSessions?(cwd: string, env?: NodeJS.ProcessEnv): RuntimeConversation[];
+  listSessions?(
+    scope: string | { under: string[]; exact?: string[] },
+    env?: NodeJS.ProcessEnv,
+  ): RuntimeConversation[];
+  /** AG-17.1: the folder conversation `token` ran in, or null. Never throws. */
+  conversationCwd?(token: string, env?: NodeJS.ProcessEnv): string | null;
+  /**
+   * AG-18: whether conversation `token` is mid-turn (den-claude: its
+   * transcript's tail). None: the runtime can't tell. Never throws.
+   */
+  turnBusy?(token: string, env?: NodeJS.ProcessEnv): boolean;
   /**
    * What the runtime prints when it exits at once (0.4.8): `noConversation`
    * when a resume finds nothing to continue, `idInUse` when a new

package/src/shared/claim-code.ts

@@ -0,0 +1,163 @@
+/**
+ * The claim code (0.4.15, Ward 2026-11-07): how the browser the person
+ * opens at the end of the install signs in without a sign-in step, so that
+ * approving an agent's changes (which needs a signed-in browser session,
+ * even on localhost) works from the first page.
+ *
+ *  - `c1.<nonce>.<expiry>.<mac>`, the mac HMAC-SHA256(web.secret, context +
+ *    the rest), its context its own: a login code (web-session.ts) is never
+ *    a claim code, and the other way round.
+ *  - Valid for 30 minutes: an install hands it over, and the person may take
+ *    a while to open it. An expiry further out than that is refused.
+ *  - Single use. Used nonces are kept in `<state dir>/claim-nonces.json`
+ *    (0600) until they expire, so a server restart can't revive one. The
+ *    file holds nonces only, never a code. A file that won't parse refuses
+ *    every claim (fail closed); the sign-in flows still work.
+ *  - Minted by the CLI (`<cli> web claim-link`), which reads web.secret as
+ *    the same OS user. The CLI refuses inside an agent's session
+ *    (claimRefusalForAgent): an agent must never hold one.
+ *
+ * Limit: an agent running as the same OS user could, in principle, read
+ * web.secret or the browser's cookie store from disk. That is the strength
+ * of Den's other person-only routes too; only an OS boundary is stronger.
+ */
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import { ACTOR_TOKEN_ENV } from "./actor-token.js";
+import { AGENT_ACTOR_ENV } from "./sessions/env.js";
+
+export const CLAIM_CODE_TTL_MS = 30 * 60_000;
+const SKEW_MS = 5_000;
+const CONTEXT = "den-claim-v1:";
+export const CLAIM_NONCES_FILE = "claim-nonces.json";
+
+function mac(secret: Buffer, body: string): Buffer {
+  return createHmac("sha256", secret)
+    .update(CONTEXT + body)
+    .digest();
+}
+
+/** A fresh claim code, valid for 30 minutes from `now`. */
+export function mintClaimCode(
+  secret: Buffer,
+  now: number = Date.now(),
+): string {
+  const nonce = randomBytes(16).toString("base64url");
+  const body = `c1.${nonce}.${(now + CLAIM_CODE_TTL_MS).toString(36)}`;
+  return `${body}.${mac(secret, body).toString("base64url")}`;
+}
+
+export type ClaimCodeCheck =
+  | { ok: true; nonce: string; expiresAt: number }
+  | { ok: false; reason: "malformed" | "bad_mac" | "expired" };
+
+/**
+ * Whether `code` is a claim code this secret minted, still in its 30
+ * minutes. Constant-time mac. Single use is ClaimNonces'.
+ */
+export function checkClaimCode(
+  code: string,
+  secret: Buffer,
+  now: number = Date.now(),
+): ClaimCodeCheck {
+  const m =
+    /^(c1\.([A-Za-z0-9_-]{22})\.([0-9a-z]{1,11}))\.([A-Za-z0-9_-]{43})$/.exec(
+      code,
+    );
+  if (!m) return { ok: false, reason: "malformed" };
+  const given = Buffer.from(m[4], "base64url");
+  const want = mac(secret, m[1]);
+  if (given.length !== want.length || !timingSafeEqual(given, want))
+    return { ok: false, reason: "bad_mac" };
+  const expiresAt = parseInt(m[3], 36);
+  if (
+    !Number.isFinite(expiresAt) ||
+    now >= expiresAt ||
+    expiresAt - now > CLAIM_CODE_TTL_MS + SKEW_MS
+  )
+    return { ok: false, reason: "expired" };
+  return { ok: true, nonce: m[2], expiresAt };
+}
+
+/**
+ * `<origin>/auth?claim=<code>`: the sign-in route, so it is classed as one
+ * (a mutating GET: another site can't open it; an agent's token can't).
+ */
+export function claimLink(origin: string, code: string): string {
+  return `${origin.replace(/\/+$/, "")}/auth?claim=${encodeURIComponent(code)}`;
+}
+
+/**
+ * Why the CLI won't let a browser in from here (a claim link, a sign-in
+ * link, pairing a device, the GitHub owner), or null when it may: inside
+ * an agent's session (DEN_AGENT or DEN_ACTOR_TOKEN set) it never does.
+ */
+export function personGrantRefusal(env: NodeJS.ProcessEnv): string | null {
+  if (env[AGENT_ACTOR_ENV] !== undefined || env[ACTOR_TOKEN_ENV] !== undefined)
+    return "An agent can't do this: it lets a browser in as you. Run it in your own terminal.";
+  return null;
+}
+
+/** Why the CLI won't mint a claim code here, or null when it may. */
+export function claimRefusalForAgent(env: NodeJS.ProcessEnv): string | null {
+  return personGrantRefusal(env)
+    ? "An agent can't make a claim link: it signs a browser in as the person. Run it in your own terminal."
+    : null;
+}
+
+/** The used claim nonces, kept until they expire (a file, 0600). */
+export class ClaimNonces {
+  constructor(private readonly stateDir: string) {}
+
+  private file(): string {
+    return path.join(this.stateDir, CLAIM_NONCES_FILE);
+  }
+
+  /** The used nonces; null when the file is there but won't parse (fail closed). */
+  private read(): Record<string, number> | null {
+    let raw: string;
+    try {
+      raw = fs.readFileSync(this.file(), "utf-8");
+    } catch (e) {
+      return (e as NodeJS.ErrnoException).code === "ENOENT" ? {} : null;
+    }
+    let o: unknown;
+    try {
+      o = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+    if (!o || typeof o !== "object" || Array.isArray(o)) return null;
+    const out: Record<string, number> = {};
+    for (const [k, v] of Object.entries(o as Record<string, unknown>))
+      if (/^[A-Za-z0-9_-]{22}$/.test(k) && typeof v === "number") out[k] = v;
+    return out;
+  }
+
+  private write(used: Record<string, number>): void {
+    fs.mkdirSync(this.stateDir, { recursive: true });
+    const tmp = `${this.file()}.${process.pid}.${randomBytes(4).toString("hex")}`;
+    fs.writeFileSync(tmp, JSON.stringify(used) + "\n", { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, this.file());
+  }
+
+  /**
+   * Use `nonce` (its code expires at `expiresAt`): true the first time,
+   * false once used. Expired entries are pruned on the way.
+   */
+  consume(nonce: string, expiresAt: number, now: number = Date.now()): boolean {
+    const used = this.read();
+    // Unreadable: refuse every claim rather than forget which were used.
+    if (!used) return false;
+    for (const [k, exp] of Object.entries(used)) if (exp <= now) delete used[k];
+    if (nonce in used) {
+      this.write(used);
+      return false;
+    }
+    used[nonce] = expiresAt;
+    this.write(used);
+    return true;
+  }
+}

package/src/shared/cli-command.ts

@@ -143,6 +143,37 @@ export function sshTarget(
   return /^[a-z0-9._:-]+$/.test(h) && !h.startsWith("-") ? h : fallback;
 }
 
+/** An account name ssh can take before `@`: letters, digits, `.`, `_`, `-`. */
+const SSH_USER_RE = /^[A-Za-z0-9_][A-Za-z0-9._-]{0,63}$/;
+
+/**
+ * `web.ssh_user` as stored (SEC-2a-UX): the account the signed-out page's
+ * ssh link and command log in as. undefined when unset (the account Den
+ * runs as); "" leaves the account off. Throws naming the key otherwise.
+ */
+export function parseSshUser(v: unknown): string | undefined {
+  if (v === undefined || v === null) return undefined;
+  if (typeof v !== "string" || (v.trim() !== "" && !SSH_USER_RE.test(v.trim())))
+    throw new Error(
+      `web.ssh_user must be an account name (letters, digits, ".", "_", "-"), or "" to leave it off; got ${JSON.stringify(v)}`,
+    );
+  return v.trim();
+}
+
+/**
+ * The account for the ssh link: `setting` when set ("" for none), else
+ * `osUser` when ssh can take it, else none.
+ */
+export function sshUser(setting: string | undefined, osUser: string): string {
+  if (setting !== undefined) return setting;
+  return SSH_USER_RE.test(osUser) ? osUser : "";
+}
+
+/** `user@target`, or the bare target when there's no user. */
+export function sshLogin(target: string, user: string): string {
+  return user ? `${user}@${target}` : target;
+}
+
 /** `Mac-Studio.localdomain` → `Mac-Studio`; an IP literal stays whole. */
 export function shortHostname(hostname: string): string {
   const h = hostname.trim();

package/src/shared/den-config.ts

@@ -831,6 +831,11 @@ export interface McpConfig {
   run_tests?: { envs?: string[] };
   /** `remote: true` lets the log tools read non-local sources (e.g. CloudWatch). */
   logs?: { remote?: boolean };
+  /**
+   * The held writes (workspace_create, repo_add, service_try): on by
+   * default, each run only after the person's Allow. false hides them.
+   */
+  approvals?: boolean;
 }
 
 /** `mcp:` with its defaults applied. */
@@ -838,6 +843,8 @@ export interface ResolvedMcpConfig {
   actions: McpAction[];
   runTestsEnvs: Environment[];
   logsRemote: boolean;
+  /** Whether the held writes are registered (default true). */
+  approvals: boolean;
 }
 
 /**
@@ -865,10 +872,15 @@ export function readMcpConfig(
       return e as Environment;
     },
   );
+  if (raw.approvals !== undefined && typeof raw.approvals !== "boolean")
+    throw new Error(
+      `mcp.approvals: true or false, not ${JSON.stringify(raw.approvals)}`,
+    );
   return {
     actions: [...new Set(actions)],
     runTestsEnvs: [...new Set(runTestsEnvs)],
     logsRemote: raw.logs?.remote === true,
+    approvals: raw.approvals !== false,
   };
 }
 

package/src/shared/environment-manager/workspaces.ts

@@ -355,6 +355,26 @@ export function repoFolders(cfg: WorkspaceConfig | undefined): string[] {
     .filter((p): p is string => typeof p === "string" && path.isAbsolute(p));
 }
 
+/**
+ * Where Bring in looks for a workspace's conversations (AG-17.1). Its own
+ * folder, and everything in it; each by-path repo's folder, outside it
+ * too. When its folder is only the shared repos root (no folder of its
+ * own), the root's other subfolders are other workspaces' repos or no
+ * repo at all: only its repos' folders count, and the root itself only
+ * exactly.
+ */
+export function conversationFolders(
+  name: string,
+  cfg: WorkspaceConfig,
+  reposRoot: string,
+): { under: string[]; exact: string[] } {
+  const dir = resolveWorkspaceDir(name, cfg, reposRoot);
+  const repos = repoFolders(cfg);
+  if (path.resolve(dir) === path.resolve(reposRoot))
+    return { under: repos, exact: [dir] };
+  return { under: [dir, ...repos], exact: [] };
+}
+
 export function getWorkspaceByName(name: string): {
   name: string;
   config: WorkspaceConfig;

package/src/shared/github-app.ts

@@ -83,6 +83,13 @@ export function githubClientId(configured: string | undefined): string {
   return (configured ?? MO_DEN_GITHUB_CLIENT_ID).trim();
 }
 
+/**
+ * The docs section the signed-out page's Learn more opens (SEC-2a-UX):
+ * docs/distributions.md, "Signing in with GitHub", in the public repo.
+ */
+export const GITHUB_SIGNIN_DOCS =
+  "https://github.com/Monster-Orange/den/blob/main/docs/distributions.md#signing-in-with-github";
+
 /** What a GitHub button says while no client id is configured. */
 export function noClientIdMessage(cli: string): string {
   return (