@tokenoftrust/cli 1.4.0-rc.2 → 1.4.0-rc.21

package/README.md

@@ -5,11 +5,12 @@ One command to go from a Token of Trust invite to a running store.
 ```sh
 npm i -g @tokenoftrust/cli
 
-tot checkout                 # list the stores you can build on
-tot checkout <tenant> --clone ./my-store
+tot clone                    # list the stores you can build on
+tot clone <tenant> my-store  # mirrors `git clone`; dir defaults to <tenant>
 cd my-store
 tot dev                      # run it locally with save→reload — no Docker needed
-tot submit                   # (coming) submit it for preview
+tot preview                  # bundle your edits into a compliance-reviewed preview
+tot ship                     # promote a reconciled preview live (diff + one confirm)
 ```
 
 **Prerequisites: Node.js and an invite. Nothing else.** `tot dev` downloads the
@@ -22,10 +23,12 @@ be fetched.)
 
 | Command | Status | What it does |
 | --- | --- | --- |
-| `tot checkout [<tenant>]` | **built** | Clone a store you're entitled to build on, with an authenticated remote configured. No arg → list your stores. |
-| `tot validate` | next | Lint your store before you submit. |
+| `tot clone [<tenant>] [<dir>]` | **built** | Clone a store you're entitled to build on (mirrors `git clone`), with an authenticated remote configured. Dir defaults to `<tenant>`. No arg → list your stores. |
+| `tot validate` | next | Lint your store before you preview. |
 | `tot dev` | **built** | Run your store locally with save→reload — NATIVELY (no Docker; falls back to it with `--docker` or automatically if the native artifact isn't available). |
-| `tot submit` | next | Submit your store for preview (pushes the preview ref, reports the reconcile/compliance verdict + preview URL). |
+| `tot preview` | **built** | Bundle your edits into a compliance-reviewed preview (validates, auto-commits the known content trees, pushes the preview ref, opens/updates a candidate PR, reports the reconcile/compliance verdict + preview URL). `tot submit` / `tot deploy` still work as teaching aliases for this same flow. |
+| `tot ship` | **built** | Promote a reconciled preview live: always shows a diff-vs-live and asks for one `[y/N]` confirm (no `--yes`, refuses outside a terminal); records an approval request if you're not authorised to ship yourself. |
+| `tot pr [list\|view\|close]` | **built** | See and manage the candidate PRs `tot preview` opens (`gh pr`-shaped). |
 | `tot doctor` | built | Check this machine is ready and show which context `tot` detected. |
 
 ## Context-aware
@@ -34,7 +37,7 @@ The same `tot` does the right thing wherever you run it (walks up like `git`):
 
 - **storefront monorepo** — a full platform checkout;
 - **tenant checkout** — a standalone `content/ public/ theme.json .tot/config.json` clone (tenant read from `.tot/config.json`);
-- **loose** — anywhere else; `tot checkout <tenant> --clone <dir>` gets you a checkout.
+- **loose** — anywhere else; `tot clone <tenant>` gets you a checkout.
 
 `tot doctor` prints the detected context.
 
@@ -42,8 +45,8 @@ The same `tot` does the right thing wherever you run it (walks up like `git`):
 
 `tot` talks to the Token of Trust MCP (default `https://mcp.tokenoftrust.com`, override with `--mcp` or `MCP_BASE_URL`). It is **single-plane**: the only identity is **you**, signed in against the MCP over OAuth.
 
-- Run `tot login` once — it opens your browser (or falls back to a device code on a headless box), you sign in as yourself, and the session is cached at `~/.tot/credentials.json` and refreshed silently. Every later command (`tot checkout`, `tot start`, `tot submit`, …) runs as you, with no re-auth. Entitlement is derived server-side from your ToT memberships.
-- Not signed in? On a terminal, `tot start` / `tot checkout` **offer to sign you in right there** and continue in-flow — no "run `tot login`, then re-run".
+- Run `tot login` once — it opens your browser (or falls back to a device code on a headless box), you sign in as yourself, and the session is cached at `~/.tot/credentials.json` and refreshed silently. Every later command (`tot clone`, `tot start`, `tot preview`, `tot ship`, …) runs as you, with no re-auth. Entitlement is derived server-side from your ToT memberships.
+- Not signed in? On a terminal, `tot start` / `tot clone` **offer to sign you in right there** and continue in-flow — no "run `tot login`, then re-run".
 - The old operator env-triple (`TOT_API_KEY` / `TOT_SECRET_KEY` / `TOT_APP_DOMAIN`) **no longer signs the CLI in** — tot-mcp went OAuth-first on 2026-07-23. If those vars are set, `tot` prints a one-line advisory and uses your `tot login` session anyway; it never reads them for auth.
 
 ### Optional: multiple identities at once (`TOT_PROFILE`)

package/bin/tot.mjs

@@ -2,29 +2,16 @@
 /**
  * `tot` — the Token of Trust developer CLI.
  *
- * One command a developer learns to go from an invite to a running store:
- *
- *   tot start                 invite → running store in one command      ← built (orchestrates the below, value-first)
- *   tot login                 sign in to Token of Trust (OAuth)          ← built (MCP OAuth PKCE loopback; caches ~/.tot/credentials.json)
- *   tot logout                sign out (clear the cached session)        ← built (deletes ~/.tot/credentials.json; local-only, no server revoke)
- *   tot whoami                who you're signed in as                    ← built
- *   tot grants                capability/tier/expiry per store you can act on  ← built (introspection diagnostics)
- *   tot checkout [<tenant>]   clone a store you can build on            ← built
- *   tot validate              lint your store before you submit         ← built
- *   tot dev                   run your store locally with save→reload   ← built (monorepo: host astro; standalone: runs the published runner image)
- *   tot submit                submit your store for preview             ← built (validate + push preview ref; MCP preview_status read-back)
- *   tot doctor                check this machine is ready
- *   tot ideas                 copy-paste AI prompts that reliably wow
- *   tot feedback              send a note to ToT + your recent CLI activity  ← built (activity-log.mjs → feedback_submit MCP tool)
- *   tot app scaffold/dev      build + locally exercise a Private App        ← built (offline; see src/commands/app/)
- *   tot help                  this help
+ * One command a developer learns to go from an invite to a running store. The
+ * user-facing command list is the single source of truth in `COMMANDS` below;
+ * `usage()` renders it, so add new commands there — never in a second list.
  *
  * Context-aware (see src/context.mjs): the same `tot` does the right thing from
  * inside the storefront monorepo, from inside a standalone tenant checkout, or
  * from anywhere else. Every command receives the detected context.
  *
  * This package is `@tokenoftrust/cli` (bin `tot`). Its heaviest command, `tot dev`,
- * fetches the published storefront runner; `tot checkout/validate/submit` are
+ * fetches the published storefront runner; `tot clone/validate/submit` are
  * pure Node. Dependency-free by design so `npm i -g @tokenoftrust/cli` stays light.
  */
 import "../src/ensure-node.mjs"; // hard Node-version gate — must stay first (see the module doc)
@@ -32,9 +19,10 @@ import { readFileSync } from "node:fs";
 import { detectContext } from "../src/context.mjs";
 import { printError } from "../src/errors.mjs";
 import { recordActivity, redactArgs } from "../src/activity-log.mjs";
+import { emitActivity, capRendered } from "../src/activity.mjs";
 import { maybeNotifyUpdate } from "../src/update-check.mjs";
 
-const BUILD_ORDER = ["checkout", "validate", "dev", "submit"];
+const BUILD_ORDER = ["clone", "validate", "dev", "preview"];
 
 // CLI version (stamped into the activity log). Read from our own package.json; best-effort.
 const VERSION = (() => {
@@ -45,26 +33,48 @@ const VERSION = (() => {
   }
 })();
 
+// Single source of truth for the user-facing command list. `usage()` renders
+// it and the file header points here; keep new commands in this one array so the
+// help output can't drift from a second hand-maintained copy. `invocation` is the
+// text after `tot ` (including any argument hint); `blurb` is the one-line help.
+const COMMANDS = [
+  { invocation: "start", blurb: "invite → running store in one command (start here)" },
+  { invocation: "login", blurb: "sign in to Token of Trust" },
+  { invocation: "logout", blurb: "sign out (clear the cached session)" },
+  { invocation: "whoami", blurb: "show who you're signed in as" },
+  { invocation: "link", blurb: "link your identity so your stores resolve" },
+  { invocation: "grants", blurb: "capability/tier/expiry per store you can act on" },
+  { invocation: "clone [<tenant>]", blurb: "clone a store you can build on" },
+  { invocation: "validate", blurb: "lint your store before you submit" },
+  { invocation: "dev", blurb: "run your store locally with save→reload" },
+  { invocation: "preview", blurb: "push your store to a reviewable preview" },
+  { invocation: "ship", blurb: "publish the tenant's current green aggregate live (plan → confirm → ship)" },
+  { invocation: "accept / tot merge", blurb: "queue a PR into the preview aggregate — operator verb, no go-live (plan → confirm → integrate)" },
+  { invocation: "sync", blurb: "fetch `preview` and merge it into your local branch (accept-conflict recovery)" },
+  { invocation: "rollback [<version>]", blurb: "instant re-point to a prior live version (list → confirm → rollback)" },
+  { invocation: "revert --preview <PR|sha>", blurb: "remove already-integrated content from the preview aggregate via a new revert commit — no force-reset (plan → confirm → revert)" },
+  { invocation: "hotfix --pr <N>", blurb: "OWNER-ONLY exception: release an urgent fix from main to live, bypassing unshipped preview work (plan → confirm → release → auto forward-integrate)" },
+  { invocation: "retire", blurb: "evict a candidate PR's preview to reclaim space — operator verb, rebuildable (plan → confirm → evict)" },
+  { invocation: "go-live", blurb: "cut the apex domain over to the storefront (readiness → confirm → cutover)" },
+  { invocation: "pr", blurb: "list / view / close your candidate PRs" },
+  { invocation: "branches", blurb: "full branch-cleanup report — every branch, any PR state, cleanup eligibility" },
+  { invocation: "cleanup", blurb: "owner-confirmed branch GC (--dry-run to classify only; deletes terminal branches only)" },
+  { invocation: "doctor", blurb: "check this machine is ready" },
+  { invocation: "ideas", blurb: "copy-paste AI prompts that reliably wow" },
+  { invocation: 'feedback "<msg>"', blurb: "send feedback to Token of Trust (attaches recent activity)" },
+  { invocation: "app scaffold <name>", blurb: "scaffold a Storefront Private App" },
+  { invocation: "app dev ...", blurb: "local, offline Private App webhook/manifest/JWT harness" },
+  { invocation: "help", blurb: "show this help" },
+  { invocation: "--version", blurb: "print the CLI version" },
+];
+
 function usage() {
+  const col = Math.max(...COMMANDS.map((c) => `tot ${c.invocation}`.length)) + 2;
+  const lines = COMMANDS.map((c) => `  ${`tot ${c.invocation}`.padEnd(col)}${c.blurb}`).join("\n");
   console.log(`
 tot — Token of Trust developer CLI
 
-  tot start                 invite → running store in one command (start here)
-  tot login                 sign in to Token of Trust
-  tot logout                sign out (clear the cached session)
-  tot whoami                show who you're signed in as
-  tot grants                capability/tier/expiry per store you can act on
-  tot checkout [<tenant>]   clone a store you can build on
-  tot validate              lint your store before you submit
-  tot dev                   run your store locally with save→reload
-  tot submit                submit your store for preview
-  tot doctor                check this machine is ready
-  tot ideas                 copy-paste AI prompts that reliably wow
-  tot feedback "<msg>"      send feedback to Token of Trust (attaches recent activity)
-  tot app scaffold <name>   scaffold a Storefront Private App
-  tot app dev ...           local, offline Private App webhook/manifest/JWT harness
-  tot help                  show this help
-  tot --version             print the CLI version
+${lines}
 
 Run \`tot <command> --help\` for command-specific options.
 `);
@@ -96,12 +106,12 @@ async function dispatch(cmd, rest, ctx) {
 
   if (cmd === "logout") {
     const { run } = await import("../src/commands/logout.mjs");
-    return run(rest, ctx);
+    return /** @type {any} */ (run)(rest, ctx);
   }
 
   if (cmd === "feedback") {
     const { run } = await import("../src/commands/feedback.mjs");
-    return run(rest, ctx);
+    return /** @type {any} */ (run)(rest, ctx);
   }
 
   if (cmd === "whoami") {
@@ -109,6 +119,11 @@ async function dispatch(cmd, rest, ctx) {
     return run(rest, ctx);
   }
 
+  if (cmd === "link") {
+    const { run } = await import("../src/commands/link.mjs");
+    return run(rest, ctx);
+  }
+
   if (cmd === "doctor") {
     const { run } = await import("../src/commands/doctor.mjs");
     return run(rest, ctx);
@@ -124,8 +139,17 @@ async function dispatch(cmd, rest, ctx) {
     return run(rest, ctx);
   }
 
-  if (cmd === "checkout") {
-    const { run } = await import("../src/commands/checkout.mjs");
+  if (cmd === "clone") {
+    const { run } = await import("../src/commands/clone.mjs");
+    return run(rest, ctx);
+  }
+
+  // Plumbing, not a developer-facing verb (like git's own credential helpers,
+  // never listed in `git help`) — `tot clone` configures it as this checkout's
+  // `credential.helper`, and git alone invokes it (get/store/erase) on every
+  // fetch/push. See src/commands/git-credential.mjs's header (unit u10).
+  if (cmd === "git-credential") {
+    const { run } = await import("../src/commands/git-credential.mjs");
     return run(rest, ctx);
   }
 
@@ -139,8 +163,103 @@ async function dispatch(cmd, rest, ctx) {
     return run(rest, ctx);
   }
 
-  if (cmd === "submit") {
-    const { run } = await import("../src/commands/submit.mjs");
+  // dev → preview → ship. `preview` is the first-class verb; `submit`/`deploy`
+  // reach the SAME preview flow as teaching aliases (preview.mjs prints a one-line
+  // hint nudging the developer onto `tot preview` / `tot ship`).
+  if (cmd === "preview") {
+    const { run } = await import("../src/commands/preview.mjs");
+    return run(rest, ctx);
+  }
+
+  if (cmd === "submit" || cmd === "deploy") {
+    const { run } = await import("../src/commands/preview.mjs");
+    return run(rest, ctx, { alias: cmd });
+  }
+
+  if (cmd === "ship") {
+    const { run } = await import("../src/commands/ship.mjs");
+    return run(rest, ctx);
+  }
+
+  // `accept` queue-integrates a PR into the protected `preview` aggregate (b08) —
+  // NO merge-to-main, NO go-live; going live is `tot ship`, which publishes the
+  // whole current GREEN AGGREGATE (b10). Backed by POST /api/changes/integrate
+  // (b07's TenantIntegrationQueue.enqueue); see accept.mjs's header. `merge` is a
+  // first-class alias, not a teaching nudge: both dispatch straight to the same command.
+  if (cmd === "accept" || cmd === "merge") {
+    const { run } = await import("../src/commands/accept.mjs");
+    return run(rest, ctx);
+  }
+
+  // `sync` is the common accept-conflict recovery path (P1 item 12): fetches the
+  // protected `preview` branch and merges it into the developer's local branch so
+  // they can resolve locally, then re-`tot preview`. Purely local — no push, no
+  // MCP call, never touches the shared `preview`/`main` refs themselves. See
+  // sync.mjs's header for the full contract.
+  if (cmd === "sync") {
+    const { run } = await import("../src/commands/sync.mjs");
+    return run(rest, ctx);
+  }
+
+  if (cmd === "rollback") {
+    const { run } = await import("../src/commands/rollback.mjs");
+    return run(rest, ctx);
+  }
+
+  // `revert --preview <PR|integration-sha>` removes already-integrated content from
+  // the protected `preview` aggregate via a NEW auditable revert commit (b21) — NO
+  // force-reset, NO touch to main/live. Backed by POST /api/changes/revert (b07's
+  // TenantIntegrationQueue.enqueueRevert). To undo something already LIVE, that's
+  // `tot rollback`, not this. See revert.mjs's header.
+  if (cmd === "revert") {
+    const { run } = await import("../src/commands/revert.mjs");
+    return run(rest, ctx);
+  }
+
+  // `hotfix --pr <N>` is the OWNER-ONLY EXCEPTION lane (b22): release an urgent fix
+  // from `main` to live while `preview` still holds other unshipped work, EXCLUDING
+  // that unshipped preview head, then automatically forward-integrate main → preview
+  // and re-validate. It is DELIBERATELY a distinct verb — never a `--base main` flag
+  // on `tot ship` (which publishes the whole green preview aggregate). Backed by
+  // GET/POST /api/changes/hotfix → b22's HotfixOrchestrator. See hotfix.mjs's header.
+  if (cmd === "hotfix") {
+    const { run } = await import("../src/commands/hotfix.mjs");
+    return run(rest, ctx);
+  }
+
+  // `retire` evicts a candidate PR's hosted preview to reclaim space (unit U7) —
+  // a DISTINCT operator verb from `accept`/reject: retire touches no change
+  // lifecycle and is reversible-by-rebuild (`tot preview build`). See retire.mjs.
+  if (cmd === "retire") {
+    const { run } = await import("../src/commands/retire.mjs");
+    return run(rest, ctx);
+  }
+
+  if (cmd === "go-live") {
+    const { run } = await import("../src/commands/go-live.mjs");
+    return run(rest, ctx);
+  }
+
+  if (cmd === "pr") {
+    const { run } = await import("../src/commands/pr.mjs");
+    return run(rest, ctx);
+  }
+
+  // `branches` is the FULL branch-cleanup report (every branch, any PR state) —
+  // distinct from `tot pr list`, which only shows OPEN PRs (P1 item 9). Read-only;
+  // always safe to run, and the report `tot cleanup` reuses before deleting anything.
+  if (cmd === "branches") {
+    const { run } = await import("../src/commands/branches.mjs");
+    return run(rest, ctx);
+  }
+
+  // `cleanup` is owner-confirmed BRANCH GC (P1 items 9/10) — an irreversible git-ref
+  // delete, distinct from `tot retire`'s hosted-preview eviction (rebuildable, no
+  // branch touched). `--dry-run` classifies and prints; it never deletes. Age alone
+  // never makes a branch eligible; main/preview are always kept; orphans are
+  // quarantined, never auto-deleted. See cleanup.mjs's header.
+  if (cmd === "cleanup") {
+    const { run } = await import("../src/commands/cleanup.mjs");
     return run(rest, ctx);
   }
 
@@ -149,10 +268,21 @@ async function dispatch(cmd, rest, ctx) {
     return run(rest, ctx);
   }
 
+  // `checkout` was deliberately freed up: it's no longer a tot verb precisely so it
+  // can mean what it means in git. Point both ways rather than a bare "unknown".
+  if (cmd === "checkout") {
+    console.error(
+      "`tot checkout` isn't a tot command — `checkout` now means what it does in git.\n\n" +
+        "  • switch branches / restore files in your store:  git checkout <ref>\n" +
+        "  • clone a store you can build on:                 tot clone <tenant>\n",
+    );
+    return 2;
+  }
+
   if (BUILD_ORDER.includes(cmd)) {
     console.error(
       `\`tot ${cmd}\` isn't built yet.\n\n` +
-        `Build order: ${BUILD_ORDER.map((c) => (c === "checkout" ? `${c}✓` : c)).join(" → ")}.\n` +
+        `Build order: ${BUILD_ORDER.map((c) => (c === "clone" ? `${c}✓` : c)).join(" → ")}.\n` +
         `Inside a storefront checkout you can use the in-repo scripts today ` +
         `(e.g. \`pnpm tot ${cmd}\`).`,
     );
@@ -164,12 +294,39 @@ async function dispatch(cmd, rest, ctx) {
   return 2;
 }
 
+/**
+ * The safe `subcommand` value for a command's activity event. Only the fixed
+ * sub-dispatcher verbs (e.g. `app scaffold` / `app dev`) are surfaced — an
+ * arbitrary positional (a tenant name, a path, a code) is NEVER used, so the
+ * activity `subcommand` field can't carry PII even before redaction. Returns
+ * undefined for every command without a fixed subcommand vocabulary.
+ */
+function safeSubcommand(cmd, rest) {
+  if (cmd === "app") {
+    const sub = rest.find((t) => t && !t.startsWith("-"));
+    if (sub === "scaffold" || sub === "dev") return sub;
+  }
+  return undefined;
+}
+
 async function main() {
   const [cmd, ...rest] = process.argv.slice(2);
   const ctx = detectContext();
   const startedAt = Date.now();
+  const command = cmd || "(none)";
+  const subcommand = safeSubcommand(cmd, rest);
   let code = 0;
   let errMsg = null;
+
+  // D3: emit `cli.command.invoked` on start — best-effort, a SILENT no-op without a
+  // hosted-bridge credential (never a network call / never blocks). Fired without
+  // await so it adds no latency to the command; settled alongside the result below.
+  const invokedEmit = emitActivity({
+    action: "cli.command.invoked",
+    outcome: { status: "invoked" },
+    payload: { args: { command, ...(subcommand ? { subcommand } : {}), cliVersion: VERSION, node: process.version } },
+  });
+
   try {
     code = await dispatch(cmd, rest, ctx);
     return code;
@@ -177,17 +334,35 @@ async function main() {
     errMsg = e?.message || String(e);
     throw e;
   } finally {
+    const exitCode = errMsg ? 1 : (code ?? 0);
+    const durationMs = Date.now() - startedAt;
     // Best-effort activity breadcrumb (never throws, never blocks). `feedback`'s own
     // free-text message is omitted — it's user-typed and belongs only in the report.
     recordActivity({
       ts: new Date().toISOString(),
       v: VERSION,
-      cmd: cmd || "(none)",
+      cmd: command,
       args: cmd === "feedback" ? ["«omitted»"] : redactArgs(rest),
-      code: errMsg ? 1 : (code ?? 0),
-      ms: Date.now() - startedAt,
+      code: exitCode,
+      ms: durationMs,
       ...(errMsg ? { err: String(errMsg).slice(0, 200) } : {}),
     });
+    // D3: emit `cli.command.result` (exit code + duration + a bounded/redacted
+    // rendered field). The house-style error text is capped + run through the JS
+    // redaction mirror; per the D0 catalog the `cli.*` rendered lane is empty-
+    // allowlisted, so it's DROPPED by design (the safe default for a high-volume
+    // action) — the emit path still exercises the mirror. Bounded-await here (with
+    // the invoked emit) so a live bridge flushes before the process exits; a no-op
+    // when there's no credential.
+    const resultEmit = emitActivity({
+      action: "cli.command.result",
+      outcome: { status: errMsg ? "failed" : "succeeded", durationMs },
+      payload: {
+        args: { command, ...(subcommand ? { subcommand } : {}), cliVersion: VERSION, exitCode, durationMs },
+        ...(errMsg ? { rendered: { output: capRendered(errMsg) } } : {}),
+      },
+    });
+    await Promise.allSettled([invokedEmit, resultEmit]);
     // Nudge if a newer/unsupported version exists (drawn from cache — instant),
     // and kick a detached registry refresh if stale. Never throws, never blocks.
     maybeNotifyUpdate(VERSION);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tokenoftrust/cli",
-  "version": "1.4.0-rc.2",
-  "description": "Token of Trust developer CLI — check out a tenant store, run it locally with save→reload, and submit it for preview. Installs the `tot` command.",
+  "version": "1.4.0-rc.21",
+  "description": "Token of Trust developer CLI — clone a tenant store, run it locally with save→reload, and submit it for preview. Installs the `tot` command.",
   "license": "Apache-2.0",
   "author": "Token of Trust",
   "homepage": "https://www.tokenoftrust.com",
@@ -36,7 +36,12 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "devDependencies": {
+    "@types/node": "^20.16.0",
+    "typescript": "^5.6.3"
+  },
   "scripts": {
+    "typecheck": "tsc --noEmit",
     "test": "node --test",
     "prepublishOnly": "node ../../scripts/build/check-cli-clean.mjs ."
   }