komplian 0.4.3 → 0.4.4

package/README.md

@@ -4,7 +4,9 @@
 
 1. Install [GitHub CLI](https://cli.github.com) and **git** (one-time per machine).
 2. Browser login: `gh auth login -h github.com -s repo -s read:org -w`
-3. `npx komplian onboard --yes`
+3. `npx komplian onboard --yes` (sin `@versión`: usa `latest` del registry público).
+
+**`npm ERR! ETARGET` / “No matching version”** (también si falló **`postman`**, no solo `onboard`): es el mismo paquete npm. Usa **`npx komplian postman login`** / **`npx komplian postman --yes`** **sin** `@0.4.x`; comprueba `npm config get registry` → `https://registry.npmjs.org/`; `npm cache clean --force`. Detalle: `ONBOARDING.md` en el monorepo.
 
 ### Postman (colección + entornos)
 

package/komplian-localhost.mjs

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+/**
+ * Komplian localhost — genera `.env.local` con secretos aleatorios (crypto) y arranca
+ * api, app, web, admin, docs en paralelo (concurrently).
+ *
+ * Seguridad: nada se commitea; secretos solo en disco local (.env*.local / .komplian/).
+ * No imprime valores de claves.
+ *
+ * Uso:
+ *   npx komplian localhost --yes
+ *   npx komplian localhost --yes --minimal          # solo app + web + docs (sin DB real)
+ *   npx komplian localhost --env-only --force       # solo escribir env
+ *
+ * URLs de Neon (opcional, una o tres):
+ *   KOMPLIAN_LOCALHOST_DATABASE_URL                 # misma para app/admin/web/api
+ *   KOMPLIAN_LOCALHOST_APP_DATABASE_URL
+ *   KOMPLIAN_LOCALHOST_ADMIN_DATABASE_URL
+ *   KOMPLIAN_LOCALHOST_WEB_DATABASE_URL
+ * O archivo (gitignored): komplian-localhost.secrets.env o .komplian/localhost-secrets.env
+ */
+
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const c = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  bold: "\x1b[1m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+};
+
+function log(s = "") {
+  console.log(s);
+}
+
+const PLACEHOLDER_DB =
+  "postgresql://127.0.0.1:5432/komplian_localhost_placeholder?sslmode=disable";
+
+function rndHex(n = 32) {
+  return randomBytes(n).toString("hex");
+}
+
+function parseEnvFile(content) {
+  const out = {};
+  for (const line of content.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t || t.startsWith("#")) continue;
+    const eq = t.indexOf("=");
+    if (eq === -1) continue;
+    const key = t.slice(0, eq).trim();
+    let val = t.slice(eq + 1).trim();
+    if (
+      (val.startsWith('"') && val.endsWith('"')) ||
+      (val.startsWith("'") && val.endsWith("'"))
+    ) {
+      val = val.slice(1, -1);
+    }
+    out[key] = val;
+  }
+  return out;
+}
+
+function loadSecretsFromDisk(workspaceRoot) {
+  const paths = [
+    join(workspaceRoot, "komplian-localhost.secrets.env"),
+    join(workspaceRoot, ".komplian", "localhost-secrets.env"),
+  ];
+  for (const p of paths) {
+    if (!existsSync(p)) continue;
+    try {
+      return parseEnvFile(readFileSync(p, "utf8"));
+    } catch {
+      /* ignore */
+    }
+  }
+  return {};
+}
+
+function resolveDatabaseUrls(workspaceRoot) {
+  const file = loadSecretsFromDisk(workspaceRoot);
+  const single =
+    process.env.KOMPLIAN_LOCALHOST_DATABASE_URL?.trim() ||
+    file.KOMPLIAN_LOCALHOST_DATABASE_URL?.trim();
+  const app =
+    process.env.KOMPLIAN_LOCALHOST_APP_DATABASE_URL?.trim() ||
+    file.KOMPLIAN_LOCALHOST_APP_DATABASE_URL?.trim() ||
+    single;
+  const admin =
+    process.env.KOMPLIAN_LOCALHOST_ADMIN_DATABASE_URL?.trim() ||
+    file.KOMPLIAN_LOCALHOST_ADMIN_DATABASE_URL?.trim() ||
+    single;
+  const web =
+    process.env.KOMPLIAN_LOCALHOST_WEB_DATABASE_URL?.trim() ||
+    file.KOMPLIAN_LOCALHOST_WEB_DATABASE_URL?.trim() ||
+    single;
+  const hasReal =
+    !!(app && admin && web) &&
+    !String(app).includes("komplian_localhost_placeholder");
+  return { app, admin, web, apiApp: app, apiAdmin: admin, apiWeb: web, hasReal };
+}
+
+function writeAtomic(path, content) {
+  writeFileSync(path, content, { encoding: "utf8", mode: 0o600 });
+  try {
+    if (process.platform !== "win32") chmodSync(path, 0o600);
+  } catch {
+    /* ignore */
+  }
+}
+
+function findWorkspaceRoot(start) {
+  let dir = resolve(start);
+  for (let i = 0; i < 8; i++) {
+    if (
+      existsSync(join(dir, "api", "package.json")) &&
+      existsSync(join(dir, "app", "package.json"))
+    ) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(start);
+}
+
+function buildShared() {
+  const apiKey = rndHex(32);
+  const adminApiKey = rndHex(32);
+  return {
+    apiKey,
+    adminApiKey,
+    jwtSecret: rndHex(32),
+    encryptionKey: rndHex(32),
+    nextAuthSecret: rndHex(32),
+    csrfSecret: rndHex(32),
+    cronSecret: rndHex(32),
+    internalWebhook: rndHex(32),
+    twoFactorEnc: rndHex(32),
+    hashSecret: rndHex(32),
+    nextAuthAdmin: rndHex(32),
+  };
+}
+
+function header(project) {
+  return `# Generated by komplian localhost — do not commit (${project})
+# Regenerate: npx komplian localhost --yes --force
+
+`;
+}
+
+function writeAppEnv(root, s, db, opts) {
+  const p = join(root, "app", ".env.local");
+  if (existsSync(p) && !opts.force) return { path: p, skipped: true };
+  const useNoDb = opts.minimal || !db.app || db.app.includes("placeholder");
+  const lines = [
+    header("app"),
+    useNoDb ? "DEV_MODE_NO_DB=true" : "DEV_MODE_NO_DB=",
+    "",
+    `DATABASE_URL=${db.app || PLACEHOLDER_DB}`,
+    `NEXTAUTH_URL=http://localhost:3001`,
+    `NEXTAUTH_SECRET=${s.nextAuthSecret}`,
+    `AUTH_SECRET=${s.nextAuthSecret}`,
+    `CSRF_SECRET=${s.csrfSecret}`,
+    "",
+    `NEXT_PUBLIC_APP_URL=http://localhost:3001`,
+    `NEXT_PUBLIC_API_URL=http://localhost:4000`,
+    "",
+    `KOMPLIAN_API_URL=http://localhost:4000`,
+    `KOMPLIAN_API_KEY=${s.apiKey}`,
+    `KOMPLIAN_INTERNAL_WEBHOOK_SECRET=${s.internalWebhook}`,
+    "",
+    `ENCRYPTION_KEY=${s.encryptionKey}`,
+    `TWO_FACTOR_ENCRYPTION_KEY=${s.twoFactorEnc}`,
+    `HASH_SECRET=${s.hashSecret}`,
+    "",
+    "# Optional: OPENAI_API_KEY=  Stripe, Shopify, Google OAuth — ver app/.env.example",
+  ];
+  writeAtomic(p, lines.join("\n"));
+  return { path: p, skipped: false };
+}
+
+function writeApiEnv(root, s, db, opts) {
+  const p = join(root, "api", ".env.local");
+  if (existsSync(p) && !opts.force) return { path: p, skipped: true };
+  const appU = db.apiApp || PLACEHOLDER_DB;
+  const adminU = db.apiAdmin || PLACEHOLDER_DB;
+  const webU = db.apiWeb || PLACEHOLDER_DB;
+  const lines = [
+    header("api"),
+    `APP_DATABASE_URL=${appU}`,
+    `ADMIN_DATABASE_URL=${adminU}`,
+    `WEB_DATABASE_URL=${webU}`,
+    "",
+    `API_KEY=${s.apiKey}`,
+    `ADMIN_API_KEY=${s.adminApiKey}`,
+    `KOMPLIAN_INTERNAL_WEBHOOK_SECRET=${s.internalWebhook}`,
+    `JWT_SECRET=${s.jwtSecret}`,
+    `ENCRYPTION_KEY=${s.encryptionKey}`,
+    "",
+    "# OPENAI_API_KEY=  RESEND_API_KEY=  — ver api/.env.example",
+    "",
+    `CRON_SECRET=${s.cronSecret}`,
+    "",
+    `APP_URL=http://localhost:3001`,
+    `WEB_URL=http://localhost:3003`,
+    `ADMIN_URL=http://localhost:3002`,
+    `API_BASE_URL=http://localhost:4000`,
+    "",
+    `PORT=4000`,
+    `NODE_ENV=development`,
+    `LOG_LEVEL=debug`,
+  ];
+  writeAtomic(p, lines.join("\n"));
+  return { path: p, skipped: false };
+}
+
+function writeWebEnv(root, s, db, opts) {
+  const p = join(root, "web", ".env.local");
+  if (existsSync(p) && !opts.force) return { path: p, skipped: true };
+  const lines = [
+    header("web"),
+    `DATABASE_URL=${db.web || PLACEHOLDER_DB}`,
+    `KOMPLIAN_API_URL=http://localhost:4000`,
+    `KOMPLIAN_API_KEY=${s.apiKey}`,
+    "",
+    "# GMAIL_USER= GMAIL_PASS= — opcional",
+  ];
+  writeAtomic(p, lines.join("\n"));
+  return { path: p, skipped: false };
+}
+
+function writeAdminEnv(root, s, db, opts) {
+  const p = join(root, "admin", ".env.local");
+  if (existsSync(p) && !opts.force) return { path: p, skipped: true };
+  const lines = [
+    header("admin"),
+    `DATABASE_URL=${db.admin || PLACEHOLDER_DB}`,
+    `NEXTAUTH_URL=http://localhost:3002`,
+    `NEXTAUTH_SECRET=${s.nextAuthAdmin}`,
+    `AUTH_SECRET=${s.nextAuthAdmin}`,
+    `API_URL=http://localhost:4000`,
+    `ADMIN_API_KEY=${s.adminApiKey}`,
+  ];
+  writeAtomic(p, lines.join("\n"));
+  return { path: p, skipped: false };
+}
+
+function writeDocsEnv(root, opts) {
+  const p = join(root, "docs", ".env.local");
+  if (existsSync(p) && !opts.force) return { path: p, skipped: true };
+  const lines = [
+    header("docs"),
+    "# Vacío: docs no requiere secretos para next dev local",
+  ];
+  writeAtomic(p, lines.join("\n"));
+  return { path: p, skipped: false };
+}
+
+async function confirmOverwrite(yes) {
+  if (yes) return true;
+  const rl = createInterface({ input, output });
+  const ans = await rl.question(
+    `\n${c.bold}Sobrescribir .env.local existentes? [y/N]${c.reset} `
+  );
+  rl.close();
+  return /^y(es)?$/i.test((ans || "").trim());
+}
+
+function parseLocalhostArgs(argv) {
+  const opts = {
+    yes: false,
+    force: false,
+    envOnly: false,
+    workspace: "",
+    minimal: false,
+    help: false,
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") opts.yes = true;
+    else if (a === "--force") opts.force = true;
+    else if (a === "--env-only") opts.envOnly = true;
+    else if (a === "--minimal") opts.minimal = true;
+    else if (a === "-h" || a === "--help") opts.help = true;
+    else if (a === "--workspace" || a === "-w") opts.workspace = argv[++i] || "";
+    else if (a.startsWith("-")) {
+      log(`${c.red}✗${c.reset} Opción desconocida: ${a}`);
+      process.exit(1);
+    } else rest.push(a);
+  }
+  if (rest[0]) opts.workspace = rest[0];
+  return opts;
+}
+
+function usageLocalhost() {
+  log(`Uso: npx komplian localhost [opciones] [carpeta-monorepo]`);
+  log(``);
+  log(`  Genera .env.local por proyecto (secretos aleatorios) y ejecuta npm run dev en paralelo.`);
+  log(`  ${c.dim}Neon: export KOMPLIAN_LOCALHOST_DATABASE_URL=… o komplian-localhost.secrets.env${c.reset}`);
+  log(``);
+  log(`  -y, --yes       Sin confirmación interactiva`);
+  log(`  --force         Sobrescribir .env.local aunque existan`);
+  log(`  --minimal       Solo app + web + docs (omitir api y admin)`);
+  log(`  --env-only      Solo escribir env, no arrancar servidores`);
+  log(`  -w, --workspace Ruta al monorepo (por defecto: cwd)`);
+  log(`  -h, --help`);
+}
+
+function checkNodeModules(root, names) {
+  const missing = [];
+  for (const n of names) {
+    if (!existsSync(join(root, n, "node_modules"))) missing.push(n);
+  }
+  return missing;
+}
+
+export async function runLocalhost(argv) {
+  const opts = parseLocalhostArgs(argv);
+  if (opts.help) {
+    usageLocalhost();
+    return;
+  }
+
+  let workspaceRoot = opts.workspace.trim()
+    ? resolve(opts.workspace.replace(/^~(?=$|[/\\])/, process.env.HOME || ""))
+    : findWorkspaceRoot(process.cwd());
+
+  if (!existsSync(join(workspaceRoot, "api", "package.json"))) {
+    log(`${c.red}✗${c.reset} No parece un monorepo Komplian (falta api/package.json): ${workspaceRoot}`);
+    process.exit(1);
+  }
+
+  const db = resolveDatabaseUrls(workspaceRoot);
+  const dbForWrites = {
+    app: db.app || PLACEHOLDER_DB,
+    admin: db.admin || PLACEHOLDER_DB,
+    web: db.web || PLACEHOLDER_DB,
+    apiApp: db.apiApp || PLACEHOLDER_DB,
+    apiAdmin: db.apiAdmin || PLACEHOLDER_DB,
+    apiWeb: db.apiWeb || PLACEHOLDER_DB,
+  };
+
+  const hasAnyEnv = [
+    "app",
+    "api",
+    "web",
+    "admin",
+    "docs",
+  ].some((name) => existsSync(join(workspaceRoot, name, ".env.local")));
+
+  if (hasAnyEnv && !opts.force) {
+    const ok = await confirmOverwrite(opts.yes);
+    if (!ok) {
+      log(`${c.yellow}○${c.reset} Cancelado. Usa ${c.bold}--force${c.reset} para regenerar.`);
+      return;
+    }
+    opts.force = true;
+  }
+
+  const s = buildShared();
+
+  const written = [];
+  written.push(writeAppEnv(workspaceRoot, s, dbForWrites, opts));
+  if (!opts.minimal) {
+    written.push(writeApiEnv(workspaceRoot, s, dbForWrites, opts));
+    written.push(writeWebEnv(workspaceRoot, s, dbForWrites, opts));
+    written.push(writeAdminEnv(workspaceRoot, s, dbForWrites, opts));
+  } else {
+    written.push(writeWebEnv(workspaceRoot, s, dbForWrites, opts));
+  }
+  written.push(writeDocsEnv(workspaceRoot, opts));
+
+  log("");
+  log(`${c.cyan}━━ .env.local ━━${c.reset} ${c.dim}(permisos 600)${c.reset}`);
+  for (const w of written) {
+    const st = w.skipped ? `${c.dim}sin cambios${c.reset}` : `${c.green}ok${c.reset}`;
+    log(`  ${st} ${w.path}`);
+  }
+
+  if (!db.hasReal && !opts.minimal) {
+    log("");
+    log(`${c.yellow}⚠${c.reset} Sin URLs Neon reales: api/admin/web usarán un placeholder local.`);
+    log(`  ${c.dim}Define KOMPLIAN_LOCALHOST_DATABASE_URL o komplian-localhost.secrets.env${c.reset}`);
+    log(`  ${c.dim}O usa ${c.bold}--minimal${c.reset} para solo app + web + docs.${c.reset}`);
+  }
+
+  if (opts.envOnly) {
+    log("");
+    log(`${c.green}✓${c.reset} Solo entorno. Arranca con: ${c.bold}npx komplian localhost --yes${c.reset}`);
+    return;
+  }
+
+  const services = opts.minimal
+    ? ["app", "web", "docs"]
+    : ["api", "app", "web", "admin", "docs"];
+  const missing = checkNodeModules(workspaceRoot, services);
+  if (missing.length) {
+    log("");
+    log(`${c.red}✗${c.reset} Falta node_modules en: ${missing.join(", ")}`);
+    log(`  ${c.dim}Ejecuta npm install en cada carpeta (o npx komplian onboard --yes --install).${c.reset}`);
+    process.exit(1);
+  }
+
+  const colors = "blue,green,cyan,magenta,yellow";
+  const names = services.join(",");
+  const scripts = services.map((name) => {
+    const dir = join(workspaceRoot, name);
+    if (/[\s"]/.test(dir)) {
+      return `npm run dev --prefix "${dir.replace(/"/g, '\\"')}"`;
+    }
+    return `npm run dev --prefix ${dir}`;
+  });
+
+  log("");
+  log(`${c.cyan}━━ Servicios (${services.length}) ━━${c.reset} ${workspaceRoot}`);
+  log(`${c.dim}Ctrl+C detiene todos.${c.reset}`);
+  log("");
+
+  const child = spawn(
+    process.platform === "win32" ? "npx.cmd" : "npx",
+    ["--yes", "concurrently@9", "-c", colors, "-n", names, ...scripts],
+    {
+      cwd: workspaceRoot,
+      stdio: "inherit",
+      shell: true,
+      env: { ...process.env },
+    }
+  );
+
+  const killAll = () => {
+    try {
+      child.kill("SIGINT");
+    } catch {
+      /* ignore */
+    }
+  };
+  process.on("SIGINT", () => {
+    killAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", killAll);
+
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}

package/komplian-onboard.mjs

@@ -394,10 +394,11 @@ function npmInstallEach(workspace) {
 }
 
 function usage() {
-  log(`Uso: komplian onboard [opciones] [carpeta]  |  komplian postman [opciones]`);
+  log(`Uso: komplian onboard [opciones] [carpeta]  |  komplian postman [opciones]  |  komplian localhost [opciones]`);
   log(`  npx komplian onboard --yes`);
   log(`  npx komplian postman login   ${c.dim}(una vez · guarda API key)${c.reset}`);
   log(`  npx komplian postman --yes    ${c.dim}(email @komplian.com)${c.reset}`);
+  log(`  npx komplian localhost --yes  ${c.dim}(env local + api app web admin docs)${c.reset}`);
   log(``);
   log(`  Antes (una vez): gh auth login -h github.com -s repo -s read:org -w`);
   log(`  Requisitos: Node 18+, git, GitHub CLI (gh)`);
@@ -486,6 +487,11 @@ async function main() {
     await runPostman(rawArgv.slice(1));
     return;
   }
+  if (rawArgv[0] === "localhost") {
+    const { runLocalhost } = await import("./komplian-localhost.mjs");
+    await runLocalhost(rawArgv.slice(1));
+    return;
+  }
 
   const configPath = join(__dirname, "komplian-team-repos.json");
   const { argv, fromOnboardSubcommand } = normalizeArgv(rawArgv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "komplian",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Komplian developer workspace: GitHub clone (onboard) + Postman collection/environments (postman). Node 18+.",
   "type": "module",
   "engines": {
@@ -12,6 +12,7 @@
   "files": [
     "komplian-onboard.mjs",
     "komplian-postman.mjs",
+    "komplian-localhost.mjs",
     "komplian-team-repos.json",
     "README.md"
   ],
@@ -19,7 +20,7 @@
     "access": "public"
   },
   "scripts": {
-    "prepublishOnly": "node --check komplian-onboard.mjs && node --check komplian-postman.mjs"
+    "prepublishOnly": "node --check komplian-onboard.mjs && node --check komplian-postman.mjs && node --check komplian-localhost.mjs"
   },
   "keywords": [
     "komplian",