create-kontrolia-auth 2.0.1 → 2.1.0

package/README.md

@@ -20,8 +20,12 @@ Eso hace, en orden:
      contenedores por ti** (`docker compose up -d`) y aplica las migraciones
      en cuanto Postgres está listo.
 4. **Primera aplicación** (opcional): registra tu app y su catálogo de permisos.
-5. **Despliegue**: genera los `.env.local` de `auth-server` y `admin-panel` y te
-   da los pasos exactos para Docker, Vercel, Railway, Render, Coolify o manual.
+5. **Despliegue**: genera los `.env.local` de `auth-server` y `admin-panel`. Si
+   eliges Vercel y el repo ya está en GitHub, puede **crear los dos proyectos
+   por ti** vía la API de Vercel (carpeta y variables de entorno correctas de
+   una vez, sin tocar el dashboard ni la CLI de Vercel) — solo pide un API
+   token de vercel.com/account/tokens. Para Docker, Railway, Render o
+   Coolify te da los pasos exactos.
 
 Si ya estás **dentro del repo** (desarrollo), el instalador lo detecta y se
 salta la descarga:

package/dist/steps/deployment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../src/steps/deployment.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAoCpD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAkI3F"}
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../src/steps/deployment.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA6GpD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAwI3F"}

package/dist/steps/deployment.js

@@ -1,6 +1,7 @@
 import * as p from "@clack/prompts";
 import { updateEnvValue, writeEnvFile } from "../utils/files.js";
 import { registerOAuthClient } from "../utils/oauth-client.js";
