@unbox-plus/cli 0.20.4

package/template/scripts/sistema.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Orçamento de sistema visual — conta o que faz a loja ter "cara de IA".
+
+POR QUE ISTO EXISTE
+O `escala.py` irmão mede o TETO da tipografia (tipo grande demais). Este mede a
+QUANTIDADE — que é outro defeito, com outra causa e outro sintoma. O levantamento
+de 334 ajustes em três lojas do CLI achou a causa mecânica do diagnóstico que o
+Bruno deu duas vezes ("ta tudo com mt cara de AI... qual design system vc ta
+seguindo?"):
+
+    escala tipográfica    76 tamanhos distintos     (alvo ~6)
+    raios                 10 valores                (alvo: derivados de um token)
+    cor fora de token     14+ hex soltos            (alvo: zero)
+
+Nenhum desses três é cobrado em lugar nenhum da esteira hoje. E nenhum se conserta
+com prompt: o gerador acrescenta um tamanho novo a cada seção porque cada acréscimo
+é individualmente defensável. Orçamento obriga a gastar; instrução deixa acumular.
+
+O QUE CONTA COMO DEFINIÇÃO DE TOKEN (e por isso não é violação)
+O bloco `:root` / `@theme` do globals.css é onde as cores DEVEM viver — hex ali é a
+definição, não o vazamento. Violação é hex escrito em componente ou em regra CSS
+fora do bloco de tokens.
+
+USO
+    sistema.py <dir-do-projeto> [--tipos 8] [--raios 5] [--hex 0] [--secoes 8]
+
+CÓDIGOS DE SAÍDA
+    0  dentro do orçamento
+    1  estourou algum teto
+    2  O GATE NÃO RODOU (caminho errado, ou varreu zero arquivo)
+
+O 2 existe pela mesma razão do 2 do escala.py: gate que varre o vazio e diz "limpo"
+aprova sem ter olhado.
+"""
+import re
+import sys
+import pathlib
+from collections import Counter
+
+EXT_CODIGO = {".tsx", ".ts", ".jsx", ".js"}
+EXT_CSS = {".css"}
+IGNORAR = {"node_modules", ".next", ".git", "shots", "reviews", "public", "marca"}
+
+# ── tipografia ────────────────────────────────────────────────────────────────
+# Tailwind arbitrário `text-[13px]` / `text-[clamp(...)]` e utilitários nomeados.
+RE_TEXT_ARB = re.compile(r"text-\[([^\]]+)\]")
+RE_TEXT_NOM = re.compile(r"\btext-(xs|sm|base|lg|xl|[2-9]xl)\b")
+RE_CSS_FS = re.compile(r"font-size:\s*([^;}]+)")
+
+# ── raios ─────────────────────────────────────────────────────────────────────
+RE_ROUND_ARB = re.compile(r"rounded(?:-[a-z]{1,2})?-\[([^\]]+)\]")
+RE_ROUND_NOM = re.compile(r"\brounded(?:-[trbl]{1,2})?-(none|sm|md|lg|xl|[2-3]xl|full)\b")
+RE_CSS_RADIUS = re.compile(r"border-radius:\s*([^;}]+)")
+
+# ── cor ───────────────────────────────────────────────────────────────────────
+# ── largura de container ──────────────────────────────────────────────────────
+# "A margem esta errada" quase nunca e margem: sao larguras de container divergentes.
+# Na Punch o scaffold entregou cabecalho 1400, rodape 1180 e <main> 1240, e o cliente
+# reclamou em TRES rodadas diferentes porque cada tela expunha uma combinacao.
+# So contam as larguras de PAGINA (>=1000px): abaixo disso sao medidas de leitura e
+# larguras de componente, que legitimamente variam.
+RE_CONTAINER = re.compile(r"max-w-\[(\d{4,})px\]")
+PISO_CONTAINER = 1000
+
+RE_HEX = re.compile(r"#[0-9a-fA-F]{3,8}\b")
+RE_FALLBACK = re.compile(r"var\(\s*(--[A-Za-z0-9-]+)\s*,\s*(#[0-9a-fA-F]{3,8})\s*\)")
+
+
+def arquivos(raiz, exts):
+    for p in raiz.rglob("*"):
+        if p.suffix.lower() not in exts:
+            continue
+        if any(parte in IGNORAR for parte in p.parts):
+            continue
+        yield p
+
+
+def normalizar(valor):
+    """`13px`, ` 13px `, `13PX` são o mesmo tamanho. clamp() conta como um valor próprio."""
+    return re.sub(r"\s+", "", valor).lower()
+
+
+def bloco_de_tokens(texto):
+    """Devolve os intervalos (ini, fim) de `:root{...}` e `@theme{...}` — onde hex é lei."""
+    faixas = []
+    for m in re.finditer(r"(:root[^{]*|@theme[^{]*)\{", texto):
+        i = m.end() - 1
+        prof = 0
+        for j in range(i, len(texto)):
+            if texto[j] == "{":
+                prof += 1
+            elif texto[j] == "}":
+                prof -= 1
+                if prof == 0:
+                    faixas.append((m.start(), j))
+                    break
+    return faixas
+
+
+def medir(raiz):
+    tipos, raios, hexes, fallbacks = Counter(), Counter(), Counter(), {}
+    containers = {}
+    onde_hex = {}
+    vistos = 0
+
+    for p in arquivos(raiz, EXT_CODIGO | EXT_CSS):
+        vistos += 1
+        try:
+            t = p.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+
+        for m in RE_TEXT_ARB.finditer(t):
+            v = normalizar(m.group(1))
+            if "px" in v or "rem" in v or "clamp" in v or "vw" in v:
+                tipos[v] += 1
+        for m in RE_TEXT_NOM.finditer(t):
+            tipos["tw:" + m.group(1)] += 1
+        for m in RE_CSS_FS.finditer(t):
+            tipos[normalizar(m.group(1))] += 1
+
+        for m in RE_ROUND_ARB.finditer(t):
+            raios[normalizar(m.group(1))] += 1
+        for m in RE_ROUND_NOM.finditer(t):
+            raios["tw:" + m.group(1)] += 1
+        for m in RE_CSS_RADIUS.finditer(t):
+            raios[normalizar(m.group(1))] += 1
+
+        for m in RE_CONTAINER.finditer(t):
+            larg = int(m.group(1))
+            if larg >= PISO_CONTAINER:
+                containers.setdefault(larg, set()).add(str(p.relative_to(raiz)))
+
+        faixas = bloco_de_tokens(t) if p.suffix.lower() in EXT_CSS else []
+        # intervalos ocupados por fallback de var(): contam separado
+        faixas_fb = []
+        for m in RE_FALLBACK.finditer(t):
+            faixas_fb.append((m.start(), m.end()))
+            fallbacks.setdefault(m.group(1), Counter())[m.group(2).lower()] += 1
+        for m in RE_HEX.finditer(t):
+            if any(ini <= m.start() <= fim for ini, fim in faixas):
+                continue  # definição de token, não vazamento
+            if any(ini <= m.start() <= fim for ini, fim in faixas_fb):
+                continue  # fallback de var(), medido à parte
+            h = m.group(0).lower()
+            hexes[h] += 1
+            onde_hex.setdefault(h, []).append(
+                f"{p.relative_to(raiz)}:{t.count(chr(10), 0, m.start()) + 1}"
+            )
+
+    return vistos, tipos, raios, hexes, onde_hex, fallbacks, containers
+
+
+def contar_secoes(raiz):
+    """Momentos da home, lidos da receita. Devolve None quando não há receita."""
+    for nome in ("components/home/home-recipe.ts", "components/home/home-recipe.tsx"):
+        p = raiz / nome
+        if p.exists():
+            t = p.read_text(encoding="utf-8", errors="ignore")
+            return len(re.findall(r"\bsection:\s*[\"']", t))
+    return None
+
+
+def linha(rotulo, achado, teto, amostra=""):
+    marca = "ok " if achado <= teto else "ESTOUROU"
+    print(f"{marca:9}{rotulo:<26}{achado:>4}  (teto {teto}){amostra}")
+    return achado <= teto
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        sys.exit(__doc__)
+    raiz = pathlib.Path(args[0]).resolve()
+    tetos = {"tipos": 8, "raios": 5, "hex": 0, "secoes": 8}
+    for chave in tetos:
+        flag = f"--{chave}"
+        if flag in args:
+            tetos[chave] = int(args[args.index(flag) + 1])
+
+    if not raiz.is_dir():
+        print(f"ERRO: {raiz} nao e um diretorio — o gate NAO RODOU", file=sys.stderr)
+        sys.exit(2)
+
+    vistos, tipos, raios, hexes, onde_hex, fallbacks, containers = medir(raiz)
+    if vistos == 0:
+        print(f"ERRO: nenhum arquivo varrido em {raiz} — o gate NAO RODOU", file=sys.stderr)
+        sys.exit(2)
+
+    print(f"Orcamento de sistema · {vistos} arquivos varridos em {raiz.name}\n")
+    ok = True
+    ok &= linha("tamanhos de tipo", len(tipos), tetos["tipos"])
+    ok &= linha("raios", len(raios), tetos["raios"])
+    ok &= linha("hex fora de token", len(hexes), tetos["hex"])
+
+    secoes = contar_secoes(raiz)
+    if secoes is not None:
+        ok &= linha("momentos da home", secoes, tetos["secoes"])
+    else:
+        print(f"{'—':9}{'momentos da home':<26}   ?  (sem receita encontrada)")
+
+    if len(tipos) > tetos["tipos"]:
+        print("\n  tipos mais usados:", ", ".join(f"{v}×{n}" for v, n in tipos.most_common(6)))
+        print("  os", len(tipos) - 6, "restantes sao a gordura:", ", ".join(list(tipos)[6:18]))
+    if len(raios) > tetos["raios"]:
+        print("\n  raios:", ", ".join(f"{v}×{n}" for v, n in raios.most_common(12)))
+    if hexes:
+        print("\n  hex fora de token:")
+        for h, n in hexes.most_common(12):
+            print(f"    {h}  {n}×  {onde_hex[h][0]}")
+
+    if containers:
+        ok &= linha("larguras de container", len(containers), 1)
+        if len(containers) > 1:
+            print("\n  cada largura e um alinhamento diferente na mesma pagina:")
+            for larg in sorted(containers, reverse=True):
+                arqs = sorted(containers[larg])
+                print(f"    {larg}px  em {len(arqs)}: " + ", ".join(arqs[:3]))
+
+    mentirosos = {tok: c for tok, c in fallbacks.items() if len(c) > 1}
+    if mentirosos:
+        print("\n  fallback de var() com mais de um hex — pelo menos um mente:")
+        for tok, c in list(mentirosos.items())[:8]:
+            print(f"    {tok}: " + ", ".join(f"{h} ({n}×)" for h, n in c.most_common()))
+        ok = False
+
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

package/template/scripts/subscribe-webhook.ts

@@ -0,0 +1,36 @@
+// ⚠️ EFEITO REAL: cria uma assinatura de webhook na loja de produção.
+// Use sob demanda. Imprime o `secret` — cole em UNBOX_WEBHOOK_SECRET no .env.local.
+//
+//   npm run unbox:webhook:subscribe -- https://SEU-DOMINIO/api/webhooks/unbox
+//   (em dev, exponha localhost com um túnel, ex.: ngrok/cloudflared)
+import "./load-env"; // SEMPRE o primeiro import — parser de env idêntico ao do app
+import { UnboxClient } from "../lib/unbox/client";
+
+const endpoint = process.argv[2] || process.env.WEBHOOK_ENDPOINT;
+if (!endpoint) {
+  console.error("Uso: npm run unbox:webhook:subscribe -- <https://seu-dominio/api/webhooks/unbox>");
+  process.exit(1);
+}
+
+(async () => {
+  const client = new UnboxClient({
+    apiKey: process.env.UNBOX_API_KEY ?? "",
+    shopId: process.env.UNBOX_SHOP_ID!,
+    // API de parceiros: presente = signIn e leituras compativeis roteiam pra ela
+    partnerApiKey: process.env.UNBOX_PARTNER_API_KEY,
+    partnerGqlUrl: process.env.UNBOX_PARTNER_GRAPHQL_URL,
+    captchaBypass: process.env.UNBOX_CAPTCHA_BYPASS,
+  });
+  await client.signIn(process.env.UNBOX_USER!, process.env.UNBOX_PASS!);
+
+  for (const eventType of ["ORDER_STATUS_UPDATE", "ORDER_CREATED"]) {
+    try {
+      const sub = await client.subscribeWebhook(eventType, endpoint);
+      console.log(`✅ ${eventType} → ${endpoint}`);
+      console.log(`   secret: ${sub.secret}`);
+    } catch (e: any) {
+      console.error(`❌ ${eventType}: ${e.message}`);
+    }
+  }
+  console.log("\nCole o secret em UNBOX_WEBHOOK_SECRET no .env.local.");
+})();

package/template/scripts/test-live.ts

@@ -0,0 +1,186 @@
+// Teste ao vivo do SDK contra a loja real (produção). Roda só leituras seguras + monta o payload
+// de placeOrder (dry-run). NÃO cria pedido/webhook/OTP.
+//
+//   npm run unbox:test
+import "./load-env"; // SEMPRE o primeiro import — parser de env idêntico ao do app
+import { UnboxClient } from "../lib/unbox/client";
+import { friendlyError, cartEventLabel } from "../lib/unbox/errors";
+import { orderStatusLabel } from "../lib/unbox/customer";
+
+const SHOP = process.env.UNBOX_SHOP_ID!;
+const SLUG = process.env.UNBOX_SHOP_SLUG ?? "minha-loja";
+const client = new UnboxClient({
+  apiKey: process.env.UNBOX_API_KEY ?? "",
+  shopId: SHOP,
+  // API de parceiros: presente = signIn e leituras compativeis roteiam pra ela
+  partnerApiKey: process.env.UNBOX_PARTNER_API_KEY,
+  partnerGqlUrl: process.env.UNBOX_PARTNER_GRAPHQL_URL,
+  captchaBypass: process.env.UNBOX_CAPTCHA_BYPASS,
+});
+
+let pass = 0,
+  fail = 0;
+async function step<T>(name: string, fn: () => Promise<T> | T): Promise<T | undefined> {
+  try {
+    const r = await fn();
+    console.log(`✅ ${name}`);
+    pass++;
+    return r;
+  } catch (e: any) {
+    console.log(`❌ ${name}\n   → ${e.message}`);
+    fail++;
+    return undefined;
+  }
+}
+
+const ADDR = {
+  fullName: "Allan Teste", taxPayerId: "08383142951", postal: "04551-080",
+  address1: "Rua São Tomé", address2: "Apto 703", number: "73",
+  neighborhood: "Vila Olímpia", city: "São Paulo", region: "SP",
+  cityCode: "3550308", phone: "11999990000",
+};
+
+(async () => {
+  console.log(client.usesPartnerApi
+    ? `ℹ️  API de PARCEIROS ativa (${client.partnerGqlUrl}) — signIn + leituras compatíveis roteiam por ela`
+    : "ℹ️  Modo core puro (sem UNBOX_PARTNER_API_KEY) — todas as chamadas via core/REST");
+  await step("1. signIn (loja)", async () => {
+    const token = await client.signIn(process.env.UNBOX_USER!, process.env.UNBOX_PASS!);
+    // Setup só-parceiro: UNBOX_SHOP_ID pode vir vazio — extrai do JWT (mesmos claims
+    // arn:unbox:shopId que o app usa em lib/unbox/store.ts). Necessário pros passos core.
+    if (!client.shopId) {
+      try {
+        const payload = token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
+        const claims = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+        client.shopId = claims["arn:unbox:shopId"] ?? "";
+        if (client.shopId) console.log(`   shopId (do JWT): ${client.shopId}`);
+      } catch { /* segue sem shopId — passos core vão acusar */ }
+    }
+    return token;
+  });
+
+  const cat = await step("2. getCatalog", async () => {
+    const c = await client.getCatalog({ first: 10 });
+    console.log(`   totalCount=${c.totalCount}`);
+    return c;
+  });
+
+  let picked: any;
+  if (cat) {
+    picked = (cat.nodes as any[])
+      .map((n) => n.product)
+      .find((p) => !p.isSoldOut && p.variants?.[0]?.pricing?.[0]?.price);
+    if (picked) console.log(`   produto: "${picked.title}" @ ${picked.variants[0].pricing[0].displayPrice}`);
+  }
+
+  await step("3. getProductBySlug", async () => {
+    if (!picked) throw new Error("sem produto");
+    const p = await client.getProductBySlug(picked.slug);
+    if (!p?.product?._id) throw new Error("produto não encontrado");
+    return p;
+  });
+
+  await step("4. getTags", async () => {
+    const t = await client.getTags(); // sem filtro isTopLevel — mesmo path que o app usa
+    console.log(`   ${t.length} categorias`);
+    return t;
+  });
+
+  await step("5. getShop (promoções + assinatura)", async () => {
+    const s = await client.getShop(SLUG);
+    console.log(`   shopSales: ${(s.shopSales ?? []).map((x: any) => x.label).join(", ")}`);
+    console.log(`   freqs: ${(s.recurringOrdersPolicy?.allowedFrequencies ?? []).map((f: any) => f.title).join(", ")}`);
+    return s;
+  });
+
+  await step("6. getPaymentMethods", async () => {
+    const m = await client.getPaymentMethods();
+    console.log(`   ${m.map((x: any) => x.name).join(", ")}`);
+    return m;
+  });
+
+  await step("7. listDiscountCodes", async () => {
+    const d = await client.listDiscountCodes(3);
+    console.log(`   totalCount=${d.totalCount}`);
+    return d;
+  });
+
+  const v = picked?.variants?.[0];
+  const cart = await step("8. createCart", async () => {
+    if (!picked) throw new Error("sem produto");
+    const r = await client.createCart([{ productId: picked.productId, productVariantId: v._id, price: v.pricing[0].price, quantity: 1 }]);
+    console.log(`   cartId=${r.cartId} subtotal=${r.cart.checkout.summary.total.displayAmount}`);
+    return r;
+  });
+
+  await step("8b. addCartItems / getCart / update / remove", async () => {
+    if (!cart || !picked) throw new Error("sem carrinho");
+    await client.addCartItems(cart.cartId, cart.cartToken, [{ productId: picked.productId, productVariantId: v._id, price: v.pricing[0].price, quantity: 1 }]);
+    const reloaded = await client.getCart(cart.cartId, cart.cartToken);
+    const itemId = reloaded.items.edges[0].node._id;
+    await client.updateItemQuantity(cart.cartId, cart.cartToken, itemId, 3);
+    await client.removeCartItems(cart.cartId, cart.cartToken, [itemId]);
+    console.log(`   getCart itens=${reloaded.items.totalCount}; add/update/remove OK`);
+    return true;
+  });
+
+  let fgId: string | undefined;
+  await step("9. setShippingAddress", async () => {
+    if (!cart) throw new Error("sem carrinho");
+    fgId = await client.setShippingAddress(cart.cartId, cart.cartToken, ADDR as any);
+    console.log(`   fulfillmentGroupId=${fgId}`);
+    return fgId;
+  });
+
+  let fmId: string | undefined;
+  await step("10. quoteShipping", async () => {
+    if (!cart || !fgId) throw new Error("pré-requisito faltando");
+    const opts = await client.quoteShipping(cart.cartId, cart.cartToken, fgId);
+    fmId = opts[0]?.fulfillmentMethod._id;
+    console.log(`   ${opts.length} opção(ões); 1ª: ${opts[0]?.fulfillmentMethod.displayName} ${opts[0]?.price?.displayAmount}`);
+    if (!fmId) throw new Error("sem opções de frete");
+    return opts;
+  });
+
+  let finalCart: any;
+  await step("11. selectShipping", async () => {
+    if (!cart || !fgId || !fmId) throw new Error("pré-requisito faltando");
+    finalCart = await client.selectShipping(cart.cartId, cart.cartToken, fgId, fmId);
+    console.log(`   total c/ frete=${finalCart.checkout.summary.total.displayAmount}`);
+    return finalCart;
+  });
+
+  await step("12. buildOrderItems + payload placeOrder (DRY-RUN)", async () => {
+    if (!finalCart || !cart || !fmId) throw new Error("pré-requisito faltando");
+    const items = client.buildOrderItems(finalCart);
+    const total = finalCart.checkout.summary.total.amount;
+    console.log(`   payload OK: ${items.length} item(ns), total=R$${total} (placeOrder NÃO chamado)`);
+    return true;
+  });
+
+  await step("13. customerAccountExists", async () => {
+    const r = await client.customerAccountExists(process.env.UNBOX_TEST_EMAIL ?? "cliente@example.com");
+    console.log(`   existe? ${r}`);
+    return r;
+  });
+
+  await step("14. getAddressByPostalCode", async () => {
+    const a = await client.getAddressByPostalCode("04551-080");
+    console.log(`   ${a.address1}, ${a.neighborhood} - ${a.city}/${a.region}`);
+    return a;
+  });
+
+  await step("16. errors/labels", async () => {
+    const checks: Array<[string, string]> = [
+      [friendlyError({ message: "INSUFFICIENT_FUNDS_ERROR" }), "Pagamento recusado: saldo/limite insuficiente."],
+      [cartEventLabel("SALE_FREE_ITEM_ADDED"), "🎁 Você ganhou um brinde!"],
+      [orderStatusLabel("PENDING"), "Aguardando pagamento"],
+    ];
+    for (const [got, exp] of checks) if (got !== exp) throw new Error(`esperava "${exp}", veio "${got}"`);
+    console.log(`   ${checks.length} mapeamentos OK`);
+    return true;
+  });
+
+  console.log(`\n──────────── ${pass} passaram, ${fail} falharam ────────────`);
+  process.exit(fail ? 1 : 0);
+})();