@unbox-plus/cli 0.20.4

package/LICENSE.md

@@ -0,0 +1,46 @@
+# Licença do Unbox CLI
+
+Copyright (c) 2026 Unbox. Todos os direitos reservados.
+
+## 1. Permissão de uso
+
+A Unbox concede a você uma licença gratuita, mundial, não exclusiva e
+intransferível para **instalar e executar** este software (o "CLI") na sua
+forma original e não modificada, exclusivamente para criar storefronts
+integrados à plataforma Unbox — por exemplo, via `npm install` ou `npx`.
+
+## 2. Código gerado
+
+Os arquivos **gerados** pelo CLI a partir do template (o projeto de storefront
+criado na sua máquina) são seus. Você pode usá-los, modificá-los, hospedá-los
+e distribuí-los livremente, sem qualquer restrição desta licença.
+
+Esta licença aplica-se apenas ao código do CLI em si (incluindo o diretório
+`template/` enquanto parte deste pacote), não ao resultado que ele produz.
+
+## 3. Restrições
+
+Salvo o disposto na seção 2, você **não** pode:
+
+- modificar o CLI ou criar obras derivadas dele;
+- redistribuir o CLI, modificado ou não, fora dos canais oficiais da Unbox
+  (npm registry e distribuições feitas pela própria Unbox);
+- sublicenciar, vender ou oferecer o CLI como parte de outro produto ou
+  serviço.
+
+## 4. Marcas
+
+Esta licença não concede qualquer direito sobre nomes, logotipos ou marcas da
+Unbox.
+
+## 5. Sem garantias
+
+O SOFTWARE É FORNECIDO "NO ESTADO EM QUE SE ENCONTRA", SEM GARANTIAS DE
+QUALQUER TIPO, EXPRESSAS OU IMPLÍCITAS. EM NENHUMA HIPÓTESE A UNBOX SERÁ
+RESPONSÁVEL POR QUALQUER RECLAMAÇÃO, DANO OU OUTRA RESPONSABILIDADE
+DECORRENTE DO USO DO SOFTWARE.
+
+## 6. Rescisão
+
+Qualquer violação destas condições encerra automaticamente os direitos
+concedidos por esta licença.

package/README.md

