create-panal-agent 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-panal-agent",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Crea un agente de IA para Panal, funcionando y cobrando on-chain, en cinco minutos",
   "type": "module",
   "license": "MIT",

package/template/_package.json

@@ -10,7 +10,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@panal/sdk": "^0.5.0",
+    "@panal/sdk": "^0.6.0",
     "dotenv": "^17.0.0",
     "tsx": "^4.19.0",
     "viem": "^2.21.0"

package/template/src/agent.ts

@@ -11,6 +11,8 @@
  * anclado en la cadena al entregar. Si luego sirves otra cosa, se nota.
  */
 
+import { textoAPdf } from './pdf.js';
+
 export interface TaskContext {
   /**
    * El id de la tarea en el escrow, o `null` si esto es una llamada x402: ahí
@@ -25,6 +27,27 @@ export interface TaskContext {
   deadline: bigint;
 }
 
+/** Un archivo que entregas junto al texto. */
+export interface TaskFile {
+  /** Cómo se va a llamar. Sin rutas: `informe.pdf`, no `salida/informe.pdf`. */
+  name: string;
+  /** El contenido. Un Buffer/Uint8Array para binario, un string para texto. */
+  data: Uint8Array | string;
+  /** Tipo MIME, si lo sabes: `application/pdf`, `image/png`… */
+  mime?: string;
+}
+
+/**
+ * Lo que devuelve tu agente: un texto, o un texto con archivos.
+ *
+ * Los archivos no viajan a la cadena —no cabrían—, pero SU HASH sí: el motor
+ * lo mete en el texto de la entrega antes de anclarlo. Así el cliente puede
+ * descargarlos y demostrar que son exactamente los que le entregaste. Un
+ * enlace a secas no daría eso: quien lo aloja podría cambiar el archivo
+ * después de cobrar y no habría con qué demostrarlo.
+ */
+export type TaskResult = string | { text: string; files?: TaskFile[] };
+
 /** Cómo se llama esto en los logs: `#31` si viene del escrow, `x402` si no. */
 function etiqueta(ctx: TaskContext): string {
   return ctx.taskId === null ? 'x402' : `#${ctx.taskId}`;
@@ -35,9 +58,20 @@ function etiqueta(ctx: TaskContext): string {
  *
  * @param brief  El encargo, tal y como lo escribió el cliente.
  * @param ctx    Datos de la tarea, por si te sirven.
- * @returns      El trabajo terminado.
+ * @returns      El trabajo terminado: un texto, o `{ text, files }` si además
+ *               entregas archivos. Por ejemplo:
+ *
+ *                   return {
+ *                     text: 'Aquí tienes el informe que pediste.',
+ *                     files: [{ name: 'informe.pdf', data: pdf, mime: 'application/pdf' }],
+ *                   };
+ *
+ *               No tienes que calcular ningún hash ni servir ninguna descarga:
+ *               de eso se ocupa `server.ts`. Ojo con una cosa, y solo con una:
+ *               si construyes el nombre a partir del encargo, límpialo antes,
+ *               porque lo escribe quien te contrató.
  */
-export async function handleTask(brief: string, ctx: TaskContext): Promise<string> {
+export async function handleTask(brief: string, ctx: TaskContext): Promise<TaskResult> {
   // ──────────────────────────────────────────────────────────────────────────
   // EJEMPLO: un agente que responde con un LLM.
   //
@@ -66,7 +100,7 @@ export async function handleTask(brief: string, ctx: TaskContext): Promise<strin
     const problema = revisar(brief, texto);
     if (!problema) {
       console.log(`[agente] ${etiqueta(ctx)} resuelta: ${texto.length} caracteres`);
-      return texto;
+      return conPdfSiLoPidio(brief, texto, ctx);
     }
     console.error(`[agente] ${etiqueta(ctx)} intento ${intento}: ${problema}`);
     // A la segunda se entrega igual. Tu revisión puede equivocarse, y un falso
@@ -74,7 +108,7 @@ export async function handleTask(brief: string, ctx: TaskContext): Promise<strin
     // entregar algo imperfecto y que él decida, que dejarlo sin nada.
     if (intento === 2) {
       console.error(`[agente] ${etiqueta(ctx)} se entrega pese a: ${problema}`);
-      return texto;
+      return conPdfSiLoPidio(brief, texto, ctx);
     }
     queja = problema;
   }
@@ -112,9 +146,42 @@ function revisar(brief: string, resultado: string): string | null {
     return 'la respuesta lleva Markdown (**, # o ```) y el cliente lo verá en crudo: devuélvela en texto plano';
   }
 
+  // Si el cliente pide "y mándamelo en PDF", el modelo tiende a contestar que
+  // él no genera archivos — mientras el archivo va adjunto. Prohibírselo en el
+  // prompt reduce el problema pero no lo cierra: llegó a salir "no menciono el
+  // PDF porque no debo". Se comprueba, y se reintenta.
+  //
+  // Se busca la palabra JUNTO A una frase autorreferencial, no la palabra
+  // suelta: alguien puede encargar de verdad trabajo sobre PDFs, y ahí la
+  // palabra es el encargo.
+  const meta = /(no (puedo|incluyo|voy a|debo|menciono|se adjunt|se genera)|el sistema (se encarg|lo adjunt)|i (cannot|can't|am not)|the system will)/i;
+  for (const linea of resultado.split('\n')) {
+    if (/\b(pdf|archivo|fichero|adjunto|attachment|file)\b/i.test(linea) && meta.test(linea)) {
+      return 'has comentado que no generas archivos; el agente los adjunta solo. Reescríbelo sin ninguna referencia a archivos, PDFs ni adjuntos: solo el trabajo';
+    }
+  }
+
   return null;
 }
 
+/**
+ * Adjunta el trabajo en PDF si el encargo lo pedía. El texto se entrega igual.
+ *
+ * Se mira el encargo en vez de mandarlo siempre: a un agente también lo llaman
+ * otros programas, y adjuntarles un archivo que no pidieron es peso muerto.
+ *
+ * Bórralo si tu agente no entrega PDFs, o cámbialo por lo que tú generes: una
+ * imagen, un CSV, un ZIP. El motor calcula el hash de lo que devuelvas aquí y
+ * lo ancla en la cadena, así que el cliente puede demostrar que el archivo que
+ * se baja es exactamente el que le entregaste.
+ */
+function conPdfSiLoPidio(brief: string, texto: string, ctx: TaskContext): TaskResult {
+  if (!/\bpdf\b/i.test(brief)) return texto;
+  const pdf = textoAPdf(`Panal - entrega ${etiqueta(ctx)}`, texto);
+  console.log(`[agente] ${etiqueta(ctx)} PDF de ${pdf.byteLength} bytes adjunto`);
+  return { text: texto, files: [{ name: 'entrega.pdf', data: pdf, mime: 'application/pdf' }] };
+}
+
 async function pedirAlModelo(brief: string, apiKey: string, queja: string | null): Promise<string> {
   const res = await fetch(`${process.env.LLM_BASE_URL ?? 'https://api.openai.com/v1'}/chat/completions`, {
     method: 'POST',
@@ -139,7 +206,11 @@ async function pedirAlModelo(brief: string, apiKey: string, queja: string | null
             'You are a professional agent on the Panal marketplace. ' +
             'RULE 1: detect the language of the request and reply in that exact same language; never switch. ' +
             'RULE 2: plain text only, never Markdown — no # headings, no ** bold, no backticks. ' +
-            'RULE 3: deliver finished professional work, with no preamble or meta-commentary.',
+            'RULE 3: deliver finished professional work, with no preamble or meta-commentary.\n' +
+            // El agente adjunta el archivo por su cuenta; el modelo no se entera
+            // y, sin esta regla, se disculpa por no poder generarlo.
+            'RULE 4: the client may ask for the result as a PDF or a file. The agent attaches it after ' +
+            'you answer. Never mention files, PDFs or attachments — not even to say you cannot make them.',
         },
         { role: 'user', content: brief },
         // La corrección va como un mensaje más: decirle QUÉ falló acierta mucho

package/template/src/pdf.ts

@@ -0,0 +1,180 @@
+/**
+ * Un PDF de verdad, sin dependencias. Puedes borrar este archivo si tu agente
+ * no entrega PDFs.
+ *
+ * No es una plantilla ni un HTML impreso: se escriben los objetos del PDF a
+ * mano, con su tabla xref y sus offsets en bytes. Sale un archivo que abre
+ * cualquier lector, y no añade ni un paquete a tus dependencias — meter una
+ * librería de 4 MB para pintar texto monoespaciado en un A4 no sale a cuenta.
+ *
+ * Se usa desde `agent.ts`:
+ *
+ *     const pdf = textoAPdf('Mi informe', texto);
+ *     return { text: texto, files: [{ name: 'informe.pdf', data: pdf, mime: 'application/pdf' }] };
+ *
+ * El motor calcula su hash y lo ancla en la cadena; tú no tocas nada de eso.
+ *
+ * Lo que hace bien y cuesta acertar a mano: parte las líneas largas para que no
+ * se salgan del papel, pagina solo, y traduce los símbolos que la codificación
+ * del PDF no tiene en vez de destrozarlos en silencio.
+ */
+
+/** A4 en puntos, que es la unidad del PDF. */
+const ANCHO = 595;
+const ALTO = 842;
+const MARGEN = 50;
+const CUERPO = 9.5;
+const INTERLINEA = 12.5;
+/** Cuántas líneas caben en una página con estos márgenes. */
+const LINEAS_POR_PAGINA = Math.floor((ALTO - MARGEN * 2) / INTERLINEA);
+/** Ancho de caracteres a 9.5pt en Courier: 0.6 em, redondeado a la baja. */
+const COLUMNAS = Math.floor((ANCHO - MARGEN * 2) / (CUERPO * 0.6));
+
+/**
+ * Escapa un texto para meterlo entre paréntesis en un PDF.
+ *
+ * Los paréntesis delimitan las cadenas, así que uno sin escapar rompe el
+ * archivo entero — y un JSON viene lleno de ellos.
+ */
+function escapar(texto: string): string {
+  return texto.replace(/\\/g, '\\\\').replace(/\(/g, '\\(').replace(/\)/g, '\\)');
+}
+
+/**
+ * Parte las líneas largas para que no se salgan del papel.
+ *
+ * Un PDF no ajusta el texto solo: lo que no cabe, sencillamente no se ve. Con
+ * un JSON de una sola línea eso significa entregar una hoja casi en blanco.
+ */
+function ajustar(lineas: string[]): string[] {
+  const out: string[] = [];
+  for (const linea of lineas) {
+    if (linea.length <= COLUMNAS) {
+      out.push(linea);
+      continue;
+    }
+    // Se conserva la sangría al partir: en un JSON es lo que deja ver la
+    // estructura, y sin ella el corte lo vuelve ilegible.
+    const sangria = /^\s*/.exec(linea)![0].slice(0, 20);
+    let resto = linea;
+    let primera = true;
+    while (resto.length > 0) {
+      const ancho = primera ? COLUMNAS : COLUMNAS - sangria.length;
+      out.push((primera ? '' : sangria) + resto.slice(0, ancho));
+      resto = resto.slice(ancho);
+      primera = false;
+    }
+  }
+  return out;
+}
+
+/**
+ * Sustitutos ASCII de los símbolos que WinAnsiEncoding no tiene.
+ *
+ * Sin esto, `Buffer.from(txt, 'latin1')` los recorta al byte bajo y salen
+ * caracteres que no significan nada: un "≠" acababa impreso como "`", así que
+ * un caso de prueba que decía "b ≠ 0" pasaba a decir "b ` 0". Silencioso, y
+ * dentro de un entregable que se cobra.
+ */
+const SUSTITUTOS: Record<string, string> = {
+  '≠': '!=', '≤': '<=', '≥': '>=', '≈': '~=', '±': '+/-', '×': 'x', '÷': '/',
+  '→': '->', '←': '<-', '⇒': '=>', '∞': 'infinito', '∅': 'vacio',
+  '“': '"', '”': '"', '„': '"', '‘': "'", '’': "'", '‹': '<', '›': '>',
+  '–': '-', '—': '-', '…': '...', '•': '-', '·': '·', '™': '(TM)', '€': 'EUR',
+};
+
+/**
+ * Latin-1, que es lo que entiende WinAnsiEncoding —la codificación de las
+ * fuentes base del PDF—, sustituyendo antes lo que no cabe.
+ *
+ * Lo que no tiene sustituto se marca con "?" a propósito: un interrogante
+ * avisa de que ahí faltaba algo; un carácter aleatorio miente.
+ */
+function aLatin1(texto: string): Buffer {
+  const convertido = [...texto]
+    .map((c) => {
+      if (SUSTITUTOS[c]) return SUSTITUTOS[c];
+      return c.codePointAt(0)! <= 0xff ? c : '?';
+    })
+    .join('');
+  return Buffer.from(convertido, 'latin1');
+}
+
+/** Construye el PDF. Devuelve los bytes, listos para escribir o entregar. */
+export function textoAPdf(titulo: string, contenido: string): Uint8Array {
+  const lineas = ajustar([titulo, '', ...contenido.split('\n')]);
+
+  // Se reparte en páginas antes de escribir nada: hay que saber cuántas son
+  // para numerar los objetos, y en un PDF los objetos se referencian por número.
+  const paginas: string[][] = [];
+  for (let i = 0; i < lineas.length; i += LINEAS_POR_PAGINA) {
+    paginas.push(lineas.slice(i, i + LINEAS_POR_PAGINA));
+  }
+  if (paginas.length === 0) paginas.push(['(sin contenido)']);
+
+  // Numeración: 1 catálogo, 2 árbol de páginas, 3 fuente, y luego cada página
+  // con su flujo de contenido, dos objetos por página.
+  const FUENTE = 3;
+  const primeraPagina = 4;
+  const idPagina = (i: number) => primeraPagina + i * 2;
+  const idContenido = (i: number) => primeraPagina + i * 2 + 1;
+
+  const objetos: Buffer[] = [];
+  const add = (n: number, cuerpo: string | Buffer) => {
+    objetos[n] = Buffer.concat([
+      aLatin1(`${n} 0 obj\n`),
+      typeof cuerpo === 'string' ? aLatin1(cuerpo) : cuerpo,
+      aLatin1('\nendobj\n'),
+    ]);
+  };
+
+  const kids = paginas.map((_, i) => `${idPagina(i)} 0 R`).join(' ');
+  add(1, '<< /Type /Catalog /Pages 2 0 R >>');
+  add(2, `<< /Type /Pages /Kids [${kids}] /Count ${paginas.length} >>`);
+  add(FUENTE, '<< /Type /Font /Subtype /Type1 /BaseFont /Courier /Encoding /WinAnsiEncoding >>');
+
+  paginas.forEach((lineasPagina, i) => {
+    add(
+      idPagina(i),
+      `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${ANCHO} ${ALTO}] ` +
+        `/Resources << /Font << /F1 ${FUENTE} 0 R >> >> /Contents ${idContenido(i)} 0 R >>`,
+    );
+
+    const flujo = aLatin1(
+      [
+        'BT',
+        `/F1 ${CUERPO} Tf`,
+        `${INTERLINEA} TL`,
+        `${MARGEN} ${ALTO - MARGEN} Td`,
+        ...lineasPagina.map((l) => `(${escapar(l)}) Tj T*`),
+        'ET',
+      ].join('\n'),
+    );
+    // /Length va en BYTES, no en caracteres: con acentos no es lo mismo, y un
+    // lector estricto rechaza el archivo si no cuadra.
+    add(idContenido(i), Buffer.concat([aLatin1(`<< /Length ${flujo.length} >>\nstream\n`), flujo, aLatin1('\nendstream')]));
+  });
+
+  // Ensamblado: hay que ir apuntando el offset en bytes de cada objeto, porque
+  // la tabla xref del final los indexa por posición absoluta en el archivo.
+  const total = objetos.length - 1;
+  const partes: Buffer[] = [aLatin1('%PDF-1.4\n')];
+  const offsets: number[] = [];
+  let cursor = partes[0]!.length;
+
+  for (let n = 1; n <= total; n++) {
+    offsets[n] = cursor;
+    partes.push(objetos[n]!);
+    cursor += objetos[n]!.length;
+  }
+
+  const xref = [
+    'xref',
+    `0 ${total + 1}`,
+    '0000000000 65535 f ',
+    ...Array.from({ length: total }, (_, i) => `${String(offsets[i + 1]).padStart(10, '0')} 00000 n `),
+  ].join('\n');
+
+  partes.push(aLatin1(`${xref}\ntrailer\n<< /Size ${total + 1} /Root 1 0 R >>\nstartxref\n${cursor}\n%%EOF\n`));
+  return new Uint8Array(Buffer.concat(partes));
+}

package/template/src/server.ts

@@ -25,20 +25,24 @@ import { createServer, type IncomingMessage, type ServerResponse } from 'node:ht
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import {
+  appendFilesManifest,
   buildQuote,
   createPanalClient,
   MAINNET_ADDRESSES,
   parsePaymentHeader,
   permitNonce,
   readPermitDomain,
+  sanitizeFileName,
   TaskStatus,
   verifyAndSettle,
+  type DeliveredFile,
   type PermitDomain,
 } from '@panal/sdk';
 import { privateKeyToAccount } from 'viem/accounts';
 import { isAddress, keccak256, parseEther, toBytes, verifyMessage } from 'viem';
 import type { Address } from 'viem';
 import { handleTask } from './agent.js';
+import type { TaskFile, TaskResult } from './agent.js';
 
 const PORT = Number(process.env.PORT ?? 8787);
 const DATA_DIR = process.env.DATA_DIR ?? './data';
@@ -113,6 +117,8 @@ async function dominioPermit(): Promise<PermitDomain> {
 
 mkdirSync(DATA_DIR, { recursive: true });
 const resultPath = (taskId: bigint) => join(DATA_DIR, `result-${taskId}.txt`);
+/** Carpeta de los archivos de una tarea. Una por tarea, para no mezclarlas. */
+const filesDir = (taskId: bigint) => join(DATA_DIR, 'files', taskId.toString());
 
 function saveResult(taskId: bigint, text: string): void {
   writeFileSync(resultPath(taskId), text, 'utf8');
@@ -125,6 +131,46 @@ function loadResult(taskId: bigint): string | null {
   }
 }
 
+/**
+ * Guarda en disco los archivos de una entrega y devuelve su manifiesto.
+ *
+ * El nombre se limpia con `sanitizeFileName` ANTES de tocar el disco: llega en
+ * lo que devuelve `handleTask`, y un agente que construya el nombre a partir
+ * del encargo del cliente estaría dejando que un desconocido elija dónde
+ * escribir. Un `../../.env` acabaría en la raíz del proyecto.
+ */
+function saveFiles(taskId: bigint, files: TaskFile[]): DeliveredFile[] {
+  const dir = filesDir(taskId);
+  mkdirSync(dir, { recursive: true });
+
+  return files.map((f) => {
+    const name = sanitizeFileName(f.name);
+    const bytes = typeof f.data === 'string' ? new TextEncoder().encode(f.data) : new Uint8Array(f.data);
+    writeFileSync(join(dir, name), bytes);
+    return {
+      name,
+      size: bytes.byteLength,
+      ...(f.mime ? { mime: f.mime } : {}),
+      // El hash de los BYTES, no del enlace: es lo único que sobrevive a que
+      // alguien cambie el archivo después de haber cobrado.
+      hash: keccak256(bytes),
+      path: `/files/${taskId}/${encodeURIComponent(name)}`,
+    };
+  });
+}
+
+/**
+ * Deja lo que devolvió `handleTask` en una forma sola.
+ *
+ * Se acepta un string a secas porque es lo que devuelve el 95 % de los agentes
+ * y obligarles a envolverlo en un objeto sería cobrarles la complejidad de una
+ * función que no usan.
+ */
+function normalizarSalida(salida: TaskResult): { text: string; files: TaskFile[] } {
+  if (typeof salida === 'string') return { text: salida, files: [] };
+  return { text: salida.text, files: salida.files ?? [] };
+}
+
 /** Tareas que se están procesando ahora mismo: evita trabajar dos veces. */
 const inFlight = new Set<string>();
 
@@ -154,13 +200,19 @@ async function work(taskId: bigint, brief: string): Promise<void> {
   inFlight.add(key);
   try {
     const task = await panal.getTask(taskId);
-    const text = await handleTask(brief, {
+    const salida = await handleTask(brief, {
       taskId,
       client: task.client,
       amount: task.amount,
       deadline: task.deadline,
     });
 
+    // Tu handleTask puede devolver un texto a secas —lo normal— o un texto con
+    // archivos. Los archivos se escriben en disco y su hash se cuela en el
+    // texto: lo que se ancla en la cadena pasa a cubrirlos también.
+    const { text: cuerpo, files } = normalizarSalida(salida);
+    const text = files.length ? appendFilesManifest(cuerpo, saveFiles(taskId, files)) : cuerpo;
+
     // Primero se guarda y luego se entrega: si el orden fuera al revés y el
     // proceso muriera entre medias, el hash estaría anclado on-chain y el texto
     // perdido, o sea una entrega imposible de cumplir.
@@ -379,12 +431,23 @@ const server = createServer((req, res) => {
       // Ya está cobrado: pase lo que pase a partir de aquí, hay que responder
       // algo. Si el modelo revienta, se dice; callarse sería quedarse el dinero.
       try {
-        const answer = await handleTask(prompt, {
+        const salida = await handleTask(prompt, {
           taskId: null,
           client: leido.payment.payer,
           amount: cobro.amount,
           deadline: 0n,
         });
+        // En una llamada x402 no hay tarea, así que no hay nada que anclar ni
+        // ninguna firma con la que proteger una descarga: los archivos no
+        // tienen dónde agarrarse. Se responde el texto y se avisa en el log en
+        // vez de callarlo, que si no el autor busca el fallo donde no está.
+        const { text: answer, files } = normalizarSalida(salida);
+        if (files.length) {
+          console.error(
+            `[x402] tu handleTask devolvió ${files.length} archivo(s) y una llamada x402 no puede entregarlos: ` +
+              'no hay tarea que los ancle ni firma que proteja la descarga. Solo va el texto.',
+          );
+        }
         res.setHeader('x-payment-tx', cobro.txHash);
         json(res, 200, { answer, paid: { txHash: cobro.txHash, amount: cobro.amount.toString(), asset: X402_TOKEN } });
       } catch (err) {
@@ -495,6 +558,60 @@ const server = createServer((req, res) => {
       return;
     }
 
+    // ---- El cliente se baja los archivos de su entrega ----------------------
+    //
+    // Se protege igual que el resultado, y con LA MISMA firma: `Panal resultado
+    // #<id>` abre el texto y todos sus archivos. Firmar una vez por archivo
+    // sería pedirle al cliente cuatro firmas por una entrega de cuatro PDFs.
+    const archivo = /^\/files\/(\d+)\/([^/]+)$/.exec(url.pathname);
+    if (archivo && req.method === 'GET') {
+      const taskId = BigInt(archivo[1]!);
+      const address = url.searchParams.get('address');
+      const signature = url.searchParams.get('signature');
+      if (!address || !signature) {
+        json(res, 400, { error: 'faltan address y signature' });
+        return;
+      }
+      const task = await panal.getTask(taskId);
+      if (address.toLowerCase() !== task.client.toLowerCase()) {
+        json(res, 403, { error: 'solo el cliente de la tarea puede descargar sus archivos' });
+        return;
+      }
+      if (!(await signedBy(resultSignMessage(taskId), signature, task.client))) {
+        json(res, 401, { error: 'firma inválida' });
+        return;
+      }
+
+      // El nombre viene de la URL, o sea de fuera: se limpia igual que al
+      // escribirlo. Sin esto, `/files/31/..%2F..%2F.env` leería el .env.
+      let nombre: string;
+      try {
+        nombre = sanitizeFileName(decodeURIComponent(archivo[2]!));
+      } catch {
+        json(res, 400, { error: 'nombre de archivo inválido' });
+        return;
+      }
+
+      let bytes: Buffer;
+      try {
+        bytes = readFileSync(join(filesDir(taskId), nombre));
+      } catch {
+        json(res, 404, { error: 'esa tarea no tiene ese archivo' });
+        return;
+      }
+
+      res.writeHead(200, {
+        'content-type': 'application/octet-stream',
+        'content-length': bytes.byteLength,
+        // `attachment` a propósito: lo que hay dentro lo eligió el agente, y no
+        // se le deja que el navegador del cliente lo ejecute como una página.
+        'content-disposition': `attachment; filename="${nombre}"`,
+        'x-content-type-options': 'nosniff',
+      });
+      res.end(bytes);
+      return;
+    }
+
     json(res, 404, { error: 'no existe' });
   })().catch((err) => {
     console.error(`[http] ${err instanceof Error ? err.message : err}`);