@create-lft-app/cli 1.0.2 → 1.0.4

package/dist/bin/cli.js

@@ -1,20 +1,89 @@
 #!/usr/bin/env node
 
 // bin/cli.ts
-import "dotenv/config";
 import { program } from "commander";
 
 // src/index.ts
-import path5 from "path";
-import { confirm as confirm2 } from "@inquirer/prompts";
+import path4 from "path";
+import { confirm } from "@inquirer/prompts";
+
+// src/config/static-config.ts
+import { config } from "dotenv";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+config({ path: resolve(__dirname, "../../.env"), quiet: true });
+var STATIC_CONFIG = {
+  github: {
+    token: process.env.LFT_GITHUB_TOKEN || "",
+    username: process.env.LFT_GITHUB_USERNAME || "",
+    org: process.env.LFT_GITHUB_ORG || ""
+  },
+  supabase: {
+    token: process.env.LFT_SUPABASE_TOKEN || "",
+    orgId: process.env.LFT_SUPABASE_ORG_ID || "",
+    region: process.env.LFT_SUPABASE_REGION || "us-east-1"
+  },
+  jira: {
+    email: process.env.LFT_JIRA_EMAIL || "",
+    token: process.env.LFT_JIRA_TOKEN || "",
+    domain: process.env.LFT_JIRA_DOMAIN || ""
+  }
+};
 
 // src/config/index.ts
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
-import { createCipheriv, createDecipheriv, randomBytes, createHash } from "crypto";
-import nodeMachineId from "node-machine-id";
-import { input, password, select, confirm } from "@inquirer/prompts";
+async function loadConfig() {
+  return {
+    version: "1.0.0",
+    credentials: {
+      github: {
+        token: STATIC_CONFIG.github.token,
+        username: STATIC_CONFIG.github.username
+      },
+      supabase: {
+        accessToken: STATIC_CONFIG.supabase.token,
+        organizationId: STATIC_CONFIG.supabase.orgId
+      },
+      jira: {
+        email: STATIC_CONFIG.jira.email,
+        apiToken: STATIC_CONFIG.jira.token,
+        domain: STATIC_CONFIG.jira.domain
+      }
+    },
+    defaults: {
+      githubOrg: STATIC_CONFIG.github.org || void 0,
+      supabaseRegion: STATIC_CONFIG.supabase.region,
+      jiraProjectType: "software"
+    }
+  };
+}
+async function hasConfig() {
+  return STATIC_CONFIG.github.token !== "" && STATIC_CONFIG.supabase.token !== "" && STATIC_CONFIG.jira.token !== "";
+}
+
+// src/services/github.ts
+import { Octokit } from "octokit";
+
+// src/ui/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+async function withSpinner(text, fn, successText) {
+  const spinner = createSpinner(text).start();
+  try {
+    const result = await fn();
+    spinner.succeed(successText || text);
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
 
 // src/ui/logger.ts
 import chalk from "chalk";
@@ -63,324 +132,20 @@ var logger = {
   }
 };
 