@@ -0,0 +1,175 @@
+# Unbox CLI
+
+CLI que gera um storefront Next.js completo integrado com a API Unbox, a partir da foundation
+oficial (`storefront-foundation`), já com a sua marca aplicada: estilo visual (layout, fontes,
+neutros), cores e nome da loja.
+
+## Uso — sem instalar nada
+
+> **Passo 0**: precisa do Node.js instalado (baixe em [nodejs.org](https://nodejs.org), botão
+> "LTS", instalador comum de 2 minutos). É o único pré-requisito da máquina.
+
+Navegue até a pasta onde queira criar o projeto e rode:
+
+```bash
+npx @unbox-plus/cli create-unbox-store
+```
+
+O `npx` roda o CLI direto do pacote publicado no NPM, sem instalar nada global.
+Ele vai perguntar:
+
+1. Nome da pasta/projeto
+2. Nome de exibição da loja
+3. Cor primária (hex) — botões, preços, links
+4. Cor de destaque/CTA (hex) — banners de oferta
+5. Site atual da marca (opcional, Enter pra pular)
+6. Instagram da marca (opcional, Enter pra pular)
+7. Objetivo da loja em uma frase (opcional, Enter pra pular)
+8. **Estilo visual da loja** — o CLI sugere um a partir do objetivo/site/Instagram e você
+   confirma ou troca: **Essencial** (completo e equilibrado), **Promocional** (oferta em
+   primeiro plano), **Editorial** (clube/assinatura, tipografia de revista) ou **Boutique**
+   (minimal premium). O estilo define layout da home, fontes, neutros, chrome e raios já no
+   scaffold; o agente de Branding refina depois no briefing.
+9. Se você já tem as credenciais da loja Unbox (`UNBOX_PARTNER_API_KEY` ou `UNBOX_API_KEY`,
+   `UNBOX_USER`, `UNBOX_PASS`)
+   - **Não tem ainda?** Sem problema — responda "não" e o projeto sobe em **modo mockup**
+     (layout completo, sem dados reais da loja). Preencha `.env.local` depois.
+10. Checkout customizável (código no projeto) ou padrão hospedado da Unbox
+11. Se quer que ele já rode `npm install`
+
+Tudo (menos credenciais) fica registrado em `marca/briefing.json` do projeto gerado — é a
+"memória" do formulário pro agente de Branding não reperguntar nada.
+
+Ao final, o próximo passo é o **briefing de marca no Claude Code** (não `npm run dev`):
+
+```bash
+cd <nome-do-projeto>
+claude
+```
+
+O Claude Code abre direto no briefing (agente 15, via `.claude/settings.json` +
+`.claude/agents/branding-briefing.md` gerados no projeto) e conduz a personalização ANTES de o
+cliente ver a loja padrão — regra "perguntar antes de mostrar". Encerrado o briefing, o próprio
+agente remove a chave `"agent"` do `.claude/settings.json` e as sessões seguintes voltam ao
+Claude normal.
+
+### Alternativa mais universal: instalar global o pacote via NPM
+
+Se `npx` der algum problema no ambiente da outra pessoa (versão de npm diferente), esse caminho
+funciona em qualquer npm recente:
+
+```bash
+npm install -g @unbox-plus/cli
+create-unbox-store
+```
+
+## Uso — sem instalar, clonando a pasta/repositório
+
+Se você recebeu a pasta inteira (zip) ou clonou o repositório:
+
+```bash
+cd create-unbox-store
+npm install
+node bin/cli.js
+```
+
+## Uso não-interativo (scripts/CI)
+
+```bash
+npx @unbox-plus/cli create-unbox-store minha-loja --yes --no-install
+```
+
+Gera com as cores/nome default e o estilo **essencial** — use `--estilo <nome>`
+(essencial, promocional, editorial, boutique) pra escolher outro sem interação. Cores e
+tokens podem ser editados depois em `app/globals.css` (bloco "CONFIGURE"); o layout da home
+em `components/home/home-recipe.ts`.
+
+## Checkout hospedado da Unbox: duas regras
+
+Quem escolhe "Padrão da Unbox" no wizard não precisa fazer nada: o CLI monta a URL certa. Quem
+preencher `UNBOX_HOSTED_CHECKOUT_URL` à mão depois precisa das duas:
+
+1. **Caminho completo, não o domínio.** `https://sualoja.com.br/carrinho/finalizar-pedido`. A raiz
+   é a home da loja e ignora os parâmetros em silêncio.
+2. **Loja e checkout no mesmo domínio.** Com a loja em um host e o checkout em outro, o cliente cai
+   no `/login`. Com os dois sob o mesmo domínio, funciona.
+
+A URL carrega `?id=&token=&freq=&step=1`. O token faz parte do contrato: sem ele, o checkout não
+encontra o carrinho.
+
+## A loja já tem um GTM próprio?
+
+Preencha `NEXT_PUBLIC_GTM_ID`. O container da marca convive com o container central da Unbox: são
+dois independentes lendo o mesmo `dataLayer`. Três coisas que não são óbvias:
+
+1. **Com o container preenchido, o Pixel do código é desligado automaticamente.** Pixel no
+   container e no código conta `PageView` duas vezes, e a inflação é silenciosa.
+2. **Quem configura o container precisa saber:** numa SPA, o gatilho "All Pages" só pega o
+   carregamento inicial. Para contar troca de rota, a tag de pageview escuta o evento
+   personalizado `dataLayerReady`, que a loja emite em toda rota principal (com `pageType` e os
+   produtos em vista). O gatilho nativo "History Change" também funciona.
+3. **Ligar o Pixel derruba o Best Practices do Lighthouse** de 100 para ~77
+   (`third-party-cookies`). Não tem conserto no front, é como o Pixel funciona. A mitigação é a
+   API de Conversões server-side, que já vem pronta em `app/api/capi/route.ts` e no webhook de
+   pagamento.
+
+## Requisitos
+
+- Node.js ≥ 20 (recomendado: 22 LTS — veja `.nvmrc` no projeto gerado)
+- Credenciais da loja Unbox (`UNBOX_API_KEY`, `UNBOX_USER`, `UNBOX_PASS`) — opcional pra rodar em
+  modo mockup, obrigatório antes de ir pra produção (`npm run unbox:test` confirma a conexão)
+
+## O que o CLI gera
+
+Next.js 15 (App Router) + Tailwind v4 + shadcn/ui sobre Base UI, com catálogo, carrinho,
+checkout, área do cliente (OTP login, pedidos, assinaturas, endereços), páginas legais, PWA e
+SEO básico já implementados — ver `DEPLOY.md` e `QA.md` dentro do projeto gerado para o checklist
+de deploy na Vercel.
+
+## ⚠️ Antes de publicar a loja — decisões que ficam para quem usa
+
+A foundation inclui alguns placeholders que **funcionam, mas precisam de uma decisão consciente**
+antes de a loja ir ao ar. Nenhum deles quebra o projeto — o CLI não resolve isso automaticamente
+de propósito, para não tomar essa decisão no lugar de quem está publicando.
+
+1. **Prova social: a foundation não traz nenhuma.** Sem avaliação real em
+   `lib/enrichment/products.json`, a loja não mostra nota, estrelas, contagem nem depoimento
+   (o bloco some, não cai em placeholder). Antes de publicar, decida: popular com dados reais
+   ou publicar sem prova social. **O agente 15 (Branding) pede esse material no briefing.**
+   O `unbox:honestidade` lista qualquer número ou promessa que entrar sem lastro.
+2. **Módulos de CRO — só 1 de 10 na foundation.** Dos 10 módulos do "Unbox AI CRO Package"
+   (prova social, urgência de estoque, countdown, frete grátis, upsell, recently viewed, sticky
+   CTA, trust strip, kits, brindes), só a **barra de frete grátis** vem pronta. Os outros nove
+   são construídos pelo agente `13-cro.md`, que o briefing oferece ao terminar — o wizard não
+   pergunta mais sobre isso (perguntava, gravava num arquivo que ninguém lia, e o agente 13
+   perguntava de novo).
+3. **SEO avançado — o básico está, os 7 módulos não.** A foundation traz JSON-LD de produto,
+   Organization + WebSite/SearchAction na home, imagem Open Graph gerada e canonical por
+   página. Breadcrumbs, FAQ schema, OG por produto e templates de título/description por
+   página são do agente `14-seo.md`.
+4. **Kits/combos vêm vazios** (`lib/enrichment/combos.ts`) — a seção só aparece na loja depois de
+   alguém popular `COMBOS` com os kits reais.
+
+### Onde continuar depois do setup
+
+Todo projeto gerado já vem com `agents/MANAGER.md` — descreve exatamente o que cada agente
+resolve e a ordem recomendada dos passos manuais: **15 (Branding) primeiro**, depois os opcionais
+13 (CRO) e 14 (SEO), e por último 12 (Deploy).
+
+## Editor da loja (a partir da 0.20.0)
+
+A loja gerada nasce editável pelo editor da Unbox (chat e painel visual sobre um documento de conteúdo). O que o template traz, e que não pode ser removido sem desligar o editor em silêncio:
+
+- `lib/editable/` (a foundation do editor, cópia byte a byte; correção entra por versão, nunca à mão), com o slug da loja carimbado em `config.ts` no scaffold.
+- `next.config.ts` com `frame-ancestors` para `NEXT_PUBLIC_EDITOR_ORIGIN` (variável de BUILD: precisa existir antes do `next build`).
+- `app/api/revalidate` aceitando o token do editor e devolvendo o recibo com `conteudo`.
+- `middleware.ts` deixando passar o token de prévia e as rotas `/api/unbox/*`.
+- `app/api/unbox/paginas`, `catalogo` e `vitrine`, e `lib/rotas-editaveis.ts` com as tabelas `SO_CHROME` e `CONTAINERS_POR_ROTA`: rota nova entra na tabela ou o gate reprova.
+- `app/layout.tsx` com o `EditableProvider` e a linha única `<Rastreio />` (GTM, GA4, Meta Pixel, TikTok, Pinterest e WhatsApp decididos pela foundation).
+- Home, cabeçalho, rodapé, catálogo e página de produto com primitivos; ids de seção são chaves de arquivo e não têm renomear.
+
+Gate: `npm run unbox:editavel` mede toda página que a loja declara. Saída 0 = aprovado; 1 = reprovado dizendo qual página; 2 = não rodou (rota dinâmica sem exemplo, por exemplo sem catálogo), nunca aprovação.
+
+Variáveis: `EDITOR_URL`, `NEXT_PUBLIC_EDITOR_ORIGIN`, `UNBOX_EDITOR_SHOP` (opcional: sobrepõe o slug carimbado). `META_CAPI_TOKEN` é segredo de servidor e nunca entra no documento do editor.
+
+A seção "Editor: o que não pode quebrar" do `CLAUDE.md` do template lista cada ponto com o que acontece se for tocado.

package/bin/cli.js

@@ -0,0 +1,439 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import prompts from "prompts";
+import { normalizeHex, deriveBrandTokens } from "../src/colors.js";
+import { applyPreset, applyStoreName } from "../src/theme.js";
+import { PRESETS, PRESET_NAMES, suggestPreset } from "../src/presets.js";
+import crypto from "node:crypto";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = path.join(__dirname, "..", "template");
+const EXCLUDE = new Set(["bootstrap.sh", "package-lock.json", ".DS_Store"]);
+// Cores default = CANVAS PROVISÓRIA, não escolha estética. Tinta quase-preta + âmbar
+// contido: a base mais neutra possível pra qualquer marca cair bem em cima. Trocar pelas
+// cores REAIS é o primeiro ato do briefing (o build avisa enquanto estiverem aqui).
+const DEFAULT_PRIMARY = "#18181B";
+const DEFAULT_CTA = "#D97706";
+// Removidos do projeto quando o checkout é o PADRÃO hospedado pela Unbox — sem UI de checkout
+// customizada nesse modo, esses arquivos ficariam mortos (ver app/api/checkout-destination).
+const CUSTOM_CHECKOUT_PATHS = ["app/(loja)/checkout", "components/checkout", "app/api/checkout"];
+
+const CHECKOUT_WARNING = `
+  ⚠️  Checkout customizável escolhido. Leia antes de continuar:
+  Ao customizar o checkout, a Unbox deixa de controlar essa experiência: passa a ser
+  responsabilidade deste projeto. Checkout é a área mais sensível pra conversão da loja: um erro
+  de implementação aqui (frete, pagamento, validação de endereço) pode custar vendas de verdade.
+  Teste bem (npm run unbox:test, QA.md) antes de publicar.
+`;
+
+function copyTemplate(targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+  for (const entry of fs.readdirSync(TEMPLATE_DIR)) {
+    if (EXCLUDE.has(entry)) continue;
+    // "gitignore" (sem ponto) vira ".gitignore" no projeto — o npm pack remove/renomeia
+    // arquivos .gitignore de dentro do pacote, então o template o carrega sem o ponto.
+    const dest = entry === "gitignore" ? ".gitignore" : entry;
+    fs.cpSync(path.join(TEMPLATE_DIR, entry), path.join(targetDir, dest), { recursive: true });
+  }
+}
+
+// Ctrl+C no meio das perguntas: sem isto o `prompts` devolve undefined e o CLI seguia
+// gerando um projeto com defaults (nome "undefined", checkout custom, sem credenciais).
+const onCancel = () => { console.log("\n  Cancelado. Nada foi gerado."); process.exit(1); };
+
+function removeCustomCheckout(targetDir) {
+  for (const rel of CUSTOM_CHECKOUT_PATHS) {
+    fs.rmSync(path.join(targetDir, rel), { recursive: true, force: true });
+  }
+}
+
+/** "https://minhaloja.com.br/" ou "minhaloja.com.br" → "https://minhaloja.com.br" (sem barra final).
+ *  Retorna null se não for um domínio válido (espaço, caminho, sem TLD) — nunca gera URL torta. */
+function normalizeDomain(input) {
+  let d = String(input ?? "").trim().replace(/\/+$/, "");
+  if (!d) return null;
+  if (!/^https?:\/\//i.test(d)) d = `https://${d}`;
+  try {
+    const u = new URL(d);
+    if (u.protocol !== "https:" && u.protocol !== "http:") return null;
+    if (u.pathname !== "/" || u.search || u.hash || u.username || u.port) return null;
+    if (!/^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(u.hostname) || u.hostname.includes("..")) return null;
+    return `${u.protocol}//${u.hostname}`;
+  } catch {
+    return null;
+  }
+}
+const validaDominio = (v) => (normalizeDomain(v) ? true : "Informe só o domínio, ex.: minhaloja.com.br (sem caminho, sem espaço)");
+
+function setProjectName(targetDir, name) {
+  const pkgPath = path.join(targetDir, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  pkg.name = name;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
+/** Valor seguro pra linha KEY=... do .env.local. O Next lê o arquivo com dotenv + dotenv-expand:
+ *  sem aspas, `#` vira comentário (senha truncada), `$X` é expandido (some) e espaço quebra.
+ *  Caso real: senha com `$` chegava cortada e o signIn falhava sem pista.
+ *  Medido com o @next/env real (9 valores adversos): aspas simples NÃO protegem `$1` (o expand
+ *  roda mesmo assim) e aspas duplas não desfazem `\"`. O único formato que devolve todos os
+ *  valores intactos é CRASE com `$` escapado como `\$`. Só caracteres simples saem crus. */
+function envValue(v) {
+  const s = String(v ?? "").replace(/\r?\n/g, "");
+  if (s === "" || /^[A-Za-z0-9_.\/:@+=,-]*$/.test(s)) return s;
+  const esc = s.replace(/\$/g, "\\$");
+  if (!s.includes("`")) return "`" + esc + "`";
+  // Valor com crase: aspas duplas (a única perda possível é uma aspa dupla interna, sem escape em dotenv).
+  return `"${esc.replace(/"/g, "")}"`;
+}
+
+function writeEnvLocal(targetDir, values) {
+  const examplePath = path.join(targetDir, ".env.example");
+  const lines = fs.readFileSync(examplePath, "utf8").split("\n");
+  // Segredos que a loja precisa e ninguém gera à mão: SESSION_SECRET assina o cookie de posse
+  // do pedido (lib/session.ts) e REVALIDATE_SECRET protege /api/revalidate e /api/payment-link.
+  const all = {
+    SESSION_SECRET: crypto.randomBytes(32).toString("hex"),
+    REVALIDATE_SECRET: crypto.randomBytes(24).toString("hex"),
+    ...values,
+  };
+  const out = lines.map((line) => {
+    const match = line.match(/^([A-Z0-9_]+)=/);
+    if (!match) return line;
+    const key = match[1];
+    if (all[key] !== undefined) return `${key}=${envValue(all[key])}`;
+    return line;
+  });
+  fs.writeFileSync(path.join(targetDir, ".env.local"), out.join("\n"));
+}
+
+/**
+ * Grava marca/briefing.json com o que o formulário coletou (menos credenciais).
+ * É a "memória" do scaffold pro agente 15 (Branding): ele lê isso na Regra 0 e
+ * não repergunta nada daqui. Campos opcionais vazios são omitidos.
+ */
+function writeBriefing(targetDir, data) {
+  const briefing = Object.fromEntries(
+    Object.entries(data).filter(([, v]) => v !== undefined && String(v).trim() !== ""),
+  );
+  const dir = path.join(targetDir, "marca");
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "briefing.json"), JSON.stringify(briefing, null, 2) + "\n");
+}
+
+function printHelp() {
+  console.log(`
+  create-unbox-store: gera um storefront Next.js integrado à Unbox
+
+  Uso:
+    npx --package=./create-unbox-store.tgz create-unbox-store [pasta] [flags]
+
+  Sem flags, roda o wizard interativo: nome da loja, cores, estilo visual,
+  credenciais da Unbox (Enter pra pular = modo mockup) e checkout.
+  As credenciais coletadas viram o .env.local do projeto gerado.
+
+  Flags:
+    --yes, -y          não pergunta nada (defaults + modo mockup; pasta default "minha-loja")
+    --estilo <nome>    estilo visual: essencial | promocional | editorial | boutique
+    --install          roda npm install ao final
+    --no-install       não roda npm install
+    --help, -h         esta ajuda
+
+  Exemplos:
+    npx --package=./create-unbox-store.tgz create-unbox-store minha-loja
+    npx --package=./create-unbox-store.tgz create-unbox-store loja-x --yes --no-install --estilo boutique
+
+  Depois de gerar: cd <pasta> && claude  (o briefing de marca abre sozinho)
+  Docs completas: README.md dentro do zip da beta.
+`);
+}
+
+function parseArgs(argv) {
+  const flags = { yes: false, install: undefined, target: undefined, estilo: undefined };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") { printHelp(); process.exit(0); }
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (arg === "--install") flags.install = true;
+    else if (arg === "--no-install") flags.install = false;
+    else if (arg === "--estilo") flags.estilo = argv[++i];
+    else if (arg.startsWith("--estilo=")) flags.estilo = arg.slice("--estilo=".length);
+    else if (arg.startsWith("--")) {
+      // Flag desconhecida vira erro, não silêncio: "--estylo boutique" ignorado geraria
+      // uma loja com o estilo errado sem ninguém perceber.
+      console.error(`\n✗ Flag desconhecida: "${arg}". Veja as opções com --help.`);
+      process.exit(1);
+    }
+    else positional.push(arg);
+  }
+  flags.target = positional[0];
+  if (flags.estilo && !PRESET_NAMES.includes(flags.estilo)) {
+    console.error(`\n✗ Estilo desconhecido: "${flags.estilo}". Opções: ${PRESET_NAMES.join(", ")}.`);
+    process.exit(1);
+  }
+  return flags;
+}
+
+async function main() {
+  console.log("");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("  create-unbox-store");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("");
+
+  const flags = parseArgs(process.argv.slice(2));
+  const nonInteractive = flags.yes || !process.stdin.isTTY;
+
+  let targetName = flags.target;
+  let hasCreds = false;
+  let displayName, primary, cta;
+  let checkoutMode = "custom";
+  let hostedCheckoutUrl = "";
+  let site = "", instagram = "", objetivo = "";
+  let estilo = flags.estilo ?? "essencial";
+
+  if (nonInteractive) {
+    targetName = targetName || "minha-loja";
+    displayName = path.basename(targetName);
+    primary = DEFAULT_PRIMARY;
+    cta = DEFAULT_CTA;
+  } else {
+    const answers = await prompts([
+      {
+        type: targetName ? null : "text",
+        name: "targetName",
+        message: "Nome da pasta/projeto",
+        initial: "minha-loja",
+      },
+      {
+        type: "text",
+        name: "displayName",
+        message: "Nome de exibição da loja",
+        initial: (prev) => prev || "Minha Loja",
+      },
+      {
+        type: "text",
+        name: "primary",
+        message: "Cor primária (hex): botões, preços, links",
+        initial: DEFAULT_PRIMARY,
+        validate: (v) => (normalizeHex(v) ? true : "Hex inválido, ex: #15803D"),
+      },
+      {
+        type: "text",
+        name: "cta",
+        message: "Cor de destaque/CTA (hex): ofertas, banners",
+        initial: DEFAULT_CTA,
+        validate: (v) => (normalizeHex(v) ? true : "Hex inválido, ex: #F3C012"),
+      },
+      {
+        type: "text",
+        name: "site",
+        message: "Site atual da marca (URL, Enter se não tiver)",
+      },
+      {
+        type: "text",
+        name: "instagram",
+        message: "Instagram da marca (@usuario ou URL, Enter pra pular)",
+      },
+      {
+        type: "text",
+        name: "objetivo",
+        message: "Objetivo da loja em uma frase (ex.: aumentar o ticket médio, Enter pra pular)",
+      },
+      {
+        type: flags.estilo ? null : "select",
+        name: "estilo",
+        message: "Estilo visual da loja (sugerido a partir do que você contou; layout, fontes e clima mudam com ele)",
+        choices: (prev, values) => {
+          const sugg = suggestPreset(values);
+          return PRESET_NAMES.map((name) => ({
+            title: `${PRESETS[name].label}${name === sugg ? " (sugerido)" : ""}: ${PRESETS[name].tagline}`,
+            value: name,
+          }));
+        },
+        initial: (prev, values) => PRESET_NAMES.indexOf(suggestPreset(values)),
+      },
+      {
+        type: "confirm",
+        name: "hasCreds",
+        message: "Você já tem as credenciais da Unbox (key de parceiro ou da loja + UNBOX_USER/UNBOX_PASS)?",
+        initial: false,
+      },
+      {
+        type: "select",
+        name: "checkoutMode",
+        message: "Checkout: customizável (código neste projeto) ou padrão da Unbox (hospedado)?",
+        choices: [
+          { title: "Customizável (mais flexível, mas você assume o risco)", value: "custom" },
+          { title: "Padrão da Unbox (hospedado, sem código aqui)", value: "unbox" },
+        ],
+        initial: 0,
+      },
+      {
+        type: (prev) => (prev === "unbox" ? "text" : null),
+        name: "checkoutDomain",
+        message: "Domínio da loja vinculado na Unbox (ex.: minhaloja.com.br). O checkout usa esse mesmo domínio",
+        validate: validaDominio,
+      },
+    ], { onCancel });
+    targetName = targetName || answers.targetName;
+    displayName = answers.displayName || targetName;
+    primary = normalizeHex(answers.primary) || DEFAULT_PRIMARY;
+    cta = normalizeHex(answers.cta) || DEFAULT_CTA;
+    site = (answers.site ?? "").trim();
+    instagram = (answers.instagram ?? "").trim();
+    objetivo = (answers.objetivo ?? "").trim();
+    estilo = flags.estilo ?? answers.estilo ?? "essencial";
+    hasCreds = answers.hasCreds;
+    checkoutMode = answers.checkoutMode ?? "custom";
+    if (checkoutMode === "unbox") {
+      const dom = normalizeDomain(answers.checkoutDomain);
+      if (dom) {
+        hostedCheckoutUrl = `${dom}/carrinho/finalizar-pedido`;
+      } else {
+        // Sem domínio válido NÃO dá pra apagar o checkout do projeto: a loja ficaria sem
+        // nenhum (o botão "finalizar" cairia em 404). Mantém o customizável e avisa.
+        checkoutMode = "custom";
+        console.log("\n  ⚠ Domínio do checkout hospedado ausente/inválido: mantendo o checkout customizável.");
+        console.log("    Pra usar o hospedado depois: preencha UNBOX_HOSTED_CHECKOUT_URL no .env.local.\n");
+      }
+    }
+    if (checkoutMode === "custom") console.log(CHECKOUT_WARNING);
+  }
+
+  const targetDir = path.resolve(process.cwd(), targetName);
+
+  if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+    console.error(`\n✗ A pasta "${targetName}" já existe e não está vazia. Abortando.`);
+    process.exit(1);
+  }
+
+  let credAnswers = {};
+  if (hasCreds) {
+    credAnswers = await prompts([
+      { type: "text", name: "UNBOX_PARTNER_API_KEY", message: "UNBOX_PARTNER_API_KEY: api key única do PARCEIRO (recomendada; Enter se ainda usa key por loja)" },
+      { type: "text", name: "UNBOX_API_KEY", message: "UNBOX_API_KEY: key da loja, modelo antigo (Enter pra pular se informou a de parceiro)" },
+      { type: "text", name: "UNBOX_USER", message: "UNBOX_USER" },
+      { type: "password", name: "UNBOX_PASS", message: "UNBOX_PASS" },
+      { type: "text", name: "UNBOX_SHOP_ID", message: "UNBOX_SHOP_ID (opcional, Enter pra deixar em branco)" },
+      { type: "text", name: "UNBOX_SHOP_SLUG", message: "UNBOX_SHOP_SLUG (opcional, Enter pra deixar em branco)" },
+      {
+        // Só faz sentido com a key de parceiro: é o segredo que o header x-captcha-verification
+        // espera no placeOrder/OTP (sem ele, a key vai no lugar e o cliente vê CAPTCHA_MALFORMED_ERROR).
+        type: (_prev, values) => (values.UNBOX_PARTNER_API_KEY?.trim() ? "password" : null),
+        name: "UNBOX_CAPTCHA_BYPASS",
+        message: "UNBOX_CAPTCHA_BYPASS: segredo de bypass do reCAPTCHA (pedir à Unbox junto com a key de parceiro; Enter pra pular)",
+      },
+      { type: "password", name: "UNBOX_MCP_TOKEN", message: "Token do MCP da Unbox (opcional, habilita o .mcp.json pronto; pedir à Unbox; Enter pra pular)" },
+    ], { onCancel });
+  } else {
+    console.log("\n  Subindo em modo mockup. Preencha o .env.local depois e rode `npm run unbox:test`.\n");
+  }
+
+  console.log(`\n→ Gerando projeto em ${targetDir} ...`);
+  copyTemplate(targetDir);
+  setProjectName(targetDir, targetName);
+  // MCP da Unbox: com o token informado, o .mcp.json REAL já sai pronto (preenchido com as
+  // credenciais coletadas). O .mcp.json.example fica sempre só com placeholders — nunca
+  // embarque credencial viva em arquivo de exemplo (ele vai pro git; o .mcp.json não).
+  if (credAnswers.UNBOX_MCP_TOKEN) {
+    const subst = {
+      SEU_UNBOX_MCP_TOKEN: credAnswers.UNBOX_MCP_TOKEN,
+      SUA_UNBOX_PARTNER_API_KEY: credAnswers.UNBOX_PARTNER_API_KEY || credAnswers.UNBOX_API_KEY || "",
+      SEU_UNBOX_USER: credAnswers.UNBOX_USER || "",
+      SUA_UNBOX_PASS: credAnswers.UNBOX_PASS || "",
+    };
+    // Percorre o JSON e troca os placeholders como VALORES — nunca replace de string no texto
+    // (credencial com `$&`, `$'` ou aspas corrompia o arquivo; JSON.stringify escapa tudo).
+    const troca = (v) => (typeof v === "string" && v in subst ? subst[v]
+      : Array.isArray(v) ? v.map(troca)
+      : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, troca(x)]))
+      : v);
+    const example = JSON.parse(fs.readFileSync(path.join(targetDir, ".mcp.json.example"), "utf8"));
+    fs.writeFileSync(path.join(targetDir, ".mcp.json"), JSON.stringify(troca(example), null, 2) + "\n");
+    delete credAnswers.UNBOX_MCP_TOKEN; // não é env do app — não vai pro .env.local
+    console.log("  ✓ MCP da Unbox configurado (.mcp.json pronto; fora do git)");
+  } else {
+    delete credAnswers.UNBOX_MCP_TOKEN;
+  }
+  // Porta de preview: se escopa pelo DOMÍNIO sozinha (liga em *.vercel.app/*.myunbox.com.br,
+  // some em domínio próprio e no localhost) — nenhuma env necessária no .env.local.
+  writeEnvLocal(targetDir, {
+    ...credAnswers,
+    NEXT_PUBLIC_SITE_NAME: displayName,
+    ...(hostedCheckoutUrl ? { UNBOX_HOSTED_CHECKOUT_URL: hostedCheckoutUrl } : {}),
+  });
+
+  if (checkoutMode === "unbox") {
+    removeCustomCheckout(targetDir);
+    console.log(`  ✓ Checkout padrão da Unbox configurado (${hostedCheckoutUrl})`);
+  }
+
+  const preset = PRESETS[estilo];
+  const brandTokens = deriveBrandTokens({ primary, cta }, preset);
+  applyPreset(targetDir, estilo, brandTokens);
+  applyStoreName(targetDir, displayName);
+  console.log(`  ✓ Estilo "${preset.label}" aplicado: layout, fontes e neutros do preset + primária ${primary}, CTA ${cta}, loja "${displayName}"`);
+
+  writeBriefing(targetDir, {
+    loja: displayName,
+    corPrimaria: primary,
+    corCta: cta,
+    estilo,
+    // Dials de composição (1-10). Default do preset; o agente 15 revalida no briefing.
+    // variancia = quão assimétrica/ousada é a composição · motion = quanta animação
+    // (0 desliga) · densidade = quanto conteúdo por tela (arejado ↔ compacto).
+    dials: PRESETS[estilo]?.dials,
+    site,
+    instagram,
+    objetivo,
+    checkout: checkoutMode === "unbox" ? "padrao-unbox" : "customizavel",
+    geradoPor: "create-unbox-store",
+    criadoEm: new Date().toISOString(),
+  });
+  console.log("  ✓ Briefing inicial salvo em marca/briefing.json (o agente de marca lê daqui)");
+
+  let install = flags.install ?? true;
+  if (!nonInteractive && flags.install === undefined) {
+    const res = await prompts({
+      type: "confirm",
+      name: "install",
+      message: "Rodar `npm install` agora? (pode demorar ~2 min)",
+      initial: true,
+    }, { onCancel });
+    install = res.install;
+  }
+
+  if (install) {
+    console.log("\n→ Instalando dependências...");
+    execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+  }
+
+  console.log("");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  console.log("  ✓ Projeto criado!");
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+  // "Perguntar antes de mostrar": o próximo passo é o BRIEFING no Claude Code (agente 15),
+  // não "npm run dev" — o cliente não deve ver a loja padrão antes da personalização.
+  console.log(`
+  Próximo passo: dar a cara da sua marca pra loja.
+
+  cd ${targetName}
+  ${install ? "" : "npm install\n  "}claude
+
+  O Claude Code abre direto no briefing de marca e puxa a conversa sozinho.
+  Ele entrevista você, aplica logo, cores e conteúdo reais, e só então te
+  mostra a loja, já personalizada.
+
+  (Não tem o Claude Code? npm install -g @anthropic-ai/claude-code)
+
+  Antes de ir pra produção: npm run unbox:test
+  Depois do briefing, os passos opcionais (CRO, SEO, Deploy): agents/MANAGER.md
+`);
+}
+
+main();