@uniweb/build 0.14.28 → 0.14.30

package/src/hosts/netlify.js

@@ -0,0 +1,281 @@
+/**
+ * Netlify host adapter
+ *
+ * Shares Cloudflare Pages' `_redirects` emission — the format originated
+ * at Netlify and the two hosts read it identically — but owns its own
+ * deploy and CI scaffolding, which is why this is a canonical adapter
+ * rather than the alias it used to be. (The registry header states the
+ * rule: adapters that need to *behave* differently per name become
+ * canonical entries, not aliases. `netlify deploy` and `wrangler pages
+ * deploy` are different tools with different auth.)
+ *
+ * deploy: drives the `netlify` CLI with `--json` so the deploy URL comes
+ * back structured instead of scraped from human output.
+ *
+ * initCi: emits a GitHub Actions workflow (push → production deploy) and,
+ * opt-in, a pull-request preview workflow using Netlify deploy aliases.
+ */
+
+import { DeployError, spawnTool, readCredential, credentialHint } from './deploy-utils.js'
+import { emitRedirectsFile } from './cloudflare-pages.js'
+import {
+  setupSteps,
+  uniwebBuildCommand,
+  pushTrigger,
+  prCommentStep,
+  workflowHeader,
+} from './ci-workflow.js'
+
+const NETLIFY_INSTALL = [
+  'Install the Netlify CLI:',
+  '  npm install -g netlify-cli',
+  '  # or run it without installing: npx netlify-cli …',
+  '',
+  'Then authenticate with `netlify login`, or set NETLIFY_AUTH_TOKEN.',
+].join('\n')
+
+function translateNetlifyError(code, stderr) {
+  const out = stderr.trim()
+
+  if (/Not authorized|401|invalid token|Access Denied/i.test(out)) {
+    return new DeployError(
+      'Netlify rejected the credentials.',
+      {
+        hint: credentialHint({
+          what: 'a Netlify personal access token',
+          envVars: ['NETLIFY_AUTH_TOKEN'],
+          docsUrl: 'Create one at https://app.netlify.com/user/applications#personal-access-tokens',
+        }),
+      }
+    )
+  }
+
+  if (/site not found|Site not found|404/i.test(out)) {
+    return new DeployError(
+      'That Netlify site does not exist (or the token cannot see it).',
+      {
+        hint: [
+          'Create it once, or link an existing one:',
+          '  netlify sites:create --name my-site',
+          '  # or, from the site directory: netlify link',
+          '',
+          'Then set `siteId` on the target in deploy.yml, or export NETLIFY_SITE_ID.',
+        ].join('\n'),
+      }
+    )
+  }
+
+  return null
+}
+
+/**
+ * Parse `netlify deploy --json` output. The CLI prints a single JSON
+ * object; older versions prefix it with progress noise, so scan for the
+ * first `{`. Best-effort — a parse miss only costs us the echoed URL.
+ */
+export function parseNetlifyJson(stdout) {
+  const start = stdout.indexOf('{')
+  if (start === -1) return null
+  try {
+    return JSON.parse(stdout.slice(start))
+  } catch {
+    return null
+  }
+}
+
+async function deploy({ distDir, deployConfig = {}, env = process.env, log = () => {} }) {
+  const siteId = readCredential(deployConfig, env, 'siteId', 'NETLIFY_SITE_ID')
+  if (!siteId) {
+    throw new DeployError(
+      'Netlify needs a site id.',
+      {
+        hint: [
+          'Add it to the target in deploy.yml:',
+          '',
+          '  targets:',
+          '    production:',
+          '      host: netlify',
+          '      siteId: 1a2b3c4d-….   # Site settings → General → Site ID',
+          '',
+          'Or export NETLIFY_SITE_ID. Create a site with `netlify sites:create`.',
+        ].join('\n'),
+      }
+    )
+  }
+
+  const subprocessEnv = { ...env }
+  if (!env.NETLIFY_AUTH_TOKEN) {
+    log('  No NETLIFY_AUTH_TOKEN set — falling back to your `netlify login` session.')
+  }
+
+  // --alias produces a named preview deploy; without it (and with --prod)
+  // this publishes to the site's production URL.
+  const isPreview = !!deployConfig.alias
+  const args = ['deploy', `--dir=${distDir}`, `--site=${siteId}`, '--json']
+  if (isPreview) {
+    args.push(`--alias=${deployConfig.alias}`)
+  } else {
+    args.push('--prod')
+  }
+  if (deployConfig.message) args.push(`--message=${deployConfig.message}`)
+
+  log(`\n→ Deploying to Netlify site ${siteId}${isPreview ? ` (preview: ${deployConfig.alias})` : ''}`)
+  // --json means stdout is a machine payload; don't echo it as progress.
+  const { stdout } = await spawnTool('netlify', args, {
+    env: subprocessEnv,
+    log,
+    install: NETLIFY_INSTALL,
+    translate: translateNetlifyError,
+    quiet: true,
+  })
+
+  const result = parseNetlifyJson(stdout)
+  const url = result?.deploy_url || result?.url || null
+  log('\n✓ Deploy complete.')
+  if (url) log(`  ${url}`)
+  return { url }
+}
+
+async function initCi({
+  site,
+  packageManager = 'pnpm',
+  nodeVersion = '20',
+  pnpmVersion = '11',
+  domain = null,
+  previews = true,
+}) {
+  const sitePath = site.path
+  const build = uniwebBuildCommand({ packageManager, host: 'netlify' })
+  const setup = setupSteps({ packageManager, nodeVersion, pnpmVersion })
+
+  const files = [{
+    path: '.github/workflows/deploy-netlify.yml',
+    content: `${workflowHeader({
+      title: 'Deploy to Netlify',
+      command: 'uniweb add ci --host=netlify',
+      notes: [
+        'Requires two repository secrets (Settings → Secrets and variables → Actions):',
+        '  NETLIFY_AUTH_TOKEN  — personal access token',
+        '  NETLIFY_SITE_ID     — Site settings → General → Site ID',
+      ],
+    })}
+
+name: Deploy to Netlify
+
+${pushTrigger()}
+
+concurrency:
+  group: netlify-production
+  cancel-in-progress: true
+
+jobs:
+  build-deploy:
+    runs-on: ubuntu-latest
+    env:
+      NETLIFY_AUTH_TOKEN: \${{ secrets.NETLIFY_AUTH_TOKEN }}
+      NETLIFY_SITE_ID: \${{ secrets.NETLIFY_SITE_ID }}
+    steps:
+${setup}
+      - run: ${build}
+        working-directory: ${sitePath}
+      - name: Publish to Netlify
+        run: npx netlify-cli deploy --prod --dir=${sitePath}/dist --message="\${{ github.event.head_commit.message }}"
+`,
+  }]
+
+  if (previews) {
+    files.push({
+      path: '.github/workflows/preview-netlify.yml',
+      content: `${workflowHeader({
+        title: 'Preview deploy for pull requests — Netlify',
+        command: 'uniweb add ci --host=netlify',
+        notes: [
+          'Each PR deploys to a named alias (pr-<number>) and the URL is',
+          'posted as a comment on the PR.',
+          '',
+          'No teardown job: Netlify keeps deploys immutable by design and',
+          'expires aliases with the site\'s retention policy. Deleting them',
+          'per-PR would fight the platform rather than help.',
+        ],
+      })}
+
+name: Preview (Netlify)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+concurrency:
+  group: netlify-preview-\${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  preview:
+    runs-on: ubuntu-latest
+    env:
+      NETLIFY_AUTH_TOKEN: \${{ secrets.NETLIFY_AUTH_TOKEN }}
+      NETLIFY_SITE_ID: \${{ secrets.NETLIFY_SITE_ID }}
+    steps:
+${setup}
+      - run: ${build}
+        working-directory: ${sitePath}
+      - name: Publish preview
+        id: publish
+        run: |
+          URL=$(npx netlify-cli deploy \\
+            --dir=${sitePath}/dist \\
+            --alias=pr-\${{ github.event.pull_request.number }} \\
+            --json | jq -r '.deploy_url')
+          echo "url=$URL" >> "$GITHUB_OUTPUT"
+${prCommentStep({
+  urlExpression: '${{ steps.publish.outputs.url }}',
+  hostLabel: 'Netlify',
+})}
+`,
+    })
+  }
+
+  const targetConfig = { host: 'netlify' }
+  if (domain) targetConfig.domain = domain
+
+  const postInstructions = [
+    'Create the site once: `netlify sites:create --name <name>` (or link an existing one).',
+    'Add two repository secrets under Settings → Secrets and variables → Actions:',
+    '  NETLIFY_AUTH_TOKEN  (https://app.netlify.com/user/applications)',
+    '  NETLIFY_SITE_ID     (Site settings → General → Site ID)',
+    'Commit and push the workflow — the deploy runs on every push to the default branch.',
+  ]
+  if (previews) {
+    postInstructions.push('Pull requests deploy to a pr-<number> alias, commented on the PR.')
+  }
+  if (domain) {
+    postInstructions.push(`Attach ${domain} under Domain management in the Netlify dashboard.`)
+  }
+
+  return { files, postInstructions, targetConfig }
+}
+
+const adapter = {
+  name: 'netlify',
+  display: {
+    order: 30,
+    pushWith: 'the netlify CLI',
+    title: 'Netlify',
+    qualifier: 'free, CI on push',
+    summary: 'Static hosting with deploy previews. Set up a workflow, or upload from here with the netlify CLI.',
+    ci: true,
+    previews: true,
+  },
+  async postBuild({ distDir, localeConfigs, onProgress }) {
+    // Same _redirects contract as Cloudflare Pages.
+    await emitRedirectsFile(distDir, localeConfigs, onProgress)
+  },
+  deploy,
+  initCi,
+}
+
+export default adapter