-// src/ui/spinner.ts
-import ora from "ora";
-function createSpinner(text) {
-  return ora({
-    text,
-    spinner: "dots"
-  });
-}
-async function withSpinner(text, fn, successText) {
-  const spinner = createSpinner(text).start();
-  try {
-    const result = await fn();
-    spinner.succeed(successText || text);
-    return result;
-  } catch (error) {
-    spinner.fail();
-    throw error;
-  }
-}
-
-// src/config/index.ts
-var { machineIdSync } = nodeMachineId;
-var CONFIG_FILE = path.join(os.homedir(), ".lftrc");
-var ALGORITHM = "aes-256-gcm";
-function getEncryptionKey() {
-  const machineId = machineIdSync();
-  return createHash("sha256").update(machineId + "lft-secret").digest();
-}
-function encryptConfig(config) {
-  const key = getEncryptionKey();
-  const iv = randomBytes(16);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  let encrypted = cipher.update(JSON.stringify(config), "utf8", "hex");
-  encrypted += cipher.final("hex");
-  const authTag = cipher.getAuthTag();
-  return JSON.stringify({
-    iv: iv.toString("hex"),
-    tag: authTag.toString("hex"),
-    data: encrypted
-  });
-}
-function decryptConfig(encrypted) {
-  const { iv, tag, data } = JSON.parse(encrypted);
-  const key = getEncryptionKey();
-  const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(iv, "hex"));
-  decipher.setAuthTag(Buffer.from(tag, "hex"));
-  let decrypted = decipher.update(data, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return JSON.parse(decrypted);
-}
-var ENV_VARS = {
-  GITHUB_TOKEN: "LFT_GITHUB_TOKEN",
-  GITHUB_USERNAME: "LFT_GITHUB_USERNAME",
-  GITHUB_ORG: "LFT_GITHUB_ORG",
-  SUPABASE_TOKEN: "LFT_SUPABASE_TOKEN",
-  SUPABASE_ORG_ID: "LFT_SUPABASE_ORG_ID",
-  SUPABASE_REGION: "LFT_SUPABASE_REGION",
-  JIRA_EMAIL: "LFT_JIRA_EMAIL",
-  JIRA_TOKEN: "LFT_JIRA_TOKEN",
-  JIRA_DOMAIN: "LFT_JIRA_DOMAIN"
-};
-function loadConfigFromEnv() {
-  const githubToken = process.env[ENV_VARS.GITHUB_TOKEN];
-  const githubUsername = process.env[ENV_VARS.GITHUB_USERNAME];
-  const supabaseToken = process.env[ENV_VARS.SUPABASE_TOKEN];
-  const supabaseOrgId = process.env[ENV_VARS.SUPABASE_ORG_ID];
-  const jiraEmail = process.env[ENV_VARS.JIRA_EMAIL];
-  const jiraToken = process.env[ENV_VARS.JIRA_TOKEN];
-  const jiraDomain = process.env[ENV_VARS.JIRA_DOMAIN];
-  if (!githubToken || !supabaseToken || !jiraToken) {
-    return null;
-  }
-  return {
-    version: "1.0.0",
-    credentials: {
-      github: {
-        token: githubToken,
-        username: githubUsername || ""
-      },
-      supabase: {
-        accessToken: supabaseToken,
-        organizationId: supabaseOrgId || ""
-      },
-      jira: {
-        email: jiraEmail || "",
-        apiToken: jiraToken,
-        domain: jiraDomain || ""
-      }
-    },
-    defaults: {
-      githubOrg: process.env[ENV_VARS.GITHUB_ORG],
-      supabaseRegion: process.env[ENV_VARS.SUPABASE_REGION] || "us-east-1",
-      jiraProjectType: "software"
-    }
-  };
-}
-function hasEnvConfig() {
-  return !!(process.env[ENV_VARS.GITHUB_TOKEN] && process.env[ENV_VARS.SUPABASE_TOKEN] && process.env[ENV_VARS.JIRA_TOKEN]);
-}
-async function hasConfig() {
-  if (hasEnvConfig()) return true;
+// src/services/github.ts
+async function createGitHubRepo(projectName, config2) {
+  const octokit = new Octokit({ auth: config2.credentials.github.token });
+  const org = config2.defaults.githubOrg;
+  const owner = org || config2.credentials.github.username;
   try {
-    await fs.access(CONFIG_FILE);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function loadConfig() {
-  const envConfig = loadConfigFromEnv();
-  if (envConfig) {
-    return envConfig;
-  }
-  const encrypted = await fs.readFile(CONFIG_FILE, "utf8");
-  return decryptConfig(encrypted);
-}
-async function saveConfig(config) {
-  const encrypted = encryptConfig(config);
-  await fs.writeFile(CONFIG_FILE, encrypted, "utf8");
-}
-async function showConfig() {
-  if (!await hasConfig()) {
-    logger.warning("No hay configuraci\xF3n guardada");
-    logger.info('Ejecuta "create-lft-app config" para configurar');
-    return;
-  }
-  const config = await loadConfig();
-  logger.newLine();
-  logger.title("Configuraci\xF3n actual:");
-  logger.newLine();
-  logger.subtitle("GitHub:");
-  logger.table([
-    { label: "Usuario", value: config.credentials.github.username },
-    { label: "Token", value: "***" + config.credentials.github.token.slice(-4) },
-    { label: "Org por defecto", value: config.defaults.githubOrg || "(ninguna)" }
-  ]);
-  logger.newLine();
-  logger.subtitle("Supabase:");
-  logger.table([
-    { label: "Org ID", value: config.credentials.supabase.organizationId },
-    { label: "Token", value: "***" + config.credentials.supabase.accessToken.slice(-4) },
-    { label: "Regi\xF3n", value: config.defaults.supabaseRegion }
-  ]);
-  logger.newLine();
-  logger.subtitle("Jira:");
-  logger.table([
-    { label: "Email", value: config.credentials.jira.email },
-    { label: "Dominio", value: config.credentials.jira.domain },
-    { label: "Token", value: "***" + config.credentials.jira.apiToken.slice(-4) }
-  ]);
-}
-async function resetConfig() {
-  if (!await hasConfig()) {
-    logger.info("No hay configuraci\xF3n para resetear");
-    return;
-  }
-  const shouldReset = await confirm({
-    message: "\xBFEst\xE1s seguro de que quieres eliminar la configuraci\xF3n?",
-    default: false
-  });
-  if (shouldReset) {
-    await fs.unlink(CONFIG_FILE);
-    logger.success("Configuraci\xF3n eliminada");
-  }
-}
-async function configureCredentials(options = {}) {
-  let config;
-  if (await hasConfig()) {
-    config = await loadConfig();
-    logger.info("Configuraci\xF3n existente encontrada. Actualizando...");
-  } else {
-    config = {
-      version: "1.0.0",
-      credentials: {
-        github: { token: "", username: "" },
-        supabase: { accessToken: "", organizationId: "" },
-        jira: { email: "", apiToken: "", domain: "" }
-      },
-      defaults: {
-        supabaseRegion: "us-east-1",
-        jiraProjectType: "software"
-      }
-    };
-  }
-  const configureAll = !options.onlyGithub && !options.onlySupabase && !options.onlyJira;
-  if (configureAll || options.onlyGithub) {
-    logger.newLine();
-    logger.title("Configuraci\xF3n de GitHub");
-    logger.subtitle("Necesitas un Personal Access Token con permisos: repo, read:org");
-    logger.link("Crear token", "https://github.com/settings/tokens/new");
-    logger.newLine();
-    const githubToken = await password({
-      message: "GitHub Personal Access Token:",
-      mask: "*"
-    });
-    const isValid = await withSpinner(
-      "Validando token de GitHub...",
-      async () => {
-        const response = await fetch("https://api.github.com/user", {
-          headers: { Authorization: `Bearer ${githubToken}` }
-        });
-        if (!response.ok) return null;
-        return response.json();
-      }
-    );
-    if (!isValid) {
-      throw new Error("Token de GitHub inv\xE1lido");
-    }
-    config.credentials.github.token = githubToken;
-    config.credentials.github.username = isValid.login;
-    logger.success(`Conectado como: ${isValid.login}`);
-    const useOrg = await confirm({
-      message: "\xBFQuieres usar una organizaci\xF3n por defecto?",
-      default: false
-    });
-    if (useOrg) {
-      config.defaults.githubOrg = await input({
-        message: "Nombre de la organizaci\xF3n:"
-      });
-    }
-  }
-  if (configureAll || options.onlySupabase) {
-    logger.newLine();
-    logger.title("Configuraci\xF3n de Supabase");
-    logger.subtitle("Necesitas un Access Token de la Management API");
-    logger.link("Crear token", "https://supabase.com/dashboard/account/tokens");
-    logger.newLine();
-    const supabaseToken = await password({
-      message: "Supabase Access Token:",
-      mask: "*"
-    });
-    const orgs = await withSpinner(
-      "Obteniendo organizaciones de Supabase...",
-      async () => {
-        const response = await fetch("https://api.supabase.com/v1/organizations", {
-          headers: { Authorization: `Bearer ${supabaseToken}` }
-        });
-        if (!response.ok) return null;
-        return response.json();
-      }
-    );
-    if (!orgs || orgs.length === 0) {
-      throw new Error("Token de Supabase inv\xE1lido o no tienes organizaciones");
-    }
-    config.credentials.supabase.accessToken = supabaseToken;
-    if (orgs.length === 1) {
-      config.credentials.supabase.organizationId = orgs[0].id;
-      logger.success(`Usando organizaci\xF3n: ${orgs[0].name}`);
-    } else {
-      const selectedOrg = await select({
-        message: "Selecciona la organizaci\xF3n:",
-        choices: orgs.map((org) => ({ name: org.name, value: org.id }))
-      });
-      config.credentials.supabase.organizationId = selectedOrg;
-    }
-    config.defaults.supabaseRegion = await select({
-      message: "Regi\xF3n por defecto:",
-      choices: [
-        { name: "US East (Virginia)", value: "us-east-1" },
-        { name: "US West (Oregon)", value: "us-west-1" },
-        { name: "EU West (Ireland)", value: "eu-west-1" },
-        { name: "AP Southeast (Singapore)", value: "ap-southeast-1" },
-        { name: "AP Northeast (Tokyo)", value: "ap-northeast-1" },
-        { name: "SA East (S\xE3o Paulo)", value: "sa-east-1" }
-      ],
-      default: "us-east-1"
-    });
-  }
-  if (configureAll || options.onlyJira) {
-    logger.newLine();
-    logger.title("Configuraci\xF3n de Jira");
-    logger.subtitle("Necesitas un API Token de Atlassian");
-    logger.link("Crear token", "https://id.atlassian.com/manage-profile/security/api-tokens");
-    logger.newLine();
-    const jiraEmail = await input({
-      message: "Email de Atlassian:"
+    const existing = await octokit.rest.repos.get({
+      owner,
+      repo: projectName
     });
-    const jiraToken = await password({
-      message: "Jira API Token:",
-      mask: "*"
-    });
-    const jiraDomain = await input({
-      message: "Dominio de Jira (ej: empresa.atlassian.net):",
-      validate: (value) => {
-        if (!value.includes(".atlassian.net")) {
-          return "El dominio debe terminar en .atlassian.net";
-        }
-        return true;
-      }
-    });
-    const isValid = await withSpinner(
-      "Validando credenciales de Jira...",
-      async () => {
-        const auth = Buffer.from(`${jiraEmail}:${jiraToken}`).toString("base64");
-        const response = await fetch(`https://${jiraDomain}/rest/api/3/myself`, {
-          headers: { Authorization: `Basic ${auth}` }
-        });
-        return response.ok;
-      }
-    );
-    if (!isValid) {
-      throw new Error("Credenciales de Jira inv\xE1lidas");
-    }
-    config.credentials.jira.email = jiraEmail;
-    config.credentials.jira.apiToken = jiraToken;
-    config.credentials.jira.domain = jiraDomain;
-    logger.success("Credenciales de Jira v\xE1lidas");
+    logger.success(`GitHub: ${owner}/${projectName} (ya existe)`);
+    return existing.data.html_url;
+  } catch {
   }
-  await saveConfig(config);
-  logger.newLine();
-  logger.success("Configuraci\xF3n guardada en ~/.lftrc");
-}
-
-// src/services/github.ts
-import { Octokit } from "octokit";
-async function createGitHubRepo(projectName, config) {
-  const octokit = new Octokit({ auth: config.credentials.github.token });
-  const org = config.defaults.githubOrg;
   return withSpinner(
     "Creando repositorio en GitHub...",
     async () => {
@@ -403,7 +168,7 @@ async function createGitHubRepo(projectName, config) {
       }
       return repo.data.html_url;
     },
-    `Repositorio creado: ${org || config.credentials.github.username}/${projectName}`
+    `GitHub: ${owner}/${projectName}`
   );
 }
 
@@ -422,7 +187,7 @@ async function waitForProjectReady(projectId, token, maxAttempts = 60) {
         return;
       }
     }
-    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 5e3));
     spinner.text = `Provisionando base de datos... (${Math.floor((i + 1) * 5 / 60)}min ${(i + 1) * 5 % 60}s)`;
   }
   spinner.fail("Timeout esperando a que el proyecto est\xE9 listo");
@@ -443,10 +208,28 @@ async function getProjectApiKeys(projectId, token) {
   }
   return { anonKey, serviceKey };
 }
