shilo-cli 0.2.0 → 0.3.1

package/src/commands/pull.js

@@ -0,0 +1,239 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const config = require('../config');
+const remote = require('../remote');
+const prompt = require('../prompt');
+const ui = require('../ui');
+const sync = require('../sync');
+const { validatePath } = require('../textguard');
+const { resolveContext } = require('../context');
+
+const CONCURRENCY = sync.CONCURRENCY;
+
+/**
+ * Resuelve la ruta absoluta de escritura para un `repoPath`, blindando contra
+ * path traversal. Valida cada segmento con las mismas reglas del backend y
+ * exige que el destino final quede dentro de `destDir`.
+ * Devuelve `{ ok: true, target }` o `{ ok: false, reason }`.
+ */
+function safeTarget(destDir, repoPath) {
+  const check = validatePath(repoPath);
+  if (!check.ok) return { ok: false, reason: check.reason };
+
+  const target = path.resolve(destDir, repoPath);
+  const rel = path.relative(destDir, target);
+  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {
+    return { ok: false, reason: 'la ruta escaparía de la carpeta destino' };
+  }
+  return { ok: true, target };
+}
+
+/**
+ * shilo pull [carpeta] [--project <uuid>] [--base-url <url>] [--dry-run] [--yes] [--force]
+ *
+ * Baja un proyecto de Shilo a una carpeta local y deja `.shilo.json` listo para
+ * un `push` posterior.
+ *
+ * Seguridad ante trabajo local sin guardar: el pull NO pisa un archivo local que
+ * difiera del remoto salvo con `--force`. Los archivos que sólo existen en el
+ * remoto, y los que ya coinciden byte a byte, se resuelven solos. Un archivo que
+ * sólo existe localmente nunca se toca (el pull no borra).
+ */
+async function pull(args) {
+  const ctx = resolveContext(args, { requireDir: false });
+  if (!ctx.ok) return ctx.code;
+
+  const { dir, projectId, baseURL, cfg, client, mgr } = ctx;
+
+  // La carpeta destino puede no existir todavía: la creamos al escribir. Si
+  // existe pero es un archivo, es un error del usuario.
+  if (fs.existsSync(dir) && !fs.statSync(dir).isDirectory()) {
+    ui.error(`No es una carpeta válida: ${dir}`);
+    return 1;
+  }
+
+  const dryRun = !!args['dry-run'];
+
+  ui.info(`Proyecto ${ui.c.bold(projectId)} en ${ui.c.cyan(baseURL)} — recorriendo árbol ...`);
+
+  let tree;
+  try {
+    tree = await sync.walkRemote(client, projectId, mgr);
+  } catch (e) {
+    ui.error(`No se pudo recorrer el proyecto: ${e.message}`);
+    return 1;
+  } finally {
+    config.persistCredsIfChanged(cfg, mgr.current);
+  }
+
+  for (const err of tree.errors) {
+    ui.warn(`no se pudo listar ${ui.c.dim(err.folderPath || '(raíz)')} — ${err.reason}`);
+  }
+
+  // 1) Separar texto (descargable) de lo que no se puede bajar sin corromper.
+  const candidates = [];
+  const skippedBinary = [];
+  const unsafe = [];
+  for (const f of tree.files) {
+    const safe = safeTarget(dir, f.repoPath);
+    if (!safe.ok) {
+      unsafe.push({ repoPath: f.repoPath, reason: safe.reason });
+      continue;
+    }
+    if (!sync.isTextMime(f.mime_type)) {
+      skippedBinary.push({ repoPath: f.repoPath, reason: `mime no textual (${f.mime_type})` });
+      continue;
+    }
+    candidates.push({ ...f, target: safe.target });
+  }
+
+  for (const u of unsafe) ui.warn(`saltado ${ui.c.dim(u.repoPath)} — ${u.reason}`);
+  for (const s of skippedBinary) ui.warn(`saltado ${ui.c.dim(s.repoPath)} — ${s.reason}`);
+
+  // 2) Clasificar contra lo que hay en disco, sin bajar nada todavía.
+  //    `maybeSame` (mismo tamaño) se confirma recién al descargar el contenido.
+  const local = sync.walkLocal(dir);
+  const localByPath = new Map(local.files.map((f) => [f.repoPath, f]));
+
+  const newFiles = [];    // sólo en el remoto: bajar sin riesgo
+  const maybeSame = [];   // existe local con el mismo tamaño
+  const conflicting = []; // existe local con distinto tamaño: pisaría trabajo
+  for (const f of candidates) {
+    const localFile = localByPath.get(f.repoPath);
+    if (!localFile) newFiles.push(f);
+    else if (typeof f.size === 'number' && f.size !== localFile.size) conflicting.push(f);
+    else maybeSame.push(f);
+  }
+
+  const remotePaths = new Set(candidates.map((f) => f.repoPath));
+  const onlyLocal = local.files.filter((f) => !remotePaths.has(f.repoPath));
+
+  ui.info('');
+  ui.info(
+    `  ${ui.c.green('nuevos:')}          ${newFiles.length}\n` +
+      `  ${ui.c.yellow('en conflicto:')}    ${conflicting.length}   ${ui.c.dim('(difieren en tamaño del local)')}\n` +
+      `  ${ui.c.dim('posiblemente iguales:')} ${maybeSame.length}\n` +
+      `  ${ui.c.dim('sólo locales:')}     ${onlyLocal.length}   ${ui.c.dim('(el pull no los toca)')}` +
+      (skippedBinary.length ? `\n  ${ui.c.dim('binarios saltados:')} ${skippedBinary.length}` : '') +
+      (unsafe.length ? `\n  ${ui.c.red('inseguros:')}       ${unsafe.length}` : '')
+  );
+  ui.info('');
+
+  // 3) --dry-run: mostrar el plan contra el estado local y salir sin tocar disco.
+  if (dryRun) {
+    for (const f of newFiles) ui.info(`  ${ui.c.green('↓')} ${f.repoPath} ${ui.c.dim('(nuevo)')}`);
+    for (const f of conflicting) {
+      const localFile = localByPath.get(f.repoPath);
+      const delta = f.size - localFile.size;
+      ui.info(
+        `  ${ui.c.yellow('~')} ${f.repoPath} ` +
+          ui.c.dim(`(sobrescribe tu versión local, ${delta > 0 ? '+' : ''}${delta} bytes)`)
+      );
+    }
+    for (const f of onlyLocal) ui.info(`  ${ui.c.dim('·')} ${ui.c.dim(`${f.repoPath} (sólo local, se conserva)`)}`);
+    ui.info('');
+    if (conflicting.length > 0) {
+      ui.warn(`${conflicting.length} archivo(s) locales se sobrescribirían: hace falta --force.`);
+      ui.info(ui.c.dim('Mirá "shilo diff <archivo>" antes de bajarlos.'));
+    }
+    ui.info(
+      ui.c.dim(
+        '(--dry-run: no se bajó nada. Los "posiblemente iguales" se confirman al descargar.)'
+      )
+    );
+    return 0;
+  }
+
+  // 4) Sin --force, los conflictos quedan afuera en vez de abortar todo el pull:
+  //    lo nuevo se baja igual y el usuario decide qué hacer con el resto.
+  let toDownload = [...newFiles, ...maybeSame];
+  if (conflicting.length > 0) {
+    if (args.force) {
+      toDownload = toDownload.concat(conflicting);
+    } else {
+      ui.warn(`${conflicting.length} archivo(s) difieren de tu copia local y NO se van a bajar:`);
+      for (const f of conflicting) ui.info(`  ${ui.c.yellow('~')} ${f.repoPath}`);
+      ui.info(ui.c.dim('Usá --force para sobrescribirlos, o "shilo diff <archivo>" para comparar.'));
+      ui.info('');
+    }
+  }
+
+  if (toDownload.length === 0) {
+    ui.info('No hay archivos para bajar.');
+    return conflicting.length > 0 && !args.force ? 1 : 0;
+  }
+
+  // 5) Confirmar (salvo --yes).
+  if (!args.yes) {
+    const overwrites = toDownload.filter((f) => fs.existsSync(f.target)).length;
+    const label = overwrites
+      ? `¿Bajar ${toDownload.length} archivo(s) a "${dir}" (${overwrites} ya existen)?`
+      : `¿Bajar ${toDownload.length} archivo(s) a "${dir}"?`;
+    const ok = await prompt.confirm(label, true);
+    if (!ok) {
+      ui.info('Cancelado.');
+      return 0;
+    }
+  }
+
+  // 6) Descargar y escribir, con pool. Recién acá se sabe si un archivo del
+  //    mismo tamaño era realmente idéntico: si lo era, no se reescribe.
+  const written = [];
+  const unchanged = [];
+  const failed = [];
+  const outcomes = await sync.runPool(toDownload, CONCURRENCY, async (f) => {
+    const creds = await mgr.valid();
+    const read = await client.readFile(projectId, f.repoPath, creds);
+    const content = read.file && read.file.content != null ? read.file.content : '';
+
+    const current = sync.readLocalText(f.target);
+    if (current !== null && current === content) {
+      return { repoPath: f.repoPath, skipped: true };
+    }
+
+    fs.mkdirSync(path.dirname(f.target), { recursive: true });
+    fs.writeFileSync(f.target, content, 'utf8');
+    return { repoPath: f.repoPath, skipped: false };
+  });
+
+  for (const res of outcomes) {
+    if (res && res.__error) {
+      failed.push({ repoPath: res.item.repoPath, reason: res.__error });
+      ui.error(`${res.item.repoPath} — ${res.__error}`);
+    } else if (res.skipped) {
+      unchanged.push(res.repoPath);
+    } else {
+      written.push(res.repoPath);
+      ui.success(`${ui.c.green('↓')} ${res.repoPath}`);
+    }
+  }
+
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 7) Binding + marca de sincronización para el `status` siguiente. Sólo si el
+  //    pull cubrió todo: con conflictos pendientes la carpeta NO quedó alineada.
+  const complete = failed.length === 0 && (args.force || conflicting.length === 0);
+  try {
+    if (complete) {
+      remote.write(dir, { projectId, baseURL, lastSync: new Date().toISOString() });
+    } else if (written.length > 0) {
+      remote.write(dir, { projectId, baseURL });
+    }
+  } catch (e) {
+    ui.warn(`No se pudo escribir ${remote.REMOTE_FILENAME}: ${e.message}`);
+  }
+
+  // 8) Resumen.
+  ui.info('');
+  const tail = unchanged.length ? ` (${unchanged.length} ya estaban al día)` : '';
+  if (failed.length === 0) {
+    ui.success(`Pull completo: ${written.length} archivo(s) actualizados en "${dir}"${tail}.`);
+    return conflicting.length > 0 && !args.force ? 1 : 0;
+  }
+  ui.warn(`Pull con problemas: ${failed.length} archivo(s) fallaron, ${written.length} bajados${tail}.`);
+  return 1;
+}
+
+module.exports = pull;