+import { createVercelProject, detectGitHubRepo } from "../utils/vercel-api.js";
 const NEXT_STEPS = {
     docker: "Ya está: los servicios auth-server y admin-panel viven en el mismo docker/docker-compose.yml. Corre `docker compose -f docker/docker-compose.yml up -d` para tenerlos arriba.",
     vercel: "Lo más confiable con un monorepo pnpm es conectar el repo desde el dashboard (no desplegar carpetas sueltas por CLI):\n" +
@@ -26,6 +27,63 @@ const NEXT_STEPS = {
     coolify: "Crea dos recursos 'Next.js App' en Coolify apuntando a apps/auth-server y apps/admin-panel, y pega en cada uno las variables de su .env.local.",
     manual: "Corre `pnpm build && pnpm start` en apps/auth-server y apps/admin-panel en el servidor/K8s de tu elección, usando los .env.local generados.",
 };
+/**
+ * Offers to create both Vercel projects via the REST API instead of walking
+ * the user through the dashboard/CLI by hand — the same three fields that
+ * are easy to get wrong doing this manually (gitRepository, rootDirectory,
+ * environmentVariables) are just fields in one request body here. Returns
+ * true only if both projects were created, so the caller knows whether to
+ * still show the manual fallback instructions.
+ */
+async function tryAutoCreateVercelProjects(repoRoot, authServerEnv, adminPanelEnv) {
+    const repo = await detectGitHubRepo(repoRoot);
+    if (!repo) {
+        p.note("No encontré un remoto de GitHub en este repo (`git remote get-url origin`) — sin eso no puedo crear los " +
+            "proyectos de Vercel por ti. Sube el repo a GitHub y vuelve a correr el instalador, o sigue los pasos " +
+            "manuales de abajo.", "Creación automática no disponible");
+        return false;
+    }
+    const auto = await p.confirm({
+        message: `¿Quieres que cree los dos proyectos de Vercel automáticamente (conectados a ${repo}, con sus variables ya puestas)? Solo necesito un API token de Vercel.`,
+        initialValue: true,
+    });
+    if (p.isCancel(auto) || !auto)
+        return false;
+    const token = await p.password({
+        message: "API token de Vercel (vercel.com/account/tokens — no se guarda, solo se usa ahora)",
+        validate: (value) => (value.trim() ? undefined : "Requerido"),
+    });
+    if (p.isCancel(token))
+        return false;
+    const namePrefix = repo.split("/")[1] ?? "kontrolia-auth";
+    const authSpinner = p.spinner();
+    authSpinner.start("Creando proyecto de Vercel para auth-server");
+    const authResult = await createVercelProject({
+        token,
+        repo,
+        name: `${namePrefix}-auth-server`,
+        rootDirectory: "apps/auth-server",
+        env: authServerEnv,
+    });
+    authSpinner.stop(authResult.ok ? "Proyecto auth-server creado" : `Falló auth-server: ${authResult.error}`);
+    const adminSpinner = p.spinner();
+    adminSpinner.start("Creando proyecto de Vercel para admin-panel");
+    const adminResult = await createVercelProject({
+        token,
+        repo,
+        name: `${namePrefix}-admin-panel`,
+        rootDirectory: "apps/admin-panel",
+        env: adminPanelEnv,
+    });
+    adminSpinner.stop(adminResult.ok ? "Proyecto admin-panel creado" : `Falló admin-panel: ${adminResult.error}`);
+    if (authResult.ok && adminResult.ok) {
+        p.note("Los dos proyectos ya están conectados a tu repo, con la carpeta y las variables correctas. Entra a " +
+            "vercel.com/dashboard y dale \"Deploy\" a cada uno (o empuja un commit a tu rama principal) para el primer despliegue.", "Listo");
+        return true;
+    }
+    p.note("Algo falló creando los proyectos — usa los pasos manuales de abajo para lo que no se haya creado.", "Revisa el error de arriba");
+    return false;
+}
 /**
  * Question B from the architecture plan: where do auth-server/admin-panel
  * run? Fully independent from the database question above — this only
@@ -106,21 +164,23 @@ export async function askDeploymentStep(repoRoot, db) {
     }
     const s = p.spinner();
     s.start("Generando apps/auth-server/.env.local y apps/admin-panel/.env.local");
-    await writeEnvFile(`${repoRoot}/apps/auth-server/.env.local`, {
+    const authServerEnv = {
         NEXT_PUBLIC_SUPABASE_URL: db.supabaseUrl,
         NEXT_PUBLIC_SUPABASE_ANON_KEY: db.anonKey,
         SUPABASE_URL: db.supabaseUrl,
         SUPABASE_SERVICE_ROLE_KEY: db.serviceRoleKey,
         NEXT_PUBLIC_ADMIN_PANEL_URL: adminPanelUrl,
         NEXT_PUBLIC_COOKIE_DOMAIN: cookieDomain,
-    });
-    await writeEnvFile(`${repoRoot}/apps/admin-panel/.env.local`, {
+    };
+    await writeEnvFile(`${repoRoot}/apps/auth-server/.env.local`, authServerEnv);
+    const adminPanelEnv = {
         NEXT_PUBLIC_SUPABASE_URL: db.supabaseUrl,
         NEXT_PUBLIC_SUPABASE_ANON_KEY: db.anonKey,
         NEXT_PUBLIC_AUTH_SERVER_URL: authServerUrl,
         NEXT_PUBLIC_COOKIE_DOMAIN: cookieDomain,
         NEXT_PUBLIC_OAUTH_CLIENT_ID: oauthClientId ?? "",
-    });
+    };
+    await writeEnvFile(`${repoRoot}/apps/admin-panel/.env.local`, adminPanelEnv);
     if (db.mode === "new-self-hosted") {
         // database.ts wrote SITE_URL="http://localhost:3000" as a fixed default
         // *before* this step ever asked where auth-server actually lives —
@@ -141,5 +201,8 @@ export async function askDeploymentStep(repoRoot, db) {
         p.note("docker/.env se actualizó con las URLs reales — como el contenedor de auth (GoTrue) ya estaba arriba con los " +
             "valores por defecto, corre `docker compose -f docker/docker-compose.yml up -d` una vez más para que los tome.", "Reinicia el docker-compose");
     }
-    p.note(NEXT_STEPS[target], `Despliegue: ${target}`);
+    const autoCreated = target === "vercel" && (await tryAutoCreateVercelProjects(repoRoot, authServerEnv, adminPanelEnv));
+    if (!autoCreated) {
+        p.note(NEXT_STEPS[target], `Despliegue: ${target}`);
+    }
 }

package/dist/utils/vercel-api.d.ts

@@ -0,0 +1,35 @@
+import type { EnvValues } from "./files.js";
+/**
+ * Resolves "owner/repo" from the git remote, so the wizard can offer to
+ * create Vercel projects automatically instead of walking the user through
+ * `vercel`/dashboard steps by hand. Only understands GitHub remotes (https
+ * or ssh) — Vercel's own gitRepository.type also supports gitlab/bitbucket,
+ * but this product's docs and CLI only ever assume GitHub.
+ */
+export declare function detectGitHubRepo(repoRoot: string): Promise<string | null>;
+export interface CreateVercelProjectOptions {
+    token: string;
+    /** "owner/repo" on GitHub. */
+    repo: string;
+    name: string;
+    rootDirectory: string;
+    env: EnvValues;
+}
+export interface CreateVercelProjectResult {
+    ok: boolean;
+    /** Only present when ok is false. */
+    error?: string;
+}
+/**
+ * Creates a Vercel project via the REST API — connected to the GitHub repo,
+ * scoped to one app's folder in this monorepo, with its environment
+ * variables already set. This is what makes automatic setup possible: the
+ * same three things (gitRepository, rootDirectory, environmentVariables)
+ * that are easy to get wrong doing this by hand (see the "vercel CLI run
+ * from inside the app folder" failure mode) are just fields in one request
+ * body here.
+ *
+ * https://vercel.com/docs/rest-api/reference/endpoints/projects/create-a-new-project
+ */
+export declare function createVercelProject(options: CreateVercelProjectOptions): Promise<CreateVercelProjectResult>;
+//# sourceMappingURL=vercel-api.d.ts.map

package/dist/utils/vercel-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-api.d.ts","sourceRoot":"","sources":["../../src/utils/vercel-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAQ/E;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,SAAS,CAAC;CAChB;AAED,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,OAAO,CAAC;IACZ,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAgCjH"}

package/dist/utils/vercel-api.js

@@ -0,0 +1,61 @@
+import { run } from "./exec.js";
+/**
+ * Resolves "owner/repo" from the git remote, so the wizard can offer to
+ * create Vercel projects automatically instead of walking the user through
+ * `vercel`/dashboard steps by hand. Only understands GitHub remotes (https
+ * or ssh) — Vercel's own gitRepository.type also supports gitlab/bitbucket,
+ * but this product's docs and CLI only ever assume GitHub.
+ */
+export async function detectGitHubRepo(repoRoot) {
+    try {
+        const url = (await run("git", ["remote", "get-url", "origin"], { cwd: repoRoot })).trim();
+        const match = url.match(/github\.com[:/]([^/]+)\/(.+?)(\.git)?$/);
+        return match ? `${match[1]}/${match[2]}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Creates a Vercel project via the REST API — connected to the GitHub repo,
+ * scoped to one app's folder in this monorepo, with its environment
+ * variables already set. This is what makes automatic setup possible: the
+ * same three things (gitRepository, rootDirectory, environmentVariables)
+ * that are easy to get wrong doing this by hand (see the "vercel CLI run
+ * from inside the app folder" failure mode) are just fields in one request
+ * body here.
+ *
+ * https://vercel.com/docs/rest-api/reference/endpoints/projects/create-a-new-project
+ */
+export async function createVercelProject(options) {
+    const environmentVariables = Object.entries(options.env).map(([key, value]) => ({
+        key,
+        value,
+        type: "encrypted",
+        target: ["production", "preview", "development"],
+    }));
+    let response;
+    try {
+        response = await fetch("https://api.vercel.com/v11/projects", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${options.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                name: options.name,
+                framework: "nextjs",
+                gitRepository: { type: "github", repo: options.repo },
+                rootDirectory: options.rootDirectory,
+                environmentVariables,
+            }),
+        });
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+    if (response.ok)
+        return { ok: true };
+    const body = (await response.json().catch(() => null));
+    return { ok: false, error: body?.error?.message ?? `HTTP ${response.status}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kontrolia-auth",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "license": "MIT",
   "description": "Turnkey installer for KontrolIA Auth. `npx create-kontrolia-auth mi-app` checks requirements, downloads the repo, installs deps, and runs a wizard: (1) connect to an existing Supabase project or create a new self-hosted one via Docker; (2) where to deploy auth-server/admin-panel (Docker, Vercel, Railway, Render, Coolify). Also exposes `update`, `migrate` and `doctor` subcommands.",
   "keywords": [