@wallavi/vercel-build 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1011 @@
+#!/usr/bin/env node
+'use strict';
+
+var crypto = require('crypto');
+var fs = require('fs');
+var path3 = require('path');
+var zod = require('zod');
+var child_process = require('child_process');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var API_VERCEL_URL = "https://api.vercel.com";
+var LIMITE_PAGINA_VERCEL = 100;
+var MAX_PAGINAS_VERCEL = 1e3;
+var ESTADOS_DEPLOYMENT = [
+  "BUILDING",
+  "ERROR",
+  "INITIALIZING",
+  "QUEUED",
+  "READY",
+  "CANCELED"
+];
+var ErrorContratoVercel = class extends Error {
+  constructor(mensaje) {
+    super(mensaje);
+    this.name = "ErrorContratoVercel";
+  }
+};
+var ErrorRedVercel = class extends Error {
+  estado;
+  constructor(mensaje, estado) {
+    super(mensaje);
+    this.name = "ErrorRedVercel";
+    if (estado !== void 0) this.estado = estado;
+  }
+};
+var esquemaPaginacion = zod.z.object({
+  count: zod.z.number().int().nonnegative(),
+  next: zod.z.number().finite().nullable(),
+  prev: zod.z.number().finite().nullable()
+}).passthrough();
+var esquemaEquipo = zod.z.object({
+  id: zod.z.string().regex(/^team_.+/),
+  slug: zod.z.string().min(1)
+}).passthrough();
+var esquemaPaginaTeams = zod.z.object({
+  teams: zod.z.array(esquemaEquipo),
+  pagination: esquemaPaginacion
+}).passthrough();
+var esquemaEstadoDeployment = zod.z.enum(ESTADOS_DEPLOYMENT);
+var esquemaDeployment = zod.z.object({
+  uid: zod.z.string().min(1),
+  name: zod.z.string().min(1),
+  createdAt: zod.z.number().finite(),
+  state: esquemaEstadoDeployment.optional(),
+  readyState: esquemaEstadoDeployment.optional(),
+  buildingAt: zod.z.number().finite().optional(),
+  ready: zod.z.number().finite().optional()
+}).passthrough().refine((d) => d.state !== void 0 || d.readyState !== void 0, {
+  message: "cada deployment debe incluir state o readyState"
+});
+var esquemaPaginaDeployments = zod.z.object({
+  deployments: zod.z.array(esquemaDeployment),
+  pagination: esquemaPaginacion
+}).passthrough();
+var esquemaArchivoDeployments = zod.z.object({
+  paginas: zod.z.array(esquemaPaginaDeployments).min(1)
+}).passthrough();
+var SCRIPT_FETCH = [
+  "const [u] = process.argv.slice(1), h = require('node:fs').readFileSync(0, 'utf8');",
+  "fetch(u, { method: 'GET', headers: JSON.parse(h) })",
+  "  .then(async (r) => process.stdout.write(JSON.stringify({ estado: r.status, cuerpo: await r.text() })))",
+  "  .catch((e) => { process.stderr.write(String(e?.message || e)); process.exit(1); });"
+].join("\n");
+var solicitarVercel = (url, headers) => {
+  const r = child_process.spawnSync(process.execPath, ["-e", SCRIPT_FETCH, url], {
+    input: JSON.stringify(headers),
+    shell: false,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (r.error || r.status !== 0) {
+    throw new ErrorRedVercel(
+      r.error?.message ?? (r.stderr.trim() || `fallo de red en ${url}`)
+    );
+  }
+  return JSON.parse(r.stdout);
+};
+function pedirJsonVercel(rutaQuery, token, solicitar = solicitarVercel, baseUrl = API_VERCEL_URL) {
+  let respuesta;
+  try {
+    respuesta = solicitar(`${baseUrl}${rutaQuery}`, {
+      Authorization: `Bearer ${token}`
+    });
+  } catch (e) {
+    if (e instanceof ErrorRedVercel || e instanceof ErrorContratoVercel)
+      throw e;
+    throw new ErrorRedVercel(e.message);
+  }
+  if (respuesta.estado < 200 || respuesta.estado >= 300) {
+    throw new ErrorRedVercel(
+      `HTTP ${respuesta.estado} en GET ${rutaQuery}`,
+      respuesta.estado
+    );
+  }
+  try {
+    return { estado: respuesta.estado, valor: JSON.parse(respuesta.cuerpo) };
+  } catch (e) {
+    throw new ErrorContratoVercel(
+      `JSON inv\xE1lido en GET ${rutaQuery}: ${e.message}`
+    );
+  }
+}
+function resolverEquipo(equipo, token, solicitar = solicitarVercel, baseUrl = API_VERCEL_URL) {
+  if (/^team_.+/.test(equipo)) return equipo;
+  let until;
+  for (let pagina = 1; ; pagina++) {
+    const query = until === void 0 ? `limit=${LIMITE_PAGINA_VERCEL}` : `limit=${LIMITE_PAGINA_VERCEL}&until=${until}`;
+    const { valor } = pedirJsonVercel(
+      `/v2/teams?${query}`,
+      token,
+      solicitar,
+      baseUrl
+    );
+    const r = esquemaPaginaTeams.safeParse(valor);
+    if (!r.success) {
+      throw new ErrorContratoVercel(
+        `GET /v2/teams inv\xE1lido: ${r.error.message}`
+      );
+    }
+    const encontrado = r.data.teams.find((t) => t.slug === equipo);
+    if (encontrado) return encontrado.id;
+    const next = r.data.pagination.next;
+    if (next === null) {
+      throw new ErrorContratoVercel(`no se encontr\xF3 el equipo: ${equipo}`);
+    }
+    if (until !== void 0 && next >= until) {
+      throw new ErrorContratoVercel(`pagination.next (${next}) no decrece`);
+    }
+    if (pagina >= MAX_PAGINAS_VERCEL) {
+      throw new ErrorContratoVercel(`super\xF3 ${MAX_PAGINAS_VERCEL} p\xE1ginas`);
+    }
+    until = next;
+  }
+}
+function leerRespuestaDeployments(ruta, untilInicial) {
+  if (!fs.existsSync(ruta)) {
+    throw new ErrorContratoVercel(`no existe el archivo: ${ruta}`);
+  }
+  let crudo;
+  try {
+    crudo = JSON.parse(fs.readFileSync(ruta, "utf8"));
+  } catch (e) {
+    throw new ErrorContratoVercel(
+      `${ruta}: JSON inv\xE1lido: ${e.message}`
+    );
+  }
+  const rArchivo = esquemaArchivoDeployments.safeParse(crudo);
+  const rPagina = rArchivo.success ? null : esquemaPaginaDeployments.safeParse(crudo);
+  const paginas = rArchivo.success ? rArchivo.data.paginas : rPagina?.success ? [rPagina.data] : null;
+  if (!paginas || paginas.length > MAX_PAGINAS_VERCEL) {
+    throw new ErrorContratoVercel(
+      `${ruta}: estructura de deployments inv\xE1lida`
+    );
+  }
+  let cursorPrevio = untilInicial;
+  paginas.forEach((p, i) => {
+    const next = p.pagination.next;
+    const esUltima = i === paginas.length - 1;
+    if (!esUltima && next === null || esUltima && next !== null) {
+      throw new ErrorContratoVercel(
+        `paginaci\xF3n inconsistente en p\xE1gina ${i + 1}`
+      );
+    }
+    if (next !== null && cursorPrevio !== void 0 && next >= cursorPrevio) {
+      throw new ErrorContratoVercel(`pagination.next (${next}) no decrece`);
+    }
+    if (next !== null) cursorPrevio = next;
+  });
+  return paginas;
+}
+function calcularMinutosPorDia(paginas, desde, hasta) {
+  const dias = /* @__PURE__ */ new Map();
+  for (let t = Date.parse(`${desde}T00:00:00.000Z`); t <= Date.parse(`${hasta}T00:00:00.000Z`); t += 864e5) {
+    dias.set(new Date(t).toISOString().slice(0, 10), /* @__PURE__ */ new Map());
+  }
+  for (const pagina of paginas) {
+    for (const d of pagina.deployments) {
+      if (d.state !== "READY" && d.readyState !== "READY" || d.buildingAt === void 0 || d.ready === void 0)
+        continue;
+      const porProyecto = dias.get(
+        new Date(d.buildingAt).toISOString().slice(0, 10)
+      );
+      porProyecto?.set(
+        d.name,
+        (porProyecto.get(d.name) ?? 0) + (d.ready - d.buildingAt)
+      );
+    }
+  }
+  const r2 = (ms) => Math.round(ms / 6e4 * 100) / 100;
+  return {
+    dias: [...dias.entries()].map(([fecha, porProyecto]) => ({
+      fecha,
+      minutos: r2([...porProyecto.values()].reduce((a, b) => a + b, 0)),
+      porProyecto: Object.fromEntries(
+        [...porProyecto.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([nombre, ms]) => [nombre, r2(ms)])
+      )
+    }))
+  };
+}
+function leerArgumentosMedir(args) {
+  const f = leerFlagsCli(args, [
+    "--equipo",
+    "--desde",
+    "--hasta",
+    "--respuesta"
+  ]);
+  if (!f.ok) return f;
+  const { equipo, desde, hasta, respuesta } = f.valores;
+  if (!equipo) return { ok: false, motivo: "falta --equipo <slug|team_id>" };
+  if (!desde) return { ok: false, motivo: "falta --desde <AAAA-MM-DD>" };
+  if (!hasta) return { ok: false, motivo: "falta --hasta <AAAA-MM-DD>" };
+  const rango = rangoFechasUtc(desde, hasta);
+  if (!rango.ok) return rango;
+  return {
+    ok: true,
+    valor: { equipo, desde, hasta, ...respuesta ? { respuesta } : {} }
+  };
+}
+function ejecutarMedir(opciones) {
+  const rango = rangoFechasUtc(opciones.desde, opciones.hasta);
+  if (!rango.ok) {
+    opciones.error(`wallavi-vercel medir: ${rango.motivo}`);
+    return 2;
+  }
+  const token = opciones.env.VERCEL_TOKEN?.trim() ?? "";
+  try {
+    let paginas;
+    if (opciones.respuesta !== void 0) {
+      paginas = leerRespuestaDeployments(
+        path3__namespace.resolve(opciones.cwd, opciones.respuesta),
+        rango.until
+      );
+    } else {
+      if (!token) {
+        opciones.error("wallavi-vercel medir: falta VERCEL_TOKEN");
+        return 2;
+      }
+      const baseUrl = opciones.baseUrl ?? opciones.env.VERCEL_API_URL?.trim() ?? API_VERCEL_URL;
+      const teamId = resolverEquipo(
+        opciones.equipo,
+        token,
+        opciones.solicitar,
+        baseUrl
+      );
+      paginas = consultarDeployments({
+        teamId,
+        since: rango.since,
+        until: rango.until,
+        token,
+        solicitar: opciones.solicitar,
+        baseUrl
+      }).paginas;
+    }
+    opciones.salida(
+      JSON.stringify(
+        calcularMinutosPorDia(paginas, opciones.desde, opciones.hasta),
+        null,
+        2
+      )
+    );
+    return 0;
+  } catch (e) {
+    opciones.error(
+      `wallavi-vercel medir: ${redactarToken(e.message, token)}`
+    );
+    return e instanceof ErrorContratoVercel ? 2 : 1;
+  }
+}
+function comandoMedir(args, entorno) {
+  const leido = leerArgumentosMedir(args);
+  if (!leido.ok) {
+    entorno.error(`wallavi-vercel medir: ${leido.motivo}`);
+    return 2;
+  }
+  return ejecutarMedir({ ...entorno, ...leido.valor });
+}
+var medir = comandoMedir;
+
+// src/comandos/capturar.ts
+var ARCHIVO_DEPLOYMENTS_V6 = "deployments-v6.json";
+var ARCHIVO_CAPTURA_V6 = "captura-v6.json";
+var REFERENCIA_DEPLOYMENTS_V6 = "https://vercel.com/docs/rest-api/reference/endpoints/deployments/list-deployments";
+function redactarToken(texto, token) {
+  const limpio = token?.trim();
+  return limpio ? texto.split(limpio).join("[REDACTED]") : texto;
+}
+function validarFechaIso(fecha) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(fecha)) return null;
+  const ms = Date.parse(`${fecha}T00:00:00.000Z`);
+  return !Number.isNaN(ms) && new Date(ms).toISOString().slice(0, 10) === fecha ? ms : null;
+}
+function rangoFechasUtc(desde, hasta) {
+  const desdeMs = validarFechaIso(desde);
+  if (desdeMs === null)
+    return { ok: false, motivo: `--desde inv\xE1lida: ${desde}` };
+  const hastaMs = validarFechaIso(hasta);
+  if (hastaMs === null)
+    return { ok: false, motivo: `--hasta inv\xE1lida: ${hasta}` };
+  if (desdeMs > hastaMs) {
+    return {
+      ok: false,
+      motivo: `--desde (${desde}) posterior a --hasta (${hasta})`
+    };
+  }
+  return {
+    ok: true,
+    since: desdeMs,
+    until: Date.parse(`${hasta}T23:59:59.999Z`)
+  };
+}
+function leerFlagsCli(args, permitidas) {
+  const valores = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    const flag = permitidas.find((p) => arg === p || arg.startsWith(`${p}=`));
+    if (!flag) return { ok: false, motivo: `argumento no reconocido: ${arg}` };
+    const v = arg === flag ? args[++i] : arg.slice(flag.length + 1);
+    if (!v || v.trim() === "" || v.startsWith("-")) {
+      return { ok: false, motivo: `falta el valor de ${flag}` };
+    }
+    valores[flag.slice(2)] = v.trim();
+  }
+  return { ok: true, valores };
+}
+function consultarDeployments(opciones) {
+  const solicitar = opciones.solicitar ?? solicitarVercel;
+  const baseUrl = opciones.baseUrl ?? API_VERCEL_URL;
+  const paginas = [];
+  const pedidos = [];
+  let untilActual = opciones.until;
+  for (let pagina = 1; ; pagina++) {
+    const since = String(opciones.since);
+    const until = String(untilActual);
+    const limit = String(LIMITE_PAGINA_VERCEL);
+    const query = `teamId=${encodeURIComponent(opciones.teamId)}&since=${since}&until=${until}&limit=${limit}`;
+    const { estado, valor } = pedirJsonVercel(
+      `/v6/deployments?${query}`,
+      opciones.token,
+      solicitar,
+      baseUrl
+    );
+    const r = esquemaPaginaDeployments.safeParse(valor);
+    if (!r.success) {
+      throw new ErrorContratoVercel(
+        `GET /v6/deployments inv\xE1lido: ${r.error.message}`
+      );
+    }
+    paginas.push(r.data);
+    pedidos.push({ query: { since, until, limit }, estado });
+    const next = r.data.pagination.next;
+    if (next === null) return { paginas, pedidos };
+    if (next >= untilActual) {
+      throw new ErrorContratoVercel(`pagination.next (${next}) no decrece`);
+    }
+    if (pagina >= MAX_PAGINAS_VERCEL) {
+      throw new ErrorContratoVercel(`super\xF3 ${MAX_PAGINAS_VERCEL} p\xE1ginas`);
+    }
+    untilActual = next;
+  }
+}
+var esquemaPedidoCaptura = zod.z.object({
+  query: zod.z.object({
+    since: zod.z.string().min(1),
+    until: zod.z.string().min(1),
+    limit: zod.z.string().min(1)
+  }).strict(),
+  estado: zod.z.number().int()
+}).passthrough();
+var esquemaCapturaV6 = zod.z.object({
+  origen: zod.z.enum(["documentacion", "captura"]),
+  referencia: zod.z.string().min(1),
+  fecha: zod.z.string().min(1),
+  metodo: zod.z.literal("GET"),
+  ruta: zod.z.literal("/v6/deployments"),
+  desde: zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  hasta: zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  pedidos: zod.z.array(esquemaPedidoCaptura),
+  archivo: zod.z.string().min(1),
+  sha256: zod.z.string().regex(/^[0-9a-f]{64}$/),
+  transformaciones: zod.z.array(zod.z.string())
+}).passthrough();
+function leerArgumentosCapturar(args) {
+  const f = leerFlagsCli(args, ["--equipo", "--desde", "--hasta", "--salida"]);
+  if (!f.ok) return f;
+  const { equipo, desde, hasta, salida } = f.valores;
+  if (!equipo) return { ok: false, motivo: "falta --equipo <slug|team_id>" };
+  if (!desde) return { ok: false, motivo: "falta --desde <AAAA-MM-DD>" };
+  if (!hasta) return { ok: false, motivo: "falta --hasta <AAAA-MM-DD>" };
+  if (!salida) return { ok: false, motivo: "falta --salida <carpeta>" };
+  const rango = rangoFechasUtc(desde, hasta);
+  if (!rango.ok) return rango;
+  return { ok: true, valor: { equipo, desde, hasta, salida } };
+}
+function armarCapturaV6(opciones) {
+  const sha256 = crypto.createHash("sha256").update(opciones.contenidoDeployments, "utf8").digest("hex");
+  return {
+    origen: opciones.origen ?? "captura",
+    referencia: opciones.referencia ?? REFERENCIA_DEPLOYMENTS_V6,
+    fecha: opciones.fecha ?? (/* @__PURE__ */ new Date()).toISOString(),
+    metodo: "GET",
+    ruta: "/v6/deployments",
+    desde: opciones.desde,
+    hasta: opciones.hasta,
+    pedidos: opciones.pedidos.map((p) => ({
+      query: { ...p.query },
+      estado: p.estado
+    })),
+    archivo: ARCHIVO_DEPLOYMENTS_V6,
+    sha256,
+    transformaciones: opciones.transformaciones ?? []
+  };
+}
+function ejecutarCapturar(opciones) {
+  const rango = rangoFechasUtc(opciones.desde, opciones.hasta);
+  if (!rango.ok) {
+    opciones.error(`wallavi-vercel capturar: ${rango.motivo}`);
+    return 2;
+  }
+  const token = opciones.env.VERCEL_TOKEN?.trim() ?? "";
+  if (!token) {
+    opciones.error("wallavi-vercel capturar: falta VERCEL_TOKEN");
+    return 2;
+  }
+  try {
+    const baseUrl = opciones.baseUrl ?? opciones.env.VERCEL_API_URL?.trim() ?? API_VERCEL_URL;
+    const teamId = resolverEquipo(
+      opciones.equipo,
+      token,
+      opciones.solicitar,
+      baseUrl
+    );
+    const { paginas, pedidos } = consultarDeployments({
+      teamId,
+      since: rango.since,
+      until: rango.until,
+      token,
+      solicitar: opciones.solicitar,
+      baseUrl
+    });
+    const rutaCarpeta = path3__namespace.resolve(opciones.cwd, opciones.salida);
+    fs.mkdirSync(rutaCarpeta, { recursive: true });
+    const contenidoDeployments = `${JSON.stringify({ paginas }, null, 2)}
+`;
+    fs.writeFileSync(
+      path3__namespace.join(rutaCarpeta, ARCHIVO_DEPLOYMENTS_V6),
+      contenidoDeployments,
+      "utf8"
+    );
+    const captura = armarCapturaV6({
+      desde: opciones.desde,
+      hasta: opciones.hasta,
+      pedidos,
+      contenidoDeployments,
+      origen: opciones.origen,
+      referencia: opciones.referencia,
+      fecha: opciones.fecha,
+      transformaciones: opciones.transformaciones
+    });
+    fs.writeFileSync(
+      path3__namespace.join(rutaCarpeta, ARCHIVO_CAPTURA_V6),
+      `${JSON.stringify(captura, null, 2)}
+`,
+      "utf8"
+    );
+    opciones.salidaTexto?.(JSON.stringify(captura, null, 2));
+    return 0;
+  } catch (e) {
+    opciones.error(
+      `wallavi-vercel capturar: ${redactarToken(e.message, token)}`
+    );
+    return e instanceof ErrorContratoVercel ? 2 : 1;
+  }
+}
+function comandoCapturar(args, entorno) {
+  const leido = leerArgumentosCapturar(args);
+  if (!leido.ok) {
+    entorno.error(`wallavi-vercel capturar: ${leido.motivo}`);
+    return 2;
+  }
+  return ejecutarCapturar({
+    cwd: entorno.cwd,
+    env: entorno.env,
+    error: entorno.error,
+    salidaTexto: entorno.salida,
+    ...leido.valor
+  });
+}
+var capturar = comandoCapturar;
+var ARCHIVO_CONFIG = "vercel-build.config.json";
+function normalizarCarpeta(carpeta) {
+  let limpia = carpeta.trim();
+  while (limpia.startsWith("./")) limpia = limpia.slice(2);
+  while (limpia.length > 1 && limpia.endsWith("/"))
+    limpia = limpia.slice(0, -1);
+  return limpia === "" ? "." : limpia;
+}
+var esquemaCarpeta = zod.z.string().min(1).transform(normalizarCarpeta).refine((c) => !c.startsWith("/") && !c.split("/").includes(".."), {
+  message: "debe ser una ruta relativa a la ra\xEDz, sin .."
+});
+var esquemaProyecto = zod.z.object({
+  carpetas: zod.z.array(esquemaCarpeta),
+  carpetasExtra: zod.z.array(esquemaCarpeta).optional()
+}).strict();
+var esquemaConfig = zod.z.object({
+  ramasConPreview: zod.z.array(zod.z.string().min(1)),
+  proyectos: zod.z.record(zod.z.string().min(1), esquemaProyecto)
+}).strict();
+function configVacia() {
+  return { ramasConPreview: [], proyectos: {} };
+}
+function describirProblema(p) {
+  const ruta = p.path.join(".");
+  const llaves = p.code === "unrecognized_keys" ? p.keys.map((k) => ruta ? `${ruta}.${k}` : k).join(", ") : "";
+  return `${llaves || ruta || "(ra\xEDz)"}: ${p.message}`;
+}
+function validarConfig(valor, origen = ARCHIVO_CONFIG) {
+  const r = esquemaConfig.safeParse(valor);
+  if (!r.success) {
+    throw new Error(
+      `${origen}: ${r.error.issues.map(describirProblema).join("; ")}`
+    );
+  }
+  return r.data;
+}
+function leerConfig(ruta = ARCHIVO_CONFIG) {
+  if (!fs.existsSync(ruta)) return configVacia();
+  let valor;
+  try {
+    valor = JSON.parse(fs.readFileSync(ruta, "utf8"));
+  } catch (e) {
+    throw new Error(`${ruta}: JSON inv\xE1lido: ${e.message}`);
+  }
+  return validarConfig(valor, ruta);
+}
+function proyectoDeCarpeta(config, carpeta) {
+  const buscada = normalizarCarpeta(carpeta);
+  for (const [nombre, proyecto] of Object.entries(config.proyectos)) {
+    if (proyecto.carpetas.includes(buscada)) return { nombre, proyecto };
+  }
+  return null;
+}
+
+// src/cambios.ts
+function ejecutar(comando, args, opciones) {
+  const r = child_process.spawnSync(comando, args, {
+    cwd: opciones.cwd,
+    env: opciones.env ?? process.env,
+    shell: false,
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    stdio: opciones.heredar ? "inherit" : "pipe"
+  });
+  const fallo = r.error?.message ?? (r.signal ? `termin\xF3 por la se\xF1al ${r.signal}` : void 0);
+  return {
+    codigo: r.status,
+    salida: r.stdout ?? "",
+    error: r.stderr ?? "",
+    ...fallo ? { fallo } : {}
+  };
+}
+var incierto = (motivo) => ({
+  resultado: "incierto",
+  motivo
+});
+function salidaGit(ej, cwd, args) {
+  const r = ej("git", args, { cwd });
+  return r.codigo === 0 ? r.salida.trim() : null;
+}
+function ubicarEnRepo(carpeta, ej = ejecutar) {
+  const raiz = salidaGit(ej, carpeta, ["rev-parse", "--show-toplevel"]);
+  const prefijo = salidaGit(ej, carpeta, ["rev-parse", "--show-prefix"]);
+  if (!raiz || prefijo === null) return null;
+  return { raiz, prefijo: normalizarCarpeta(prefijo) };
+}
+function nombrePaquete(archivo) {
+  if (!fs.existsSync(archivo)) return null;
+  try {
+    const n = JSON.parse(fs.readFileSync(archivo, "utf8")).name;
+    return typeof n === "string" && n !== "" ? n : null;
+  } catch {
+    return null;
+  }
+}
+function comandoTurbo(raiz) {
+  const local = path3__namespace.join(raiz, "node_modules", ".bin", "turbo");
+  if (fs.existsSync(local)) return [local, []];
+  let version = "latest";
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path3__namespace.join(raiz, "package.json"), "utf8")
+    );
+    const decl = pkg.devDependencies?.turbo;
+    if (typeof decl === "string" && decl !== "") version = decl;
+  } catch {
+  }
+  return ["npx", ["--yes", `turbo@${version}`]];
+}
+function paquetesDeTurbo(salida) {
+  const i = salida.indexOf("{");
+  if (i === -1) return null;
+  try {
+    const p = JSON.parse(salida.slice(i)).packages;
+    return Array.isArray(p) && p.every((x) => typeof x === "string") ? p : null;
+  } catch {
+    return null;
+  }
+}
+function diffGit(ej, cwd, antes, rutas) {
+  const r = ej("git", ["diff", "--quiet", antes, "HEAD", "--", ...rutas], {
+    cwd
+  });
+  const lista = rutas.join(", ");
+  if (r.codigo === 0)
+    return { resultado: "sin-cambios", motivo: `git: sin cambios en ${lista}` };
+  if (r.codigo === 1)
+    return { resultado: "con-cambios", motivo: `git: hay cambios en ${lista}` };
+  return incierto(`git diff fall\xF3 (${r.fallo ?? `c\xF3digo ${r.codigo}`})`);
+}
+function evaluarCambios(opciones) {
+  const ej = opciones.ejecutar ?? ejecutar;
+  const env = opciones.env ?? process.env;
+  const carpeta = path3__namespace.resolve(opciones.carpeta);
+  const ubicacion = ubicarEnRepo(carpeta, ej);
+  if (!ubicacion) return incierto(`${carpeta} no est\xE1 en un repo de Git`);
+  const { raiz, prefijo } = ubicacion;
+  const head = salidaGit(ej, raiz, ["rev-parse", "HEAD"]);
+  if (!head) return incierto("no se pudo leer HEAD");
+  if (env.VERCEL_GIT_COMMIT_SHA && env.VERCEL_GIT_COMMIT_SHA !== head) {
+    return incierto(`VERCEL_GIT_COMMIT_SHA no coincide con HEAD (${head})`);
+  }
+  const antes = opciones.antes ?? env.VERCEL_GIT_PREVIOUS_SHA ?? "";
+  if (antes === "") return incierto("no hay commit anterior");
+  if (antes.startsWith("-"))
+    return incierto(`commit anterior inv\xE1lido: ${antes}`);
+  if (ej("git", ["cat-file", "-e", `${antes}^{commit}`], { cwd: raiz }).codigo !== 0) {
+    return incierto(`el commit anterior ${antes} no est\xE1 en el clon`);
+  }
+  let config;
+  try {
+    config = opciones.config ?? leerConfig(path3__namespace.join(raiz, ARCHIVO_CONFIG));
+  } catch (e) {
+    return incierto(e.message);
+  }
+  const proy = proyectoDeCarpeta(config, prefijo)?.proyecto;
+  const extras = [
+    .../* @__PURE__ */ new Set([...proy?.carpetas ?? [], ...proy?.carpetasExtra ?? []])
+  ].filter((c) => c !== prefijo);
+  const nombre = nombrePaquete(path3__namespace.join(raiz, prefijo, "package.json"));
+  if (!fs.existsSync(path3__namespace.join(raiz, "turbo.json")) || !nombre) {
+    return diffGit(ej, raiz, antes, [prefijo, ...extras]);
+  }
+  const [turbo, base] = comandoTurbo(raiz);
+  const r = ej(
+    turbo,
+    [...base, "build", `--filter=${nombre}...[${antes}]`, "--dry=json"],
+    {
+      cwd: raiz,
+      env
+    }
+  );
+  if (r.codigo !== 0)
+    return incierto(`turbo fall\xF3 (${r.fallo ?? `c\xF3digo ${r.codigo}`})`);
+  const paquetes = paquetesDeTurbo(r.salida);
+  if (!paquetes) return incierto("la salida de turbo no trae packages");
+  const afectados = paquetes.filter((p) => p !== "//");
+  if (afectados.length > 0) {
+    return {
+      resultado: "con-cambios",
+      motivo: `turbo: afectados ${afectados.join(", ")}`
+    };
+  }
+  if (extras.length > 0) return diffGit(ej, raiz, antes, extras);
+  return {
+    resultado: "sin-cambios",
+    motivo: `turbo: ${nombre} sin paquetes afectados`
+  };
+}
+
+// src/comandos/desplegar.ts
+var VARIABLES_VERCEL = [
+  "VERCEL_TOKEN",
+  "VERCEL_ORG_ID",
+  "VERCEL_PROJECT_ID"
+];
+var PASOS_VERCEL = [
+  ["pull", "--yes", "--environment=production"],
+  ["build", "--prod"],
+  ["deploy", "--prebuilt", "--prod"]
+];
+function leerArgumentosDesplegar(args) {
+  let carpeta;
+  let antes;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--carpeta" || arg.startsWith("--carpeta=")) {
+      const valor = arg === "--carpeta" ? args[++i] : arg.slice("--carpeta=".length);
+      if (!valor || valor.trim() === "" || valor.startsWith("-")) {
+        return { ok: false, motivo: "falta el valor de --carpeta <ruta>" };
+      }
+      carpeta = valor.trim();
+      continue;
+    }
+    if (arg === "--antes" || arg.startsWith("--antes=")) {
+      const valor = arg === "--antes" ? args[++i] : arg.slice("--antes=".length);
+      if (!valor || valor.trim() === "" || valor.startsWith("-")) {
+        return { ok: false, motivo: "falta el valor de --antes <sha>" };
+      }
+      antes = valor.trim();
+      continue;
+    }
+    return { ok: false, motivo: `argumento no reconocido: ${arg}` };
+  }
+  if (!carpeta) {
+    return {
+      ok: false,
+      motivo: "falta la opci\xF3n obligatoria --carpeta <ruta>"
+    };
+  }
+  return {
+    ok: true,
+    valor: { carpeta, ...antes !== void 0 ? { antes } : {} }
+  };
+}
+function redactarCredenciales(texto, env) {
+  let limpio = texto;
+  for (const nombre of VARIABLES_VERCEL) {
+    const valor = env[nombre]?.trim();
+    if (valor) {
+      limpio = limpio.split(valor).join("[REDACTED]");
+    }
+  }
+  return limpio;
+}
+function ejecutarDesplegar(opciones) {
+  const ej = opciones.ejecutar ?? ejecutar;
+  const evaluar = opciones.evaluar ?? evaluarCambios;
+  const rutaCarpeta = path3__namespace.resolve(opciones.cwd, opciones.carpeta);
+  if (!fs.existsSync(rutaCarpeta) || !fs.statSync(rutaCarpeta).isDirectory()) {
+    opciones.error(
+      `wallavi-vercel desplegar: la carpeta no existe: ${opciones.carpeta}`
+    );
+    return 2;
+  }
+  const faltan = VARIABLES_VERCEL.filter(
+    (nombre) => !opciones.env[nombre]?.trim()
+  );
+  if (faltan.length > 0) {
+    opciones.error(`wallavi-vercel desplegar: faltan ${faltan.join(", ")}`);
+    return 2;
+  }
+  const evaluacion = evaluar({
+    carpeta: rutaCarpeta,
+    ...opciones.antes !== void 0 ? { antes: opciones.antes } : {},
+    env: opciones.env,
+    ejecutar: ej
+  });
+  if (evaluacion.resultado === "sin-cambios") {
+    opciones.salida(
+      `wallavi-vercel desplegar: sin cambios (${evaluacion.motivo})`
+    );
+    return 0;
+  }
+  for (const paso of PASOS_VERCEL) {
+    const r = ej("vercel", paso, {
+      cwd: rutaCarpeta,
+      env: opciones.env
+    });
+    if (r.salida.trim() !== "") {
+      opciones.salida(redactarCredenciales(r.salida.trimEnd(), opciones.env));
+    }
+    if (r.error.trim() !== "") {
+      opciones.error(redactarCredenciales(r.error.trimEnd(), opciones.env));
+    }
+    if (r.codigo !== 0) {
+      const codigo = r.codigo ?? 127;
+      opciones.error(
+        redactarCredenciales(
+          `wallavi-vercel desplegar: vercel ${paso.join(" ")} fall\xF3 (${r.fallo ?? `c\xF3digo ${codigo}`})`,
+          opciones.env
+        )
+      );
+      return codigo;
+    }
+  }
+  opciones.salida(
+    `wallavi-vercel desplegar: desplegado (${evaluacion.motivo})`
+  );
+  return 0;
+}
+function comandoDesplegar(args, entorno) {
+  const leido = leerArgumentosDesplegar(args);
+  if (!leido.ok) {
+    entorno.error(`wallavi-vercel desplegar: ${leido.motivo}`);
+    return 2;
+  }
+  return ejecutarDesplegar({
+    ...entorno,
+    carpeta: leido.valor.carpeta,
+    ...leido.valor.antes !== void 0 ? { antes: leido.valor.antes } : {}
+  });
+}
+var desplegar = comandoDesplegar;
+var RAMA_PRINCIPAL = "main";
+var PREFIJO_PREVIEW = "preview/";
+function ramaPermitida(rama, config) {
+  return rama === RAMA_PRINCIPAL || rama.startsWith(PREFIJO_PREVIEW) || config.ramasConPreview.includes(rama);
+}
+function ejecutarIgnorar(opciones) {
+  const ej = opciones.ejecutar ?? ejecutar;
+  const evaluar = opciones.evaluar ?? evaluarCambios;
+  const decidir = (codigo, motivo) => {
+    opciones.salida(
+      `wallavi-vercel ignorar: ${codigo === 0 ? "no compilar" : "compilar"} (${motivo})`
+    );
+    return codigo;
+  };
+  const rama = opciones.env.VERCEL_GIT_COMMIT_REF?.trim() ?? "";
+  if (!rama) {
+    return decidir(1, "falta VERCEL_GIT_COMMIT_REF");
+  }
+  let config = opciones.config;
+  if (!config) {
+    const carpeta = path3__namespace.resolve(opciones.cwd);
+    const ubicacion = ubicarEnRepo(carpeta, ej);
+    if (!ubicacion) {
+      return decidir(1, `${carpeta} no est\xE1 en un repo de Git`);
+    }
+    try {
+      config = leerConfig(path3__namespace.join(ubicacion.raiz, ARCHIVO_CONFIG));
+    } catch (e) {
+      return decidir(1, e.message);
+    }
+  }
+  if (!ramaPermitida(rama, config)) {
+    return decidir(0, `rama ${rama} fuera de las permitidas`);
+  }
+  const shaActual = opciones.env.VERCEL_GIT_COMMIT_SHA?.trim() ?? "";
+  if (!shaActual) {
+    return decidir(1, "falta VERCEL_GIT_COMMIT_SHA");
+  }
+  const shaAnterior = opciones.env.VERCEL_GIT_PREVIOUS_SHA?.trim() ?? "";
+  if (!shaAnterior) {
+    return decidir(1, "falta VERCEL_GIT_PREVIOUS_SHA");
+  }
+  const evaluacion = evaluar({
+    carpeta: opciones.cwd,
+    antes: shaAnterior,
+    env: opciones.env,
+    config,
+    ejecutar: ej
+  });
+  if (evaluacion.resultado === "sin-cambios") {
+    return decidir(0, evaluacion.motivo);
+  }
+  return decidir(1, evaluacion.motivo);
+}
+function comandoIgnorar(args, entorno) {
+  if (args.length > 0) {
+    entorno.error(
+      `wallavi-vercel ignorar: argumentos no reconocidos: ${args.join(" ")}`
+    );
+    return 2;
+  }
+  return ejecutarIgnorar(entorno);
+}
+var ignorar = comandoIgnorar;
+
+// src/index.ts
+var USO = `Uso: wallavi-vercel <comando> [opciones]
+
+Comandos:
+  ignorar                                                                          decide si Vercel debe omitir el build
+  desplegar --carpeta <ruta> [--antes <sha>]                                       compila y despliega a producci\xF3n si hay cambios
+  medir --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> [...]    calcula los minutos de build por d\xEDa en UTC
+  capturar --equipo <slug|team_id> --desde <AAAA-MM-DD> --hasta <AAAA-MM-DD> ...   descarga deployments de Vercel y escribe su captura
+
+Opciones:
+  -h, --help                                                                       muestra esta ayuda
+`;
+var COMANDOS = {
+  ignorar: comandoIgnorar,
+  desplegar: comandoDesplegar,
+  medir: comandoMedir,
+  capturar: comandoCapturar
+};
+function principal(argv, entorno) {
+  const [nombre, ...args] = argv;
+  if (nombre === void 0 || nombre === "--help" || nombre === "-h") {
+    (nombre === void 0 ? entorno.error : entorno.salida)(USO);
+    return nombre === void 0 ? 2 : 0;
+  }
+  const comando = Object.hasOwn(COMANDOS, nombre) && COMANDOS[nombre];
+  if (!comando) {
+    entorno.error(`wallavi-vercel: comando desconocido: ${nombre}
+${USO}`);
+    return 2;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    entorno.salida(USO);
+    return 0;
+  }
+  return comando(args, entorno);
+}
+if (__require.main === module) {
+  process.exitCode = principal(process.argv.slice(2), {
+    cwd: process.cwd(),
+    env: process.env,
+    salida: (t) => console.log(t),
+    error: (t) => console.error(t)
+  });
+}
+
+exports.API_VERCEL_URL = API_VERCEL_URL;
+exports.ARCHIVO_CAPTURA_V6 = ARCHIVO_CAPTURA_V6;
+exports.ARCHIVO_CONFIG = ARCHIVO_CONFIG;
+exports.ARCHIVO_DEPLOYMENTS_V6 = ARCHIVO_DEPLOYMENTS_V6;
+exports.COMANDOS = COMANDOS;
+exports.ESTADOS_DEPLOYMENT = ESTADOS_DEPLOYMENT;
+exports.ErrorContratoVercel = ErrorContratoVercel;
+exports.ErrorRedVercel = ErrorRedVercel;
+exports.LIMITE_PAGINA_VERCEL = LIMITE_PAGINA_VERCEL;
+exports.MAX_PAGINAS_VERCEL = MAX_PAGINAS_VERCEL;
+exports.PASOS_VERCEL = PASOS_VERCEL;
+exports.PREFIJO_PREVIEW = PREFIJO_PREVIEW;
+exports.RAMA_PRINCIPAL = RAMA_PRINCIPAL;
+exports.REFERENCIA_DEPLOYMENTS_V6 = REFERENCIA_DEPLOYMENTS_V6;
+exports.USO = USO;
+exports.VARIABLES_VERCEL = VARIABLES_VERCEL;
+exports.armarCapturaV6 = armarCapturaV6;
+exports.calcularMinutosPorDia = calcularMinutosPorDia;
+exports.capturar = capturar;
+exports.comandoCapturar = comandoCapturar;
+exports.comandoDesplegar = comandoDesplegar;
+exports.comandoIgnorar = comandoIgnorar;
+exports.comandoMedir = comandoMedir;
+exports.comandoTurbo = comandoTurbo;
+exports.configVacia = configVacia;
+exports.consultarDeployments = consultarDeployments;
+exports.desplegar = desplegar;
+exports.ejecutar = ejecutar;
+exports.ejecutarCapturar = ejecutarCapturar;
+exports.ejecutarDesplegar = ejecutarDesplegar;
+exports.ejecutarIgnorar = ejecutarIgnorar;
+exports.ejecutarMedir = ejecutarMedir;
+exports.esquemaArchivoDeployments = esquemaArchivoDeployments;
+exports.esquemaCapturaV6 = esquemaCapturaV6;
+exports.esquemaConfig = esquemaConfig;
+exports.esquemaDeployment = esquemaDeployment;
+exports.esquemaEquipo = esquemaEquipo;
+exports.esquemaEstadoDeployment = esquemaEstadoDeployment;
+exports.esquemaPaginaDeployments = esquemaPaginaDeployments;
+exports.esquemaPaginaTeams = esquemaPaginaTeams;
+exports.esquemaPaginacion = esquemaPaginacion;
+exports.esquemaPedidoCaptura = esquemaPedidoCaptura;
+exports.evaluarCambios = evaluarCambios;
+exports.ignorar = ignorar;
+exports.leerArgumentosCapturar = leerArgumentosCapturar;
+exports.leerArgumentosDesplegar = leerArgumentosDesplegar;
+exports.leerArgumentosMedir = leerArgumentosMedir;
+exports.leerConfig = leerConfig;
+exports.leerFlagsCli = leerFlagsCli;
+exports.leerRespuestaDeployments = leerRespuestaDeployments;
+exports.medir = medir;
+exports.normalizarCarpeta = normalizarCarpeta;
+exports.paquetesDeTurbo = paquetesDeTurbo;
+exports.pedirJsonVercel = pedirJsonVercel;
+exports.principal = principal;
+exports.proyectoDeCarpeta = proyectoDeCarpeta;
+exports.ramaPermitida = ramaPermitida;
+exports.rangoFechasUtc = rangoFechasUtc;
+exports.redactarToken = redactarToken;
+exports.resolverEquipo = resolverEquipo;
+exports.solicitarVercel = solicitarVercel;
+exports.ubicarEnRepo = ubicarEnRepo;
+exports.validarConfig = validarConfig;
+exports.validarFechaIso = validarFechaIso;