uniweb 0.12.9 → 0.12.11

package/src/utils/host-prompt.js

@@ -0,0 +1,50 @@
+/**
+ * Interactive host adapter selection
+ *
+ * Prompts the user to pick a host adapter from the registry. Used when
+ * `--host` is passed without a value to `uniweb deploy / build / export`.
+ *
+ * Non-interactive contexts (CI, piped input, --non-interactive) get a
+ * structured error instead of a prompt — never silently default to
+ * something the user didn't pick.
+ */
+
+import { promptSelect } from './workspace.js'
+import { isNonInteractive } from './interactive.js'
+
+/**
+ * Pick a host adapter, optionally with a pre-selection.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.args — Argv, used only to gate non-interactive mode.
+ * @param {string|null} [opts.preselect] — Suggested adapter name; the prompt
+ *   highlights this so Enter accepts it without arrow-key navigation.
+ * @returns {Promise<string>} The chosen adapter name.
+ * @throws {Error} When non-interactive (with the registry list in the message),
+ *   or when the user aborts the prompt.
+ */
+export async function promptForHost({ args, preselect = null } = {}) {
+  // Lazy-load so this module doesn't pull @uniweb/build at import time
+  // for callers that never reach the prompt path.
+  const { listAdapters } = await import('@uniweb/build/hosts')
+  const adapters = listAdapters()
+
+  if (isNonInteractive(args || [])) {
+    const list = adapters.join(', ')
+    throw new Error(
+      `--host requires a value when running non-interactively. Known adapters: ${list}.`
+    )
+  }
+
+  // promptSelect doesn't expose initial-index, so move the preselect to
+  // the top of the list — the menu still highlights index 0 by default.
+  const ordered = preselect && adapters.includes(preselect)
+    ? [preselect, ...adapters.filter(a => a !== preselect)]
+    : adapters
+
+  const choice = await promptSelect('Pick a host adapter:', ordered)
+  if (!choice) {
+    throw new Error('Host selection cancelled.')
+  }
+  return choice
+}

package/src/utils/update-check.js

@@ -52,15 +52,46 @@ function writeState(state) {
 
 /**
  * Print update notification to stderr (doesn't interfere with piped output).
+ * `tone` controls the lead-in: 'soft' (default — trailing notice for finished
+ * commands) vs 'eager' (leading notice for staleness-sensitive commands like
+ * `create`, where the user is about to scaffold files from CLI-bundled
+ * templates and a stale CLI means stale starter content).
  */
-function printNotification(current, latest) {
+function printNotification(current, latest, tone = 'soft') {
   const yellow = '\x1b[33m'
   const cyan = '\x1b[36m'
   const dim = '\x1b[2m'
   const reset = '\x1b[0m'
   console.error('')
-  console.error(`${yellow}Update available:${reset} ${dim}${current}${reset} → ${cyan}${latest}${reset}`)
-  console.error(`${dim}Run${reset} npm i -g uniweb ${dim}to update${reset}`)
+  if (tone === 'eager') {
+    console.error(`${yellow}Heads up:${reset} this CLI is ${dim}${current}${reset}; latest is ${cyan}${latest}${reset}.`)
+    console.error(`${dim}Templates ship with the CLI — consider updating first:${reset} npm i -g uniweb`)
+    console.error(`${dim}Or run a one-shot fresh:${reset} npx uniweb@latest <command>`)
+  } else {
+    console.error(`${yellow}Update available:${reset} ${dim}${current}${reset} → ${cyan}${latest}${reset}`)
+    console.error(`${dim}Run${reset} npm i -g uniweb ${dim}to update${reset}`)
+  }
+}
+
+/**
+ * Synchronously read the cache and print an eager notification if a newer
+ * version is known. No network fetch — only reads what `startUpdateCheck`
+ * has previously cached. Returns true if a notification was printed.
+ *
+ * Use this for staleness-sensitive verbs (`create`) BEFORE the verb does
+ * its work, so the user sees the warning before any files are written
+ * from CLI-bundled templates. For other verbs, the trailing soft
+ * notification from startUpdateCheck() is sufficient.
+ *
+ * @param {string} currentVersion
+ * @returns {boolean} true if a notification was printed
+ */
+export function maybeEagerNotification(currentVersion) {
+  const state = readState()
+  if (!state.latestVersion) return false
+  if (compareSemver(state.latestVersion, currentVersion) <= 0) return false
+  printNotification(currentVersion, state.latestVersion, 'eager')
+  return true
 }
 
 /**