uniweb 0.84.0 → 0.86.0

package/src/commands/site.js

@@ -0,0 +1,358 @@
+/**
+ * `uniweb site` — the sites in a workspace, on the backend you are logged in to.
+ *
+ *   uniweb site list [--json]                   each site's name, uuid, and whether it is live
+ *   uniweb site unpublish [<site-uuid>] [--yes]  take a site offline; its content stays
+ *   uniweb site delete [<site-uuid>] [--yes]     delete a site — final, no restore
+ *
+ * Without a uuid, `unpublish` and `delete` act on the site this project is synced to on
+ * that backend. The workspace is the command's (`--org @x` / `--personal`), else the
+ * login's — as for every site request.
+ *
+ * ⭐ A live site is not deleted: the backend refuses while it is published, so `delete`
+ * says to unpublish it first, and anything else still active (a plan, a domain, stored
+ * form messages) is named in the backend's own words and resolved in the app. A delete
+ * of the project's own site also drops the project's record of it, as `uniweb forget`
+ * does, so its next push creates a new site.
+ *
+ * ⛔ Both write verbs ask first, and `--yes` is the only way past the question. Without
+ * a terminal they refuse rather than print what they would have done: a script that
+ * reads exit 0 as "deleted" must not be told 0 for nothing.
+ *
+ * Auth: the session of the backend you are logged in to (`uniweb login`) / UNIWEB_TOKEN.
+ */
+
+import { existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { BackendClient, WorkspaceMismatchError, describeWorkspace } from '../backend/client.js'
+import { resolveWorkspace } from '../backend/workspace.js'
+import { checkFlags } from '../utils/flag-guard.js'
+import { confirm, isNonInteractive } from '../utils/interactive.js'
+import { readSiteIdentity } from '../utils/site-identity.js'
+import { findSites, findWorkspaceRoot } from '../utils/workspace.js'
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m'
+}
+// As in every verb: errors on stderr, the rest on stdout — and under `--json` nothing but
+// the JSON on stdout.
+const say = {
+  ok: (m) => console.log(`${c.green}✓${c.reset} ${m}`),
+  info: (m) => console.log(`${c.cyan}→${c.reset} ${m}`),
+  warn: (m) => console.log(`${c.yellow}⚠${c.reset} ${m}`),
+  err: (m) => console.error(`${c.red}✗${c.reset} ${m}`),
+  dim: (m) => console.log(`  ${c.dim}${m}${c.reset}`)
+}
+
+const USAGE = [
+  'uniweb site <command>',
+  '  list [--json]                    The sites in the workspace: name, uuid, whether live',
+  '  unpublish [<site-uuid>] [--yes]   Take a site offline (its content stays)',
+  '  delete [<site-uuid>] [--yes]      Delete a site — final',
+  '',
+  'Without a uuid, unpublish and delete act on the site this project is synced to.',
+  'The workspace is --org @x or --personal, else the one chosen at login.'
+].join('\n')
+
+/** A site-content uuid, loosely: enough to tell one from a site's name. */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/** The arguments that are not flags — skipping `--org`'s value. */
+function positionals(args) {
+  const out = []
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--org') {
+      i++
+      continue
+    }
+    if (a.startsWith('-')) continue
+    out.push(a)
+  }
+  return out
+}
+
+/**
+ * The site directory this command runs in — the site itself (it holds `site.yml`), or a
+ * workspace's only site. ⛔ Never a stop: outside a project — or from an install without
+ * `@uniweb/build`, which finding a workspace's sites may load — there is simply none.
+ */
+async function projectSiteDir() {
+  try {
+    const cwd = process.cwd()
+    if (existsSync(join(cwd, 'site.yml'))) return { dir: cwd }
+    const root = findWorkspaceRoot(cwd)
+    if (!root) return {}
+    const sites = await findSites(root)
+    if (sites.length === 1) return { dir: resolve(root, sites[0]) }
+    return sites.length > 1 ? { many: sites } : {}
+  } catch {
+    return {}
+  }
+}
+
+/** A client on the backend you are logged in to, working in the command's workspace. */
+async function connect(args, command) {
+  const client = new BackendClient({ args, command })
+  const ws = await resolveWorkspace({ client, args })
+  if (ws.refused) return { refused: ws.reason }
+  client.setWorkspace(ws.workspace, { source: ws.source })
+  return { client, workspace: ws.workspace }
+}
+
+/** Every site in the workspace, page by page. */
+async function allSites(client) {
+  const limit = 1000
+  const sites = []
+  for (let offset = 0; ; offset += limit) {
+    const res = await client.listSites({ limit, offset })
+    if (!res.ok) throw new Error(`Could not list the sites: HTTP ${res.status} ${res.statusText}`)
+    const page = (await res.json().catch(() => null))?.sites
+    if (!Array.isArray(page)) throw new Error('Could not list the sites: the backend sent no list.')
+    sites.push(...page)
+    if (page.length < limit) return sites
+  }
+}
+
+async function list(args) {
+  const json = args.includes('--json')
+  const conn = await connect(args, 'Listing sites')
+  if (conn.refused) {
+    say.err(conn.refused)
+    return { exitCode: 2 }
+  }
+  const { client, workspace } = conn
+  const sites = await allSites(client)
+  const rows = sites.map((s) => ({
+    uuid: s.uuid,
+    name: s.name ?? null,
+    status: s.deployment?.status ?? null,
+    published: s.deployment?.status === 'published',
+    url: s.deployment?.published_url ?? null,
+    updated_at: s.updated_at ?? null
+  }))
+  if (json) {
+    console.log(JSON.stringify({ backend: client.origin, workspace: workspace ?? null, sites: rows }))
+    return { exitCode: 0 }
+  }
+  if (!rows.length) {
+    say.info(`No sites in ${describeWorkspace(workspace)} on ${client.origin}.`)
+    return { exitCode: 0 }
+  }
+  console.log(`${c.bold}Sites in ${describeWorkspace(workspace)}${c.reset} ${c.dim}on ${client.origin}${c.reset}`)
+  for (const r of rows) {
+    const state = r.published ? `${c.green}published${c.reset}` : `${c.dim}${r.status ?? 'never published'}${c.reset}`
+    const name = r.name ?? `${c.dim}(no name)${c.reset}`
+    console.log(`  ${name}  ${c.dim}${r.uuid}${c.reset}  ${state}${r.published && r.url ? `  ${r.url}` : ''}`)
+  }
+  return { exitCode: 0 }
+}
+
+/**
+ * The site a write verb acts on: the uuid given, else this project's site on the
+ * backend the client goes to. Null, with the reason said, when there is neither.
+ */
+async function targetSite(args, client, verb) {
+  const [, given] = positionals(args)
+  if (given) {
+    if (!UUID.test(given)) {
+      say.err(`\`${given}\` is not a site uuid.`)
+      say.dim('`uniweb site list` shows each site with its uuid.')
+      return null
+    }
+    const project = await projectSiteDir()
+    const mine = project.dir ? readSiteIdentity(project.dir, client.origin).uuid : null
+    return { uuid: given, siteDir: mine === given ? project.dir : null }
+  }
+  const project = await projectSiteDir()
+  if (project.many) {
+    say.err(`This workspace has ${project.many.length} sites — name one: uniweb site ${verb} <site-uuid>, or run it inside the site.`)
+    return null
+  }
+  const uuid = project.dir ? readSiteIdentity(project.dir, client.origin).uuid : null
+  if (!uuid) {
+    say.err(
+      project.dir
+        ? `This project has no site on ${client.origin} — name one: uniweb site ${verb} <site-uuid>`
+        : `No site named, and this is not a Uniweb project — name one: uniweb site ${verb} <site-uuid>`
+    )
+    say.dim('`uniweb site list` shows each site with its uuid.')
+    return null
+  }
+  return { uuid, siteDir: project.dir }
+}
+
+/** The site's row in the workspace's list, or null when the workspace does not list it. */
+async function findSite(client, uuid) {
+  try {
+    return (await allSites(client)).find((s) => s.uuid === uuid) ?? null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Ask, unless `--yes`. The exit code when the answer is not yes: 0 for a person who
+ * declined, 2 where nobody could be asked — so a script never reads 0 for nothing done.
+ */
+async function confirmed(args, question, verb) {
+  if (args.includes('--yes')) return { yes: true }
+  if (isNonInteractive(args)) {
+    say.err(`\`uniweb site ${verb}\` asks before it acts — pass --yes to confirm it here.`)
+    return { yes: false, exitCode: 2 }
+  }
+  if (await confirm(question, false)) return { yes: true }
+  say.info('Cancelled — nothing changed.')
+  return { yes: false, exitCode: 0 }
+}
+
+/** What the backend said about a refused write, in its own words where it gave them. */
+async function sayRefusal(res, { uuid, verb, origin }) {
+  const body = await res.json().catch(() => null)
+  if (res.status === 409 && Array.isArray(body?.blockers) && body.blockers.length) {
+    say.err(`The site cannot be deleted yet:`)
+    for (const b of body.blockers) {
+      // ⭐ `detail` is written for the site's owner; the set of blockers is open, so an
+      // unknown one is shown by its detail, never dropped.
+      console.error(`  • ${b.detail || b.resource}`)
+      if (b.resource === 'published') console.error(`    ${c.dim}→ uniweb site unpublish ${uuid}${c.reset}`)
+    }
+    if (body.blockers.some((b) => b.resource !== 'published')) {
+      say.dim('Anything else listed is resolved in the app.')
+    }
+    return
+  }
+  if (res.status === 401) {
+    say.err(`Your session on ${origin} is not accepted — sign in again: uniweb login`)
+  } else if (res.status === 403) {
+    say.err(`You may not ${verb} this site — only its owner or an admin of its workspace can.`)
+  } else if (res.status === 404) {
+    say.err(`${origin} has no site ${uuid}.`)
+  } else {
+    say.err(`The backend refused: HTTP ${res.status}${body?.detail ? ` — ${body.detail}` : ''}`)
+  }
+}
+
+/**
+ * The project's record of a site it no longer has — what `uniweb forget` removes for one
+ * backend. Loaded here, not at the top: it needs `@uniweb/build`, which a command run
+ * outside a project does not have.
+ */
+async function forgetDeletedSite(siteDir, origin) {
+  try {
+    const { clearBackend } = await import('@uniweb/build/uwx')
+    const { forgetBackendCache } = await import('../backend/site-sync.js')
+    const { forgetDeploys } = await import('@uniweb/build/site')
+    clearBackend(siteDir, origin)
+    forgetBackendCache(siteDir, origin)
+    await forgetDeploys(siteDir, origin)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function unpublish(args) {
+  const conn = await connect(args, 'Unpublishing a site')
+  if (conn.refused) {
+    say.err(conn.refused)
+    return { exitCode: 2 }
+  }
+  const { client } = conn
+  const target = await targetSite(args, client, 'unpublish')
+  if (!target) return { exitCode: 2 }
+  const site = await findSite(client, target.uuid)
+  const label = site?.name ? `“${site.name}” (${target.uuid})` : target.uuid
+  const url = site?.deployment?.published_url
+  const ok = await confirmed(
+    args,
+    `Unpublish ${label} on ${client.origin}?${url ? ` Visitors get nothing at ${url} until it is published again.` : ''}`,
+    'unpublish'
+  )
+  if (!ok.yes) return { exitCode: ok.exitCode }
+
+  const res = await client.unpublishSite(target.uuid)
+  if (!res.ok) {
+    await sayRefusal(res, { uuid: target.uuid, verb: 'unpublish', origin: client.origin })
+    return { exitCode: 1 }
+  }
+  const body = await res.json().catch(() => null)
+  if (body?.was_published === false) {
+    say.info(`${label} was not published — nothing to take down.`)
+  } else {
+    say.ok(`Unpublished ${label}. Its content stays; \`uniweb publish\` puts it back online.`)
+  }
+  return { exitCode: 0 }
+}
+
+async function remove(args) {
+  const conn = await connect(args, 'Deleting a site')
+  if (conn.refused) {
+    say.err(conn.refused)
+    return { exitCode: 2 }
+  }
+  const { client, workspace } = conn
+  const target = await targetSite(args, client, 'delete')
+  if (!target) return { exitCode: 2 }
+  const site = await findSite(client, target.uuid)
+  const label = site?.name ? `“${site.name}” (${target.uuid})` : target.uuid
+  if (site?.deployment?.status === 'published') {
+    say.err(`${label} is published — unpublish it first: uniweb site unpublish ${target.uuid}`)
+    return { exitCode: 1 }
+  }
+  const ok = await confirmed(
+    args,
+    `Delete ${label} on ${client.origin}, in ${describeWorkspace(workspace)}? ` +
+      'Its pages, settings and snapshots go with it, and it cannot be undone. Records it pushed stay in the workspace.',
+    'delete'
+  )
+  if (!ok.yes) return { exitCode: ok.exitCode }
+
+  const res = await client.deleteSite(target.uuid)
+  if (!res.ok) {
+    await sayRefusal(res, { uuid: target.uuid, verb: 'delete', origin: client.origin })
+    return { exitCode: 1 }
+  }
+  say.ok(`Deleted ${label}.`)
+  if (target.siteDir) {
+    if (await forgetDeletedSite(target.siteDir, client.origin)) {
+      say.dim(`This project no longer records a site on ${client.origin}; its next push creates a new one.`)
+    } else {
+      say.dim(`This project still records it — run \`uniweb forget --server ${client.origin}\` in it.`)
+    }
+  }
+  return { exitCode: 0 }
+}
+
+export async function site(args = []) {
+  const badFlag = checkFlags('site', args)
+  if (badFlag) {
+    say.err(badFlag.message)
+    return { exitCode: 2 }
+  }
+  const sub = args[0]
+  try {
+    if (sub === 'list') return await list(args)
+    if (sub === 'unpublish') return await unpublish(args)
+    if (sub === 'delete') return await remove(args)
+  } catch (err) {
+    say.err(err instanceof WorkspaceMismatchError ? err.message : err?.message || String(err))
+    return { exitCode: 1 }
+  }
+  if (sub) {
+    say.err(`Unknown command: uniweb site ${sub}`)
+    console.error(USAGE)
+    return { exitCode: 2 }
+  }
+  console.log(USAGE)
+  return { exitCode: 0 }
+}
+
+export default site

package/src/commands/snapshot.js

@@ -33,7 +33,7 @@ import { createRequire } from 'node:module'
 import { isAbsolute, join, relative, resolve, sep } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import yaml from 'js-yaml'
-import { upsertYamlScalar } from '@uniweb/build/uwx'
+import { writeSiteConfig } from '@uniweb/build/uwx'
 
 import { didYouMean } from '../utils/args.js'
 import { humanBytes } from '../utils/bytes.js'
@@ -431,14 +431,23 @@ export async function snapshot(args = []) {
     return
   }
   const current = siteYml.data.preview
+  // Edited in place, its comments kept (`writeSiteConfig`) — and not at all when site.yml
+  // does not parse: that is said, and the file left as the author has it.
+  const setPreview = () => {
+    try {
+      writeSiteConfig(siteDir, { preview: value })
+      return true
+    } catch (err) {
+      console.log(`  ${YELLOW}site.yml not changed:${RESET} ${DIM}${err.message}${RESET}`)
+      return false
+    }
+  }
   switch (previewDecision(current, value)) {
     case 'set':
-      upsertYamlScalar(siteYml.file, 'preview', value)
-      console.log(`  site.yml: ${CYAN}preview: ${value}${RESET}`)
+      if (setPreview()) console.log(`  site.yml: ${CYAN}preview: ${value}${RESET}`)
       break
     case 'replace':
-      upsertYamlScalar(siteYml.file, 'preview', value)
-      console.log(`  site.yml: ${CYAN}preview: ${value}${RESET} ${DIM}(replaces the app-generated preview)${RESET}`)
+      if (setPreview()) console.log(`  site.yml: ${CYAN}preview: ${value}${RESET} ${DIM}(replaces the app-generated preview)${RESET}`)
       break
     case 'unchanged':
       console.log(`  ${DIM}site.yml already has preview: ${value}${RESET}`)

package/src/commands/status.js

@@ -243,7 +243,7 @@ export async function status(args = []) {
     if (siteState?.state === 'gone') {
       say.warn(`The backend has no site ${uuid} — it was deleted there, or the backend was rebuilt.`)
       say.dim(
-        `To push this as a new site: uniweb forget --backend ${probeBackend}, then uniweb push.`
+        `To push this as a new site: uniweb forget --server ${probeBackend}, then uniweb push.`
       )
     } else if (siteState?.state === 'unknown') {
       say.dim(

package/src/framework-index.json

@@ -1,16 +1,16 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-06T19:21:14.306Z",
+  "generatedAt": "2026-10-07T18:16:06.785Z",
   "packages": {
     "@uniweb/api": {
-      "version": "0.6.10",
+      "version": "0.7.0",
       "path": "framework/api",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/build": {
-      "version": "0.77.0",
+      "version": "0.79.0",
       "path": "framework/build",
       "deps": [
         "@uniweb/content-reader",
@@ -35,7 +35,7 @@
       "deps": []
     },
     "@uniweb/core": {
-      "version": "0.37.2",
+      "version": "0.38.0",
       "path": "framework/core",
       "deps": [
         "@uniweb/semantic-parser",
@@ -48,14 +48,14 @@
       "deps": []
     },
     "@uniweb/icons": {
-      "version": "0.4.28",
+      "version": "0.4.29",
       "path": "framework/icons",
       "deps": [
         "@uniweb/core"
       ]
     },
     "@uniweb/kit": {
-      "version": "0.19.18",
+      "version": "0.20.0",
       "path": "framework/kit",
       "deps": [
         "@uniweb/core",
@@ -76,7 +76,7 @@
       "deps": []
     },
     "@uniweb/projections": {
-      "version": "0.7.14",
+      "version": "0.7.15",
       "path": "framework/projections",
       "deps": [
         "@uniweb/content-writer",
@@ -84,7 +84,7 @@
       ]
     },
     "@uniweb/runtime": {
-      "version": "0.29.2",
+      "version": "0.29.3",
       "path": "framework/runtime",
       "deps": [
         "@uniweb/core",
@@ -97,7 +97,7 @@
       "deps": []
     },
     "@uniweb/schemas": {
-      "version": "0.12.0",
+      "version": "0.13.0",
       "path": "framework/schemas",
       "deps": []
     },
@@ -117,7 +117,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.17.14",
+      "version": "0.18.1",
       "path": "framework/templates",
       "deps": []
     },
@@ -127,7 +127,7 @@
       "deps": []
     },
     "@uniweb/unipress": {
-      "version": "0.10.21",
+      "version": "0.10.23",
       "path": "framework/unipress",
       "deps": [
         "@uniweb/build",

package/src/index.js

@@ -645,6 +645,15 @@ async function main() {
   const command = args[0]
   const pm = detectPackageManager()
 
+  // ⛔ THE VARIABLE THAT AIMS A PROCESS IS UNIWEB_SERVER — UNIWEB_REGISTER_URL until 2026-10-07.
+  // Set ALONE, the old name is refused rather than ignored: ignored, a script that meant a
+  // local or staging backend would go to the default one, uniweb.app, and say nothing. Set
+  // beside the new one it is ignored, so a script can carry both while CLIs of both ages run it.
+  if (process.env.UNIWEB_REGISTER_URL && !process.env.UNIWEB_SERVER) {
+    error('UNIWEB_REGISTER_URL is now UNIWEB_SERVER — rename it, and the command goes to the same backend.')
+    process.exit(2)
+  }
+
   // Handle --version / -v
   //
   // Output convention: the version goes to stdout (parseable, scriptable —
@@ -915,13 +924,13 @@ async function main() {
   }
 
   // Handle login command — the backend (username/password · paste a token ·
-  // --token <bearer>). ⭐ `--backend <url>` names it; without the flag it is the DEFAULT
-  // backend — UNIWEB_REGISTER_URL, else ~/.uniweb/config.json, else https://uniweb.app —
+  // --token <bearer>). ⭐ `--server <url>` names it; without the flag it is the DEFAULT
+  // backend — UNIWEB_SERVER, else ~/.uniweb/config.json, else https://uniweb.app —
   // and never the project's backend *[Diego, 2026-09-21: "the default backend for login, if
   // not specified, is uniweb.app"]*. ⭐ Except a WORKSPACE SWITCH — `--org` / `--personal`
   // and no way of signing in — which acts on the backend you are logged in to *[Diego,
   // 2026-10-06]* (`resolveLoginOrigin`). The backend logged in to becomes CURRENT, and
-  // every backend command goes there (only UNIWEB_REGISTER_URL outranks it) — which is why
+  // every backend command goes there (only UNIWEB_SERVER outranks it) — which is why
   // this is the one place a backend is chosen.
   //
   // ⛔ Until 2026-09-21 a bare login went to the backend of the project in the cwd, and
@@ -932,12 +941,19 @@ async function main() {
     const { readFlagValue } = await import('./utils/args.js')
     const { runRegistryLogin } = await import('./utils/registry-auth.js')
     const { resolveLoginOrigin } = await import('./utils/config.js')
+    // `--backend` was this flag's name until 2026-10-07 — renamed so it is not read as a
+    // site's `backend` service. Refused with the new name, never treated as unknown and dropped:
+    // dropped, the login would go to the default backend.
+    if (loginArgs.some((a) => a === '--backend' || a.startsWith('--backend='))) {
+      console.error('\x1b[31m✗\x1b[0m `--backend` is now `--server`: uniweb login --server <url>')
+      process.exit(2)
+    }
     let apiBase
     try {
-      apiBase = resolveLoginOrigin(readFlagValue(loginArgs, '--backend'), loginArgs)
+      apiBase = resolveLoginOrigin(readFlagValue(loginArgs, '--server'), loginArgs)
     } catch (err) {
       console.error(
-        `\x1b[31m✗\x1b[0m ${err.message} — e.g. uniweb login --backend http://localhost:8080`
+        `\x1b[31m✗\x1b[0m ${err.message} — e.g. uniweb login --server http://localhost:8080`
       )
       process.exit(2)
     }
@@ -973,6 +989,19 @@ async function main() {
     return
   }
 
+  // Handle site command — the sites in a workspace: list them, unpublish or delete one.
+  // Runs anywhere: inside a project it can act on the site the project is synced to.
+  if (command === 'site') {
+    const { site } = await import('./commands/site.js')
+    const result = await site(args.slice(1))
+    // ⛔ EXIT ONLY ONCE STDOUT HAS DRAINED. To a pipe Node writes asynchronously, so an exit
+    // straight after a long list cut it at 8192 bytes — measured 2026-10-07: `site list --json`
+    // of 79 sites reached a reading process as half a JSON document, while the same command
+    // into a file (synchronous) was whole. Pinned by test/site-list-pipe.test.js.
+    await new Promise((resolve) => process.stdout.write('', resolve))
+    process.exit(result?.exitCode ?? 0)
+  }
+
   // Handle org command (new-backend orgs/units — publish-scope management)
   if (command === 'org') {
     const { org } = await import('./commands/org.js')
@@ -1796,7 +1825,7 @@ logged in to is where the backend commands go (push, pull, publish, status,
 register, clone) — so this is how you switch. Already logged in to it, login
 does nothing; add --password, --browser, --token-paste or --token to log in again.
 
-Without --backend: https://uniweb.app (or \$UNIWEB_REGISTER_URL). No command talks
+Without --server: https://uniweb.app (or \$UNIWEB_SERVER). No command talks
 to a backend you are not logged in to — run one before logging in and it asks first.
 
 ${colors.bright}The workspace you work in.${colors.reset} A login works in ONE workspace — your
@@ -1807,7 +1836,7 @@ or name it. Already logged in, \`uniweb login --org @other\` (or \`--personal\`)
 the workspace on the backend you are logged in to, without logging in again.
 
 ${colors.bright}Options:${colors.reset}
-  --backend <url>    The backend to log in to (without it: the default backend — or, for
+  --server <url>    The backend to log in to (without it: the default backend — or, for
                      --org / --personal alone, the one you are logged in to)
   --org @org         Work in @org (an organization you belong to)
   --personal         Work in your personal workspace
@@ -1875,13 +1904,13 @@ so it is deliberately kept away from the refresh half.
 ${colors.cyan}${colors.bright}uniweb forget${colors.reset} ${colors.dim}— Remove what this project recorded about where it synced${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
-  uniweb forget --backend <url>
+  uniweb forget --server <url>
   uniweb forget --all
 
 Local files only. Every site stays where it is on its backend.
 
 ${colors.bright}Options:${colors.reset}
-  --backend <url>    Forget one backend: its entries in sync.json and in the local
+  --server <url>    Forget one backend: its entries in sync.json and in the local
                      cache, and its deploy records in deploy.yml. Its targets stay,
                      so the next publish there creates a new site.
   --all              For a COPY of a project that should become a new one. Deletes
@@ -2062,6 +2091,7 @@ ${colors.bright}Commands:${colors.reset}
   sync               Catch up, then push (refresh + push)
   status             Show a site's sync state (unpushed content, foundation)
   forget             Forget a backend, or --all to make a copied project a new one
+  site <cmd>         The sites in a workspace: list, unpublish, delete
   inspect <path>     Inspect parsed content shape of a markdown file or folder
   docs               Generate component documentation
   families           List the standard section families (for meta.js family:)
@@ -2093,8 +2123,8 @@ ${colors.bright}Global Options:${colors.reset}
 
   Backend commands (push, pull, publish, status, register, clone) go to the
   backend you are logged in to, with its session. Switch with
-  \`uniweb login --backend <url>\` (add \`--token <bearer>\` to sign in with a token);
-  a script can aim and authenticate one process with UNIWEB_REGISTER_URL and
+  \`uniweb login --server <url>\` (add \`--token <bearer>\` to sign in with a token);
+  a script can aim and authenticate one process with UNIWEB_SERVER and
   UNIWEB_TOKEN instead.
 
 ${colors.bright}Push Options:${colors.reset}