@flocon-ai/init 0.0.1 → 0.0.2

package/src/cli.mjs

@@ -1,41 +1,92 @@
 #!/usr/bin/env node
-import { spawnSync } from "node:child_process"
+import { spawn, spawnSync } from "node:child_process"
 import fs from "node:fs"
 import path from "node:path"
-import readline from "node:readline/promises"
-import { addSitemapAndLlms } from "./sitemap.mjs"
+import { addSitemapAndLlms, ownSitemapFiles } from "./sitemap.mjs"
 import { TEMPLATES } from "./templates.mjs"
+import { applyUrlRule } from "./url.mjs"
 
 const DOCS = "https://flocon-ai.com/docs"
 const TOKENS_URL = "https://flocon-ai.com/app/tokens"
 
 const FRAMEWORKS = {
   nextjs: { label: "Next.js (App Router)", pkg: "@flocon-ai/next" },
-  react: { label: "React Router v7 (framework mode)", pkg: "@flocon-ai/react" },
+  react: { label: "React Router (framework mode)", pkg: "@flocon-ai/react" },
   astro: { label: "Astro", pkg: "@flocon-ai/astro" }
 }
 
-const log = (line = "") => console.log(line)
+// Interactive = a person in a terminal: step-by-step questions (like create-next-app).
+// Not interactive (AI agents, CI, --yes, --path or --domain given): no questions, flags and defaults only, plain output.
+let interactive = false
+// @clack/prompts, loaded only for questions: it needs Node 20.12+ (util.styleText). Older Node crashed on start, even with --yes.
+let p
+
+// Node 20.12+ (the questions library needs it).
+function canAsk() {
+  const [major, minor] = process.versions.node.split(".").map(Number)
+  return major > 20 || (major === 20 && minor >= 12)
+}
+
+function log(line = "") {
+  if (!interactive) return console.log(line)
+  const text = line.replace(/^\n+/, "")
+  if (text) p.log.message(text)
+}
 
 function fail(lines) {
-  for (const line of lines) console.error(line)
+  if (interactive) p.log.error(lines.join("\n"))
+  else for (const line of lines) console.error(line)
   process.exit(1)
 }
 
+// Ctrl+C or Esc at a question.
+function cancelled() {
+  p.cancel("Cancelled. Nothing was installed or changed.")
+  process.exit(130)
+}
+
+async function ask(prompt) {
+  const value = await prompt
+  if (p.isCancel(value)) cancelled()
+  return value
+}
+
 function parseArgs(argv) {
-  const args = { yes: false, skipInstall: false, sitemap: true, path: undefined }
+  const args = { yes: false, skipInstall: false, sitemap: true, path: undefined, domain: undefined }
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i]
     if (a === "--yes") args.yes = true
     else if (a === "--skip-install") args.skipInstall = true
     else if (a === "--no-sitemap") args.sitemap = false
-    else if (a === "--path") args.path = argv[++i] ?? ""
-    else if (a.startsWith("--path=")) args.path = a.slice("--path=".length)
-    else fail([`Unknown option: ${a}`, "Options: --path <path> --yes --skip-install --no-sitemap"])
+    else if (a === "--path") {
+      const value = argv[++i]
+      // `--path --yes`: the value is missing. Without this check the path would be "/--yes".
+      if (value === undefined || value.startsWith("-")) fail(["--path needs a value, e.g. --path /blog (or --path / for the whole website)."])
+      args.path = value
+    } else if (a.startsWith("--path=")) args.path = a.slice("--path=".length)
+    else if (a === "--domain") {
+      const value = argv[++i]
+      if (value === undefined || value.startsWith("-")) fail(["--domain needs a value, e.g. --domain https://acme.com"])
+      args.domain = value
+    } else if (a.startsWith("--domain=")) args.domain = a.slice("--domain=".length)
+    else fail([`Unknown option: ${a}`, "Options: --path <path> --domain <url> --yes --skip-install --no-sitemap"])
   }
   return args
 }
 
