shilo-cli 0.8.0 → 0.9.0

package/src/commands/push.js

@@ -8,7 +8,10 @@ const prompt = require('../prompt');
 const ui = require('../ui');
 const sync = require('../sync');
 const secrets = require('../secrets');
+const safelist = require('../safelist');
 const pushindex = require('../pushindex');
+const projectconfig = require('../projectconfig');
+const { runChecks } = require('../checks');
 const { walk } = require('../walk');
 const {
   classifyContent,
@@ -266,23 +269,98 @@ function suggestIgnore(skips) {
   }
 }
 
-/** Muestra los hallazgos de secretos. Nunca imprime el valor detectado. */
-function reportSecrets(findings) {
-  const groups = secrets.groupByFile(findings);
-  ui.error(`Posibles secretos en ${groups.length} archivo(s):`);
-  for (const g of groups) {
-    if (g.name) {
-      ui.info(`  ${ui.c.red('!')} ${g.relPath} ${ui.c.dim(`(coincide con "${g.name}")`)}`);
-    }
-    for (const hit of g.content) {
-      ui.info(`  ${ui.c.red('!')} ${g.relPath}:${hit.line} ${ui.c.dim(`— parece ${hit.label}`)}`);
+/**
+ * Decide qué hacer con los posibles secretos de lo que se va a subir. Nunca
+ * imprime el valor detectado. Devuelve true si el push puede seguir.
+ *
+ * Dos tipos de hallazgo, dos salidas distintas:
+ *   - por NOMBRE (`.env`, `*.pem`…): el archivo entero es de contraseñas, así
+ *     que lo que corresponde es no subirlo → se ofrece sumarlo a `.shiloignore`.
+ *   - por CONTENIDO (una línea parece una clave): puede ser un falso positivo →
+ *     se ofrece marcar esas líneas como seguras, y la decisión queda anotada en
+ *     `.shilo/` para no volver a preguntar mientras la línea no cambie.
+ *
+ * Sin terminal interactiva (o con --yes / --dry-run) no se pregunta nada: se
+ * explica y se frena, como antes.
+ */
+async function resolveSecrets(dir, findings, { interactive }) {
+  const { pending, accepted } = safelist.partition(dir, findings);
+  if (accepted.length > 0) {
+    ui.info(
+      ui.c.dim(
+        `${accepted.length} línea(s) con posibles claves ya las marcaste como seguras antes: se suben.`
+      )
+    );
+  }
+  if (pending.length === 0) return true;
+
+  const byName = pending.filter((f) => f.kind === 'name');
+  const byContent = pending.filter((f) => f.kind === 'content');
+  const nameFiles = [...new Set(byName.map((f) => f.relPath))];
+
+  ui.info('');
+  ui.warn('Antes de subir: encontramos algo que podría ser una contraseña o clave.');
+  if (nameFiles.length > 0) {
+    ui.info('');
+    ui.info('Estos archivos suelen guardar contraseñas, y no conviene subirlos:');
+    for (const p of nameFiles) ui.info(`  ${ui.c.red('!')} ${p}`);
+  }
+  if (byContent.length > 0) {
+    ui.info('');
+    ui.info('Estas líneas parecen claves:');
+    for (const g of secrets.groupByFile(byContent)) {
+      for (const hit of g.content) {
+        ui.info(`  ${ui.c.red('!')} ${g.relPath}:${hit.line} ${ui.c.dim(`— parece ${hit.label}`)}`);
+      }
     }
   }
   ui.info('');
-  ui.info('No se subió nada. Opciones:');
-  ui.info('  · agregar esos archivos a .shiloignore (lo más común)');
-  ui.info('  · sacar el secreto del contenido y volver a intentar');
-  ui.info('  · si es un falso positivo, repetir con --allow-secrets');
+
+  const canAsk = interactive && process.stdin.isTTY;
+  if (!canAsk) {
+    ui.info('No se subió nada. Para seguir:');
+    if (nameFiles.length > 0) {
+      ui.info(`  · Agregá ${nameFiles.length === 1 ? 'ese archivo' : 'esos archivos'} a .shiloignore para no subirlos.`);
+    }
+    if (byContent.length > 0) {
+      ui.info('  · Si esas claves son públicas (están hechas para verse), corré "shilo push" en una');
+      ui.info('    terminal y respondé que sí cuando pregunte: la decisión queda guardada.');
+      ui.info('  · Si son secretas, sacalas del archivo antes de subir.');
+    }
+    return false;
+  }
+
+  if (nameFiles.length > 0) {
+    const ignore = await prompt.confirm(
+      `¿Dejamos ${nameFiles.length === 1 ? 'ese archivo' : `esos ${nameFiles.length} archivos`} afuera ` +
+        '(se agregan a .shiloignore y no se suben nunca)?',
+      true
+    );
+    if (!ignore) {
+      ui.info('No se subió nada. Si de verdad hay que subirlos, usá --allow-secrets (no recomendado).');
+      return false;
+    }
+    if (!safelist.addToShiloignore(dir, nameFiles)) {
+      ui.error('No pudimos escribir .shiloignore. No se subió nada.');
+      return false;
+    }
+    ui.success(`Listo: ${nameFiles.length} archivo(s) agregados a .shiloignore. Volvé a correr "shilo push".`);
+    // El plan ya está armado con esos archivos adentro: rearmarlo acá sería
+    // duplicar el paso 5 entero. Más simple y más claro: frenar y repetir.
+    return false;
+  }
+
+  ui.info('Algunas claves son públicas a propósito (por ejemplo, las que usa una página web para');
+  ui.info('conectarse a su base de datos). Otras dan acceso total y nunca deberían subirse.');
+  const safe = await prompt.confirm('¿Estas son públicas y es seguro subirlas?', false);
+  if (!safe) {
+    ui.info('No se subió nada. Sacá esas claves del archivo (o ignoralo en .shiloignore) y volvé a intentar.');
+    return false;
+  }
+  if (safelist.remember(dir, byContent)) {
+    ui.info(ui.c.dim('Anotado: no te lo volvemos a preguntar por estas líneas mientras no cambien.'));
+  }
+  return true;
 }
 
 /** Todas las carpetas ancestro de un conjunto de rutas de archivo. */
@@ -303,6 +381,7 @@ function neededFolders(relPaths) {
 /**
  * shilo push [carpeta] [--project <uuid>] [-m <msg>] [--dry-run] [--yes]
  *            [--allow-secrets] [--concurrency <n>] [--no-index] [--verbose]
+ *            [--allow-failing-checks]
  *
  * Replica una carpeta local a un repo de Shilo: crea archivos nuevos y actualiza
  * los que cambiaron. Desde la Etapa 3 lo hace como PROPUESTA: el servidor la
@@ -352,6 +431,15 @@ async function push(args) {
     return 1;
   }
 
+  // --deploy sólo agrega el trailer [deploy: …]; quien decide es el servidor
+  // (PLAN_DEPLOY_VERCEL, Etapa 2). Sin --deploy, manda el destino automático.
+  const deploy = parseDeploy(args.deploy);
+  if (deploy === undefined) {
+    ui.error('--deploy tiene que ser prod, preview u off.');
+    return 1;
+  }
+  const trailers = [card && `[card: ${card}]`, deploy && `[deploy: ${deploy}]`].filter(Boolean);
+
   // Procedencia (Etapa 4, punto 1). Sin --agent no se manda bloque alguno y el
   // guardado queda como escrito por una persona, que es la verdad.
   const agent = buildAgent(args);
@@ -386,17 +474,9 @@ async function push(args) {
 
   reportSkipped(skipped, { verbose });
 
-  if (findings.length > 0 && !args['allow-secrets']) {
-    ui.info('');
-    reportSecrets(findings);
-    return 1;
-  }
-  if (findings.length > 0) {
-    ui.warn(
-      `${secrets.groupByFile(findings).length} archivo(s) con posibles secretos ` +
-        `se van a subir igual (--allow-secrets).`
-    );
-  }
+  // Los hallazgos de secretos se deciden después de planificar (ver 6b): sólo
+  // importan los archivos que este push va a escribir. Uno que ya está en el
+  // proyecto tal cual no gana nada con frenar el push.
 
   if (allUploads.length === 0) {
     ui.info('No hay archivos para subir.');
@@ -602,9 +682,44 @@ async function push(args) {
 
   config.persistCredsIfChanged(cfg, mgr.current);
 
-  // Con token de acceso personal no sabemos el id del usuario; sólo importa
-  // para reconocer propuestas propias que este push reemplaza.
-  const myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  // Quién soy importa para reconocer propuestas propias que este push
+  // reemplaza. Con token de acceso personal la sesión no trae el id: lo dice el
+  // listado de propuestas (`viewer`). Sin eso, cada push repetido dejaba una
+  // propuesta duplicada al lado de la anterior.
+  let myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  let viewer = null;
+  let projectInfo = null;
+  const noteListing = (listed) => {
+    if (listed.viewer) {
+      viewer = listed.viewer;
+      if (!myId) myId = listed.viewer.id || null;
+    }
+    if (listed.project) projectInfo = listed.project;
+  };
+
+  /**
+   * Si la carpeta coincide entera con la versión actual, anotarlo: fecha de
+   * sincronización y `base`. Sin esto, después de aprobar una propuesta en la
+   * web la carpeta seguía diciendo "última sincronización hace 2 meses" y, peor,
+   * el push siguiente partía de una base vieja y veía como conflicto lo que
+   * eran tus propios cambios ya aplicados.
+   */
+  async function markAlignedIfClean() {
+    if (dryRun || !treeComplete || leftOut.length > 0) return;
+    const isIgnoredPath = sync.makePathMatcher(dir);
+    const localPaths = new Set(allUploads.map((u) => u.relPath));
+    const missing = tree.files.some(
+      (f) => !localPaths.has(f.repoPath) && !isIgnoredPath(f.repoPath)
+    );
+    if (missing) return; // el proyecto tiene cosas que acá no están: no es "igual"
+    try {
+      const listed = await client.listProposals(projectId, await mgr.valid());
+      config.persistCredsIfChanged(cfg, mgr.current);
+      if (listed.main) remote.touchSync(dir, { projectId, baseURL, base: listed.main });
+    } catch (_) {
+      // Best-effort: servidor viejo o sin red. No cambia el resultado del push.
+    }
+  }
 
   // 6) Reporte del plan.
   ui.info('');
@@ -623,11 +738,26 @@ async function push(args) {
       return 1;
     }
     if (useIndex && !dryRun) saveIndex(dir, index, plan, allUploads);
+    await markAlignedIfClean();
     ui.success('Todo al día. Nada para subir.');
     reportLeftOut(leftOut, remoteByPath);
     return 0;
   }
 
+  // 6b) Secretos: sólo en lo que se va a escribir, y sin lo que la persona ya
+  //     marcó como seguro en esta carpeta.
+  const writing = new Set([...plan.added, ...plan.modified].map((u) => u.relPath));
+  const relevant = findings.filter((f) => writing.has(f.relPath));
+  if (relevant.length > 0 && !args['allow-secrets']) {
+    const ok = await resolveSecrets(dir, relevant, { interactive: !dryRun && !args.yes });
+    if (!ok) return 1;
+  } else if (relevant.length > 0) {
+    ui.warn(
+      `${secrets.groupByFile(relevant).length} archivo(s) con posibles secretos ` +
+        `se van a subir igual (--allow-secrets).`
+    );
+  }
+
   if (dryRun) {
     for (const u of plan.added) ui.info(`  ${ui.c.green('+')} ${u.relPath}`);
     for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}`);
@@ -649,6 +779,20 @@ async function push(args) {
     }
   }
 
+  // 7b) Chequeos del proyecto (MU-93): los de `shilo.config.json` de esta
+  //     carpeta. Sin chequeos declarados no se corre nada y el push es el de
+  //     siempre. Si uno falla, no se propone nada salvo --allow-failing-checks:
+  //     entonces la propuesta viaja marcada como fallida y aplicarla exige forzar.
+  const checks = runProjectChecks(dir);
+  if (checks && checks.resultado !== 'ok') {
+    if (!args['allow-failing-checks']) {
+      ui.error('Un chequeo del proyecto falló: no se subió nada.');
+      ui.info(ui.c.dim('Arreglalo y volvé a subir, o usá --allow-failing-checks para proponer igual (queda marcada como fallida).'));
+      return 1;
+    }
+    ui.warn('Un chequeo falló: se propone igual (--allow-failing-checks) y queda marcada como fallida.');
+  }
+
   const pushedAt = Date.now();
 
   /** Log por archivo: en TTY lo tapa la barra de progreso, así que va sólo con --verbose. */
@@ -685,6 +829,7 @@ async function push(args) {
       throw e;
     }
     config.persistCredsIfChanged(cfg, mgr.current);
+    noteListing(listed);
 
     const knownBase = savedRemote && savedRemote.base ? savedRemote.base : null;
     let base = knownBase || listed.main;
@@ -733,6 +878,7 @@ async function push(args) {
     const failedWrites = [];
     const uploaded = [];
     const open = [];
+    const lineMerged = [];
     let applied = 0;
     let appliedCount = 0;
     let stale = 0;
@@ -802,12 +948,12 @@ async function push(args) {
       upProg.update(upDone);
       if (changes.length === 0) continue;
 
-      const title = buildMessage(message, changes.length, toSend.length, bi + 1, batches.length, card);
+      const title = buildMessage(message, changes.length, toSend.length, bi + 1, batches.length, trailers);
       let result;
       try {
         result = await client.propose(
           projectId,
-          { base, title, summary: '', changes, agent, prompt: promptText, card },
+          { base, title, summary: '', changes, agent, prompt: promptText, card, chequeos: checks },
           await mgr.valid()
         );
         for (const w of result.warnings || []) ui.warn(w);
@@ -836,6 +982,7 @@ async function push(args) {
       } else if (result.applied) {
         applied += sent.length;
         appliedCount += 1;
+        lineMerged.push(...(result.lineas || []));
         for (const u of sent) {
           logFile(upProg, `${u.remote ? ui.c.yellow('~') : ui.c.green('+')} ${u.relPath}`);
         }
@@ -847,7 +994,7 @@ async function push(args) {
     }
     upProg.clear();
 
-    return { failedWrites, committed: applied, commitCount: appliedCount, uploaded, open, stale, main, base };
+    return { failedWrites, committed: applied, commitCount: appliedCount, uploaded, open, stale, main, base, lineMerged };
   }
 
   /**
@@ -1223,7 +1370,7 @@ async function push(args) {
           toUpload.length,
           partNo,
           batches.length,
-          card
+          trailers
         );
         try {
           const creds = await mgr.valid();
@@ -1259,10 +1406,35 @@ async function push(args) {
     );
     outcome = await pushLegacy();
   }
-  const { failedWrites, committed, commitCount, uploaded, open, stale, main } = outcome;
+  const { failedWrites, commitCount, uploaded, open, stale } = outcome;
+  let { committed, main } = outcome;
+  const lineMerged = outcome.lineMerged || [];
 
   config.persistCredsIfChanged(cfg, mgr.current);
 
+  // 9b) Si quien sube es el dueño, lo que quedó abierto lo puede aplicar ahora
+  //     mismo en vez de ir a la web a aprobarse a sí mismo.
+  const failures = failedWrites.length + plan.failed.length;
+  let openShown = false;
+  if (open.length > 0 && failures === 0 && viewer && viewer.is_owner && !args.yes && process.stdin.isTTY) {
+    const res = await offerOwnerApply(open);
+    if (res.applied.length > 0) {
+      committed += res.applied.reduce((n, o) => n + o.paths.length, 0);
+      if (res.main) main = res.main;
+      for (const o of res.applied) open.splice(open.indexOf(o), 1);
+      lineMerged.push(...res.lineas);
+    }
+  }
+
+  // 9c) Unión por líneas (MU-92): el servidor combinó tu versión con la de otra
+  //     persona. Tu carpeta tiene que quedar con la combinada ANTES de mover la
+  //     base: si no, el push siguiente propondría tu versión sobre la nueva base
+  //     y desharía en silencio el cambio ajeno. Sólo se pisa un archivo que
+  //     sigue byte a byte como se subió; si lo tocaste mientras tanto, queda
+  //     como está y la base no se mueve, así el próximo push lo vuelve a combinar.
+  const broughtIn = await bringLineMerged(lineMerged, uploaded, { client, projectId, mgr, dir });
+  config.persistCredsIfChanged(cfg, mgr.current);
+
   // 10) Índice local: lo que subimos bien y lo que ya estaba igual. El próximo
   //     push arranca sabiendo qué no hace falta ni leer. Lo que quedó en una
   //     propuesta abierta también se anota: su hash no coincide con el de la
@@ -1271,22 +1443,27 @@ async function push(args) {
     for (const u of uploaded) {
       pushindex.record(index, u, pushedAt);
     }
+    for (const u of broughtIn.written) {
+      pushindex.record(index, u, pushedAt);
+    }
     saveIndex(dir, index, plan, allUploads, pushedAt);
   }
 
   // 11) Anotar la sincronización y la base nueva. Sólo si TODO quedó en la
   //     versión actual: con archivos fallados o propuestas abiertas, la carpeta
   //     no está alineada, y mover la base haría que el push siguiente proponga
-  //     esos mismos archivos como si nadie más los hubiera tocado.
-  const clean = failedWrites.length === 0 && plan.failed.length === 0 && open.length === 0;
-  if (clean) {
+  //     esos mismos archivos como si nadie más los hubiera tocado. Lo mismo con
+  //     una versión combinada que no se pudo traer (9c).
+  const clean = failures === 0 && open.length === 0;
+  reportLineMerged(broughtIn);
+  if (clean && broughtIn.left.length === 0) {
     remote.touchSync(dir, { projectId, baseURL, base: legacy ? null : main });
   }
 
   // 12) Resumen final.
   ui.info('');
   reportLeftOut(leftOut, remoteByPath);
-  for (const o of open) reportOpen(o);
+  if (!openShown) for (const o of open) reportOpen(o);
   if (stale > 0) {
     ui.warn(
       `${stale} archivo(s) ya no cambian nada: la versión actual avanzó y lo que tenés ` +
@@ -1301,18 +1478,91 @@ async function push(args) {
     } else {
       ui.success(`Push completo: ${committed} archivo(s) ya son parte de la versión actual.`);
     }
+    if (committed > 0 && deploy !== 'off') await reportDeploy(client, projectId, mgr, cfg);
     return 0;
   }
   for (const f of plan.failed) ui.error(`${f.relPath} — ${f.reason}`);
-  if (failedWrites.length + plan.failed.length > 0) {
-    ui.warn(`Push con problemas: ${failedWrites.length + plan.failed.length} archivo(s) fallaron.`);
-  } else {
-    ui.warn(
-      `${committed} archivo(s) subieron; ${open.reduce((n, o) => n + o.paths.length, 0)} quedaron en ` +
-        `${open.length} propuesta(s) abierta(s).`
-    );
+  if (failures > 0) {
+    ui.warn(`Push con problemas: ${failures} archivo(s) fallaron.`);
+    return 1;
+  }
+
+  // Quedó todo guardado, pero falta una aprobación. No es un error, y el
+  // mensaje empieza por eso: "0 archivo(s) subieron" se leía como un fallo.
+  const pendingFiles = open.reduce((n, o) => n + o.paths.length, 0);
+  const owner = projectInfo && projectInfo.owner;
+  const ownerName = owner ? owner.display_name || owner.username : null;
+  const approver = viewer && viewer.is_owner ? 'tu aprobación' : ownerName ? `la aprobación de ${ownerName}` : 'la aprobación del dueño del proyecto';
+  ui.success(
+    `Tus ${pendingFiles} cambio(s) están guardados en Shilo y esperan ${approver}.` +
+      (committed > 0 ? ` (Otros ${committed} ya son parte de la versión actual.)` : '')
+  );
+  for (const o of open) {
+    const link = proposalLink(baseURL, projectInfo, o.proposal);
+    if (link) ui.info(`  Revisalos acá: ${ui.c.cyan(link)}`);
+  }
+  // Exit 3 = "guardado, falta aprobar": distinto de 1 (falló algo) para que un
+  // script pueda distinguirlos, y distinto de 0 porque todavía no es la versión actual.
+  return 3;
+
+  /**
+   * Ofrece al dueño aplicar lo que quedó abierto. En los archivos en conflicto
+   * se queda la versión de esta carpeta (`propuesta`), y se dice antes de
+   * preguntar. Devuelve `{ applied: [open...], main }`.
+   */
+  async function offerOwnerApply(list) {
+    const files = list.reduce((n, o) => n + o.paths.length, 0);
+    const conflicted = list.reduce((n, o) => n + o.conflicts.length, 0);
+    ui.info('');
+    for (const o of list) reportOpen(o);
+    openShown = true;
+    ui.info(`Sos el dueño del proyecto: podés aplicar estos ${files} cambio(s) ahora, sin pasar por la web.`);
+    if (conflicted > 0) {
+      ui.info(
+        `En ${conflicted} archivo(s) que también cambiaron en el proyecto se va a quedar ` +
+          `${ui.c.bold('la versión de esta carpeta')}. Lo anterior queda en el historial.`
+      );
+    }
+    const failedChecks = list.some(needsForce);
+    if (failedChecks) {
+      ui.info(`Sus chequeos o piezas ${ui.c.red('fallaron')}: aplicarlos ahora es forzarlos, sabiendo eso.`);
+    }
+    const ok = await prompt.confirm('¿Aplicarlos ahora?', conflicted === 0 && !failedChecks);
+    const out = { applied: [], main: null, lineas: [] };
+    if (!ok) return out;
+    for (const o of list) {
+      if (!o.proposal) continue;
+      const resolutions =
+        o.conflicts.length > 0 ? Object.fromEntries(o.conflicts.map((c) => [c.path, 'propuesta'])) : null;
+      try {
+        const r = await client.resolveProposal(projectId, o.proposal.id, 'apply', await mgr.valid(), {
+          resolutions,
+          force: needsForce(o),
+        });
+        config.persistCredsIfChanged(cfg, mgr.current);
+        if (r.applied) {
+          out.applied.push(o);
+          if (r.main) out.main = r.main;
+          out.lineas.push(...(r.lineas || []));
+        } else {
+          ui.warn(`No se pudo aplicar la propuesta ${o.proposal.id.slice(0, 8)}: ${r.message || 'sigue abierta'}.`);
+        }
+      } catch (e) {
+        ui.warn(`No se pudo aplicar la propuesta ${o.proposal.id.slice(0, 8)}: ${e.message}`);
+      }
+    }
+    ui.info('');
+    return out;
   }
-  return 1;
+}
+
+/**
+ * Link web a una propuesta: `<base>/<usuario>/<proyecto>?propuesta=<id>`.
+ * null si el servidor no dijo la ruta del proyecto (servidor anterior).
+ */
+function proposalLink(baseURL, projectInfo, proposal) {
+  if (!projectInfo || !projectInfo.path || !proposal) return null;
+  return `${baseURL.replace(/\/+$/, '')}${projectInfo.path}?propuesta=${proposal.id.slice(0, 8)}`;
 }
 
 /**
@@ -1337,6 +1587,10 @@ function reportOpen(o) {
               : 'las dos versiones son distintas';
       ui.info(`  ${ui.c.red('!')} ${c.path} ${ui.c.dim(`— ${why}`)}`);
     }
+  } else if (checksFailed(o)) {
+    ui.warn('Los chequeos del proyecto fallaron: la propuesta no se aplica sola, hace falta que el dueño la fuerce.');
+  } else if (piecesFailed(o)) {
+    reportPieces(o.piezas);
   } else if (o.blockedBy.length > 0) {
     ui.warn('Otra propuesta abierta toca los mismos archivos:');
     for (const b of o.blockedBy) {
@@ -1345,15 +1599,104 @@ function reportOpen(o) {
   } else {
     ui.warn(o.message || 'La propuesta quedó abierta.');
   }
-  ui.info(
-    `  Tus ${o.paths.length} archivo(s) no se perdieron: quedaron como propuesta ${ui.c.bold(id)}, ` +
-      'abierta para que el dueño del proyecto decida.'
-  );
-  ui.info(
-    ui.c.dim('  Para resolverlo vos: "shilo pull" trae la versión actual (no pisa lo tuyo sin --force), ') +
-      ui.c.dim('ajustá y volvé a "shilo push".')
-  );
+  ui.info(`  Tus ${o.paths.length} archivo(s) no se perdieron: quedaron guardados como propuesta ${ui.c.bold(id)}.`);
+  ui.info('');
+}
+
+const checksFailed = (o) => Boolean(o.chequeos && o.chequeos.resultado === 'fallido');
+const piecesFailed = (o) => Array.isArray(o.piezas) && o.piezas.length > 0;
+/** Lo que el servidor sólo aplica si el dueño fuerza (MU-93, MU-94). */
+const needsForce = (o) => checksFailed(o) || piecesFailed(o);
+
+/**
+ * Las piezas USEE que dejarían de pasar el Nivel 1 (MU-94), con sus errores.
+ * El detalle completo lo da `verificar.js` sobre la carpeta de la pieza.
+ */
+function reportPieces(piezas) {
+  ui.warn('Estas piezas USEE no pasarían el Nivel 1; la propuesta no se aplica sola, hace falta que el dueño la fuerce:');
+  for (const p of piezas) {
+    const donde = p.raiz || '(raíz del proyecto)';
+    ui.info(`  ${ui.c.red('✗')} ${donde}${p.nueva ? ui.c.dim(' — pieza nueva') : ''}`);
+    for (const e of p.errores) ui.info(ui.c.dim(`      (${e.codigo}) ${e.mensaje}`));
+  }
+}
+
+/**
+ * Corre los chequeos de `shilo.config.json` de la carpeta (MU-93). Devuelve el
+ * resultado que viaja con la propuesta, o null si el proyecto no declara
+ * ninguno (y entonces el push es el de siempre).
+ */
+function runProjectChecks(dir) {
+  let text = null;
+  try {
+    text = fs.readFileSync(path.join(dir, projectconfig.CONFIG_PATH), 'utf8');
+  } catch (_) {
+    return null;
+  }
+  const cfgFile = projectconfig.parseProjectConfig(text);
+  for (const aviso of cfgFile.avisos) ui.warn(aviso);
+  if (cfgFile.chequeos.length === 0) return null;
+
   ui.info('');
+  const result = runChecks(dir, cfgFile.chequeos, {
+    onStart: (cmd, i, n) => ui.info(ui.c.bold(`Chequeo ${i}/${n}: ${cmd}`)),
+  });
+  ui.info('');
+  for (const c of result.comandos) {
+    const mark = c.ok ? ui.c.green('✓') : ui.c.red('✗');
+    const code = c.ok || c.codigo === undefined ? '' : ` (salió con ${c.codigo})`;
+    ui.info(`  ${mark} ${c.comando}${code} ${ui.c.dim(`${(c.ms / 1000).toFixed(1)} s`)}`);
+  }
+  const notRun = cfgFile.chequeos.length - result.comandos.length;
+  if (notRun > 0) ui.info(ui.c.dim(`  ${notRun} chequeo(s) más no se corrieron.`));
+  return result;
+}
+
+/**
+ * Trae a la carpeta las versiones que el servidor combinó por líneas (MU-92).
+ *
+ * Un archivo se pisa sólo si sigue siendo exactamente lo que se subió: la
+ * combinada contiene esos cambios, así que no se pierde nada. Si se tocó
+ * durante el push, o no se pudo leer, queda en `left` y no se escribe.
+ *
+ * @returns {Promise<{ written: Array<{relPath,size,mtimeMs,hash}>, left: string[] }>}
+ */
+async function bringLineMerged(paths, uploaded, { client, projectId, mgr, dir }) {
+  const out = { written: [], left: [] };
+  for (const relPath of [...new Set(paths)]) {
+    const u = uploaded.find((x) => x.relPath === relPath);
+    const absPath = u ? u.absPath : path.join(dir, ...relPath.split('/'));
+    try {
+      const now = fs.readFileSync(absPath);
+      if (!u || pushindex.hashContent(now) !== u.hash) throw new Error('cambió durante el push');
+      const read = await client.readFile(projectId, relPath, await mgr.valid());
+      const content = read.file && read.file.content != null ? read.file.content : null;
+      if (content === null || read.file.is_binary) throw new Error('el servidor no devolvió el texto');
+      fs.writeFileSync(absPath, content, 'utf8');
+      const st = fs.statSync(absPath);
+      out.written.push({ relPath, size: st.size, mtimeMs: st.mtimeMs, hash: pushindex.hashContent(content) });
+    } catch (_) {
+      out.left.push(relPath);
+    }
+  }
+  return out;
+}
+
+function reportLineMerged({ written, left }) {
+  if (written.length > 0) {
+    ui.info(
+      `${written.length} archivo(s) también los había cambiado otra persona, en otras líneas: ` +
+        'se combinaron y tu carpeta ya tiene la versión combinada.'
+    );
+    for (const u of written) ui.info(`  ${ui.c.cyan('≈')} ${u.relPath}`);
+  }
+  if (left.length > 0) {
+    ui.warn(
+      `${left.length} archivo(s) se combinaron con cambios de otra persona, pero no se pudieron traer ` +
+        'a tu carpeta. Tu versión sigue intacta; revisalos con "shilo diff" y el próximo push los vuelve a combinar.'
+    );
+    for (const p of left) ui.info(`  ${ui.c.yellow('≈')} ${p}`);
+  }
 }
 
 /**
@@ -1526,25 +1869,56 @@ function readPrompt(args, agent) {
 }
 
 /**
- * Arma el mensaje del commit. Si vino `--card`, se agrega como trailer
- * `[card: <id>]` al final: queda visible en el historial y es fácil de grepear
- * para cruzar un cambio con la tarjeta que lo pidió (Metrónomo u otro tablero).
+ * Arma el mensaje del commit. Los trailers (`[card: <id>]` de `--card`,
+ * `[deploy: …]` de `--deploy`) van al final: quedan visibles en el historial,
+ * se grepean fácil para cruzar un cambio con la tarjeta que lo pidió, y el
+ * servidor lee `[deploy: …]` para elegir el destino del deploy.
  * El backend corta en 500 caracteres, así que recortamos el mensaje del usuario
- * antes que el trailer.
+ * antes que los trailers.
  *
  * Desde la Etapa 4 la tarjeta viaja ADEMÁS aparte, en `provenance.card`, que es
  * lo que se puede consultar (`GET /api/commits/<id>?card=…`). El trailer no se
  * saca ni se va a sacar: es el formato de todo lo ya guardado, y la procedencia
  * entra en el oid del commit, así que lo viejo no se puede completar.
  */
-function buildMessage(userMsg, batchCount, total, partNo, nBatches, card) {
+function buildMessage(userMsg, batchCount, total, partNo, nBatches, trailers = []) {
   let base = userMsg || `shilo push: ${total} archivo(s)`;
   if (nBatches > 1) base = `${base} (${partNo}/${nBatches})`;
-  if (!card) return base.slice(0, 500);
+  if (!trailers.length) return base.slice(0, 500);
+
+  const tail = ` ${trailers.join(' ')}`;
+  const room = 500 - tail.length;
+  return `${base.slice(0, room)}${tail}`;
+}
 
-  const trailer = ` [card: ${card}]`;
-  const room = 500 - trailer.length;
-  return `${base.slice(0, room)}${trailer}`;
+/** `--deploy` → 'prod' | 'preview' | 'off'; null si no vino; undefined si es inválido. */
+function parseDeploy(raw) {
+  if (raw === undefined || raw === null || raw === false) return null;
+  const v = String(raw).trim().toLowerCase();
+  if (v === 'prod' || v === 'production') return 'prod';
+  if (v === 'preview' || v === 'off') return v;
+  return undefined;
+}
+
+/**
+ * Después de un push que cambió algo: si el proyecto despliega a Vercel, avisa
+ * que el deploy quedó en cola. Nunca hace fallar el push — un servidor sin
+ * deploys o un error de red sólo se callan.
+ */
+async function reportDeploy(client, projectId, mgr, cfg) {
+  try {
+    const info = await client.getDeploys(projectId, await mgr.valid());
+    if (info.target && info.connected) {
+      ui.info(ui.c.dim('Deploy en cola → "shilo deploys" para ver el estado.'));
+    }
+  } catch {
+    // sin deploys en el servidor, o sin red: no es asunto del push
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
 }
 
 module.exports = push;
+// Para los tests de backend/utils/__tests__/pushLineMerged.test.js.
+module.exports.bringLineMerged = bringLineMerged;
+module.exports.runProjectChecks = runProjectChecks;