-async function createSupabaseProject(projectName, config) {
-  const token = config.credentials.supabase.accessToken;
-  const orgId = config.credentials.supabase.organizationId;
-  const region = config.defaults.supabaseRegion;
+async function findExistingProject(projectName, token) {
+  const response = await fetch(`${SUPABASE_API_URL}/projects`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!response.ok) return null;
+  const projects = await response.json();
+  return projects.find((p) => p.name === projectName) || null;
+}
+async function createSupabaseProject(projectName, config2) {
+  const token = config2.credentials.supabase.accessToken;
+  const orgId = config2.credentials.supabase.organizationId;
+  const region = config2.defaults.supabaseRegion;
+  const existing = await findExistingProject(projectName, token);
+  if (existing) {
+    logger.success(`Supabase: ${projectName} (ya existe)`);
+    const { anonKey: anonKey2, serviceKey: serviceKey2 } = await getProjectApiKeys(existing.id, token);
+    return {
+      url: `https://${existing.id}.supabase.co`,
+      anonKey: anonKey2,
+      serviceKey: serviceKey2
+    };
+  }
   const dbPassword = generateSecurePassword();
   const project = await withSpinner(
     "Creando proyecto en Supabase...",
@@ -483,16 +266,14 @@ async function createSupabaseProject(projectName, config) {
 }
 function generateSecurePassword() {
   const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*";
-  let password2 = "";
+  let password = "";
   for (let i = 0; i < 32; i++) {
-    password2 += chars.charAt(Math.floor(Math.random() * chars.length));
+    password += chars.charAt(Math.floor(Math.random() * chars.length));
   }
-  return password2;
+  return password;
 }
 
 // src/utils/validation.ts
-import fs2 from "fs";
-import path2 from "path";
 function validateProjectName(name) {
   if (!name || name.trim() === "") {
     return { valid: false, error: "El nombre del proyecto no puede estar vac\xEDo" };
@@ -516,10 +297,6 @@ function validateProjectName(name) {
   if (name.length > 50) {
     return { valid: false, error: "El nombre no puede tener m\xE1s de 50 caracteres" };
   }
-  const projectPath = path2.resolve(process.cwd(), name);
-  if (fs2.existsSync(projectPath)) {
-    return { valid: false, error: `El directorio "${name}" ya existe` };
-  }
   return { valid: true };
 }
 function generateJiraKey(projectName) {
@@ -528,10 +305,29 @@ function generateJiraKey(projectName) {
 }
 
 // src/services/jira.ts
-async function createJiraProject(projectName, config) {
-  const { email, apiToken, domain } = config.credentials.jira;
+async function findExistingJiraProject(projectName, auth, domain) {
+  const response = await fetch(
+    `https://${domain}/rest/api/3/project/search?query=${encodeURIComponent(projectName)}`,
+    {
+      headers: {
+        Authorization: `Basic ${auth}`,
+        "Content-Type": "application/json"
+      }
+    }
+  );
+  if (!response.ok) return null;
+  const data = await response.json();
+  return data.values.find((p) => p.name === projectName) || null;
+}
+async function createJiraProject(projectName, config2) {
+  const { email, apiToken, domain } = config2.credentials.jira;
   const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
   const projectKey = generateJiraKey(projectName);
+  const existing = await findExistingJiraProject(projectName, auth, domain);
+  if (existing) {
+    logger.success(`Jira: ${existing.key} (ya existe)`);
+    return `https://${domain}/browse/${existing.key}`;
+  }
   return withSpinner(
     "Creando proyecto en Jira...",
     async () => {
@@ -588,13 +384,20 @@ async function createJiraProject(projectName, config) {
       const project = await response.json();
       return `https://${domain}/browse/${project.key}`;
     },
-    `Proyecto Jira creado: ${projectKey}`
+    `Proyecto Jira: ${projectKey}`
   );
 }
 
 // src/steps/scaffold-nextjs.ts
 import { execa } from "execa";
+import { existsSync } from "fs";
+import path from "path";
 async function scaffoldNextJs(projectName, projectPath) {
+  const targetDir = path.join(process.cwd(), projectName);
+  if (existsSync(targetDir)) {
+    logger.success(`Next.js: ${projectName} (ya existe)`);
+    return;
+  }
   await withSpinner(
     "Inicializando proyecto Next.js...",
     async () => {
@@ -609,71 +412,72 @@ async function scaffoldNextJs(projectName, projectPath) {
         "--src-dir",
         "--import-alias",
         "@/*",
-        "--use-npm"
+        "--use-npm",
+        "--yes"
       ], {
         cwd: process.cwd(),
         stdio: "pipe"
       });
     },
-    "Proyecto Next.js inicializado"
+    `Next.js: ${projectName}`
   );
 }
 
 // src/steps/copy-template.ts
 import { cp, mkdir, readFile, writeFile } from "fs/promises";
-import path3 from "path";
-import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path3.dirname(__filename2);
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = path2.dirname(__filename3);
 async function copyTemplate(projectPath) {
   await withSpinner(
     "Copiando template LFT...",
     async () => {
-      const templatesDir = path3.join(__dirname2, "..", "..", "templates");
-      const srcDir = path3.join(projectPath, "src");
+      const templatesDir = path2.join(__dirname3, "..", "..", "templates");
+      const srcDir = path2.join(projectPath, "src");
       await cp(
-        path3.join(templatesDir, "components", "ui"),
-        path3.join(srcDir, "components", "ui"),
+        path2.join(templatesDir, "components", "ui"),
+        path2.join(srcDir, "components", "ui"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "components", "layout"),
-        path3.join(srcDir, "components", "layout"),
+        path2.join(templatesDir, "components", "layout"),
+        path2.join(srcDir, "components", "layout"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "components", "dashboard"),
-        path3.join(srcDir, "components", "dashboard"),
+        path2.join(templatesDir, "components", "dashboard"),
+        path2.join(srcDir, "components", "dashboard"),
         { recursive: true }
       );
-      await mkdir(path3.join(srcDir, "lib"), { recursive: true });
+      await mkdir(path2.join(srcDir, "lib"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "lib", "utils.ts"),
-        path3.join(srcDir, "lib", "utils.ts")
+        path2.join(templatesDir, "lib", "utils.ts"),
+        path2.join(srcDir, "lib", "utils.ts")
       );
-      await mkdir(path3.join(srcDir, "hooks"), { recursive: true });
+      await mkdir(path2.join(srcDir, "hooks"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "hooks"),
-        path3.join(srcDir, "hooks"),
+        path2.join(templatesDir, "hooks"),
+        path2.join(srcDir, "hooks"),
         { recursive: true }
       );
       await cp(
-        path3.join(templatesDir, "app", "layout.tsx"),
-        path3.join(srcDir, "app", "layout.tsx")
+        path2.join(templatesDir, "app", "layout.tsx"),
+        path2.join(srcDir, "app", "layout.tsx")
       );
       await cp(
-        path3.join(templatesDir, "app", "page.tsx"),
-        path3.join(srcDir, "app", "page.tsx")
+        path2.join(templatesDir, "app", "page.tsx"),
+        path2.join(srcDir, "app", "page.tsx")
       );
-      await mkdir(path3.join(srcDir, "app", "dashboard"), { recursive: true });
+      await mkdir(path2.join(srcDir, "app", "dashboard"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "app", "dashboard", "page.tsx"),
-        path3.join(srcDir, "app", "dashboard", "page.tsx")
+        path2.join(templatesDir, "app", "dashboard", "page.tsx"),
+        path2.join(srcDir, "app", "dashboard", "page.tsx")
       );
-      await mkdir(path3.join(srcDir, "app", "auth", "login"), { recursive: true });
+      await mkdir(path2.join(srcDir, "app", "auth", "login"), { recursive: true });
       await cp(
-        path3.join(templatesDir, "app", "auth", "login", "page.tsx"),
-        path3.join(srcDir, "app", "auth", "login", "page.tsx")
+        path2.join(templatesDir, "app", "auth", "login", "page.tsx"),
+        path2.join(srcDir, "app", "auth", "login", "page.tsx")
       );
       await mergeGlobalStyles(projectPath, templatesDir);
     },
@@ -681,8 +485,8 @@ async function copyTemplate(projectPath) {
   );
 }
 async function mergeGlobalStyles(projectPath, templatesDir) {
-  const templateCssPath = path3.join(templatesDir, "app", "globals.css");
-  const projectCssPath = path3.join(projectPath, "src", "app", "globals.css");
+  const templateCssPath = path2.join(templatesDir, "app", "globals.css");
+  const projectCssPath = path2.join(projectPath, "src", "app", "globals.css");
   try {
     const templateCss = await readFile(templateCssPath, "utf-8");
     const existingCss = await readFile(projectCssPath, "utf-8");
@@ -759,7 +563,7 @@ async function installDependencies(projectPath) {
 
 // src/steps/create-env.ts
 import { writeFile as writeFile2, readFile as readFile2, appendFile } from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 async function createEnvFile(projectPath, supabaseKeys) {
   await withSpinner(
     "Creando archivo .env.local...",
@@ -770,10 +574,10 @@ NEXT_PUBLIC_SUPABASE_ANON_KEY=${supabaseKeys.anonKey}
 SUPABASE_SERVICE_ROLE_KEY=${supabaseKeys.serviceKey}
 `;
       await writeFile2(
-        path4.join(projectPath, ".env.local"),
+        path3.join(projectPath, ".env.local"),
         envContent
       );
-      const gitignorePath = path4.join(projectPath, ".gitignore");
+      const gitignorePath = path3.join(projectPath, ".gitignore");
       try {
         const gitignore = await readFile2(gitignorePath, "utf-8");
         if (!gitignore.includes(".env.local")) {
@@ -871,30 +675,30 @@ async function createProject(projectName, options = {}) {
   if (!validation.valid) {
     throw new Error(validation.error);
   }
-  const projectPath = path5.resolve(process.cwd(), projectName);
+  const projectPath = path4.resolve(process.cwd(), projectName);
   if (!await hasConfig()) {
     logger.warning('No se encontr\xF3 configuraci\xF3n. Ejecuta "create-lft-app config" primero.');
     throw new Error("Configuraci\xF3n no encontrada");
   }
-  const config = await loadConfig();
+  const config2 = await loadConfig();
   logger.newLine();
   logger.title("Resumen de recursos a crear:");
   logger.newLine();
   const resources = [];
   if (!options.skipGithub) {
-    resources.push({ label: "GitHub", value: `${config.defaults.githubOrg || config.credentials.github.username}/${projectName} (privado)` });
+    resources.push({ label: "GitHub", value: `${config2.defaults.githubOrg || config2.credentials.github.username}/${projectName} (privado)` });
   }
   if (!options.skipSupabase) {
-    resources.push({ label: "Supabase", value: `${projectName} en ${config.defaults.supabaseRegion}` });
+    resources.push({ label: "Supabase", value: `${projectName} en ${config2.defaults.supabaseRegion}` });
   }
   if (!options.skipJira) {
-    resources.push({ label: "Jira", value: `Proyecto "${projectName}" en ${config.credentials.jira.domain}` });
+    resources.push({ label: "Jira", value: `Proyecto "${projectName}" en ${config2.credentials.jira.domain}` });
   }
   resources.push({ label: "Next.js", value: "App Router + TypeScript + Tailwind + Dashboard" });
   logger.table(resources);
   logger.newLine();
   if (!options.autoConfirm) {
-    const shouldContinue = await confirm2({
+    const shouldContinue = await confirm({
       message: "\xBFContinuar con la creaci\xF3n?",
       default: true
     });
@@ -911,14 +715,14 @@ async function createProject(projectName, options = {}) {
   const externalTasks = [];
   if (!options.skipGithub) {
     externalTasks.push(
-      createGitHubRepo(projectName, config).then((url) => {
+      createGitHubRepo(projectName, config2).then((url) => {
         urls.github = url;
       })
     );
   }
   if (!options.skipSupabase) {
     externalTasks.push(
-      createSupabaseProject(projectName, config).then((result) => {
+      createSupabaseProject(projectName, config2).then((result) => {
         urls.supabase = result.url;
         supabaseKeys = result;
       })
@@ -926,7 +730,7 @@ async function createProject(projectName, options = {}) {
   }
   if (!options.skipJira) {
     externalTasks.push(
-      createJiraProject(projectName, config).then((url) => {
+      createJiraProject(projectName, config2).then((url) => {
         urls.jira = url;
       })
     );
@@ -959,6 +763,11 @@ program.argument("[project-name]", "Nombre del proyecto a crear").option("--skip
     logger.info("Uso: create-lft-app <nombre-proyecto>");
     process.exit(1);
   }
+  if (!await hasConfig()) {
+    logger.error("Las credenciales no est\xE1n configuradas en el paquete");
+    logger.info("Contacta al administrador del CLI");
+    process.exit(1);
+  }
   try {
     await createProject(projectName, {
       skipGithub: options.skipGithub,
@@ -974,21 +783,5 @@ program.argument("[project-name]", "Nombre del proyecto a crear").option("--skip
     process.exit(1);
   }
 });
-program.command("config").description("Configurar credenciales de APIs").option("--show", "Mostrar configuraci\xF3n actual").option("--reset", "Resetear configuraci\xF3n").option("--github", "Configurar solo GitHub").option("--supabase", "Configurar solo Supabase").option("--jira", "Configurar solo Jira").action(async (options) => {
-  showBanner();
-  if (options.show) {
-    await showConfig();
-    return;
-  }
-  if (options.reset) {
-    await resetConfig();
-    return;
-  }
-  await configureCredentials({
-    onlyGithub: options.github,
-    onlySupabase: options.supabase,
-    onlyJira: options.jira
-  });
-});
 program.parse();
 //# sourceMappingURL=cli.js.map