+// "acme.com", "https://acme.com/blog" → "https://acme.com". Undefined when it is not a domain.
+function toOrigin(input) {
+  const t = String(input ?? "").trim()
+  if (!t) return undefined
+  try {
+    const u = new URL(t.includes("://") ? t : `https://${t}`)
+    if (!/^https?:$/.test(u.protocol) || !u.hostname.includes(".")) return undefined
+    return u.origin
+  } catch {
+    return undefined
+  }
+}
+
 function readPackageJson(cwd) {
   try {
     return JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"))
@@ -57,38 +108,92 @@ function detectFramework(cwd) {
   const deps = { ...pkg.dependencies, ...pkg.devDependencies }
   if (deps.next && nextAppDir(cwd)) return "nextjs"
   if (deps.astro && fs.existsSync(path.join(cwd, "src/pages"))) return "astro"
-  if (deps["@react-router/dev"] && fs.existsSync(path.join(cwd, "app/routes.ts"))) return "react"
+  if (deps["@react-router/dev"] && rrRoutesFile(cwd)) return "react"
   return undefined
 }
 
+// React Router: the app folder (`appDirectory` in react-router.config, default "app").
+function rrAppDir(cwd) {
+  const m = /appDirectory\s*:\s*["'`]([^"'`]+)["'`]/.exec(readFirst(cwd, RR_CONFIGS))
+  return (m?.[1] ?? "app").replace(/^\.\//, "").replace(/\/+$/, "")
+}
+
+// React Router: routes.ts, or routes.js in a JavaScript project. Undefined when there is none.
+function rrRoutesFile(cwd) {
+  const app = rrAppDir(cwd)
+  return ["routes.ts", "routes.js", "routes.mts", "routes.mjs"].map((f) => `${app}/${f}`).find((f) => fs.existsSync(path.join(cwd, f)))
+}
+
+const LOCK_FILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+]
+
+// 1. The lock file, in this folder or a parent one (monorepos keep it at the repo root).
+// 2. No lock file: the tool that ran this command (pnpm dlx, yarn dlx, bunx, npx).
 function detectPackageManager(cwd) {
-  const has = (f) => fs.existsSync(path.join(cwd, f))
-  if (has("pnpm-lock.yaml")) return "pnpm"
-  if (has("yarn.lock")) return "yarn"
-  if (has("bun.lock") || has("bun.lockb")) return "bun"
+  for (let dir = path.resolve(cwd); ; dir = path.dirname(dir)) {
+    for (const [file, pm] of LOCK_FILES) if (fs.existsSync(path.join(dir, file))) return pm
+    if (dir === path.dirname(dir)) break
+  }
+  const agent = process.env.npm_config_user_agent ?? ""
+  for (const pm of ["pnpm", "yarn", "bun"]) if (agent.startsWith(pm + "/")) return pm
   return "npm"
 }
 
 const INSTALL_ARGS = { npm: ["install"], pnpm: ["add"], yarn: ["add"], bun: ["add"] }
 
 // "blog" -> "/blog", "/blog/" -> "/blog". Returns { error } when the path is not valid.
+// Next.js route groups are allowed: "/(site)/blog" -> path "/blog" (the URL), dir "/(site)/blog" (the folder).
 function normalizePath(input) {
   let p = String(input ?? "").trim()
+  // Git Bash on Windows turns "/blog" into "C:/Program Files/Git/blog" before the command sees it.
+  if (/^[A-Za-z]:[\\/]/.test(p)) {
+    return {
+      error:
+        'Git Bash changed the path into a Windows path. Type it without the first slash: --path blog (or --path "(site)/blog"). Whole website: --yes without --path.'
+    }
+  }
   if (/\s/.test(p)) return { error: "The path must not contain spaces." }
   if (p === "") p = "/"
   if (!p.startsWith("/")) p = "/" + p
   if (p.length > 1) p = p.replace(/\/+$/, "") || "/"
-  if (!/^(\/[A-Za-z0-9_-]+)*\/?$/.test(p)) {
-    return { error: "Use only letters, numbers, - and _ in the path (e.g. /blog or /guides/seo)." }
+  if (!/^(\/([A-Za-z0-9_-]+|\([A-Za-z0-9_-]+\)))*\/?$/.test(p)) {
+    // Accents (e.g. /actualités): suggest the plain letters.
+    const plain = p.normalize("NFD").replace(/[\u0300-\u036f]/g, "")
+    const tip = plain !== p && /^(\/([A-Za-z0-9_-]+|\([A-Za-z0-9_-]+\)))*\/?$/.test(plain) ? ` Try ${plain}.` : ""
+    return { error: `Use only letters, numbers, - and _ in the path (e.g. /blog or /guides/seo). A Next.js route group is fine too: /(site)/blog.${tip}` }
   }
-  return { path: p }
+  const url = p.split("/").filter((s) => s && !s.startsWith("("))
+  return { path: "/" + url.join("/"), dir: p }
 }
 
-// Next.js (app/[locale]) or Astro (src/pages/[locale]) with a `[locale]` segment: the route goes under it.
-function hasLocaleSegment(cwd, framework) {
-  if (framework === "nextjs") return fs.existsSync(path.join(cwd, nextAppDir(cwd), "[locale]"))
-  if (framework === "astro") return fs.existsSync(path.join(cwd, "src/pages/[locale]"))
-  return false
+const LAYOUTS = ["layout.tsx", "layout.jsx", "layout.js", "layout.ts"]
+const hasLayout = (dir) => LAYOUTS.some((f) => fs.existsSync(path.join(dir, f)))
+
+// The language segment the route goes under: "locale" for app/[locale] or src/pages/[locale].
+// Next.js also: no app/layout and the root layout in one top folder like app/[lang] (the Next.js i18n docs pattern).
+// Returns the segment name, or undefined.
+function localeSegment(cwd, framework) {
+  if (framework === "astro") return fs.existsSync(path.join(cwd, "src/pages/[locale]")) ? "locale" : undefined
+  if (framework !== "nextjs") return undefined
+  const appDir = path.join(cwd, nextAppDir(cwd))
+  if (fs.existsSync(path.join(appDir, "[locale]"))) return "locale"
+  if (hasLayout(appDir)) return undefined
+  const withLayout = fs
+    .readdirSync(appDir)
+    .filter((e) => /^\[[A-Za-z_]\w*\]$/.test(e) && hasLayout(path.join(appDir, e)))
+  return withLayout.length === 1 ? withLayout[0].slice(1, -1) : undefined
+}
+
+// Next.js needs a root layout above every page. Route groups like (site) do not count: they cover their own folder only.
+function missingRootLayout(cwd, file) {
+  const parts = path.dirname(file).split("/")
+  for (let i = 1; i <= parts.length; i++) if (hasLayout(path.join(cwd, ...parts.slice(0, i)))) return false
+  return true
 }
 
 // Projects we know and do not support: stop with the reason, install nothing.
@@ -114,29 +219,376 @@ function unsupportedReason(cwd) {
   return undefined
 }
 
-function routeFile(cwd, framework, urlPath, hasLocale) {
-  const prefix = urlPath === "/" ? "" : urlPath
+// Removes /* */ and // comments, so a commented-out line (e.g. // output: "export") is not read.
+// Keeps // after ":" or a quote (URLs like https://…).
+function stripComments(code) {
+  return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:"'`\\])\/\/.*$/gm, "$1")
+}
+
+// First config or code file found, without its comments.
+function readFirst(cwd, files) {
+  for (const f of files) {
+    try {
+      return stripComments(fs.readFileSync(path.join(cwd, f), "utf8"))
+    } catch {}
+  }
+  return ""
+}
+
+const NEXT_CONFIGS = ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs", "next.config.mts"]
+const ASTRO_CONFIGS = ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.mts"]
+const RR_CONFIGS = ["react-router.config.ts", "react-router.config.js", "react-router.config.mjs"]
+
+// Supported framework, but a setup Flocon cannot work with. Stop with the reason, install nothing.
+function blockedReason(cwd, framework) {
+  const pkg = readPackageJson(cwd)
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const nothing = "Nothing was installed or changed. Docs: " + DOCS
   if (framework === "nextjs") {
-    const locale = hasLocale ? "/[locale]" : ""
-    return `${nextAppDir(cwd)}${locale}${prefix}/[...slug]/page.tsx`
+    const major = Number(/\d+/.exec(String(deps.next))?.[0])
+    if (major && major < 15) {
+      return [`Flocon AI: this project uses Next.js ${major}. @flocon-ai/next needs Next.js 15 or newer.`, "Upgrade Next.js first, then run this command again.", nothing]
+    }
+    if (/output\s*:\s*["'`]export["'`]/.test(readFirst(cwd, NEXT_CONFIGS))) {
+      return [
+        'Flocon AI: this project uses output: "export" (static export). Flocon pages are read on each request, so they need a server.',
+        'Remove output: "export" from next.config and host the website on a server (Vercel, Netlify, Node…).',
+        nothing
+      ]
+    }
+  }
+  if (framework === "astro") {
+    const config = readFirst(cwd, ASTRO_CONFIGS)
+    if (!/output\s*:\s*["'`]server["'`]/.test(config) || !/adapter\s*:/.test(config)) {
+      return [
+        'Flocon AI: Astro must run in SSR (output: "server" + an adapter). Pages are read on each request.',
+        'Add an adapter (npx astro add node, or vercel, netlify, cloudflare), set output: "server" in astro.config, then run this command again.',
+        nothing
+      ]
+    }
+    if (/\bi18n\s*:/.test(config) && !fs.existsSync(path.join(cwd, "src/pages/[locale]"))) {
+      return [
+        "Flocon AI: this Astro website uses i18n routing (i18n in astro.config). This command can't set it up yet: Flocon pages in other languages would not show.",
+        "Add the Flocon route yourself (see the Astro install page in the docs).",
+        nothing
+      ]
+    }
   }
+  if (framework === "react" && /ssr\s*:\s*false/.test(readFirst(cwd, RR_CONFIGS))) {
+    return [
+      "Flocon AI: this React Router app runs in SPA mode (ssr: false). It is not supported.",
+      "Why: AI bots and search crawlers do not run JavaScript. They would see an empty page.",
+      "Set ssr: true in react-router.config, then run this command again.",
+      nothing
+    ]
+  }
+  return undefined
+}
+
+// React Router with flatRoutes(): the file name is the URL, nothing to add in app/routes.ts.
+function usesFlatRoutes(cwd) {
+  return /flatRoutes\s*\(/.test(readFirst(cwd, [rrRoutesFile(cwd)]))
+}
+
+// React Router: the route files folder, inside the app folder. flatRoutes({ rootDirectory: "pages" }) reads app/pages.
+function rrRoutesDir(cwd) {
+  const m = /flatRoutes\s*\(\s*\{[^}]*rootDirectory\s*:\s*["'`]([^"'`]+)["'`]/.exec(readFirst(cwd, [rrRoutesFile(cwd)]))
+  return (m?.[1] ?? "routes").replace(/^\.\//, "").replace(/\/+$/, "")
+}
+
+// React Router: every route path in routes.ts, with its prefix() folders.
+// e.g. ...prefix("blog", [route("*", …)]) -> "blog/*".
+function rrRoutePaths(code) {
+  const out = []
+  const stack = []
+  const re = /prefix\(\s*["'`]([^"'`]*)["'`]\s*,\s*\[|route\(\s*["'`]([^"'`]*)["'`]|\[|\]/g
+  for (const m of code.matchAll(re)) {
+    if (m[0] === "[") stack.push(null)
+    else if (m[0] === "]") stack.pop()
+    else if (m[1] !== undefined) stack.push(m[1])
+    else out.push([...stack.filter((s) => s), m[2]].map((s) => s.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/"))
+  }
+  return out
+}
+
+// Next.js 16 cacheComponents: `export const dynamic` breaks the build there.
+// React Router 7.0 to 7.7: meta() gets `data` (`loaderData` came in 7.8, v8 only has `loaderData`).
+// Installed version first, else the range in package.json. Unknown → new versions.
+function rrOldMeta(cwd) {
+  let version
+  try {
+    version = JSON.parse(fs.readFileSync(path.join(cwd, "node_modules/react-router/package.json"), "utf8")).version
+  } catch {
+    const pkg = readPackageJson(cwd)
+    version = { ...pkg?.dependencies, ...pkg?.devDependencies }["react-router"]
+  }
+  const m = /(\d+)\.(\d+)/.exec(String(version ?? ""))
+  return Boolean(m) && Number(m[1]) === 7 && Number(m[2]) < 8
+}
+
+function usesCacheComponents(cwd) {
+  return /cacheComponents\s*:\s*true/.test(readFirst(cwd, NEXT_CONFIGS))
+}
+
+// React Router: a splat route for the same URLs is already there (often a 404 page).
+// Two splats for the same URLs: the first one always wins, so Flocon pages would never show.
+// Returns the clashing route, or undefined.
+function reactSplatClash(cwd, urlPath, flat, rr) {
+  const segments = urlPath === "/" ? [] : urlPath.slice(1).split("/")
+  if (!flat) {
+    const target = [...segments, "*"].join("/")
+    const hit = rrRoutePaths(readFirst(cwd, [rr.routes])).find((p) => p === target)
+    return hit ? `route("${hit}") in ${rr.routes}` : undefined
+  }
+  // flatRoutes: "$.tsx", "blog.$.tsx", "($locale).$.tsx" (optional and pathless "_x" segments add nothing to the URL).
+  let entries = []
+  try {
+    entries = fs.readdirSync(path.join(cwd, rr.app, rr.dir))
+  } catch {}
+  for (const e of entries) {
+    const parts = e.replace(/\.(tsx|ts|jsx|js)$/, "").split(".")
+    if (parts.at(-1) !== "$") continue
+    const rest = parts.slice(0, -1).filter((p) => !/^\(.+\)$/.test(p) && !p.startsWith("_"))
+    if (rest.join("/") === segments.join("/")) return `${rr.app}/${rr.dir}/${e}`
+  }
+  return undefined
+}
+
+// Next.js: optional catch-all [[...slug]] when nothing serves the folder's own URL: it also serves that URL
+// (e.g. a Flocon page "/" = the home page). When the website has a page there (app/page.tsx, app/blog/page.tsx,
+// app/(site)/page.tsx…), plain [...slug]: Next.js refuses a page and an optional catch-all for the same URL
+// ("You cannot define a route with the same specificity as an optional catch-all route", tested with next build).
+// `dirPath` = the path with its route groups, e.g. "/(site)/blog" (Next.js only).
+function routeFile(cwd, framework, urlPath, dirPath, locale, flat, rr, optional) {
+  const prefix = urlPath === "/" ? "" : urlPath
+  const hasLocale = Boolean(locale)
+  if (framework === "nextjs") return `${nextAppDir(cwd)}${locale ? `/[${locale}]` : ""}${dirPath === "/" ? "" : dirPath}/${optional ? "[[...slug]]" : "[...slug]"}/page.tsx`
   if (framework === "astro") return `src/pages${hasLocale ? "/[locale]" : ""}${prefix}/[...slug].astro`
-  return "app/routes/flocon.tsx"
+  // flatRoutes: "/" -> $.tsx, "/blog" -> blog.$.tsx, "/guides/seo" -> guides.seo.$.tsx
+  if (flat) return `${rr.app}/${rr.dir}/${prefix ? prefix.slice(1).replaceAll("/", ".") + "." : ""}$.tsx`
+  return `${rr.app}/routes/flocon.tsx`
+}
+
+const PAGES = ["page.tsx", "page.jsx", "page.js", "page.ts"]
+
+// Next.js: the website's own page for this URL (in the folder or in a route group with the same URL), or undefined.
+// Pages Router files count too (a project moving to the App Router): pages/index.tsx, pages/blog.tsx, pages/blog/index.tsx.
+function ownPage(cwd, base, urlPath) {
+  const segments = urlPath === "/" ? [] : urlPath.slice(1).split("/")
+  for (const dir of sameUrlDirs(cwd, base, segments)) {
+    const hit = PAGES.find((f) => fs.existsSync(path.join(cwd, dir, f)))
+    if (hit) return `${dir}/${hit}`
+  }
+  for (const pages of nextPagesDirs(cwd)) {
+    const stems = [[pages, ...segments, "index"].join("/"), ...(segments.length ? [[pages, ...segments].join("/")] : [])]
+    for (const stem of stems) {
+      const hit = ["tsx", "ts", "jsx", "js"].map((ext) => `${stem}.${ext}`).find((f) => fs.existsSync(path.join(cwd, f)))
+      if (hit) return hit
+    }
+  }
+  return undefined
+}
+
+// Next.js Pages Router folders next to the App Router (a project moving to the App Router).
+// A Pages Router catch-all and an App Router catch-all for the same URLs: next build passes, next start crashes.
+function nextPagesDirs(cwd) {
+  return ["pages", "src/pages"].filter((d) => fs.existsSync(path.join(cwd, d)))
+}
+
+const isGroup = (name) => /^\(.+\)$/.test(name)
+
+// Adds the route groups inside these folders, at any depth (they add no URL segment).
+function withGroups(cwd, dirs) {
+  const out = [...dirs]
+  for (let i = 0; i < out.length; i++) {
+    let entries = []
+    try {
+      entries = fs.readdirSync(path.join(cwd, out[i]))
+    } catch {}
+    for (const e of entries) if (isGroup(e)) out.push(`${out[i]}/${e}`)
+  }
+  return out
+}
+
+// Next.js: every folder that maps to the same URL as `base` + `segments`, through route groups at any level.
+// e.g. base "app", ["blog"] -> app/blog, app/(marketing)/blog, app/(a)/(b)/blog…
+function sameUrlDirs(cwd, base, segments) {
+  let dirs = withGroups(cwd, [base])
+  for (const s of segments) dirs = withGroups(cwd, dirs.map((d) => `${d}/${s}`))
+  return dirs
+}
+
+// Next.js and Astro pick a [slug] or [lang] route before the [...slug] catch-all: Flocon pages would never show.
+// Two catch-alls in one folder break the build. Returns the clashing route, or undefined.
+function clashingRoute(cwd, framework, file, base, urlPath) {
+  if (framework === "react") return undefined
+  const ours = framework === "nextjs" ? path.basename(path.dirname(file)) : "[...slug].astro"
+  const segments = urlPath === "/" ? [] : urlPath.slice(1).split("/")
+  // Next.js: route groups like (marketing) add no URL segment, at any level: look inside them too.
+  // Pages Router folders too: pages/[...slug].tsx next to app/[[...slug]] makes next start crash.
+  const dirs = framework === "nextjs" ? [...sameUrlDirs(cwd, base, segments), ...nextPagesDirs(cwd).map((d) => [d, ...segments].join("/"))] : [path.dirname(file)]
+  for (const dir of dirs) {
+    let entries = []
+    try {
+      entries = fs.readdirSync(path.join(cwd, dir))
+    } catch {}
+    const hit = entries.find((e) => e.startsWith("[") && e !== ours)
+    if (hit) return path.join(dir, hit).split(path.sep).join("/")
+  }
+  return undefined
 }
 
-function fileIsTaken(cwd, framework, file) {
-  if (fs.existsSync(path.join(cwd, file))) return true
+// The file already at the route's place (Next.js: page.js, page.jsx… count too), or undefined.
+function takenFile(cwd, framework, file) {
+  if (fs.existsSync(path.join(cwd, file))) return file
   if (framework === "nextjs") {
     const stem = file.replace(/\.tsx$/, "")
-    return ["js", "jsx", "ts", "tsx"].some((ext) => fs.existsSync(path.join(cwd, `${stem}.${ext}`)))
+    return ["js", "jsx", "ts", "tsx"].map((ext) => `${stem}.${ext}`).find((f) => fs.existsSync(path.join(cwd, f)))
   }
-  return false
+  return undefined
+}
+
+// The Flocon route already in the project, or undefined: a catch-all route file that imports the Flocon lib.
+// Only catch-alls count: the website's own pages can use the lib too (e.g. a list of pages with getAllPages).
+function findFloconRoute(cwd, framework, rr) {
+  const root = framework === "nextjs" ? nextAppDir(cwd) : framework === "astro" ? "src/pages" : `${rr.app}/${rr.dir}`
+  const lib = FRAMEWORKS[framework].pkg
+  const isRoute = (name, dir) =>
+    framework === "nextjs"
+      ? /^page\.(tsx|ts|jsx|js)$/.test(name) && /^\[\[?\.\.\.[^\]]+\]\]?$/.test(path.basename(dir))
+      : framework === "astro"
+        ? /^\[\.\.\.[^\]]+\]\.astro$/.test(name)
+        : /(^|\.)\$\.(tsx|ts|jsx|js)$/.test(name) || /^flocon\.(tsx|ts|jsx|js)$/.test(name)
+  const walk = (dir, depth) => {
+    let entries = []
+    try {
+      entries = fs.readdirSync(path.join(cwd, dir), { withFileTypes: true })
+    } catch {}
+    for (const e of entries) {
+      const rel = `${dir}/${e.name}`
+      if (e.isDirectory() && depth < 8 && e.name !== "node_modules" && !e.name.startsWith(".")) {
+        const hit = walk(rel, depth + 1)
+        if (hit) return hit
+      } else if (e.isFile() && isRoute(e.name, dir) && fs.readFileSync(path.join(cwd, rel), "utf8").includes(lib)) return rel
+    }
+    return undefined
+  }
+  return walk(root, 0)
+}
+
+// Same place = same folder (Next.js: [...slug] from an older version counts as [[...slug]]).
+const routePlace = (file) => file.replace(/\/\[\[?\.\.\.slug\]\]?\/page\.\w+$/, "")
+
+// Next.js: route groups that have a layout (often the header + footer), e.g. ["(site)"]. Only used in hints:
+// the user picks the group by typing it in the path (/(site)/blog).
+function groupLayouts(cwd, base) {
+  let entries = []
+  try {
+    entries = fs.readdirSync(path.join(cwd, base))
+  } catch {}
+  return entries.filter((e) => isGroup(e) && hasLayout(path.join(cwd, base, e)))
+}
+
+// Folders that are often behind a login, or not for public content (admin, dashboard, (app)…).
+// Bots would only see the login page: these go last in the suggestions, without the layout hint.
+const PRIVATE_FOLDER =
+  /^\(?(app|auth|admin|dashboard|account|accounts|settings|login|signin|sign-in|signup|sign-up|register|logout|onboarding|billing|checkout|portal|platform|workspace|authenticated|protected|private|user|users|profile|me)\)?$/i
+
+// Suggestions for the path question: "/", "/blog", "/guides" first, then the website's folders (Next.js: with route groups),
+// private-looking folders last. Returns [{ value, hint }].
+function pathSuggestions(cwd, framework, base) {
+  const out = [{ value: "/", hint: "whole website" }]
+  const later = []
+  const root = framework === "nextjs" ? base : framework === "astro" ? "src/pages" : undefined
+  const walk = (dir, rel, depth) => {
+    let entries = []
+    try {
+      entries = fs.readdirSync(path.join(cwd, dir), { withFileTypes: true })
+    } catch {}
+    for (const e of entries) {
+      if (!e.isDirectory()) continue
+      const n = e.name
+      // Skip dynamic segments, private folders, parallel/intercepting routes and the API.
+      if (/^[[_@.]/.test(n) || /^\(\.+\)/.test(n) || n === "api" || n === "node_modules") continue
+      if (isGroup(n) && framework !== "nextjs") continue
+      const value = `${rel}/${n}`
+      const hidden = value.split("/").some((s) => PRIVATE_FOLDER.test(s))
+      const group = !hidden && isGroup(n) && hasLayout(path.join(cwd, dir, n))
+      const item = { value, hint: group ? `uses the layout of ${n}` : "existing folder" }
+      if (hidden) later.push(item)
+      else found.push(item)
+      if (depth < 2) walk(`${dir}/${n}`, value, depth + 1)
+    }
+  }
+  const found = []
+  if (root) walk(root, "", 0)
+  for (const value of ["/blog", "/guides"]) {
+    const existing = found.find((o) => o.value === value)
+    out.push(existing ?? { value, hint: "new folder" })
+  }
+  return [...out, ...found.filter((o) => !out.includes(o)), ...later]
+}
+
+// The website's domain, when the project already has it. Returns { origin, from } or undefined.
+function findDomain(cwd, framework) {
+  const valid = (raw, from) => {
+    // Only a plain URL. `https://${process.env.X}` is code, not a domain: written as-is it gives https://undefined/….
+    if (raw.includes("${")) return undefined
+    try {
+      const u = new URL(raw)
+      if (!/^https?:$/.test(u.protocol) || /^(localhost|127\.0\.0\.1|example\.com|www\.example\.com)$/.test(u.hostname)) return undefined
+      // Dev tunnels: never the real domain.
+      if (/(^|\.)(ngrok-free\.app|ngrok\.app|ngrok\.io|ngrok\.dev|trycloudflare\.com|loca\.lt)$/.test(u.hostname)) return undefined
+      // Preview deploys: Vercel branch URLs (app-git-main-team.vercel.app), Netlify deploy previews, Cloudflare Pages previews (<hash>.app.pages.dev).
+      // A website's own *.vercel.app / *.pages.dev name is kept: for some websites it is the real domain.
+      if (/-git-[^.]+\.vercel\.app$|^deploy-preview-\d+--[^.]+\.netlify\.app$|^[0-9a-f]{8}\.[^.]+\.pages\.dev$/.test(u.hostname)) return undefined
+      // http:// → https:// (canonical URLs on http are a bad signal; every host serves https).
+      if (u.protocol === "http:") return { origin: `https://${u.host}`, from, upgraded: true }
+      return { origin: u.origin, from }
+    } catch {
+      return undefined
+    }
+  }
+  if (framework === "nextjs") {
+    const app = nextAppDir(cwd)
+    const dirs = [app, ...fs.readdirSync(path.join(cwd, app)).filter((e) => e.startsWith("[") || isGroup(e)).map((e) => `${app}/${e}`)]
+    for (const dir of dirs) {
+      for (const f of LAYOUTS) {
+        const code = readFirst(cwd, [`${dir}/${f}`])
+        // new URL("https://acme.com"), or the fallback in new URL(process.env.X ?? "https://acme.com").
+        const m =
+          /metadataBase\s*:\s*new URL\(\s*["'`](https?:\/\/[^"'`]+)["'`]/.exec(code) ??
+          /metadataBase\s*:\s*new URL\([^)"'`]*(?:\?\?|\|\|)\s*["'`](https?:\/\/[^"'`]+)["'`]/.exec(code)
+        const hit = m && valid(m[1], `${dir}/${f}`)
+        if (hit) return hit
+      }
+    }
+  }
+  if (framework === "astro") {
+    for (const f of ASTRO_CONFIGS) {
+      const m = /\bsite\s*:\s*["'`](https?:\/\/[^"'`]+)["'`]/.exec(readFirst(cwd, [f]))
+      const hit = m && valid(m[1], f)
+      if (hit) return hit
+    }
+  }
+  const re =
+    /^\s*(?:export\s+)?(?:NEXT_PUBLIC_SITE_URL|NEXT_PUBLIC_BASE_URL|NEXT_PUBLIC_APP_URL|NEXT_PUBLIC_URL|PUBLIC_SITE_URL|SITE_URL|APP_URL|BASE_URL)\s*=\s*["']?(https?:\/\/[^\s"'#]+)/m
+  // Production files first: .env and .env.local often hold a preview or dev URL.
+  for (const f of [".env.production.local", ".env.production", ".env", ".env.local"]) {
+    try {
+      const m = re.exec(fs.readFileSync(path.join(cwd, f), "utf8"))
+      const hit = m && valid(m[1], f)
+      if (hit) return hit
+    } catch {}
+  }
+  return undefined
 }
 
 function tokenAlreadySet(cwd) {
   if (process.env.FLOCON_TOKEN) return true
   const re = /^\s*(export\s+)?FLOCON_TOKEN\s*=\s*\S/m
-  for (const f of [".env.local", ".env", ".env.development.local", ".env.development"]) {
+  // .dev.vars: local secrets on Cloudflare Workers.
+  for (const f of [".env.local", ".env", ".env.development.local", ".env.development", ".dev.vars"]) {
     try {
       if (re.test(fs.readFileSync(path.join(cwd, f), "utf8"))) return true
     } catch {}
@@ -144,9 +596,69 @@ function tokenAlreadySet(cwd) {
   return false
 }
 
+// Runs the install. Interactive: a spinner, the package manager output only if it fails.
+async function install(cmd, cwd) {
+  const shell = process.platform === "win32"
+  if (!interactive) return spawnSync(cmd[0], cmd.slice(1), { cwd, stdio: "inherit", shell }).status === 0
+  const spin = p.spinner()
+  spin.start(`Installing ${cmd.at(-1)} with ${cmd[0]}`)
+  const { code, out } = await new Promise((resolve) => {
+    let out = ""
+    const child = spawn(cmd[0], cmd.slice(1), { cwd, shell })
+    child.stdout.on("data", (d) => (out += d))
+    child.stderr.on("data", (d) => (out += d))
+    child.on("error", (e) => resolve({ code: 1, out: String(e) }))
+    child.on("close", (code) => resolve({ code, out }))
+  })
+  if (code === 0) spin.stop(`Installed ${cmd.at(-1)}`)
+  else {
+    spin.stop("Install failed", 1)
+    console.error(out.trim())
+  }
+  return code === 0
+}
+
+// The project's formatter, when it has one: { name, cmd } or undefined. The CLI writes its own style (no semicolons):
+// a Prettier or Biome check in the user's CI would fail on the new files.
+function formatter(cwd) {
+  const has = (files) => files.some((f) => fs.existsSync(path.join(cwd, f)))
+  const pkg = readPackageJson(cwd) ?? {}
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  if (has(["biome.json", "biome.jsonc"]) || deps["@biomejs/biome"]) return { name: "Biome", cmd: "npx biome format --write" }
+  const prettierFiles = [".prettierrc", ".prettierrc.json", ".prettierrc.yml", ".prettierrc.yaml", ".prettierrc.js", ".prettierrc.cjs", ".prettierrc.mjs", ".prettierrc.ts", "prettier.config.js", "prettier.config.cjs", "prettier.config.mjs", "prettier.config.ts"]
+  if (has(prettierFiles) || pkg.prettier || deps.prettier) return { name: "Prettier", cmd: "npx prettier --write" }
+  return undefined
+}
+
+// Cloudflare Workers / Pages: secrets are not in .env files there.
+function onCloudflare(cwd) {
+  const pkg = readPackageJson(cwd) ?? {}
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  return ["wrangler.toml", "wrangler.json", "wrangler.jsonc"].some((f) => fs.existsSync(path.join(cwd, f))) || Boolean(deps["@opennextjs/cloudflare"] || deps["@astrojs/cloudflare"] || deps["@cloudflare/vite-plugin"])
+}
+
+// Shell-safe path for printed commands: ( ) must be quoted in bash, zsh and PowerShell.
+const shellPath = (dir) => (/[()]/.test(dir) ? `"${dir}"` : dir)
+
 async function main() {
   const args = parseArgs(process.argv.slice(2))
   const cwd = process.cwd()
+  // --path or --domain given = an AI agent or a script (Cursor and Windsurf run commands in a real terminal): no questions.
+  const flagsOnly = args.yes || args.path !== undefined || args.domain !== undefined
+  const tty = Boolean(process.stdin.isTTY && process.stdout.isTTY)
+  if (!flagsOnly && tty && !canAsk()) {
+    // A person on old Node: no silent default path, stop with the one-line command instead.
+    fail([
+      `Flocon AI: the questions need Node.js 20.12 or newer (you have ${process.versions.node}).`,
+      "Upgrade Node.js, or run it with options (no questions), e.g.: npx @flocon-ai/init --path /blog --domain https://acme.com --yes",
+      "Nothing was installed or changed."
+    ])
+  }
+  interactive = !flagsOnly && tty
+  if (interactive) {
+    p = await import("@clack/prompts")
+    p.intro("Flocon AI")
+  }
 
   // 1. Framework
   const framework = detectFramework(cwd)
@@ -155,77 +667,287 @@ async function main() {
     if (reason) fail(reason)
     fail([
       "Flocon AI: no supported framework found in this folder.",
-      "Supported: Next.js (App Router), React Router v7 (framework mode), Astro.",
+      "Supported: Next.js (App Router), React Router v7+ (framework mode), Astro.",
       "Run this command at the root of your website. Docs: " + DOCS
     ])
   }
   const { label, pkg } = FRAMEWORKS[framework]
-  log(`Found: ${label}`)
+  if (interactive) p.log.success(`Found ${label}`)
+  else log(`Found: ${label}`)
+  const blocked = blockedReason(cwd, framework)
+  if (blocked) fail(blocked)
 
-  // 2. Path (asked before anything is changed)
-  let answer = args.path
-  if (answer === undefined) {
-    if (args.yes || !process.stdin.isTTY) {
-      answer = "/"
-    } else {
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-      answer = await rl.question("Where should Flocon pages go? (e.g. / for the whole website, /blog, /guides) ")
-      rl.close()
+  const rr = framework === "react" ? { app: rrAppDir(cwd), routes: rrRoutesFile(cwd), dir: rrRoutesDir(cwd) } : undefined
+  const locale = localeSegment(cwd, framework)
+  const hasLocale = Boolean(locale)
+  const flat = framework === "react" && usesFlatRoutes(cwd)
+  const base = framework === "nextjs" ? `${nextAppDir(cwd)}${locale ? `/[${locale}]` : ""}` : undefined
+  const nothing = "Nothing was installed or changed. Docs: " + DOCS
+  const ours = findFloconRoute(cwd, framework, rr)
+
+  // The route for a path: { urlPath, dirPath, optional, file }, or { error }.
+  // Next.js route groups: the user types them in the path (/(site)/blog) to use the group's layout.
+  const plan = (answer) => {
+    const n = normalizePath(answer)
+    if (n.error) return { error: n.error }
+    if (n.dir !== n.path && framework !== "nextjs") return { error: `Route groups like (site) are a Next.js thing. Use a path without them (e.g. ${n.path}).` }
+    // Next.js: a page of the website already serves this URL (e.g. app/page.tsx for "/") → [...slug], not [[...slug]].
+    const optional = framework === "nextjs" && !ownPage(cwd, base, n.path)
+    return { urlPath: n.path, dirPath: n.dir, optional, file: routeFile(cwd, framework, n.path, n.dir, locale, flat, rr, optional) }
+  }
+  // Why the route can't go there (lines), or undefined. Checked before anything is installed.
+  const problems = ({ file, urlPath }) => {
+    // Flocon's own route: handled by the "already set up" step.
+    if (ours && routePlace(ours) === routePlace(file)) return undefined
+    const other = framework === "nextjs" ? "Pick another path (e.g. /guides)" : "Pick another path (e.g. --path /guides)"
+    const taken = takenFile(cwd, framework, file)
+    if (taken) return [`Flocon AI: ${taken} is already there (your own route). Flocon needs this file for its pages.`, `${other}, or add the Flocon route yourself where it fits.`]
+    const clash = framework === "react" ? reactSplatClash(cwd, urlPath, flat, rr) : clashingRoute(cwd, framework, file, base, urlPath)
+    if (clash) return [`Flocon AI: ${clash} is already there. It would catch these URLs before Flocon's route, so Flocon pages would not show.`, `${other}, or add the Flocon route yourself where it fits.`]
+    if (framework === "nextjs" && missingRootLayout(cwd, file)) {
+      const groups = groupLayouts(cwd, base)
+      const example = `/${groups[0] ?? "(site)"}${urlPath === "/" ? "" : urlPath}`
+      return [
+        `Flocon AI: no root layout above ${file}. Next.js needs one (e.g. ${nextAppDir(cwd)}/layout.tsx), or the build fails.`,
+        // Quoted: ( ) unquoted is a syntax error in bash, zsh and PowerShell.
+        `Your layouts are inside route groups: put the route in one, e.g. ${interactive ? example : `--path "${example}"`}.`
+      ]
     }
+    return undefined
   }
-  const normalized = normalizePath(answer)
-  if (normalized.error) fail([`Invalid path "${answer}": ${normalized.error}`])
-  const urlPath = normalized.path
 
-  // 3. Install
+  // 2. Questions (a person in a terminal), one at a time. Nothing is changed before the last "Continue?".
+  let answer = args.path
+  if (answer === undefined && interactive) {
+    const suggestions = pathSuggestions(cwd, framework, base)
+    const groupTip = framework === "nextjs" ? "\n  Add a route group to use its layout (header, footer), e.g. /(site)/blog." : ""
+    answer = await ask(
+      p.autocomplete({
+        message: `Where should Flocon pages go? Type a path or pick a folder.${groupTip}`,
+        placeholder: "/blog",
+        maxItems: 8,
+        options() {
+          const typed = (this.userInput ?? "").trim()
+          const typedDir = normalizePath(typed).dir
+          const list = suggestions.filter((o) => !typed || o.value.toLowerCase().includes(typed.toLowerCase()))
+          // What the user typed, as a choice (only a valid path, not "/(si" while typing a group).
+          const custom = typedDir && !list.some((o) => o.value === typedDir) ? [{ value: typedDir, label: typedDir, hint: "new folder" }] : []
+          return [...custom, ...list.map((o) => ({ value: o.value, label: o.value, hint: o.hint }))]
+        },
+        validate(value) {
+          if (typeof value !== "string") return "Type a path, e.g. /blog"
+          const r = plan(value)
+          return r.error ?? problems(r)?.join(" ")
+        }
+      })
+    )
+  }
+  const route = plan(answer ?? "/")
+  if (route.error) fail([`Invalid path "${answer}": ${route.error}`])
+  const { urlPath, dirPath, optional, file } = route
+  // URLs are case-sensitive: /Blog/x and /blog/x are two different pages.
+  if (/[A-Z]/.test(urlPath)) log(`Note: URLs are case-sensitive. Pages will be at ${urlPath}/…, not ${urlPath.toLowerCase()}/….`)
+
+  // --domain wins over what the project has, and skips the question.
+  let domain, domainFrom
+  if (args.domain !== undefined) {
+    domain = toOrigin(args.domain)
+    if (!domain) fail([`Invalid domain "${args.domain}": use your website's domain, e.g. --domain https://acme.com`])
+    domainFrom = "--domain"
+  } else {
+    const found = findDomain(cwd, framework)
+    domain = found?.origin
+    domainFrom = found?.upgraded ? `${found.from}, http changed to https` : found?.from
+  }
+  if (interactive && args.domain === undefined) {
+    const typed = await ask(
+      p.text({
+        message: "Your website's domain? (for canonical URLs and the sitemap)",
+        placeholder: "https://acme.com — empty = fill it in later",
+        initialValue: domain ?? "",
+        validate: (v) => (!(v ?? "").trim() || toOrigin(v) ? undefined : "Enter your domain, e.g. https://acme.com")
+      })
+    )
+    const origin = toOrigin(typed)
+    if (origin !== domain) domainFrom = "your answer"
+    domain = origin
+  }
+
+  let sitemap = args.sitemap
+  if (interactive && sitemap) {
+    sitemap = await ask(p.confirm({ message: "Add sitemap.xml and llms.txt? (they list your Flocon pages for Google and AI tools)", initialValue: true }))
+  }
+
+  // Flocon is already set up (the command ran before).
+  if (ours) {
+    // React Router, not flat: the file is always routes/flocon.tsx, the place is the path in the routes file.
+    let samePlace = routePlace(ours) === routePlace(file)
+    if (samePlace && framework === "react" && !flat && rr.routes) {
+      const want = urlPath === "/" ? "*" : `${urlPath.slice(1)}/*`
+      const registered = [...readFirst(cwd, [rr.routes]).matchAll(/route\(\s*["'`]([^"'`]*)["'`]\s*,\s*["'`][^"'`]*flocon\.tsx["'`]/g)].map((m) => m[1].replace(/^\//, ""))
+      if (registered.length && !registered.includes(want)) samePlace = false
+      // Not registered yet: the folder is in the URLs written in the file (`<domain>/blog${path}`).
+      if (!registered.length) {
+        const m = fs.readFileSync(path.join(cwd, ours), "utf8").match(/https?:\/\/[^/\s`"'$]+(?:\/\$\{[\w.]+\})?((?:\/[\w.-]+)*)\$\{(?:p\.)?path\}/)
+        if (m && m[1] !== (urlPath === "/" ? "" : urlPath)) samePlace = false
+      }
+    }
+    if (!samePlace) {
+      fail([
+        `Flocon AI is already set up at ${ours}. A second route would show every page at two URLs (duplicate content, bad for SEO).`,
+        "To move it: delete that file, then run this command again with the new path.",
+        nothing
+      ])
+    }
+    log(`Flocon AI is already set up here (${ours}). Nothing was installed.`)
+    const appDir = framework === "nextjs" ? nextAppDir(cwd) : undefined
+    // A first run left https://example.com (no domain then). Now the domain is known: put it in Flocon's own files only.
+    if (domain) {
+      const fixed = [ours, ...ownSitemapFiles({ cwd, framework, appDir, rrApp: rr?.app, rrDir: rr?.dir })].filter((f) => {
+        const full = path.join(cwd, f)
+        const code = fs.readFileSync(full, "utf8")
+        if (!code.includes("https://example.com")) return false
+        fs.writeFileSync(full, code.replaceAll("https://example.com", domain))
+        return true
+      })
+      if (fixed.length) log(`Domain set to ${domain} in: ${fixed.join(", ")}.`)
+    }
+    // Only adds what is missing (e.g. a first run with --no-sitemap).
+    let code = 0
+    if (sitemap) {
+      const res = addSitemapAndLlms({ cwd, framework, appDir, rrApp: rr?.app, rrDir: rr?.dir, routesFile: rr?.routes, urlPath, hasLocale, flat, domain, log })
+      if (res.manual) code = 1
+    }
+    if (interactive) p.outro(code ? "Do the step above, then deploy." : "Nothing else to do.")
+    process.exit(code)
+  }
+  const problem = problems(route)
+  if (problem) fail([...problem, nothing])
+  const cacheComponents = framework === "nextjs" && usesCacheComponents(cwd)
   const pm = detectPackageManager(cwd)
   const installCmd = [pm, ...INSTALL_ARGS[pm], pkg]
+
+  // Last question: the plan, then "Continue?".
+  if (interactive) {
+    const pages = `${urlPath === "/" ? "" : urlPath}/<page>`
+    p.note(
+      [
+        args.skipInstall ? undefined : `Install ${pkg} (${pm})`,
+        `Create ${file}`,
+        sitemap ? "Create sitemap.xml + llms.txt (if missing)" : undefined,
+        `Pages at ${domain ?? "https://example.com"}${pages}`
+      ]
+        .filter(Boolean)
+        .join("\n"),
+      "Plan"
+    )
+    if (!(await ask(p.confirm({ message: "Continue?", initialValue: true })))) cancelled()
+  }
+
+  // 3. Install
   if (args.skipInstall) {
     log(`Skipped install. Package: ${pkg} (package manager: ${pm}).`)
   } else {
-    log(`Installing ${pkg} with ${pm}...`)
-    const res = spawnSync(installCmd[0], installCmd.slice(1), { cwd, stdio: "inherit", shell: process.platform === "win32" })
-    if (res.status !== 0) fail([`Install failed. Run it yourself: ${installCmd.join(" ")}`])
+    if (!interactive) log(`Installing ${pkg} with ${pm}...`)
+    if (!(await install(installCmd, cwd))) fail([`Install failed. Run it yourself: ${installCmd.join(" ")}`])
   }
 
   // 4. Route file (never overwrite)
-  const hasLocale = hasLocaleSegment(cwd, framework)
-  const file = routeFile(cwd, framework, urlPath, hasLocale)
-  const template = hasLocale ? TEMPLATES[framework + "Locale"] : TEMPLATES[framework]
-  let exitCode = 0
-  if (fileIsTaken(cwd, framework, file)) {
-    exitCode = 1
-    log(`\n${file} already exists. I did not touch it. Add this file yourself (e.g. as ${file}):\n`)
-    log(template)
-  } else {
-    const full = path.join(cwd, file)
-    fs.mkdirSync(path.dirname(full), { recursive: true })
-    fs.writeFileSync(full, template, { flag: "wx" })
-    log(`Created ${file}`)
+  let template = applyUrlRule(hasLocale ? TEMPLATES[framework + "Locale"] : TEMPLATES[framework], urlPath, hasLocale, domain)
+  // Next.js language folder with another name, like app/[lang]: read it as the locale.
+  if (framework === "nextjs" && locale && locale !== "locale") {
+    template = template
+      .replace("params: Promise<{ locale: string;", `params: Promise<{ ${locale}: string;`)
+      .replaceAll("const { locale, slug } = await params", `const { ${locale}: locale, slug } = await params`)
+      .replace("under the [locale] segment", `under the [${locale}] segment`)
+  }
+  // Next.js optional catch-all: no slug on the folder's own URL.
+  if (optional) {
+    template = template
+      .replace("One catch-all route serves every Flocon page", "One optional catch-all route ([[...slug]]) serves every Flocon page")
+      .replace("slug: string[] }", "slug?: string[] }")
+      .replaceAll('"/" + slug.join("/")', '"/" + (slug ?? []).join("/")')
   }
-  if (framework === "react") {
+  // cacheComponents: `dynamic` is not allowed, `instant = false` lets the page render on each request.
+  if (cacheComponents) {
+    template = template.replace('export const dynamic = "force-dynamic"', "export const instant = false")
+    log("cacheComponents is on: the route uses `export const instant = false` (not `dynamic`).")
+  }
+  if (framework === "react" && rrOldMeta(cwd)) {
+    template = template
+      .replace("meta({ loaderData }: Route.MetaArgs)", "meta({ data }: Route.MetaArgs)")
+      .replace("if (!loaderData) return", "if (!data) return")
+      .replace("page: loaderData, url })", "page: data, url })")
+  }
+  if (flat) {
+    const stem = path.basename(file, ".tsx")
+    template = template.replace(/^\/\/ Register it .*\n/, "").replace('"./+types/flocon"', `"./+types/${stem}"`)
+  }
+  let exitCode = 0
+  const full = path.join(cwd, file)
+  fs.mkdirSync(path.dirname(full), { recursive: true })
+  fs.writeFileSync(full, template, { flag: "wx" })
+  log(`Created ${file}`)
+  if (framework === "react" && !flat) {
     const routePath = urlPath === "/" ? "*" : `${urlPath.slice(1)}/*`
-    log(`\nRegister the route last in app/routes.ts:\n  route("${routePath}", "routes/flocon.tsx")`)
+    log(`\nRegister the route last in ${rr.routes}:\n  route("${routePath}", "routes/flocon.tsx")`)
+    // routes.ts often imports only `index` (React Router template): `route` is needed too.
+    if (!/import\s*\{[^}]*\broute\b[^}]*\}\s*from\s*["']@react-router\/dev\/routes["']/.test(readFirst(cwd, [rr.routes]))) {
+      log(`And add route to the import: import { route } from "@react-router/dev/routes"`)
+    }
   }
 
   // 4b. Sitemap + llms.txt (never overwrite)
-  if (args.sitemap) {
+  const urlFiles = template.includes(domain ?? "https://example.com") ? [file] : []
+  const created = [file]
+  if (sitemap) {
     const appDir = framework === "nextjs" ? nextAppDir(cwd) : undefined
-    if (addSitemapAndLlms({ cwd, framework, appDir, urlPath, log })) exitCode = 1
+    const res = addSitemapAndLlms({ cwd, framework, appDir, rrApp: rr?.app, rrDir: rr?.dir, routesFile: rr?.routes, urlPath, hasLocale, flat, domain, log })
+    if (res.manual) exitCode = 1
+    urlFiles.push(...res.files)
+    created.push(...res.created)
   }
+  if (urlFiles.length) {
+    // Interactive: the user just confirmed the domain, no need to repeat it.
+    if (domain && !interactive) {
+      log(`\nDomain: ${domain} (${domainFrom === "--domain" ? "from --domain" : `found in ${domainFrom}`}). It is in: ${urlFiles.join(", ")}. Change it there if it is wrong.`)
+    } else if (!domain) {
+      log(`\nReplace https://example.com with your domain in: ${urlFiles.join(", ")}. The rest of the URL is already set (pages live under ${urlPath}).`)
+    }
+  }
+
+  // 4c. Formatter: the new files use the CLI's style.
+  const fmt = formatter(cwd)
+  if (fmt) log(`\nYour project uses ${fmt.name}. Format the new files: ${fmt.cmd} ${created.map((f) => `"${f}"`).join(" ")}`)
 
   // 5. Token (no prompt, no file write)
   log()
-  if (tokenAlreadySet(cwd)) {
+  const tokenSet = tokenAlreadySet(cwd)
+  const cloudflare = onCloudflare(cwd)
+  if (tokenSet) {
     log("FLOCON_TOKEN is already set. Good.")
   } else {
     log(
-      `Flocon needs FLOCON_TOKEN to work. Copy your website token from ${TOKENS_URL}, then add FLOCON_TOKEN=... to your env file (.env.local / .env) and to your host. Never commit it.`
+      `Flocon needs FLOCON_TOKEN to work. Copy your website token from ${TOKENS_URL}, then add FLOCON_TOKEN=... to your env file (${cloudflare ? ".dev.vars" : ".env.local / .env"}) and to your host. Never commit it.`
     )
   }
+  if (cloudflare) {
+    log("On Cloudflare: add FLOCON_TOKEN as a Secret (wrangler secret put FLOCON_TOKEN, or type Secret in the dashboard). wrangler deploy removes plain variables.")
+  }
+
+  const pkgJson = readPackageJson(cwd)
+  if (framework === "astro" && { ...pkgJson.dependencies, ...pkgJson.devDependencies }["@astrojs/cloudflare"]) {
+    log("On Cloudflare, secrets are not in process.env: pass the token option to each helper.")
+  }
 
-  // 6. Last step
-  log("\nNext step: add FLOCON_TOKEN to your host, then deploy.")
+  // 6. Last step. Many hosts deploy on every push: without the token, Flocon's URLs return an error (500).
+  const extra = sitemap ? ", the sitemap and llms.txt" : ""
+  const errors = urlPath === "/" ? `every unknown URL of your website${extra} return an error (500)` : `${urlPath}/…${extra} return an error (500)`
+  const last = tokenSet
+    ? "Next step: add FLOCON_TOKEN to your host too, then deploy."
+    : `Next step: add FLOCON_TOKEN to your host BEFORE you push or deploy. Without it, ${errors}.`
+  if (interactive) p.outro(last)
+  else log(`\n${last}`)
   process.exit(exitCode)
 }