abw-react-starter 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,175 @@
+# 🚀 abw-react-starter
+
+CLI to quickly bootstrap a fullstack project with:
+
+* ⚙️ **Strapi (Backend)**
+* ⚡ **Next.js (Frontend)**
+* ☁️ **Heroku deployment (optional)**
+* 🪣 **AWS S3 upload support (optional)**
+
+---
+
+## 📦 Installation
+
+### Option 1: Use without installing (recommended)
+
+```bash
+npx abw-react-starter create my-app
+```
+
+### Option 2: Install globally
+
+```bash
+npm install -g abw-react-starter
+```
+
+Then:
+
+```bash
+abw-react-starter create my-app
+```
+
+---
+
+## 🚀 Usage
+
+### Create a new project
+
+```bash
+abw-react-starter create my-app
+```
+
+or simply:
+
+```bash
+abw-react-starter my-app
+```
+
+---
+
+## ⚙️ What it does
+
+* Creates a full project structure:
+
+  * `/backend` → Strapi (TypeScript)
+  * `/frontend` → Next.js
+* Initializes Git repositories
+* Configures environment variables
+* Optionally sets up:
+
+  * AWS S3 uploads
+  * Heroku deployment (backend + frontend)
+
+---
+
+## ☁️ Deployment
+
+During setup, you will be asked:
+
+* Whether to deploy to Heroku
+* App names for backend and frontend
+* Login (if not authenticated)
+
+### Or deploy later:
+
+```bash
+abw-react-starter publish my-app
+```
+
+---
+
+## 🪣 AWS S3 Support
+
+If enabled, the CLI will:
+
+* Install S3 upload provider
+* Configure:
+
+  * `plugins.ts`
+  * `middlewares.ts`
+* Ask for:
+
+  * Bucket name
+  * Region
+  * Access keys
+* Automatically configure Heroku env variables
+
+---
+
+## 🔐 Requirements
+
+Make sure you have installed:
+
+* Node.js (>= 18)
+* npm
+* Git
+* Heroku CLI
+
+---
+
+## 🧪 Local Development
+
+### Backend
+
+```bash
+cd backend
+npm run develop
+```
+
+### Frontend
+
+```bash
+cd frontend
+npm run dev
+```
+
+---
+
+## 📁 Project Structure
+
+```
+my-app/
+├── backend/     # Strapi API
+├── frontend/    # Next.js app
+└── .abw-starter.json
+```
+
+---
+
+## 🔄 Updating
+
+If installed globally:
+
+```bash
+npm update -g abw-react-starter
+```
+
+---
+
+## 🐛 Troubleshooting
+
+### Heroku app name already taken
+
+The CLI will automatically:
+
+1. Try your chosen name
+2. Try a random suffix
+3. Fallback to Heroku-generated name
+
+---
+
+### Not logged into Heroku
+
+The CLI will prompt you to login automatically.
+
+---
+
+## 📄 License
+
+MIT
+
+---
+
+## 👨‍💻 Author
+
+Built with ❤️ by ABWorks

package/bin/create.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Command } from "commander";
 import inquirer from "inquirer";
@@ -18,6 +18,10 @@ function randHex(bytes = 16) {
   return crypto.randomBytes(bytes).toString("hex");
 }
 
