uniweb 1.0.0 → 1.0.2

package/src/commands/deploy.js

@@ -0,0 +1,537 @@
+/**
+ * Deploy Command — ship a site to its resolved target.
+ *
+ * With a destination already known (a `--host` flag, or a target in
+ * deploy.yml) `uniweb deploy` acts on it directly. With NO destination
+ * known it runs the WIZARD — "Where should this site go?" — rather than
+ * assuming one. Assuming a host was the old behavior and it was wrong;
+ * so was the picker that replaced it, which listed every registered
+ * adapter when only one could actually be deployed to. The wizard offers
+ * only destinations that can be acted on, and says what acting will do.
+ *
+ * Four outcomes, from the wizard or resolved directly:
+ *   - THIRD-PARTY host, upload now: build `dist/` in bundle mode and hand
+ *     it to the adapter's deploy hook (`github-pages`, `cloudflare-pages`,
+ *     `netlify`, `vercel`, `s3-cloudfront`).
+ *   - THIRD-PARTY host, set up CI: delegate to `uniweb add ci --host=…`,
+ *     which scaffolds a workflow so every push deploys. For most free
+ *     hosts this is the better answer, and the wizard says so.
+ *   - UNIWEB hosting (`--host=uniweb`, or a `uniweb` target in deploy.yml,
+ *     or "Uniweb Cloud" in the wizard): DELEGATE to `uniweb publish` — the
+ *     smart path (sync + dynamic hosting, brings the foundation along). So
+ *     deploy.yml stays one actionable "where this site deploys" record.
+ *   - SOMEWHERE ELSE: delegate to `uniweb export` for a self-contained
+ *     artifact you upload yourself.
+ *
+ * `uniweb publish` remains the canonical direct verb for Uniweb hosting.
+ *
+ * Host resolution:
+ *   1. --target <name> picks a target from deploy.yml (full config)
+ *   2. deploy.yml's `default:` target when no flag is given
+ *   3. with no deploy.yml at all, NO host is chosen → the wizard runs
+ *      (interactive); non-interactive → an actionable error listing the
+ *      real options
+ *   4. --host <name> is a one-off override (does NOT persist to deploy.yml)
+ *   5. --host with no value jumps straight to the wizard
+ *
+ * Usage:
+ *   uniweb deploy                  Wizard: pick a destination
+ *   uniweb deploy --host <name>    Build bundle-mode dist/ + hand to the host adapter
+ *   uniweb deploy --host=uniweb    Delegate to `uniweb publish` (Uniweb hosting)
+ *   uniweb deploy --target <name>  Pick a target from deploy.yml
+ *   uniweb deploy --dry-run        Resolve everything; upload nothing
+ *   uniweb deploy --no-save        Do not record this deploy in deploy.yml
+ *
+ * Escape hatch: UNIWEB_SKIP_BUILD=1 reuses an existing dist/.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+import {
+  loadDeployYml,
+  resolveTarget,
+  recordLastDeploy
+} from '@uniweb/build/site'
+import { promptForDestination } from '../utils/destination-prompt.js'
+import { readFlagValue } from '../utils/args.js'
+import { DEFAULT_BACKEND_ORIGIN, getRegistryApiBaseUrl, loggedInOrigin } from '../utils/config.js'
+import { normalizeOrigin } from '../utils/site-identity.js'
+import { parseBoolEnv } from '../utils/env.js'
+import { headProvenance } from '../utils/git.js'
+import { warnIfContentDoesNotConform } from '../utils/conformance.js'
+
+import {
+  findWorkspaceRoot,
+  findSites,
+  classifyPackage,
+  promptSelect
+} from '../utils/workspace.js'
+import { isNonInteractive, getCliPrefix } from '../utils/interactive.js'
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m'
+}
+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}`)
+}
+
+// ─── Main ───────────────────────────────────────────────────
+
+export async function deploy(args = []) {
+  const dryRun = args.includes('--dry-run')
+  const siteDir = await resolveSiteDir(args)
+
+  // Host dispatch. Resolution order:
+  //   1. --target <name> picks a target from deploy.yml
+  //   2. deploy.yml's `default:` target when no flag is given
+  //   3. with no deploy.yml, NO host is chosen → the wizard decides
+  //   4. --host <name> is a one-off override (does not persist on success)
+  const targetFromFlag = readFlagValue(args, '--target')
+  const hostFromFlag = readFlagValue(args, '--host')
+  const noSave = args.includes('--no-save')
+
+  let deployYml
+  try {
+    deployYml = await loadDeployYml(siteDir)
+  } catch (err) {
+    say.err(err.message)
+    process.exit(1)
+  }
+  let resolved
+  try {
+    resolved = resolveTarget(deployYml, targetFromFlag || null)
+  } catch (err) {
+    say.err(err.message)
+    process.exit(1)
+  }
+
+  // Resolve a PLAN — {kind, host?, action?} — before doing anything. A
+  // destination is "known" when the user named it (--host) or deploy.yml
+  // records one. Otherwise the wizard asks; we never assume.
+  //
+  // resolveTarget returns host:'uniweb' with fromFile:false as its
+  // no-deploy.yml fallback. That is NOT a chosen destination — treat it
+  // as "unknown" so a bare `deploy` in a fresh project opens the wizard
+  // instead of silently heading for the paid product.
+  let plan
+  // `--host` with NO value (readFlagValue → null) is an explicit "ask me",
+  // and it must outrank deploy.yml: the user typed the flag precisely to
+  // choose something other than what's recorded. Omitting the flag
+  // entirely (→ undefined) is the different case where deploy.yml wins.
+  const wantsWizard = hostFromFlag === null
+  const knownHost = wantsWizard
+    ? null
+    : hostFromFlag || (resolved.fromFile ? resolved.host : null)
+
+  if (knownHost === 'uniweb') {
+    plan = { kind: 'uniweb' }
+  } else if (knownHost) {
+    plan = { kind: 'adapter', host: knownHost, action: 'deploy' }
+  } else {
+    if (isNonInteractive(args)) {
+      if (wantsWizard) {
+        // They asked to pick, but there's no way to ask. Never silently
+        // fall back to deploy.yml — that would deploy somewhere the user
+        // was in the middle of overriding.
+        const { listAdapters } = await import('@uniweb/build/hosts')
+        say.err('`--host` requires a value when running non-interactively.')
+        say.dim(`Known adapters: ${listAdapters().join(', ')}.`)
+        say.dim('For Uniweb Cloud use `uniweb publish` (or --host=uniweb).')
+        process.exit(1)
+      }
+      say.err('`uniweb deploy` needs a destination.')
+      console.log('')
+      say.dim(
+        '`uniweb publish`          Uniweb Cloud (sync + dynamic hosting; brings the foundation along)'
+      )
+      say.dim(
+        '`uniweb deploy --host=…`  A third-party host — run `uniweb deploy --help` for the list'
+      )
+      say.dim('`uniweb add ci --host=…`  Set up CI so every push deploys')
+      say.dim(
+        '`uniweb export`           Self-contained dist/ artifact you upload anywhere'
+      )
+      process.exit(1)
+    }
+    try {
+      plan = await promptForDestination({
+        args,
+        preselect: resolved.fromFile ? resolved.host : null
+      })
+    } catch (err) {
+      say.err(err.message)
+      process.exit(1)
+    }
+    if (!plan) {
+      console.log('\nDeploy cancelled.')
+      process.exit(0)
+    }
+  }
+
+  // A static host: advisory — warns and ships (utils/conformance.js). Uniweb Cloud is
+  // `publish`, below, which refuses content that does not conform: there the backend
+  // enforces the schemas, so the check is a gate, not advice (2026-09-24).
+  if (plan.kind !== 'uniweb') {
+    await warnIfContentDoesNotConform(siteDir, { args, warn: say.warn, dim: say.dim })
+  }
+
+  // Uniweb Cloud is `publish`'s flow — delegate so deploy.yml stays one
+  // actionable record and there's a single implementation of go-live.
+  if (plan.kind === 'uniweb') {
+    // ⭐ `--host=uniweb` IS `publish` *[Diego, 2026-09-21]*: it goes to the backend you are
+    // logged in to — deploy follows the login like every other command. A deploy.yml
+    // uniweb target's `backend:` records where that target's publishes went; it routes
+    // nothing (publish files its record under the target naming its backend).
+    const goingTo = getRegistryApiBaseUrl()
+    const aimedBy = process.env.UNIWEB_SERVER
+      ? 'UNIWEB_SERVER'
+      : loggedInOrigin()
+        ? 'the backend you are logged in to'
+        : 'the default backend — you are not logged in'
+    const fromTarget =
+      resolved.fromFile &&
+      resolved.host === 'uniweb' &&
+      // not after the wizard (`--host` with no value): a pick there names no target
+      (hostFromFlag === undefined || hostFromFlag === 'uniweb')
+    const targetBackend = fromTarget
+      ? normalizeOrigin(resolved.config?.backend || DEFAULT_BACKEND_ORIGIN)
+      : null
+    if (targetBackend && targetBackend !== goingTo) {
+      if (targetFromFlag) {
+        // ⛔ A refusal, not a route: the user TYPED this destination, and going live
+        // somewhere else would contradict it with nothing said. Switching is a login.
+        say.err(
+          `Target '${resolved.targetName}' is on ${targetBackend}, but this would publish to ${goingTo} (${aimedBy}).`
+        )
+        say.dim(`To publish there, log in to it first: uniweb login --server ${targetBackend}`)
+        process.exit(1)
+      }
+      say.dim(
+        `deploy.yml's default target '${resolved.targetName}' is on ${targetBackend}; publishing to ${goingTo} (${aimedBy}).`
+      )
+    }
+    say.info('Uniweb Cloud → running `uniweb publish`.')
+    console.log('')
+    // publish ignores deploy's --host/--target; --dry-run/--no-save pass straight
+    // through.
+    const { publish } = await import('./publish.js')
+    // publish runs the conformance gate itself; deploy checked nothing for this host.
+    const result = await publish(args)
+    process.exit(result?.exitCode ?? 0)
+  }
+
+  if (plan.kind === 'export') {
+    // `export` has no --dry-run of its own, so handle it here rather than
+    // passing a flag it would ignore — a dry run that actually ran a full
+    // build would be a lie.
+    if (dryRun) {
+      say.info(
+        'Dry run — would run `uniweb export` to build a self-contained dist/.'
+      )
+      return
+    }
+    say.info('Building a self-contained artifact → running `uniweb export`.')
+    console.log('')
+    const { exportSite } = await import('./export.js')
+    await exportSite([])
+    return
+  }
+
+  // CI setup is `add ci`'s job. Shell out rather than re-implement: add
+  // owns site discovery, package-manager detection, the --force guard,
+  // and the deploy.yml target write.
+  if (plan.action === 'ci') {
+    await delegateToAddCi(siteDir, plan.host, dryRun)
+    return
+  }
+
+  // Auto-save scope: 'off' from --no-save OR an ad-hoc --host override (we don't
+  // want a one-off experiment to rewrite the file). A host picked interactively
+  // for a bare `deploy` is NOT an override — we DO want to remember it.
+  const hostOverridden = !!hostFromFlag && hostFromFlag !== resolved.host
+  // An ad-hoc --host override describes no target, so there is nothing to file a
+  // deploy under — the switch goes off without anyone typing it.
+  const saveDeploys = !(noSave || hostOverridden) && resolved.saveDeploys !== false
+
+  await deployStaticHost(siteDir, plan.host, resolved, {
+    dryRun,
+    saveDeploys,
+    hostOverridden
+  })
+}
+
+// ─── CI delegation ──────────────────────────────────────────
+
+async function delegateToAddCi(siteDir, host, dryRun) {
+  const workspaceRoot = findWorkspaceRoot(siteDir) || siteDir
+
+  // Forward the site we already resolved. Without this, `add ci` re-runs
+  // its own discovery and asks "which site?" a second time in a
+  // multi-site workspace — right after the user answered that in the
+  // wizard. `add ci --site` matches on the package name.
+  let siteFlag = ''
+  try {
+    const pkg = JSON.parse(readFileSync(join(siteDir, 'package.json'), 'utf8'))
+    if (pkg.name) siteFlag = ` --site ${JSON.stringify(pkg.name)}`
+  } catch {
+    // No readable package.json — let `add ci` resolve the site itself.
+  }
+
+  const cmd = `add ci --host ${JSON.stringify(host)}${siteFlag}`
+  if (dryRun) {
+    say.info(`Dry run — would run \`uniweb ${cmd}\` in ${workspaceRoot}`)
+    return
+  }
+  say.info(`Setting up CI → running \`uniweb ${cmd}\`.`)
+  console.log('')
+  try {
+    execSync(`node ${JSON.stringify(process.argv[1])} ${cmd}`, {
+      cwd: workspaceRoot,
+      stdio: 'inherit'
+    })
+  } catch {
+    // add ci already printed the reason and set the exit code.
+    process.exit(1)
+  }
+}
+
+// ─── Static-host deploy (S3+CloudFront, etc.) ─────────────────
+//
+// Picked when the resolved deploy.yml target (or --host override) names a
+// static-host adapter registered in @uniweb/build/hosts. Always runs
+// `uniweb build` (bundle mode + prerender) first, then hands dist/ to the
+// adapter's deploy hook for upload + invalidation.
+
+async function deployStaticHost(
+  siteDir,
+  hostName,
+  resolved,
+  { dryRun, saveDeploys, hostOverridden }
+) {
+  let getAdapter
+  try {
+    ;({ getAdapter } = await import('@uniweb/build/hosts'))
+  } catch (err) {
+    say.err('Failed to load host adapter registry from @uniweb/build/hosts.')
+    say.dim(err.message)
+    process.exit(1)
+  }
+
+  let adapter
+  try {
+    adapter = getAdapter(hostName)
+  } catch (err) {
+    say.err(err.message)
+    say.dim(
+      'Set the host in deploy.yml or pass --host=<name>. See `uniweb deploy --help`.'
+    )
+    process.exit(1)
+  }
+
+  if (typeof adapter.deploy !== 'function') {
+    say.err(`Host adapter '${hostName}' does not implement a deploy step.`)
+    say.dim(
+      `Build with \`uniweb build --host=${hostName}\` and upload \`dist/\` manually,`
+    )
+    say.dim(
+      `or use a host whose adapter ships a deploy hook (e.g., s3-cloudfront).`
+    )
+    process.exit(1)
+  }
+
+  const deployConfig = resolved.config || {}
+  const distDir = join(siteDir, 'dist')
+
+  if (dryRun) {
+    say.info(
+      `Dry run — would deploy via host adapter: ${c.bold}${adapter.name}${c.reset}`
+    )
+    say.dim(`Site dir  : ${siteDir}`)
+    say.dim(
+      `dist/     : ${existsSync(distDir) ? 'exists (would not rebuild)' : 'missing (would build)'}`
+    )
+    say.dim(`Target    : ${resolved.targetName}`)
+    if (adapter.display?.pushWith)
+      say.dim(`Uploads by: ${adapter.display.pushWith}`)
+    // Echo the resolved target's config as-is. Each adapter reads
+    // different keys (bucket/distributionId for s3, projectName for
+    // Cloudflare, siteId for Netlify), so listing a fixed set would be
+    // wrong for four of the five.
+    const configKeys = Object.keys(deployConfig)
+    if (configKeys.length) {
+      say.dim('Config    :')
+      for (const key of configKeys.sort()) {
+        say.dim(
+          `  ${key}: ${typeof deployConfig[key] === 'object' ? JSON.stringify(deployConfig[key]) : deployConfig[key]}`
+        )
+      }
+    } else {
+      say.dim(
+        'Config    : (none in deploy.yml — the adapter will say what it needs)'
+      )
+    }
+    return
+  }
+
+  // Always rebuild — the static-host flow expects fresh dist/ on every
+  // deploy. UNIWEB_SKIP_BUILD env var lets CI / dev loops reuse an
+  // existing build.
+  const skipBuild = parseBoolEnv('UNIWEB_SKIP_BUILD')
+  if (skipBuild) {
+    if (!existsSync(distDir)) {
+      say.err('UNIWEB_SKIP_BUILD is set but dist/ does not exist.')
+      process.exit(1)
+    }
+    say.info('UNIWEB_SKIP_BUILD set — reusing existing dist/.')
+  } else {
+    say.info(`Building site (host: ${adapter.name})…`)
+    console.log('')
+    try {
+      execSync(
+        `node ${JSON.stringify(process.argv[1])} build --bundle --host ${JSON.stringify(adapter.name)}`,
+        { cwd: siteDir, stdio: 'inherit' }
+      )
+    } catch {
+      say.err('Build failed. See output above.')
+      process.exit(1)
+    }
+    if (!existsSync(distDir)) {
+      say.err('Build did not produce dist/.')
+      process.exit(1)
+    }
+    console.log('')
+  }
+
+  // Hand off to the adapter. DeployError is the structured shape from
+  // @uniweb/build/hosts/s3-cloudfront — translate to user-facing output.
+  let deployResult
+  try {
+    deployResult = await adapter.deploy({
+      distDir,
+      deployConfig,
+      env: process.env,
+      log: (m) => console.log(m)
+    })
+  } catch (err) {
+    if (err && err.name === 'DeployError') {
+      say.err(err.message)
+      if (err.hint) {
+        console.log('')
+        console.log(err.hint)
+      }
+      process.exit(1)
+    }
+    throw err
+  }
+
+  // Record a fresh lastDeploy.<target> entry. Skipped on --no-save and
+  // on ad-hoc --host overrides — see saveDeploys gating in deploy().
+  const gitStamp = {
+    at: new Date().toISOString(),
+    git: headProvenance(siteDir)
+  }
+  await persistLastDeploy(siteDir, {
+    targetName: resolved.targetName,
+    targetConfig: resolved.fromFile
+      ? null
+      : { host: hostName, ...deployConfig },
+    saveDeploys,
+    lastDeploy: {
+      at: gitStamp.at,
+      host: hostName,
+      // Adapters that drive a host CLI get the public URL back from it
+      // (wrangler/netlify/vercel print it; github-pages derives it from
+      // the git remote). s3-cloudfront can't — the public URL lives in
+      // the user's CloudFront/DNS config, which we never see — so the
+      // field is simply omitted there rather than guessed.
+      ...(deployResult?.url ? { url: deployResult.url } : {}),
+      // Same provenance the Uniweb path records: which commit this artifact came
+      // from, and whether the tree was clean when it was built.
+      ...(gitStamp.git ? { git: gitStamp.git } : {})
+    }
+  })
+  if (hostOverridden && !dryRun) {
+    say.dim(
+      '--host override active — did not write to deploy.yml. Edit deploy.yml to make this permanent.'
+    )
+  }
+}
+
+// ─── deploy.yml lastDeploy persistence ──────────────────────────
+
+async function persistLastDeploy(siteDir, opts) {
+  if (opts.saveDeploys === false) return
+  try {
+    const result = await recordLastDeploy(siteDir, opts)
+    if (result?.created) {
+      say.dim(`Wrote deploy.yml (target: ${opts.targetName})`)
+    }
+  } catch (err) {
+    // The deploy itself succeeded — never fail the whole command on a
+    // memo-write error. Surface it so the user can fix the file.
+    say.dim(`Could not update deploy.yml: ${err.message}`)
+  }
+}
+
+// ─── Resolve site dir ──────────────────────────────────────
+
+// Exported so `uniweb export` / `uniweb publish` / `uniweb status` reuse the
+// same site-discovery logic. `verb` is the command being run; it appears in
+// the error messages so the user gets accurate guidance.
+export async function resolveSiteDir(args, verb = 'deploy') {
+  const cwd = process.cwd()
+  const prefix = getCliPrefix()
+
+  const type = await classifyPackage(cwd)
+  if (type === 'site') return cwd
+
+  const workspaceRoot = findWorkspaceRoot(cwd)
+  if (workspaceRoot) {
+    const sites = await findSites(workspaceRoot)
+    if (sites.length === 1) return resolve(workspaceRoot, sites[0])
+    if (sites.length > 1) {
+      if (isNonInteractive(args)) {
+        say.err(`Multiple sites found. Specify which one to ${verb}.`)
+        console.log('')
+        for (const s of sites) {
+          console.log(`  ${c.cyan}cd ${s} && ${prefix} ${verb}${c.reset}`)
+        }
+        process.exit(1)
+      }
+      const choice = await promptSelect('Which site?', sites)
+      if (!choice) {
+        console.log(
+          `\n${verb.charAt(0).toUpperCase() + verb.slice(1)} cancelled.`
+        )
+        process.exit(0)
+      }
+      return resolve(workspaceRoot, choice)
+    }
+  }
+
+  say.err('No site found in this workspace.')
+  if (verb === 'export') {
+    say.dim(
+      '`export` produces a self-contained dist/ artifact for third-party hosting.'
+    )
+  } else if (verb === 'deploy') {
+    say.dim(
+      '`deploy` ships a built site to a third-party host (use `uniweb publish` for Uniweb hosting).'
+    )
+  } else {
+    say.dim(`\`${verb}\` operates on a site.`)
+  }
+  process.exit(1)
+}