package/src/hosts/s3-cloudfront.js

@@ -30,6 +30,8 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { spawn } from 'node:child_process'
 
+import { DeployError } from './deploy-utils.js'
+
 const FUNCTION_SOURCE = `// CloudFront Function — viewer-request — directory-index resolution.
 //
 // Attach to the default cache behavior of your CloudFront distribution.
@@ -183,13 +185,9 @@ async function augmentManifest(distDir, deployConfig) {
  * Deploy hook                                                        *
  * ------------------------------------------------------------------ */
 
-class DeployError extends Error {
-  constructor(message, { hint } = {}) {
-    super(message)
-    this.name = 'DeployError'
-    this.hint = hint
-  }
-}
+// DeployError now lives in deploy-utils.js — every adapter that shells
+// out to a CLI needs the same shape. Re-exported at the bottom of this
+// file so existing importers (tests) keep resolving it here.
 
 /**
  * Run an `aws` subcommand with stdout piped to the user. stderr is
@@ -502,6 +500,15 @@ async function deploy({ distDir, deployConfig = {}, env = process.env, log = ()
 
 const adapter = {
   name: 's3-cloudfront',
+  display: {
+    order: 50,
+    pushWith: 'the aws CLI',
+    title: 'S3 + CloudFront',
+    qualifier: 'your AWS account',
+    summary: 'Builds and uploads to your own bucket, then invalidates the CDN. Needs the aws CLI and a provisioned distribution.',
+    ci: false,
+    previews: false,
+  },
   postBuild,
   deploy,
 }

package/src/hosts/vercel.js

@@ -1,17 +1,9 @@
 /**
  * Vercel host adapter
  *
- * Vercel auto-resolves directory-index requests, runs the project's
- * configured build command, and serves whatever lands in the configured
- * output directory (we use `dist/`). The framework has no helper files
- * to drop — postBuild is intentionally empty.
- *
- * Lifecycle: Git-driven. The user sets up Vercel's GitHub integration,
- * configures `npx uniweb build` as the build command, and pushes; Vercel
- * runs the build and serves the result. `uniweb deploy --host=vercel`
- * is intentionally not supported — there is no CLI-push path. See the
- * deploy command's "host adapter does not implement a deploy step" error
- * for the user-facing message when someone tries.
+ * Vercel auto-resolves directory-index requests and serves whatever lands
+ * in the output directory. The framework has no helper files to drop —
+ * postBuild is intentionally empty.
  *
  * `vercel.json` emission is not done by default. Most Vercel projects
  * don't need one (the defaults already handle directory-index, SPA
@@ -19,18 +11,254 @@
  * their own `vercel.json` next to `site.yml` and the build leaves it
  * alone.
  *
+ * Two lifecycles are supported, and they're genuinely different:
+ *   - Git-driven — connect the repo in Vercel's dashboard and let it
+ *     build. Nothing to scaffold.
+ *   - CLI-push — `uniweb deploy --host=vercel` uploads an already-built
+ *     `dist/` via the `vercel` CLI. This is the path that lets a build
+ *     run on your machine (or in a workflow you control) rather than in
+ *     Vercel's builder.
+ *
  * Registered as its own canonical adapter (not an alias of
  * generic-static) so the deploy manifest, dry-run output, and
  * deploy.yml's `host:` field record `vercel` literally — readers should
  * see what the user picked, not the canonical implementation behind it.
  */
 
+import { DeployError, spawnTool, readCredential, credentialHint } from './deploy-utils.js'
+import {
+  setupSteps,
+  uniwebBuildCommand,
+  pushTrigger,
+  prCommentStep,
+  workflowHeader,
+} from './ci-workflow.js'
+
+const VERCEL_INSTALL = [
+  'Install the Vercel CLI:',
+  '  npm install -g vercel',
+  '  # or run it without installing: npx vercel …',
+  '',
+  'Then authenticate with `vercel login`, or set VERCEL_TOKEN.',
+].join('\n')
+
+function translateVercelError(code, stderr) {
+  const out = stderr.trim()
+
+  if (/not authorized|Invalid token|forbidden|401/i.test(out)) {
+    return new DeployError(
+      'Vercel rejected the credentials.',
+      {
+        hint: credentialHint({
+          what: 'a Vercel access token',
+          envVars: ['VERCEL_TOKEN'],
+          docsUrl: 'Create one at https://vercel.com/account/tokens',
+        }),
+      }
+    )
+  }
+
+  if (/Project not found|project does not exist/i.test(out)) {
+    return new DeployError(
+      'That Vercel project does not exist (or the token cannot see it).',
+      {
+        hint: [
+          'Link the directory to a project once:',
+          '  vercel link',
+          '',
+          'In CI, set VERCEL_ORG_ID and VERCEL_PROJECT_ID instead — both are',
+          'written to .vercel/project.json by `vercel link`.',
+        ].join('\n'),
+      }
+    )
+  }
+
+  return null
+}
+
+/** Last https:// URL printed on stdout is the deployment URL. */
+export function extractVercelUrl(stdout) {
+  const matches = stdout.match(/https:\/\/\S+\.vercel\.app\S*/g)
+  if (!matches || !matches.length) return null
+  return matches[matches.length - 1].replace(/[.,)]+$/, '')
+}
+
+async function deploy({ distDir, deployConfig = {}, env = process.env, log = () => {} }) {
+  const token = readCredential(deployConfig, env, null, 'VERCEL_TOKEN')
+  const orgId = readCredential(deployConfig, env, 'orgId', 'VERCEL_ORG_ID')
+  const projectId = readCredential(deployConfig, env, 'projectId', 'VERCEL_PROJECT_ID')
+
+  const subprocessEnv = { ...env }
+  if (orgId) subprocessEnv.VERCEL_ORG_ID = orgId
+  if (projectId) subprocessEnv.VERCEL_PROJECT_ID = projectId
+  if (!token && !env.VERCEL_TOKEN) {
+    log('  No VERCEL_TOKEN set — falling back to your `vercel login` session.')
+  }
+
+  // Deploying a plain directory of static files: Vercel treats it as a
+  // static deploy with no build step, which is exactly right — `uniweb
+  // build` already produced the artifact.
+  const isPreview = deployConfig.preview === true
+  const args = ['deploy', distDir, '--yes']
+  if (!isPreview) args.push('--prod')
+  if (token) args.push(`--token=${token}`)
+  if (deployConfig.scope) args.push(`--scope=${deployConfig.scope}`)
+
+  log(`\n→ Deploying to Vercel${isPreview ? ' (preview)' : ''}`)
+  const { stdout } = await spawnTool('vercel', args, {
+    env: subprocessEnv,
+    log,
+    install: VERCEL_INSTALL,
+    translate: translateVercelError,
+  })
+
+  const url = extractVercelUrl(stdout)
+  log('\n✓ Deploy complete.')
+  if (url) log(`  ${url}`)
+  return { url }
+}
+
+async function initCi({
+  site,
+  packageManager = 'pnpm',
+  nodeVersion = '20',
+  pnpmVersion = '11',
+  domain = null,
+  previews = true,
+}) {
+  const sitePath = site.path
+  const build = uniwebBuildCommand({ packageManager, host: 'vercel' })
+  const setup = setupSteps({ packageManager, nodeVersion, pnpmVersion })
+
+  const files = [{
+    path: '.github/workflows/deploy-vercel.yml',
+    content: `${workflowHeader({
+      title: 'Deploy to Vercel',
+      command: 'uniweb add ci --host=vercel',
+      notes: [
+        'Requires three repository secrets (Settings → Secrets and variables → Actions):',
+        '  VERCEL_TOKEN       — https://vercel.com/account/tokens',
+        '  VERCEL_ORG_ID      — from .vercel/project.json after `vercel link`',
+        '  VERCEL_PROJECT_ID  — same file',
+        '',
+        'Only needed if you want the build to run here rather than in',
+        'Vercel\'s builder. Connecting the repo in the Vercel dashboard is',
+        'the zero-config alternative — in that case delete this workflow.',
+      ],
+    })}
+
+name: Deploy to Vercel
+
+${pushTrigger()}
+
+concurrency:
+  group: vercel-production
+  cancel-in-progress: true
+
+jobs:
+  build-deploy:
+    runs-on: ubuntu-latest
+    env:
+      VERCEL_ORG_ID: \${{ secrets.VERCEL_ORG_ID }}
+      VERCEL_PROJECT_ID: \${{ secrets.VERCEL_PROJECT_ID }}
+    steps:
+${setup}
+      - run: ${build}
+        working-directory: ${sitePath}
+      - name: Publish to Vercel
+        run: npx vercel deploy ${sitePath}/dist --prod --yes --token=\${{ secrets.VERCEL_TOKEN }}
+`,
+  }]
+
+  if (previews) {
+    files.push({
+      path: '.github/workflows/preview-vercel.yml',
+      content: `${workflowHeader({
+        title: 'Preview deploy for pull requests — Vercel',
+        command: 'uniweb add ci --host=vercel',
+        notes: [
+          'Each PR gets a Vercel preview deployment, posted as a comment.',
+          '',
+          'No teardown job: Vercel manages preview-deployment retention',
+          'itself. If the repo is connected to Vercel through the dashboard,',
+          'previews already happen natively — delete this workflow instead of',
+          'running both.',
+        ],
+      })}
+
+name: Preview (Vercel)
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+concurrency:
+  group: vercel-preview-\${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  preview:
+    runs-on: ubuntu-latest
+    env:
+      VERCEL_ORG_ID: \${{ secrets.VERCEL_ORG_ID }}
+      VERCEL_PROJECT_ID: \${{ secrets.VERCEL_PROJECT_ID }}
+    steps:
+${setup}
+      - run: ${build}
+        working-directory: ${sitePath}
+      - name: Publish preview
+        id: publish
+        run: |
+          URL=$(npx vercel deploy ${sitePath}/dist --yes --token=\${{ secrets.VERCEL_TOKEN }})
+          echo "url=$URL" >> "$GITHUB_OUTPUT"
+${prCommentStep({
+  urlExpression: '${{ steps.publish.outputs.url }}',
+  hostLabel: 'Vercel',
+})}
+`,
+    })
+  }
+
+  const targetConfig = { host: 'vercel' }
+  if (domain) targetConfig.domain = domain
+
+  const postInstructions = [
+    'Link the project once: `vercel link` (writes .vercel/project.json).',
+    'Add three repository secrets under Settings → Secrets and variables → Actions:',
+    '  VERCEL_TOKEN, VERCEL_ORG_ID, VERCEL_PROJECT_ID',
+    'Commit and push the workflow — the deploy runs on every push to the default branch.',
+    '',
+    'Alternative: connect the repo in the Vercel dashboard and delete these',
+    'workflows. Vercel then builds and previews natively with no secrets.',
+  ]
+  if (domain) {
+    postInstructions.push(`Attach ${domain} under the project's Domains tab.`)
+  }
+
+  return { files, postInstructions, targetConfig }
+}
+
 const adapter = {
   name: 'vercel',
+  display: {
+    order: 40,
+    pushWith: 'the vercel CLI',
+    title: 'Vercel',
+    qualifier: 'free tier, CI on push',
+    summary: 'Static hosting with native preview deployments. Connect the repo in Vercel\'s dashboard, or upload from here.',
+    ci: true,
+    previews: true,
+  },
   async postBuild() {
     // Intentionally empty. Vercel's defaults handle directory-index,
     // SPA fallback, and asset caching without per-site config.
   },
+  deploy,
+  initCi,
 }
 
 export default adapter