package/src/commands/push.js

@@ -6,6 +6,7 @@ const config = require('../config');
 const remote = require('../remote');
 const prompt = require('../prompt');
 const ui = require('../ui');
+const sync = require('../sync');
 const { walk } = require('../walk');
 const { classifyContent } = require('../textguard');
 const { ShiloClient } = require('../ShiloClient');
@@ -69,6 +70,12 @@ async function push(args) {
   const dryRun = !!args['dry-run'];
   const message =
     typeof args.message === 'string' && args.message.trim() ? args.message.trim() : null;
+  const card = typeof args.card === 'string' && args.card.trim() ? args.card.trim() : null;
+
+  if (card && card.length > 100) {
+    ui.error('El id de tarjeta (--card) no puede superar 100 caracteres.');
+    return 1;
+  }
 
   // 3) Recorrer la carpeta.
   const { files, skipped, ignored } = walk(dir);
@@ -131,40 +138,70 @@ async function push(args) {
 
   // 5) Clasificar contra el remote (added / modified / unchanged) para planear.
   //    Esto ya toca la red (getFileMeta / readFile) pero no escribe nada.
-  let creds = cfg.credentials;
+  //    Se hace con un pool de concurrencia (mismo patrón que walkRemote en
+  //    pull/status) en vez de un archivo a la vez: es lo que hacía que un push
+  //    de muchos archivos tardara minutos por puro round-trip secuencial.
+  //    `mgr` serializa el refresh del JWT para que llamadas paralelas no
+  //    quemen el mismo refresh_token.
+  const mgr = sync.makeCredsManager(client, cfg);
   const plan = { added: [], modified: [], unchanged: [], failed: [] };
 
-  for (const u of uploads) {
-    try {
-      const meta = await client.getFileMeta(projectId, u.relPath, creds);
-      creds = meta.credentials;
+  const planResults = await sync.runPool(uploads, sync.CONCURRENCY, async (u) => {
+    const creds = await mgr.valid();
+    const meta = await client.getFileMeta(projectId, u.relPath, creds);
 
-      if (!meta.exists) {
-        plan.added.push(u);
-        continue;
-      }
-      if (meta.file && meta.file.type === 'folder') {
-        plan.failed.push({ ...u, reason: 'ya existe una carpeta con ese nombre' });
-        continue;
-      }
+    if (!meta.exists) return { kind: 'added', u };
+    if (meta.file && meta.file.type === 'folder') {
+      return { kind: 'failed', u, reason: 'ya existe una carpeta con ese nombre' };
+    }
 
-      // Existe como archivo: ver si cambió comparando tamaño y luego contenido.
-      const localSize = Buffer.byteLength(u.content, 'utf8');
-      if (meta.file && typeof meta.file.size === 'number' && meta.file.size === localSize) {
-        const remoteRead = await client.readFile(projectId, u.relPath, creds);
-        creds = remoteRead.credentials;
-        if (remoteRead.file && remoteRead.file.content === u.content) {
-          plan.unchanged.push(u);
-          continue;
-        }
+    // Existe como archivo: ver si cambió comparando tamaño y luego contenido.
+    const localSize = Buffer.byteLength(u.content, 'utf8');
+    if (meta.file && typeof meta.file.size === 'number' && meta.file.size === localSize) {
+      const readCreds = await mgr.valid();
+      const remoteRead = await client.readFile(projectId, u.relPath, readCreds);
+      if (remoteRead.file && remoteRead.file.content === u.content) {
+        return { kind: 'unchanged', u };
       }
-      plan.modified.push({ ...u, remote: meta.file });
-    } catch (e) {
-      plan.failed.push({ ...u, reason: e.message });
     }
+    return { kind: 'modified', u: { ...u, remote: meta.file } };
+  });
+
+  for (const r of planResults) {
+    if (r && r.__error) {
+      plan.failed.push({ ...r.item, reason: r.__error });
+      continue;
+    }
+    if (r.kind === 'failed') plan.failed.push({ ...r.u, reason: r.reason });
+    else plan[r.kind].push(r.u);
+  }
+
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 5b) Atribución: para los archivos que vamos a pisar, quién los tocó último.
+  //     Es lo que distingue "esto lo subí yo antes" de "esto lo va a perder un
+  //     compañero". Best-effort: si el historial no se puede leer, seguimos.
+  let attribution = { index: new Map() };
+  const myId = cfg.credentials && cfg.credentials.user ? cfg.credentials.user.id : null;
+  if (plan.modified.length > 0) {
+    attribution = await sync.buildAuthorIndex(client, projectId, mgr, { commits: 50 });
+    config.persistCredsIfChanged(cfg, mgr.current);
   }
 
-  config.persistCredsIfChanged(cfg, creds);
+  /** Etiqueta " — última edición de X, fecha" para un archivo del plan. */
+  const authorNote = (u) => {
+    const meta = u.remote && attribution.index.get(u.remote.id);
+    if (!meta) return '';
+    const mine = myId && meta.authorId && meta.authorId === myId;
+    const who = mine ? ui.c.dim('vos') : ui.c.bold(meta.author);
+    return ui.c.dim(' — última edición de ') + who + ui.c.dim(`, ${sync.formatDate(meta.date)}`);
+  };
+
+  /** ¿El último que tocó este archivo fue otra persona? */
+  const touchedByOthers = plan.modified.filter((u) => {
+    const meta = u.remote && attribution.index.get(u.remote.id);
+    return meta && meta.authorId && myId && meta.authorId !== myId;
+  });
 
   // 6) Reporte del plan.
   ui.info('');
@@ -188,14 +225,38 @@ async function push(args) {
 
   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}`);
+    for (const u of plan.modified) ui.info(`  ${ui.c.yellow('~')} ${u.relPath}${authorNote(u)}`);
     for (const f of plan.failed) ui.info(`  ${ui.c.red('!')} ${f.relPath} — ${f.reason}`);
     ui.info('');
+    if (!myId && plan.modified.length > 0 && attribution.index.size > 0) {
+      ui.info(
+        ui.c.dim(
+          '(con token de acceso personal no sabemos tu id de usuario: ' +
+            'el autor se muestra, pero no se marca cuál sos vos)'
+        )
+      );
+      ui.info('');
+    }
+    if (touchedByOthers.length > 0) {
+      ui.warn(
+        `${touchedByOthers.length} de esos archivos los editó otra persona: ` +
+          `este push pisaría su versión.`
+      );
+      ui.info(ui.c.dim('Revisalos con "shilo diff <archivo>" o traelos con "shilo pull".'));
+      ui.info('');
+    }
     ui.info(ui.c.dim('(--dry-run: no se subió nada)'));
     return plan.failed.length ? 1 : 0;
   }
 
-  // 7) Confirmar (salvo --yes).
+  // 7) Confirmar (salvo --yes). Si vamos a pisar trabajo ajeno, lo decimos
+  //    antes de preguntar: es el caso que motivó todo este flujo.
+  if (touchedByOthers.length > 0) {
+    ui.warn(`Vas a pisar ${touchedByOthers.length} archivo(s) editado(s) por otra persona:`);
+    for (const u of touchedByOthers) ui.info(`  ${ui.c.red('!')} ${u.relPath}${authorNote(u)}`);
+    ui.info('');
+  }
+
   if (!args.yes) {
     const ok = await prompt.confirm(`¿Subir ${toWrite} archivo(s) al proyecto?`, true);
     if (!ok) {
@@ -209,57 +270,94 @@ async function push(args) {
   const ensuredCache = new Set();
   const failedWrites = [];
 
+  // 8a) Asegurar carpetas primero, EN SERIE. `ensuredCache` evita re-listar una
+  //     carpeta ya confirmada, pero además evita la carrera real: el backend no
+  //     siempre responde 409 de forma confiable si dos requests intentan crear
+  //     la misma carpeta al mismo tiempo, así que esta fase no se paraleliza.
+  //     Como la mayoría de los archivos comparten carpetas, el cache hace que
+  //     esto sea barato (proporcional a carpetas únicas, no a archivos).
+  const ensureFailed = new Set();
   for (const u of plan.added) {
     try {
-      creds = await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
-      const created = await client.createFile(
-        projectId, u.relPath, u.content, u.mimeType, creds
-      );
-      creds = created.credentials;
-
-      if (created.created && created.file) {
-        changes.push({
-          file_id: created.file.id,
-          action: 'added',
-          new_storage_path: created.file.storage_path,
-        });
-        ui.success(`${ui.c.green('+')} ${u.relPath}`);
-      } else {
-        // 409: apareció entremedio; caemos a update.
-        const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
-        creds = upd.credentials;
-        changes.push({
-          file_id: upd.file.id,
-          action: 'modified',
-          previous_storage_path: (created.file && created.file.storage_path) || upd.file.storage_path,
-          new_storage_path: upd.file.storage_path,
-        });
-        ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
-      }
-      config.persistCredsIfChanged(cfg, creds);
+      const creds = await mgr.valid();
+      await client.ensurePath(projectId, u.relPath, creds, ensuredCache);
     } catch (e) {
+      ensureFailed.add(u.relPath);
       failedWrites.push({ relPath: u.relPath, reason: e.message });
       ui.error(`${u.relPath} — ${e.message}`);
     }
   }
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 8b) Subidas propiamente dichas, en paralelo: acá es donde vive el grueso
+  //     del tiempo (un request por archivo), y a diferencia de ensurePath no
+  //     hay riesgo de carrera porque cada archivo tiene una ruta propia.
+  const addedReady = plan.added.filter((u) => !ensureFailed.has(u.relPath));
+  const addedResults = await sync.runPool(addedReady, sync.CONCURRENCY, async (u) => {
+    const creds = await mgr.valid();
+    const created = await client.createFile(projectId, u.relPath, u.content, u.mimeType, creds);
+
+    if (created.created && created.file) {
+      return {
+        u,
+        symbol: '+',
+        change: {
+          file_id: created.file.id,
+          action: 'added',
+          new_storage_path: created.file.storage_path,
+        },
+      };
+    }
+    // 409: apareció entremedio; caemos a update.
+    const writeCreds = await mgr.valid();
+    const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, writeCreds);
+    return {
+      u,
+      symbol: '~',
+      change: {
+        file_id: upd.file.id,
+        action: 'modified',
+        previous_storage_path: (created.file && created.file.storage_path) || upd.file.storage_path,
+        new_storage_path: upd.file.storage_path,
+      },
+    };
+  });
 
-  for (const u of plan.modified) {
-    try {
-      const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
-      creds = upd.credentials;
-      changes.push({
+  for (const r of addedResults) {
+    if (r && r.__error) {
+      failedWrites.push({ relPath: r.item.relPath, reason: r.__error });
+      ui.error(`${r.item.relPath} — ${r.__error}`);
+      continue;
+    }
+    changes.push(r.change);
+    ui.success(`${ui.c[r.symbol === '+' ? 'green' : 'yellow'](r.symbol)} ${r.u.relPath}`);
+  }
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  const modifiedResults = await sync.runPool(plan.modified, sync.CONCURRENCY, async (u) => {
+    const creds = await mgr.valid();
+    const upd = await client.writeFile(projectId, u.relPath, u.content, u.mimeType, creds);
+    return {
+      u,
+      change: {
         file_id: upd.file.id,
         action: 'modified',
         previous_storage_path: u.remote ? u.remote.storage_path : undefined,
         new_storage_path: upd.file.storage_path,
-      });
-      ui.success(`${ui.c.yellow('~')} ${u.relPath}`);
-      config.persistCredsIfChanged(cfg, creds);
-    } catch (e) {
-      failedWrites.push({ relPath: u.relPath, reason: e.message });
-      ui.error(`${u.relPath} — ${e.message}`);
+      },
+    };
+  });
+
+  for (const r of modifiedResults) {
+    if (r && r.__error) {
+      failedWrites.push({ relPath: r.item.relPath, reason: r.__error });
+      ui.error(`${r.item.relPath} — ${r.__error}`);
+      continue;
     }
+    changes.push(r.change);
+    ui.success(`${ui.c.yellow('~')} ${r.u.relPath}`);
   }
+  config.persistCredsIfChanged(cfg, mgr.current);
 
   // 9) Commit(s) en lotes de <=100.
   let committed = 0;
@@ -269,12 +367,12 @@ async function push(args) {
     for (let i = 0; i < total; i += COMMIT_BATCH) {
       const batch = changes.slice(i, i + COMMIT_BATCH);
       const partNo = Math.floor(i / COMMIT_BATCH) + 1;
-      const msg = buildMessage(message, batch.length, total, partNo, nBatches);
+      const msg = buildMessage(message, batch.length, total, partNo, nBatches, card);
       try {
-        const result = await client.createCommit(projectId, msg, batch, creds);
-        creds = result.credentials;
+        const creds = await mgr.valid();
+        await client.createCommit(projectId, msg, batch, creds);
         committed += batch.length;
-        config.persistCredsIfChanged(cfg, creds);
+        config.persistCredsIfChanged(cfg, mgr.current);
       } catch (e) {
         ui.error(`Fallo al crear el commit (lote ${partNo}/${nBatches}): ${e.message}`);
         failedWrites.push({ relPath: `<commit lote ${partNo}>`, reason: e.message });
@@ -282,9 +380,15 @@ async function push(args) {
     }
   }
 
-  config.persistCredsIfChanged(cfg, creds);
+  config.persistCredsIfChanged(cfg, mgr.current);
+
+  // 10) Anotar la sincronización: `status` la usa después para saber qué del
+  //     remoto es posterior a lo último que subimos.
+  if (failedWrites.length === 0) {
+    remote.touchSync(dir, { projectId, baseURL });
+  }
 
-  // 10) Resumen final.
+  // 11) Resumen final.
   ui.info('');
   const nCommits = Math.ceil(changes.length / COMMIT_BATCH);
   if (failedWrites.length === 0) {
@@ -297,10 +401,21 @@ async function push(args) {
   return 1;
 }
 
-function buildMessage(userMsg, batchCount, total, partNo, nBatches) {
-  const base = userMsg || `shilo push: ${total} archivo(s)`;
-  if (nBatches > 1) return `${base} (${partNo}/${nBatches})`;
-  return base;
+/**
+ * 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).
+ * El backend corta en 500 caracteres, así que recortamos el mensaje del usuario
+ * antes que el trailer.
+ */
+function buildMessage(userMsg, batchCount, total, partNo, nBatches, card) {
+  let base = userMsg || `shilo push: ${total} archivo(s)`;
+  if (nBatches > 1) base = `${base} (${partNo}/${nBatches})`;
+  if (!card) return base.slice(0, 500);
+
+  const trailer = ` [card: ${card}]`;
+  const room = 500 - trailer.length;
+  return `${base.slice(0, room)}${trailer}`;
 }
 
 module.exports = push;