+function randSuffix(size = 6) {
+  return crypto.randomBytes(size).toString("hex").slice(0, size);
+}
+
 async function run(cmd, args, opts = {}) {
   const p = execa(cmd, args, {
     stdio: "inherit",
@@ -31,6 +35,32 @@ async function runCapture(cmd, args, opts = {}) {
   return p.stdout?.trim();
 }
 
+async function runCombined(cmd, args, opts = {}) {
+  try {
+    const result = await execa(cmd, args, {
+      all: true,
+      ...opts,
+    });
+
+    return {
+      ok: true,
+      code: 0,
+      output: result.all?.trim() || "",
+      stdout: result.stdout?.trim() || "",
+      stderr: result.stderr?.trim() || "",
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      code: err?.exitCode ?? 1,
+      output: String(err?.all || err?.stderr || err?.stdout || err?.message || "").trim(),
+      stdout: String(err?.stdout || "").trim(),
+      stderr: String(err?.stderr || "").trim(),
+      error: err,
+    };
+  }
+}
+
 function ensureNoTrailingSlash(url) {
   return (url || "").replace(/\/+$/, "");
 }
@@ -43,6 +73,120 @@ async function assertCmdExists(cmd, args = ["--version"]) {
   }
 }
 
+function looksLikeHerokuNameTakenError(output) {
+  const msg = String(output || "").toLowerCase();
+  return (
+    msg.includes("name") &&
+    (msg.includes("taken") ||
+      msg.includes("already taken") ||
+      msg.includes("already exists") ||
+      msg.includes("invalid_params"))
+  );
+}
+
+async function getHerokuAppInfo(appName, cwd) {
+  const raw = await runCapture("heroku", ["apps:info", "-a", appName, "--json"], { cwd });
+  return JSON.parse(raw || "{}");
+}
+
+async function tryCreateHerokuApp(appName, region, cwd) {
+  const args = ["create"];
+  if (appName) args.push(appName);
+  args.push("--region", region);
+
+  return runCombined("heroku", args, { cwd });
+}
+
+async function createHerokuAppWithFallback({ cwd, requestedName, region, label }) {
+  const attempts = [];
+
+  if (requestedName) {
+    attempts.push(requestedName);
+    attempts.push(`${requestedName}-${randSuffix(4)}`);
+    attempts.push(`${requestedName}-${randSuffix(6)}`);
+  }
+
+  for (const candidate of attempts) {
+    console.log(`\n=== ${label}: tentar criar app Heroku "${candidate}" ===\n`);
+
+    const res = await tryCreateHerokuApp(candidate, region, cwd);
+
+    if (res.output) {
+      console.log(res.output);
+    }
+
+    if (res.ok) {
+      return candidate;
+    }
+
+    if (looksLikeHerokuNameTakenError(res.output)) {
+      console.log(`⚠️ Nome já ocupado: ${candidate}`);
+      continue;
+    }
+
+    throw res.error || new Error(`Falha ao criar app Heroku (${label}).`);
+  }
+
+  console.log(`\n=== ${label}: a criar app Heroku com nome automático ===\n`);
+
+  const autoRes = await tryCreateHerokuApp(null, region, cwd);
+
+  if (autoRes.output) {
+    console.log(autoRes.output);
+  }
+
+  if (!autoRes.ok) {
+    throw autoRes.error || new Error(`Falha ao criar app Heroku com nome automático (${label}).`);
+  }
+
+  const appsRaw = await runCapture("heroku", ["apps", "--json"], { cwd });
+  const apps = JSON.parse(appsRaw || "[]");
+
+  if (!Array.isArray(apps) || apps.length === 0) {
+    throw new Error(`Não consegui descobrir o nome final da app Heroku (${label}).`);
+  }
+
+  apps.sort((a, b) => {
+    const da = new Date(a?.created_at || 0).getTime();
+    const db = new Date(b?.created_at || 0).getTime();
+    return db - da;
+  });
+
+  const latest = apps[0]?.name;
+  if (!latest) {
+    throw new Error(`Não consegui descobrir o nome final da app Heroku (${label}).`);
+  }
+
+  return latest;
+}
+
+function upsertEnvValue(content, key, value) {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`^${escapedKey}=.*$`, "m");
+  const line = `${key}=${value}`;
+
+  if (regex.test(content)) {
+    return content.replace(regex, line);
+  }
+
+  const trimmed = content.replace(/\s*$/, "");
+  return trimmed ? `${trimmed}\n${line}\n` : `${line}\n`;
+}
+
+async function mergeEnvFile(filePath, values) {
+  let content = "";
+
+  if (await fs.pathExists(filePath)) {
+    content = await fs.readFile(filePath, "utf8");
+  }
+
+  for (const [key, value] of Object.entries(values)) {
+    content = upsertEnvValue(content, key, value ?? "");
+  }
+
+  await fs.writeFile(filePath, content);
+}
+
 /* =========================
    Heroku Login (melhorado)
 ========================= */
@@ -85,7 +229,8 @@ async function ensureHerokuLoginOrSkip() {
 ========================= */
 
 async function writeManifest(projectDir, data) {
-  await fs.writeJson(path.join(projectDir, MANIFEST_NAME), data, {
+  const current = (await readManifest(projectDir)) || {};
+  await fs.writeJson(path.join(projectDir, MANIFEST_NAME), { ...current, ...data }, {
     spaces: 2,
   });
 }
@@ -129,6 +274,7 @@ async function configureBackendS3(projectDir, aws) {
 
   const bucketUrl = `https://${aws.bucket}.s3.${aws.region}.amazonaws.com`;
 
+  console.log("\n=== BACKEND: configurar middlewares.ts ===\n");
   await fs.writeFile(
     path.join(beDir, "config", "middlewares.ts"),
     `export default [
@@ -157,6 +303,7 @@ async function configureBackendS3(projectDir, aws) {
 `
   );
 
+  console.log("\n=== BACKEND: configurar plugins.ts ===\n");
   await fs.writeFile(
     path.join(beDir, "config", "plugins.ts"),
     `export default ({ env }) => ({
@@ -176,20 +323,48 @@ async function configureBackendS3(projectDir, aws) {
           },
         },
       },
+      actionOptions: {
+        upload: {},
+        uploadStream: {},
+        delete: {},
+      },
     },
   },
 });
 `
   );
 
+  console.log("\n=== BACKEND: configurar server.ts ===\n");
   await fs.writeFile(
-    path.join(beDir, ".env"),
-    `AWS_ACCESS_KEY_ID=${aws.key}
-AWS_ACCESS_SECRET=${aws.secret}
-AWS_REGION=${aws.region}
-AWS_BUCKET=${aws.bucket}
+    path.join(beDir, "config", "server.ts"),
+    `import type { Core } from '@strapi/strapi';
+
+const config = ({ env }: Core.Config.Shared.ConfigParams): Core.Config.Server => {
+  return {
+    host: env('HOST', '0.0.0.0'),
+    port: env.int('PORT', 1337),
+    app: {
+      keys: env.array('APP_KEYS'),
+    },
+    transfer: {
+      remote: {
+        enabled: true,
+      },
+    },
+  };
+};
+
+export default config;
 `
   );
+
+  console.log("\n=== BACKEND: atualizar .env ===\n");
+  await mergeEnvFile(path.join(beDir, ".env"), {
+    AWS_ACCESS_KEY_ID: aws.key,
+    AWS_ACCESS_SECRET: aws.secret,
+    AWS_REGION: aws.region,
+    AWS_BUCKET: aws.bucket,
+  });
 }
 
 /* =========================
@@ -234,6 +409,31 @@ async function createFrontendLocal(projectDir, nodeVersion) {
   });
 
   const feDir = path.join(projectDir, "frontend");
+
+  const nextConfigTs = path.join(feDir, "next.config.ts");
+  const nextConfigJs = path.join(feDir, "next.config.js");
+
+  if (await fs.pathExists(nextConfigTs)) {
+    await fs.remove(nextConfigTs);
+    await fs.writeFile(
+      nextConfigJs,
+      `/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+module.exports = nextConfig;
+`
+    );
+  } else if (!(await fs.pathExists(nextConfigJs))) {
+    await fs.writeFile(
+      nextConfigJs,
+      `/** @type {import('next').NextConfig} */
+const nextConfig = {};
+
+module.exports = nextConfig;
+`
+    );
+  }
+
   const pkgPath = path.join(feDir, "package.json");
   const pkg = await fs.readJson(pkgPath);
 
@@ -241,10 +441,16 @@ async function createFrontendLocal(projectDir, nodeVersion) {
   pkg.engines.node = nodeVersion;
 
   pkg.scripts = pkg.scripts || {};
+  pkg.scripts.build = pkg.scripts.build || "next build";
   pkg.scripts.start = "next start -p $PORT";
 
   await fs.writeJson(pkgPath, pkg, { spaces: 2 });
 
+  const envLocalPath = path.join(feDir, ".env.local");
+  if (!(await fs.pathExists(envLocalPath))) {
+    await fs.writeFile(envLocalPath, "NEXT_PUBLIC_STRAPI_URL=http://localhost:1337\n");
+  }
+
   await initGitRepo(feDir, "Init Next frontend");
 }
 
@@ -255,26 +461,77 @@ async function createFrontendLocal(projectDir, nodeVersion) {
 async function deployBackendHeroku({ projectDir, backendApp, region }) {
   const beDir = path.join(projectDir, "backend");
 
-  await run("heroku", ["create", backendApp, "--region", region], { cwd: beDir });
-  await run("heroku", ["git:remote", "-a", backendApp], { cwd: beDir });
-  await run("heroku", ["addons:create", "heroku-postgresql", "-a", backendApp], { cwd: beDir });
+  const finalBackendApp = await createHerokuAppWithFallback({
+    cwd: beDir,
+    requestedName: backendApp,
+    region,
+    label: "BACKEND",
+  });
+
+  await run("heroku", ["git:remote", "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["addons:create", "heroku-postgresql", "-a", finalBackendApp], { cwd: beDir });
+
+  console.log("\n=== BACKEND: configurar env vars Strapi ===\n");
+  const appKeys = [randHex(16), randHex(16), randHex(16), randHex(16)].join(",");
+  const apiTokenSalt = randHex(16);
+  const adminJwtSecret = randHex(24);
+  const jwtSecret = randHex(24);
+
+  await run("heroku", ["config:set", `NODE_ENV=production`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `APP_KEYS=${appKeys}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `API_TOKEN_SALT=${apiTokenSalt}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `ADMIN_JWT_SECRET=${adminJwtSecret}`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `JWT_SECRET=${jwtSecret}`, "-a", finalBackendApp], { cwd: beDir });
+
+  await run("heroku", ["config:set", `DATABASE_CLIENT=postgres`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `DATABASE_SSL=true`, "-a", finalBackendApp], { cwd: beDir });
+  await run("heroku", ["config:set", `DATABASE_SSL_REJECT_UNAUTHORIZED=false`, "-a", finalBackendApp], {
+    cwd: beDir,
+  });
 
   const envPath = path.join(beDir, ".env");
 
   if (await fs.pathExists(envPath)) {
     const env = await fs.readFile(envPath, "utf8");
-    const get = (k) => env.match(new RegExp(`${k}=(.*)`))?.[1]?.trim();
-
-    await run("heroku", ["config:set", `AWS_BUCKET=${get("AWS_BUCKET")}`, "-a", backendApp], { cwd: beDir });
-    await run("heroku", ["config:set", `AWS_REGION=${get("AWS_REGION")}`, "-a", backendApp], { cwd: beDir });
-    await run("heroku", ["config:set", `AWS_ACCESS_KEY_ID=${get("AWS_ACCESS_KEY_ID")}`, "-a", backendApp], { cwd: beDir });
-    await run("heroku", ["config:set", `AWS_ACCESS_SECRET=${get("AWS_ACCESS_SECRET")}`, "-a", backendApp], { cwd: beDir });
+    const get = (k) => env.match(new RegExp(`^${k}=(.*)$`, "m"))?.[1]?.trim();
+
+    const awsBucket = get("AWS_BUCKET");
+    const awsRegion = get("AWS_REGION");
+    const awsAccessKeyId = get("AWS_ACCESS_KEY_ID");
+    const awsAccessSecret = get("AWS_ACCESS_SECRET");
+
+    if (awsBucket) {
+      await run("heroku", ["config:set", `AWS_BUCKET=${awsBucket}`, "-a", finalBackendApp], { cwd: beDir });
+    }
+    if (awsRegion) {
+      await run("heroku", ["config:set", `AWS_REGION=${awsRegion}`, "-a", finalBackendApp], { cwd: beDir });
+    }
+    if (awsAccessKeyId) {
+      await run("heroku", ["config:set", `AWS_ACCESS_KEY_ID=${awsAccessKeyId}`, "-a", finalBackendApp], {
+        cwd: beDir,
+      });
+    }
+    if (awsAccessSecret) {
+      await run("heroku", ["config:set", `AWS_ACCESS_SECRET=${awsAccessSecret}`, "-a", finalBackendApp], {
+        cwd: beDir,
+      });
+    }
   }
 
+  console.log("\n=== BACKEND: deploy ===\n");
   await run("git", ["push", "heroku", "main"], { cwd: beDir });
 
-  const info = JSON.parse(await runCapture("heroku", ["apps:info", "-a", backendApp, "--json"]));
-  return ensureNoTrailingSlash(info?.app?.web_url);
+  const info = await getHerokuAppInfo(finalBackendApp, beDir);
+  const backendWebUrl = ensureNoTrailingSlash(info?.app?.web_url);
+
+  if (!backendWebUrl) {
+    throw new Error("Não consegui obter web_url do backend no Heroku.");
+  }
+
+  return {
+    backendApp: finalBackendApp,
+    backendWebUrl,
+  };
 }
 
 /* =========================
@@ -284,17 +541,34 @@ async function deployBackendHeroku({ projectDir, backendApp, region }) {
 async function deployFrontendHeroku({ projectDir, frontendApp, region, backendWebUrl }) {
   const feDir = path.join(projectDir, "frontend");
 
-  await run("heroku", ["create", frontendApp, "--region", region], { cwd: feDir });
-  await run("heroku", ["git:remote", "-a", frontendApp], { cwd: feDir });
+  const finalFrontendApp = await createHerokuAppWithFallback({
+    cwd: feDir,
+    requestedName: frontendApp,
+    region,
+    label: "FRONTEND",
+  });
+
+  await run("heroku", ["git:remote", "-a", finalFrontendApp], { cwd: feDir });
 
-  await run("heroku", ["config:set", `NEXT_PUBLIC_STRAPI_URL=${backendWebUrl}`, "-a", frontendApp], {
+  console.log("\n=== FRONTEND: configurar env var ===\n");
+  await run("heroku", ["config:set", `NEXT_PUBLIC_STRAPI_URL=${backendWebUrl}`, "-a", finalFrontendApp], {
     cwd: feDir,
   });
 
+  console.log("\n=== FRONTEND: deploy ===\n");
   await run("git", ["push", "heroku", "main"], { cwd: feDir });
 
-  const info = JSON.parse(await runCapture("heroku", ["apps:info", "-a", frontendApp, "--json"]));
-  return ensureNoTrailingSlash(info?.app?.web_url);
+  const info = await getHerokuAppInfo(finalFrontendApp, feDir);
+  const frontendWebUrl = ensureNoTrailingSlash(info?.app?.web_url);
+
+  if (!frontendWebUrl) {
+    throw new Error("Não consegui obter web_url do frontend no Heroku.");
+  }
+
+  return {
+    frontendApp: finalFrontendApp,
+    frontendWebUrl,
+  };
 }
 
 /* =========================
@@ -313,7 +587,6 @@ async function doCreate(projectDirArg, opts) {
   const region = (opts.region || "eu").toLowerCase();
   const nodeVersion = opts.node || "20.x";
 
-  // S3
   const { useS3 } = await inquirer.prompt([
     { type: "confirm", name: "useS3", message: "Usar S3?", default: true },
   ]);
@@ -323,9 +596,9 @@ async function doCreate(projectDirArg, opts) {
   if (useS3) {
     aws = await inquirer.prompt([
       { name: "bucket", message: "Bucket:" },
-      { name: "region", default: "eu-north-1" },
+      { name: "region", message: "Region:", default: "eu-north-1" },
       { name: "key", message: "Access Key:" },
-      { type: "password", name: "secret", message: "Secret:" },
+      { type: "password", name: "secret", message: "Secret:", mask: "*" },
     ]);
   }
 
@@ -347,7 +620,9 @@ async function doCreate(projectDirArg, opts) {
 
   await createBackendLocal(projectDir);
 
-  if (useS3) await configureBackendS3(projectDir, aws);
+  if (useS3 && aws) {
+    await configureBackendS3(projectDir, aws);
+  }
 
   await createFrontendLocal(projectDir, nodeVersion);
 
@@ -358,91 +633,212 @@ async function doCreate(projectDirArg, opts) {
     backendApp,
     frontendApp,
     useS3,
-    awsBucket: aws?.bucket,
-    awsRegion: aws?.region,
+    awsBucket: aws?.bucket || null,
+    awsRegion: aws?.region || null,
     createdAt: new Date().toISOString(),
+    deployedAt: null,
+    backendUrl: null,
+    frontendUrl: null,
   });
 
-  if (!deployNow) return;
+  if (!deployNow) {
+    console.log("\n✅ Projeto criado localmente (sem Heroku).");
+    console.log(`📁 Pasta: ${projectDir}`);
+    console.log("\nPara correr local:");
+    console.log("- Backend: cd backend && npm run develop");
+    console.log("- Frontend: cd frontend && npm run dev");
+    console.log("\nQuando quiseres publicar:");
+    console.log(`- abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  const publishAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "backendApp",
+      message: "Nome da app Heroku do backend (Strapi):",
+      default: backendApp,
+      validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+    },
+    {
+      type: "input",
+      name: "frontendApp",
+      message: "Nome da app Heroku do frontend (Next):",
+      default: frontendApp,
+      validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+    },
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Confirmas criar 2 apps Heroku e fazer deploy?",
+      default: true,
+    },
+  ]);
+
+  if (!publishAnswers.confirm) {
+    console.log("\n✅ Projeto criado localmente (não publicaste no Heroku).");
+    console.log(`Quando quiseres publicar: abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  backendApp = publishAnswers.backendApp;
+  frontendApp = publishAnswers.frontendApp;
+
+  await writeManifest(projectDir, {
+    backendApp,
+    frontendApp,
+  });
 
   const canPublish = await ensureHerokuLoginOrSkip();
-  if (!canPublish) return;
 
-  await doPublish(projectDir);
+  if (!canPublish) {
+    console.log("\n✅ Projeto criado localmente (sem publicar no Heroku).");
+    console.log(`📁 Pasta: ${projectDir}`);
+    console.log("\nPara publicar mais tarde:");
+    console.log(`- abw-react-starter publish "${projectDir}"`);
+    return;
+  }
+
+  await doPublish(projectDir, { skipHerokuLoginCheck: true });
 }
 
 /* =========================
    Publish
 ========================= */
 
-async function doPublish(projectDirArg) {
+async function doPublish(projectDirArg, options = {}) {
+  const { skipHerokuLoginCheck = false } = options;
   const projectDir = resolveProjectDir(projectDirArg);
 
   await assertCmdExists("git");
   await assertCmdExists("heroku");
 
-  const canPublish = await ensureHerokuLoginOrSkip();
-  if (!canPublish) return;
+  if (!skipHerokuLoginCheck) {
+    const canPublish = await ensureHerokuLoginOrSkip();
+    if (!canPublish) {
+      console.log("\nℹ️ Publicação cancelada. O projeto continua localmente sem deploy no Heroku.");
+      return;
+    }
+  }
 
   const manifest = await readManifest(projectDir);
+  if (!manifest) {
+    throw new Error(
+      `Não encontrei ${MANIFEST_NAME} em ${projectDir}. Cria o projeto com "abw-react-starter create <dir>" primeiro.`
+    );
+  }
+
+  const region = (manifest.region || "eu").toLowerCase();
+  const backendDir = path.join(projectDir, "backend");
+  const frontendDir = path.join(projectDir, "frontend");
+
+  if (!(await fs.pathExists(backendDir))) throw new Error("Não encontrei a pasta backend.");
+  if (!(await fs.pathExists(frontendDir))) throw new Error("Não encontrei a pasta frontend.");
+
+  let backendApp = manifest.backendApp;
+  let frontendApp = manifest.frontendApp;
+
+  if (!backendApp || !frontendApp) {
+    const projectBase = path.basename(projectDir);
+    const a = await inquirer.prompt([
+      {
+        type: "input",
+        name: "backendApp",
+        message: "Nome da app Heroku do backend (Strapi):",
+        default: backendApp || `${projectBase}-api`,
+        validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+      },
+      {
+        type: "input",
+        name: "frontendApp",
+        message: "Nome da app Heroku do frontend (Next):",
+        default: frontendApp || `${projectBase}-web`,
+        validate: (v) => (v?.length >= 3 ? true : "Nome muito curto"),
+      },
+    ]);
 
-  const backendWebUrl = await deployBackendHeroku({
+    backendApp = a.backendApp;
+    frontendApp = a.frontendApp;
+
+    await writeManifest(projectDir, {
+      backendApp,
+      frontendApp,
+    });
+  }
+
+  const backendResult = await deployBackendHeroku({
     projectDir,
-    backendApp: manifest.backendApp,
-    region: manifest.region,
+    backendApp,
+    region,
   });
 
-  const frontendWebUrl = await deployFrontendHeroku({
+  const frontendResult = await deployFrontendHeroku({
     projectDir,
-    frontendApp: manifest.frontendApp,
-    region: manifest.region,
-    backendWebUrl,
+    frontendApp,
+    region,
+    backendWebUrl: backendResult.backendWebUrl,
   });
 
   await writeManifest(projectDir, {
-    ...manifest,
-    backendUrl: backendWebUrl,
-    frontendUrl: frontendWebUrl,
+    deployedAt: new Date().toISOString(),
+    backendApp: backendResult.backendApp,
+    frontendApp: frontendResult.frontendApp,
+    backendUrl: backendResult.backendWebUrl,
+    frontendUrl: frontendResult.frontendWebUrl,
   });
 
   console.log("\n✅ Tudo pronto!");
-  console.log("Backend:", backendWebUrl);
-  console.log("Frontend:", frontendWebUrl);
+  console.log(`Backend app: ${backendResult.backendApp}`);
+  console.log(`Backend (Strapi): ${backendResult.backendWebUrl}`);
+  console.log(`Admin: ${backendResult.backendWebUrl}/admin`);
+  console.log(`Frontend app: ${frontendResult.frontendApp}`);
+  console.log(`Frontend (Next): ${frontendResult.frontendWebUrl}`);
+  console.log("\nNotas:");
+  console.log("- Content types normalmente crias localmente e depois fazes push para o backend Heroku.");
+  console.log("- Em produção, dá permissões em Public role para expor endpoints.");
 }
 
 /* =========================
-   CLI (INALTERADO)
+   CLI
 ========================= */
 
 program.name("abw-react-starter");
 
+// Comando create (default)
 program
   .command("create")
-  .argument("<projectDir>")
-  .option("--backend-app <name>")
-  .option("--frontend-app <name>")
-  .option("--node <version>", "20.x")
-  .option("--region <region>", "eu")
+  .argument("<projectDir>", "Diretório do projeto (será criado)")
+  .option("--backend-app <name>", "Nome da app Heroku do backend (Strapi)")
+  .option("--frontend-app <name>", "Nome da app Heroku do frontend (Next)")
+  .option("--node <version>", "Versão Node para Heroku (ex: 20.x)", "20.x")
+  .option("--region <region>", "Heroku region (eu | us)", "eu")
   .action(async (projectDirArg, opts) => {
     await doCreate(projectDirArg, opts);
   });
 
+// Para compatibilidade: se chamarem sem "create", trata como create
 program
-  .argument("[projectDir]")
-  .option("--backend-app <name>")
-  .option("--frontend-app <name>")
-  .option("--node <version>", "20.x")
-  .option("--region <region>", "eu");
+  .argument("[projectDir]", "Diretório do projeto (será criado)")
+  .option("--backend-app <name>", "Nome da app Heroku do backend (Strapi)")
+  .option("--frontend-app <name>", "Nome da app Heroku do frontend (Next)")
+  .option("--node <version>", "Versão Node para Heroku (ex: 20.x)", "20.x")
+  .option("--region <region>", "Heroku region (eu | us)", "eu");
 
+// Comando publish
 program
   .command("publish")
-  .argument("[projectDir]")
+  .argument("[projectDir]", "Diretório do projeto (default: .)")
+  .description("Publicar um projeto existente no Heroku")
   .action(async (projectDirArg) => {
     await doPublish(projectDirArg || ".");
   });
 
+// Se executarem sem subcomando, faz create
 program.action(async (projectDirArg, opts) => {
-  if (!projectDirArg) return program.help();
+  if (!projectDirArg) {
+    program.help();
+    return;
+  }
   await doCreate(projectDirArg, opts);
 });
 

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "abw-react-starter",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "CLI para criar projetos Strapi + Next + Heroku",
   "bin": {
     "abw-react-starter": "./bin/create.js"
   },
   "type": "module",
   "scripts": {},
-  "keywords": ["cli", "strapi", "nextjs", "heroku"],
+  "keywords": [
+    "cli",
+    "strapi",
+    "nextjs",
+    "heroku"
+  ],
   "author": "ABWorks",
   "license": "MIT",
   "dependencies": {
@@ -16,4 +21,4 @@
     "fs-extra": "^11.0.0",
     "execa": "^8.0.0"
   }
-}
+}