shilo-cli 0.3.1 → 0.5.0

package/src/config.js

@@ -58,7 +58,7 @@ function decrypt(payload) {
  * Estructura en disco:
  * {
  *   version: 1,
- *   baseURL: "https://shilo-six.vercel.app",
+ *   baseURL: "https://www.shilo.city",
  *   supabaseUrl?: "...",        // opcional, habilita refresh de token
  *   supabaseAnonKey?: "...",    // opcional (valor público)
  *   credentials: { iv, data }   // cifrado -> { jwt, refreshToken, expiresAt, user }

package/src/context.js

@@ -17,7 +17,7 @@ const ui = require('./ui');
 const sync = require('./sync');
 const { ShiloClient } = require('./ShiloClient');
 
-const DEFAULT_BASE_URL = 'https://shilo-six.vercel.app';
+const DEFAULT_BASE_URL = 'https://www.shilo.city';
 
 /**
  * Devuelve `{ ok: true, dir, projectId, baseURL, cfg, client, mgr, savedRemote }`

package/src/prompt.js

@@ -9,10 +9,18 @@ const readline = require('readline');
 function question(query) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
-    rl.question(query, (answer) => {
+    let done = false;
+    const finish = (answer) => {
+      if (done) return;
+      done = true;
       rl.close();
       resolve(answer.trim());
-    });
+    };
+    // Sin esto, stdin cerrado (pipe agotado, CI, `< /dev/null`) deja el callback
+    // de `question` sin disparar nunca: la promesa no resuelve y el proceso
+    // termina en silencio. Con EOF respondemos vacío y el llamador decide.
+    rl.on('close', () => finish(''));
+    rl.question(query, finish);
   });
 }
 

package/src/pushindex.js

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * Índice local de sincronización (`.shilo/index.json`).
+ *
+ * Guarda, por archivo subido con éxito, el `size` + `mtimeMs` + hash que tenía
+ * en el momento del push. En el push siguiente, un archivo cuyo size y mtime
+ * coinciden con el índice no cambió localmente: no hace falta leerlo ni pedirle
+ * el contenido al servidor para compararlo. Es la misma idea que el index de
+ * git, y es lo que convierte un "push sin cambios" de cientos de round-trips a
+ * casi ninguno.
+ *
+ * Dos límites conocidos, asumidos a conciencia:
+ *
+ *   - `mtime` tiene resolución de 1 s en varios sistemas de archivos: un cambio
+ *     hecho dentro del mismo segundo que el push podría no detectarse. Por eso
+ *     las entradas escritas en el mismo segundo del push se marcan `racy: true`
+ *     y en el push siguiente se revalidan por hash en vez de por mtime (mismo
+ *     truco que usa git).
+ *   - El índice dice qué subimos nosotros, no qué hay hoy en el servidor. Si
+ *     alguien edita el archivo en la web dejándolo del mismo tamaño, el índice
+ *     lo daría por igual. La planificación cruza el índice con el árbol remoto
+ *     (tamaño + id) para acotar eso; la ventana que queda es la misma que ya
+ *     acepta `shilo status`.
+ *
+ * `.shilo/` está en DEFAULT_IGNORES, así que el índice nunca se sube.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const INDEX_VERSION = 1;
+const DIR_NAME = '.shilo';
+const FILE_NAME = 'index.json';
+
+function indexPath(dir) {
+  return path.join(dir, DIR_NAME, FILE_NAME);
+}
+
+/** SHA-256 hex de un contenido utf8. */
+function hashContent(content) {
+  return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+}
+
+/**
+ * Lee el índice de `dir`. Devuelve un índice vacío si no existe, está corrupto,
+ * es de otra versión o pertenece a otro proyecto/servidor: en todos esos casos
+ * la única consecuencia es que el push replanifica desde cero, que es
+ * exactamente el comportamiento anterior.
+ */
+function read(dir, { projectId, baseURL } = {}) {
+  const empty = { version: INDEX_VERSION, projectId, baseURL, entries: {} };
+  let raw;
+  try {
+    raw = fs.readFileSync(indexPath(dir), 'utf8');
+  } catch (_) {
+    return empty;
+  }
+
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (_) {
+    return empty;
+  }
+
+  if (!data || data.version !== INDEX_VERSION || !data.entries) return empty;
+  if (projectId && data.projectId && data.projectId !== projectId) return empty;
+  if (baseURL && data.baseURL && data.baseURL !== baseURL) return empty;
+
+  return {
+    version: INDEX_VERSION,
+    projectId: projectId || data.projectId || null,
+    baseURL: baseURL || data.baseURL || null,
+    entries: data.entries,
+  };
+}
+
+/**
+ * Escribe el índice. Es una optimización, no un dato de verdad: si falla (disco
+ * lleno, carpeta de sólo lectura) se devuelve `false` y el push sigue.
+ */
+function write(dir, index) {
+  const target = indexPath(dir);
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(
+      target,
+      JSON.stringify({ ...index, version: INDEX_VERSION, updatedAt: new Date().toISOString() }, null, 2),
+      'utf8'
+    );
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * ¿El archivo local está intacto respecto de lo que registra el índice?
+ *
+ * `file` es una entrada del walk: { relPath, size, mtimeMs }.
+ * Devuelve:
+ *   { fresh: true, entry }    -> no cambió; no hace falta leerlo
+ *   { fresh: false, entry }   -> cambió, o hay que revalidar por hash
+ */
+function isFresh(index, file) {
+  const entry = index.entries[file.relPath];
+  if (!entry) return { fresh: false, entry: null };
+  if (entry.size !== file.size) return { fresh: false, entry };
+  // Entrada dudosa (escrita en el mismo segundo que el push): no confiar en el
+  // mtime, hay que mirar el contenido.
+  if (entry.racy) return { fresh: false, entry };
+  if (Math.abs(entry.mtimeMs - file.mtimeMs) > 1) return { fresh: false, entry };
+  return { fresh: true, entry };
+}
+
+/**
+ * Registra un archivo recién subido. `pushedAtMs` es el instante del push: si
+ * el mtime del archivo cae en ese mismo segundo, la entrada queda marcada como
+ * dudosa (ver comentario de cabecera).
+ */
+function record(index, { relPath, size, mtimeMs, hash }, pushedAtMs = Date.now()) {
+  index.entries[relPath] = {
+    size,
+    mtimeMs,
+    hash,
+    racy: Math.floor(mtimeMs / 1000) >= Math.floor(pushedAtMs / 1000),
+  };
+  return index;
+}
+
+/** Saca del índice los archivos que ya no existen localmente. */
+function prune(index, presentPaths) {
+  const present = presentPaths instanceof Set ? presentPaths : new Set(presentPaths);
+  for (const relPath of Object.keys(index.entries)) {
+    if (!present.has(relPath)) delete index.entries[relPath];
+  }
+  return index;
+}
+
+module.exports = {
+  INDEX_VERSION,
+  indexPath,
+  hashContent,
+  read,
+  write,
+  isFresh,
+  record,
+  prune,
+};

package/src/remote.js

@@ -10,7 +10,7 @@
  * Estructura en disco:
  * {
  *   "projectId": "<uuid>",
- *   "baseURL": "https://shilo-six.vercel.app",
+ *   "baseURL": "https://www.shilo.city",
  *   "lastSync": "2026-07-27T12:00:00.000Z"
  * }
  *
@@ -40,7 +40,8 @@ function read(dir) {
   if (!fs.existsSync(p)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    // Notepad y PowerShell escriben UTF-8 con BOM, que `JSON.parse` rechaza.
+    raw = JSON.parse(fs.readFileSync(p, 'utf8').replace(/^/, ''));
   } catch (e) {
     throw new Error(`Remote corrupto en ${p}: ${e.message}`);
   }

package/src/secrets.js

@@ -0,0 +1,168 @@
+'use strict';
+
+/**
+ * Red de contención contra subir secretos.
+ *
+ * Dos capas, ambas offline y baratas:
+ *
+ *   1. Denylist por nombre: archivos que casi nunca deberían vivir en un repo
+ *      compartido (`.env`, claves privadas, credenciales de service account).
+ *   2. Escaneo de contenido sobre los primeros KB de cada archivo de texto,
+ *      buscando las formas de token más comunes.
+ *
+ * El criterio de diseño es asimétrico a propósito: un falso positivo cuesta una
+ * bandera (`--allow-secrets`) o una línea en `.shiloignore`; un falso negativo
+ * cuesta rotar todas las claves de producción. Ante la duda, se avisa.
+ *
+ * NUNCA se imprime el valor detectado, sólo archivo, línea y qué parece ser.
+ */
+
+// Patrones de nombre (mismo subconjunto glob que .gitignore, sobre el basename).
+const DENY_NAMES = [
+  '.env',
+  '.env.*',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  '*.keystore',
+  '*.jks',
+  'id_rsa*',
+  'id_dsa*',
+  'id_ecdsa*',
+  'id_ed25519*',
+  'credentials.json',
+  'service-account*.json',
+  'serviceaccount*.json',
+  '.npmrc',
+  '.netrc',
+  '.pypirc',
+  '.htpasswd',
+];
+
+// Excepciones: plantillas pensadas justamente para commitear.
+const DENY_EXCEPTIONS = [
+  '.env.example',
+  '.env.sample',
+  '.env.template',
+  '.env.defaults',
+];
+
+function globToRegExp(glob) {
+  let out = '^';
+  for (const ch of glob) {
+    if (ch === '*') out += '.*';
+    else if (ch === '?') out += '.';
+    else if ('\\^$.|+()[]{}'.includes(ch)) out += '\\' + ch;
+    else out += ch;
+  }
+  return new RegExp(out + '$', 'i');
+}
+
+const DENY_RES = DENY_NAMES.map(globToRegExp);
+const EXCEPTION_RES = DENY_EXCEPTIONS.map(globToRegExp);
+
+/**
+ * ¿El nombre del archivo está en la denylist? Devuelve `null` o el patrón que
+ * lo capturó (para poder explicarlo).
+ */
+function deniedByName(relPath) {
+  const name = relPath.split('/').pop();
+  if (EXCEPTION_RES.some((re) => re.test(name))) return null;
+  for (let i = 0; i < DENY_RES.length; i++) {
+    if (DENY_RES[i].test(name)) return DENY_NAMES[i];
+  }
+  return null;
+}
+
+/**
+ * Formas de credencial reconocibles por su prefijo/estructura. Se apunta a
+ * precisión razonable: prefijos propietarios y claves PEM, no "cualquier string
+ * largo", que dispararía en cada hash del repo.
+ */
+const CONTENT_PATTERNS = [
+  { label: 'clave de API de Anthropic', re: /\bsk-ant-[A-Za-z0-9_-]{20,}/ },
+  { label: 'clave de API de OpenAI', re: /\bsk-(?:proj-)?[A-Za-z0-9]{32,}/ },
+  { label: 'token de GitHub', re: /\bgh[pousr]_[A-Za-z0-9]{36,}/ },
+  { label: 'access key de AWS', re: /\bAKIA[0-9A-Z]{16}\b/ },
+  { label: 'clave de API de Google', re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { label: 'token de Slack', re: /\bxox[abprs]-[0-9A-Za-z-]{10,}/ },
+  { label: 'clave de Stripe', re: /\b[sr]k_live_[0-9A-Za-z]{20,}/ },
+  { label: 'token de Supabase / JWT', re: /\bey[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/ },
+  { label: 'clave privada PEM', re: /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/ },
+  { label: 'token de acceso personal de Shilo', re: /\bshilo_pat_[A-Za-z0-9_-]{20,}/ },
+  { label: 'contraseña en una URL', re: /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]{6,}@/i },
+];
+
+// Cuánto se mira de cada archivo. Los secretos viven arriba (config, headers),
+// y acotarlo mantiene el escaneo en costo despreciable.
+const SCAN_BYTES = 8192;
+
+/**
+ * Escanea un fragmento de texto. Devuelve `[{ line, label }]` — sin el valor.
+ */
+function scanText(text) {
+  const hits = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length > 4000) continue; // minificado/base64: ruido, no señal
+    for (const { label, re } of CONTENT_PATTERNS) {
+      if (re.test(line)) {
+        hits.push({ line: i + 1, label });
+        break; // un hallazgo por línea alcanza para avisar
+      }
+    }
+  }
+  return hits;
+}
+
+/**
+ * Inspecciona un archivo ya leído (o su cabecera) y devuelve los hallazgos.
+ *
+ *   inspect('.env', head) ->
+ *     [{ relPath, kind: 'name', pattern: '.env' },
+ *      { relPath, kind: 'content', line: 4, label: '...' }]
+ */
+function inspect(relPath, head) {
+  const findings = [];
+
+  const pattern = deniedByName(relPath);
+  if (pattern) findings.push({ relPath, kind: 'name', pattern });
+
+  if (typeof head === 'string' && head) {
+    for (const hit of scanText(head.slice(0, SCAN_BYTES))) {
+      findings.push({ relPath, kind: 'content', line: hit.line, label: hit.label });
+    }
+  }
+
+  return findings;
+}
+
+/**
+ * Agrupa hallazgos por archivo, preservando el orden de aparición.
+ * Devuelve `[{ relPath, name: <patrón|null>, content: [{ line, label }] }]`.
+ */
+function groupByFile(findings) {
+  const byPath = new Map();
+  for (const f of findings) {
+    if (!byPath.has(f.relPath)) {
+      byPath.set(f.relPath, { relPath: f.relPath, name: null, content: [] });
+    }
+    const entry = byPath.get(f.relPath);
+    if (f.kind === 'name') entry.name = f.pattern;
+    else entry.content.push({ line: f.line, label: f.label });
+  }
+  return [...byPath.values()];
+}
+
+module.exports = {
+  DENY_NAMES,
+  DENY_EXCEPTIONS,
+  CONTENT_PATTERNS,
+  SCAN_BYTES,
+  deniedByName,
+  scanText,
+  inspect,
+  groupByFile,
+};

package/src/sync.js

@@ -16,6 +16,43 @@ const config = require('./config');
 const { walk } = require('./walk');
 
 const CONCURRENCY = 8; // pool para el N+1 de listar carpetas (el backend no tiene árbol recursivo)
+const MAX_CONCURRENCY = 32;
+
+/**
+ * Concurrencia efectiva: `--concurrency <n>` pisa a `SHILO_CONCURRENCY`, que
+ * pisa al default. Un valor inválido no rompe el comando, cae al default.
+ * El default (8) es conservador en fibra y agresivo en una conexión mala; esto
+ * deja que quien sabe cuál tiene, lo diga.
+ */
+function resolveConcurrency(args = {}) {
+  const raw = args.concurrency != null ? args.concurrency : process.env.SHILO_CONCURRENCY;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n < 1) return CONCURRENCY;
+  return Math.min(Math.floor(n), MAX_CONCURRENCY);
+}
+
+/**
+ * Control de concurrencia que puede bajar sola ante un 429. `runPool` la
+ * consulta antes de tomar cada ítem, así que el ajuste tiene efecto dentro de
+ * la misma tanda, no recién en la siguiente.
+ */
+function makeThrottle(initial) {
+  let limit = initial;
+  let warned = false;
+  return {
+    get limit() {
+      return limit;
+    },
+    /** Devuelve true la primera vez, para que el caller avise una sola vez. */
+    reduce() {
+      const before = limit;
+      limit = Math.max(1, Math.floor(limit / 2));
+      const first = !warned && limit < before;
+      if (first) warned = true;
+      return first;
+    },
+  };
+}
 
 // Mime types que sabemos que vuelven como texto legible. El backend siempre
 // devuelve el contenido vía `data.text()`, así que un binario (p.ej. image/png
@@ -76,44 +113,72 @@ function makeCredsManager(client, cfg) {
  * Corre `worker(item)` sobre `items` con concurrencia limitada. Preserva el
  * orden de `items` en el array de resultados. Un worker que lanza deja el hueco
  * como `{ __error: <msg>, item }` para que el caller decida.
+ *
+ * `concurrency` puede ser un número o un throttle de `makeThrottle()`: en ese
+ * caso el límite se relee antes de tomar cada ítem, y los workers sobrantes se
+ * retiran solos si el límite bajó (p. ej. tras un 429).
+ *
+ * `onProgress(done, total)` se llama después de cada ítem terminado.
  */
-async function runPool(items, concurrency, worker) {
+async function runPool(items, concurrency, worker, { onProgress = null } = {}) {
   const results = new Array(items.length);
+  const throttle = typeof concurrency === 'number' ? { limit: concurrency } : concurrency;
+  const initial = Math.min(throttle.limit, items.length);
   let next = 0;
+  let active = 0;
+  let done = 0;
 
   async function drain() {
+    active++;
     while (next < items.length) {
+      // Si el límite bajó mientras corríamos, este worker se retira.
+      if (active > throttle.limit) break;
       const i = next++;
       try {
         results[i] = await worker(items[i], i);
       } catch (e) {
         results[i] = { __error: e.message, item: items[i] };
       }
+      done++;
+      if (onProgress) onProgress(done, items.length);
     }
+    active--;
   }
 
   const runners = [];
-  for (let k = 0; k < Math.min(concurrency, items.length); k++) {
-    runners.push(drain());
-  }
+  for (let k = 0; k < initial; k++) runners.push(drain());
   await Promise.all(runners);
+
+  // Si todos los workers se retiraron por un recorte de concurrencia pero
+  // quedaron ítems, se completa con un pase al límite vigente.
+  while (next < items.length) {
+    const rest = [];
+    for (let k = 0; k < Math.max(1, throttle.limit); k++) rest.push(drain());
+    await Promise.all(rest);
+  }
+
   return results;
 }
 
 /**
  * Recorre el árbol remoto de un proyecto listando carpeta por carpeta (BFS con
  * pool). El backend no expone un endpoint recursivo, así que es N+1: un request
- * por carpeta, pero ninguno baja contenido. Devuelve `{ files, errors }`:
- *   files: [{ repoPath, name, id, size, mime_type, updated_at }]
- *   errors: [{ folderPath, reason }]
+ * por carpeta, pero ninguno baja contenido. Devuelve `{ files, folders, errors }`:
+ *   files:   [{ repoPath, name, id, size, mime_type, content_hash, storage_path, updated_at }]
+ *   folders: Set<repoPath>   — lo que ya existe, para no re-crearlo en el push
+ *   errors:  [{ folderPath, reason }]
+ *
+ * Un solo recorrido acá reemplaza un `getFileMeta` por archivo en el push: para
+ * un repo de 142 archivos en 30 carpetas, 142 requests pasan a 30.
  */
-async function walkRemote(client, projectId, mgr) {
+async function walkRemote(client, projectId, mgr, { concurrency = CONCURRENCY } = {}) {
   const files = [];
+  const folders = new Set();
   const errors = [];
   let frontier = ['']; // rutas de carpeta a listar; '' = raíz
 
   while (frontier.length > 0) {
-    const listed = await runPool(frontier, CONCURRENCY, async (folderPath) => {
+    const listed = await runPool(frontier, concurrency, async (folderPath) => {
       const creds = await mgr.valid();
       const { files: entries } = await client.listFiles(projectId, creds, folderPath);
       return { folderPath, entries };
@@ -129,6 +194,7 @@ async function walkRemote(client, projectId, mgr) {
       for (const entry of entries) {
         const repoPath = folderPath ? `${folderPath}/${entry.name}` : entry.name;
         if (entry.type === 'folder') {
+          folders.add(repoPath);
           nextFrontier.push(repoPath);
         } else {
           files.push({
@@ -137,6 +203,13 @@ async function walkRemote(client, projectId, mgr) {
             id: entry.id,
             size: entry.size,
             mime_type: entry.mime_type,
+            // content_hash y storage_path vienen en el listado desde la
+            // migración 010: con el hash se decide "cambió / no cambió" sin
+            // descargar el archivo, y con el storage_path se arma el commit sin
+            // pedir la metadata de nuevo. En archivos anteriores a 010 el hash
+            // es null y el llamador cae al camino viejo.
+            content_hash: entry.content_hash || null,
+            storage_path: entry.storage_path || null,
             updated_at: entry.updated_at || entry.created_at || null,
           });
         }
@@ -146,7 +219,7 @@ async function walkRemote(client, projectId, mgr) {
   }
 
   files.sort((a, b) => a.repoPath.localeCompare(b.repoPath));
-  return { files, errors };
+  return { files, folders, errors };
 }
 
 /**
@@ -328,6 +401,9 @@ function toRepoPath(dir, userPath) {
 
 module.exports = {
   CONCURRENCY,
+  MAX_CONCURRENCY,
+  resolveConcurrency,
+  makeThrottle,
   isTextMime,
   makeCredsManager,
   runPool,

package/src/textguard.js

@@ -4,14 +4,20 @@
  * Validación de nombres y detección de binarios para el push.
  *
  * Shilo sólo acepta contenido de texto (el endpoint path-based sube el body
- * como utf8, así que un binario se corrompería) y restringe los nombres de
- * archivo/carpeta a un charset acotado. Aquí filtramos ambos casos ANTES de
- * tocar la red, para poder avisar y saltar.
+ * como utf8, así que un binario se corrompería) y rechaza los nombres de
+ * archivo/carpeta que rompen una ruta o no son portables. Aquí filtramos ambos
+ * casos ANTES de tocar la red, para poder avisar y saltar.
  */
 
-// Charset permitido por el backend (ver backend/api/files/[projectId].js):
-//   ^[a-zA-Z0-9._\-\[\]()@]+$  y ni "." ni ".." ni separadores de ruta.
-const VALID_NAME = /^[a-zA-Z0-9._\-[\]()@]+$/;
+// Espejo de `backend/utils/filenames.js`: lista negra, no lista blanca. El
+// backend acepta cualquier carácter que no rompa una ruta —acentos, espacios,
+// kanji—, así que restringir acá sólo hacía que un repo perfectamente válido
+// se subiera incompleto.
+const ILLEGAL_CHARS = /[<>:"/\\|?*]/;
+
+// Nombres de dispositivo reservados de Windows, con o sin extensión.
+const WIN_RESERVED = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\.|$)/i;
+
 const MAX_NAME_LEN = 255;
 const MAX_FILE_BYTES = 26214400; // 25 MB, igual que el backend
 const MAX_DEPTH = 10; // profundidad máxima de carpetas
@@ -32,27 +38,49 @@ const BINARY_EXTENSIONS = new Set([
   'ttf', 'otf', 'woff', 'woff2', 'eot', 'psd', 'ai', 'sketch', 'db', 'sqlite',
 ]);
 
+// Los bytes de control se chequean por código y no con un rango en el regex:
+// escritos literalmente el archivo deja de ser texto plano para git y grep, y
+// escritos como escape son invisibles al leer el código. Un bucle es explícito.
+function hasControlChars(str) {
+  for (let i = 0; i < str.length; i += 1) {
+    const code = str.charCodeAt(i);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+
 /**
  * Valida un nombre individual (archivo o carpeta) contra las reglas de Shilo.
+ * Espejo de `validateFileName` en `backend/utils/filenames.js`: mismos rechazos,
+ * mismo orden, con el mensaje en el idioma del CLI.
  * Devuelve `{ ok: true }` o `{ ok: false, reason }`.
  */
-function validateName(name) {
+function validateName(rawName) {
+  // El backend guarda el nombre normalizado y sin espacios al borde: validamos
+  // sobre esa misma forma para no aceptar acá algo que allá se transforma.
+  const name = typeof rawName === 'string' ? rawName.normalize('NFC').trim() : '';
+
   if (!name || name === '.' || name === '..') {
     return { ok: false, reason: 'nombre reservado (. o ..)' };
   }
   if (name.length > MAX_NAME_LEN) {
     return { ok: false, reason: `nombre demasiado largo (>${MAX_NAME_LEN})` };
   }
-  if (name.includes('/') || name.includes('\\')) {
-    return { ok: false, reason: 'contiene separador de ruta' };
-  }
-  if (!VALID_NAME.test(name)) {
+  if (ILLEGAL_CHARS.test(name) || hasControlChars(name)) {
     return {
       ok: false,
-      reason: 'caracteres no permitidos (usá solo A-Z a-z 0-9 . _ - [ ] ( ) @ y sin espacios/acentos)',
+      reason: 'caracteres no permitidos (/ \\ : * ? " < > | o bytes de control)',
     };
   }
-  return { ok: true };
+  if (WIN_RESERVED.test(name)) {
+    return { ok: false, reason: 'nombre de dispositivo reservado en Windows (CON, NUL, COM1…)' };
+  }
+  // Windows descarta el punto final al crear el archivo, así que "informe." y
+  // "informe" terminarían siendo el mismo archivo en disco.
+  if (name.endsWith('.')) {
+    return { ok: false, reason: 'no puede terminar en punto' };
+  }
+  return { ok: true, name };
 }
 
 /**
@@ -118,7 +146,9 @@ function classifyContent(name, buffer) {
 }
 
 module.exports = {
-  VALID_NAME,
+  ILLEGAL_CHARS,
+  WIN_RESERVED,
+  hasControlChars,
   MAX_NAME_LEN,
   MAX_FILE_BYTES,
   MAX_DEPTH,