autoform-mcp-server 1.2.1 → 1.4.0

package/dist/index.js

@@ -6,11 +6,12 @@ import { handleDetectFields, detectFieldsSchema } from './tools/detectFields.js'
 import { handleFillPdf, fillPdfSchema } from './tools/fillPdf.js';
 import { handleFillAtCoordinates, fillAtCoordinatesSchema, handleGetPdfInfo, getPdfInfoSchema } from './tools/fillAtCoordinates.js';
 import { handleFillBatchAtCoordinates, fillBatchAtCoordinatesSchema } from './tools/fillBatchAtCoordinates.js';
+import { handleFillBatchAcroForm, fillBatchAcroFormSchema } from './tools/fillBatchAcroForm.js';
 import { handleSaveCoordinatesAsTemplate, saveCoordinatesAsTemplateSchema } from './tools/saveCoordinatesAsTemplate.js';
 import { handleGenerateBatch, generateBatchSchema } from './tools/generateBatch.js';
 import { handleListTemplates, listTemplatesSchema } from './tools/manageTemplates.js';
 import { handleImportTemplate, importTemplateSchema } from './tools/importTemplate.js';
-const server = new Server({ name: 'autoform', version: '1.2.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'autoform', version: '1.4.0' }, { capabilities: { tools: {} } });
 // Register all tools
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -20,7 +21,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         // Single fill
         fillPdfSchema,
         fillAtCoordinatesSchema,
-        // Batch fill
+        // Batch fill (preferred for multiple documents)
+        fillBatchAcroFormSchema,
         fillBatchAtCoordinatesSchema,
         generateBatchSchema,
         // Template management
@@ -44,6 +46,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await handleFillAtCoordinates(args);
             case 'autoform_fill_batch_at_coordinates':
                 return await handleFillBatchAtCoordinates(args);
+            case 'autoform_fill_batch_acroform':
+                return await handleFillBatchAcroForm(args);
             case 'autoform_save_coordinates_as_template':
                 return await handleSaveCoordinatesAsTemplate(args);
             case 'autoform_generate_batch':
@@ -66,4 +70,4 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Start server
 const transport = new StdioServerTransport();
 await server.connect(transport);
-console.error('[AutoForm MCP] Server v1.2.0 started — 9 tools registered');
+console.error('[AutoForm MCP] Server v1.4.0 started — 10 tools registered');

package/dist/services/batchGenerator.js

@@ -23,11 +23,15 @@ export class BatchGenerator {
         }
         const outputPaths = [];
         const errors = [];
+        // If merging, write individuals to temp dir (will be cleaned up)
+        const workingDir = mergeIntoSingle
+            ? fs.mkdtempSync(path.join(OUTPUT_DIR, '.tmp_batch_'))
+            : OUTPUT_DIR;
         for (let docNum = 0; docNum < documentsNeeded; docNum++) {
             try {
                 const mappings = this.createMappings(data, template, docNum, mode);
                 const docNumStr = String(docNum + 1).padStart(3, '0');
-                const outputPath = path.join(OUTPUT_DIR, `${safeName}_${docNumStr}_${timestamp}.pdf`);
+                const outputPath = path.join(workingDir, `${safeName}_${docNumStr}_${timestamp}.pdf`);
                 await PdfService.generateSingleDocument(basePdf, mappings, outputPath);
                 outputPaths.push(outputPath);
             }
@@ -35,11 +39,28 @@ export class BatchGenerator {
                 errors.push(`Doc ${docNum + 1}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        // Merge if requested
+        // Merge if requested — and clean up individuals
         let mergedPath;
         if (mergeIntoSingle && outputPaths.length > 0) {
             mergedPath = path.join(OUTPUT_DIR, `${safeName}_merged_${timestamp}.pdf`);
             await PdfService.mergePdfs(outputPaths, mergedPath);
+            // Delete temp files and dir
+            for (const p of outputPaths) {
+                try {
+                    fs.unlinkSync(p);
+                }
+                catch { /* ignore */ }
+            }
+            try {
+                fs.rmdirSync(workingDir);
+            }
+            catch { /* ignore */ }
+            return {
+                documentsGenerated: outputPaths.length,
+                outputPaths: [],
+                mergedPath,
+                errors
+            };
         }
         return {
             documentsGenerated: outputPaths.length,

package/dist/services/pdfService.d.ts

@@ -11,6 +11,16 @@ export declare class PdfService {
     }>;
     /** Fill AcroForm fields and save */
     static fillAcroForm(pdfPath: string, values: Record<string, string>, outputPath: string): Promise<number>;
+    /**
+     * Batch fill AcroForm: generate N PDFs from the same base PDF, one per data row.
+     * If merge=true, all outputs are concatenated into a single PDF and temp files are cleaned.
+     * Optionally accepts a fieldMap to translate logical data keys → technical AcroForm field names.
+     */
+    static batchFillAcroForm(pdfPath: string, dataRows: Array<Record<string, string>>, outputDir: string, baseName: string, merge?: boolean, fieldMap?: Record<string, string>): Promise<{
+        outputPaths: string[];
+        mergedPath?: string;
+        errors: string[];
+    }>;
     /** Fill PDF using template coordinates (drawText), same logic as web app's pdfGenerator */
     static fillWithTemplate(pdfPath: string, fields: FieldBox[], values: Record<string, string>, outputPath: string): Promise<number>;
     /**

package/dist/services/pdfService.js

@@ -98,6 +98,86 @@ export class PdfService {
         fs.writeFileSync(outputPath, savedBytes);
         return filled;
     }
+    /**
+     * Batch fill AcroForm: generate N PDFs from the same base PDF, one per data row.
+     * If merge=true, all outputs are concatenated into a single PDF and temp files are cleaned.
+     * Optionally accepts a fieldMap to translate logical data keys → technical AcroForm field names.
+     */
+    static async batchFillAcroForm(pdfPath, dataRows, outputDir, baseName, merge = false, fieldMap) {
+        const outputPaths = [];
+        const errors = [];
+        const timestamp = new Date().toISOString().slice(0, 10);
+        fs.mkdirSync(outputDir, { recursive: true });
+        const workingDir = merge
+            ? fs.mkdtempSync(path.join(outputDir, '.tmp_batch_'))
+            : outputDir;
+        // Load the base PDF once
+        const bytes = fs.readFileSync(pdfPath);
+        for (let i = 0; i < dataRows.length; i++) {
+            try {
+                const row = dataRows[i];
+                // Translate logical keys to technical field names if a map is provided
+                const resolvedValues = {};
+                for (const [key, value] of Object.entries(row)) {
+                    const technicalName = fieldMap?.[key] ?? key;
+                    resolvedValues[technicalName] = String(value ?? '');
+                }
+                const num = String(i + 1).padStart(3, '0');
+                const outPath = path.join(workingDir, `${baseName}_${num}_${timestamp}.pdf`);
+                // Re-load each iteration to get a fresh form instance
+                const pdfDoc = await PDFDocument.load(bytes);
+                const form = pdfDoc.getForm();
+                for (const [name, value] of Object.entries(resolvedValues)) {
+                    try {
+                        const field = form.getField(name);
+                        if (field instanceof PDFTextField) {
+                            field.setText(value);
+                        }
+                        else if (field instanceof PDFCheckBox) {
+                            if (['true', '1', 'yes', 'si', 'sí'].includes(value.toLowerCase()))
+                                field.check();
+                            else
+                                field.uncheck();
+                        }
+                        else if (field instanceof PDFDropdown) {
+                            field.select(value);
+                        }
+                        else if (field instanceof PDFRadioGroup) {
+                            field.select(value);
+                        }
+                    }
+                    catch {
+                        // Field not found — skip silently
+                    }
+                }
+                form.flatten();
+                const savedBytes = await pdfDoc.save();
+                fs.writeFileSync(outPath, savedBytes);
+                outputPaths.push(outPath);
+            }
+            catch (err) {
+                errors.push(`Fila ${i + 1}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        let mergedPath;
+        if (merge && outputPaths.length > 0) {
+            mergedPath = path.join(outputDir, `${baseName}_merged_${timestamp}.pdf`);
+            await this.mergePdfs(outputPaths, mergedPath);
+            // Clean up temp files and dir
+            for (const p of outputPaths) {
+                try {
+                    fs.unlinkSync(p);
+                }
+                catch { /* ignore */ }
+            }
+            try {
+                fs.rmdirSync(workingDir);
+            }
+            catch { /* ignore */ }
+            return { outputPaths: [], mergedPath, errors };
+        }
+        return { outputPaths, mergedPath, errors };
+    }
     /** Fill PDF using template coordinates (drawText), same logic as web app's pdfGenerator */
     static async fillWithTemplate(pdfPath, fields, values, outputPath) {
         const bytes = fs.readFileSync(pdfPath);
@@ -202,11 +282,14 @@ export class PdfService {
      * Each entry in `dataRows` produces one PDF using the same field positions.
      */
     static async batchFillAtCoordinates(pdfPath, fieldDefinitions, dataRows, outputDir, baseName, merge = false) {
-        const bytes = fs.readFileSync(pdfPath);
         const outputPaths = [];
         const errors = [];
         const timestamp = new Date().toISOString().slice(0, 10);
         fs.mkdirSync(outputDir, { recursive: true });
+        // If merging, write individuals to a temp dir that will be cleaned up
+        const workingDir = merge
+            ? fs.mkdtempSync(path.join(outputDir, '.tmp_batch_'))
+            : outputDir;
         for (let i = 0; i < dataRows.length; i++) {
             try {
                 const row = dataRows[i];
@@ -221,7 +304,7 @@ export class PdfService {
                     overflowMode: def.overflowMode
                 })).filter(f => f.text.trim() !== '');
                 const num = String(i + 1).padStart(3, '0');
-                const outPath = path.join(outputDir, `${baseName}_${num}_${timestamp}.pdf`);
+                const outPath = path.join(workingDir, `${baseName}_${num}_${timestamp}.pdf`);
                 await this.fillAtCoordinates(pdfPath, fields, outPath);
                 outputPaths.push(outPath);
             }
@@ -233,6 +316,19 @@ export class PdfService {
         if (merge && outputPaths.length > 0) {
             mergedPath = path.join(outputDir, `${baseName}_merged_${timestamp}.pdf`);
             await this.mergePdfs(outputPaths, mergedPath);
+            // Clean up temp files and dir
+            for (const p of outputPaths) {
+                try {
+                    fs.unlinkSync(p);
+                }
+                catch { /* ignore */ }
+            }
+            try {
+                fs.rmdirSync(workingDir);
+            }
+            catch { /* ignore */ }
+            // Clear individual paths from response since they no longer exist
+            return { outputPaths: [], mergedPath, errors };
         }
         return { outputPaths, mergedPath, errors };
     }

package/dist/tools/detectFields.js

@@ -5,7 +5,18 @@ export const detectFieldsSchema = {
 
 CUANDO USAR: El PDF es un formulario donde puedes hacer click y escribir. Si el PDF es una imagen/diseño estatico (certificado, diploma), esta tool dira "sin campos" — en ese caso usa autoform_get_pdf_info + analisis visual.
 
-DESPUES DE DETECTAR: Usa autoform_fill_pdf para llenar los campos encontrados.`,
+⚠️ IMPORTANTE — Los nombres tecnicos NO son los labels visibles:
+- Esta tool devuelve nombres TECNICOS internos del PDF (ej: "Text1", "fld_001", "untitled_field"), que pueden NO coincidir con los labels visibles ("Nombre:", "Apellido:", "DNI:").
+- NO asumas el significado de cada campo por su nombre tecnico ni por su posicion.
+- DESPUES de detectar los campos, DEBES mirar el PDF visualmente (ya puedes ver PDFs como imagenes) y correlacionar cada campo tecnico con su label visible usando las coordenadas (x, y, page) que devuelve esta tool.
+- Solo DESPUES de esa correlacion visual procede a llenar con los datos correctos.
+
+FLUJO RECOMENDADO:
+1. autoform_detect_fields → obtienes lista de campos tecnicos con coordenadas
+2. MIRAS EL PDF VISUALMENTE → asocias cada coordenada con el label visible cercano
+3. Decides que dato va en que campo tecnico
+4. Para UN documento: autoform_fill_pdf con field_values={"nombre_tecnico": "valor"}
+5. Para MULTIPLES documentos (batch): autoform_fill_batch_acroform con data_rows y field_map si las claves son logicas.`,
     inputSchema: {
         type: 'object',
         properties: {

package/dist/tools/fillAtCoordinates.js

@@ -4,9 +4,17 @@ import { PdfService } from '../services/pdfService.js';
 const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillAtCoordinatesSchema = {
     name: 'autoform_fill_at_coordinates',
-    description: `Escribe texto en posiciones exactas de un PDF usando coordenadas en puntos PDF (origen: esquina inferior-izquierda).
+    description: `Escribe texto en posiciones exactas de UN PDF usando coordenadas en puntos PDF (origen: esquina inferior-izquierda).
 Ideal cuando Claude analiza visualmente un PDF y determina dónde colocar el texto.
 
+⚠️ ESTA TOOL ES PARA UN UNICO DOCUMENTO. Si necesitas generar multiples PDFs con los mismos campos pero datos diferentes, USA autoform_fill_batch_at_coordinates (mas eficiente, una sola llamada).
+
+IMPORTANTE — Codificación de texto:
+- El texto se pasa EXACTAMENTE como lo envías. NO simplifiques ni modifiques caracteres.
+- Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
+- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
+- Solo se filtran: emojis, caracteres de control invisibles, y patrones de script malicioso.
+
 FLUJO RECOMENDADO:
 1. Primero usa autoform_get_pdf_info para obtener las dimensiones de cada página
 2. Basándote en el análisis visual del PDF, calcula las coordenadas en puntos PDF

package/dist/tools/fillBatchAcroForm.d.ts

@@ -0,0 +1,52 @@
+export declare const fillBatchAcroFormSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+            data_rows: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            field_map: {
+                type: string;
+                description: string;
+                additionalProperties: {
+                    type: string;
+                };
+            };
+            merge_into_single: {
+                type: string;
+                description: string;
+            };
+            output_dir: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleFillBatchAcroForm(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/fillBatchAcroForm.js

@@ -0,0 +1,96 @@
+import * as path from 'path';
+import * as os from 'os';
+import { PdfService } from '../services/pdfService.js';
+const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
+export const fillBatchAcroFormSchema = {
+    name: 'autoform_fill_batch_acroform',
+    description: `Genera MULTIPLES PDFs a partir de un PDF con campos AcroForm (formulario interactivo) + array de datos. Una sola llamada genera N documentos.
+
+CUANDO USAR: El PDF base tiene campos AcroForm (detectados con autoform_detect_fields) y el usuario quiere llenarlos con datos de varias personas/filas. Escalable a cientos de documentos en una sola llamada.
+
+NO USAR SI: El PDF es estatico (sin AcroForm) → usa autoform_fill_batch_at_coordinates.
+NO USAR SI: Solo necesitas llenar UN documento → usa autoform_fill_pdf.
+
+IMPORTANTE sobre nombres de campos:
+- Los campos AcroForm tienen nombres TECNICOS (ej: "Text1", "fld_nombre", "field_001") que NO siempre coinciden con los labels visibles del PDF.
+- DESPUES de llamar autoform_detect_fields, DEBES MIRAR EL PDF VISUALMENTE para correlacionar cada campo tecnico con su label visible segun sus coordenadas.
+- Si las claves de tus data_rows NO coinciden con los nombres tecnicos, usa el parametro field_map para traducir: { "nombre_logico": "nombre_tecnico" }
+- Ejemplo: si el campo tecnico es "Text1" pero visualmente corresponde al label "Nombre:", pasa field_map={"nombre": "Text1"} y data_rows=[{"nombre": "Juan"}]
+
+MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automaticamente).
+
+CODIFICACION: Los datos se escriben EXACTAMENTE como los envias. Acentos espanoles (a e i o u n N u con tildes) estan completamente soportados. NO simplifiques caracteres.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al PDF con AcroForm'
+            },
+            data_rows: {
+                type: 'array',
+                description: 'Array de objetos, cada objeto es un documento. Claves = nombre del campo (tecnico o logico si usas field_map), valores = texto a escribir.',
+                items: {
+                    type: 'object',
+                    additionalProperties: { type: 'string' }
+                }
+            },
+            field_map: {
+                type: 'object',
+                description: '(Opcional) Mapeo de nombres logicos a nombres tecnicos de AcroForm. Formato: {"nombre_logico": "nombre_tecnico"}. Usalo cuando las claves de data_rows son mas legibles que los nombres tecnicos reales del PDF.',
+                additionalProperties: { type: 'string' }
+            },
+            merge_into_single: {
+                type: 'boolean',
+                description: '(Opcional) Si true, une todos los PDFs en uno solo y elimina los individuales. Default: false.'
+            },
+            output_dir: {
+                type: 'string',
+                description: '(Opcional) Directorio de salida. Default: ~/.autoform-mcp/output/'
+            }
+        },
+        required: ['pdf_path', 'data_rows']
+    }
+};
+export async function handleFillBatchAcroForm(args) {
+    const { pdf_path, output_dir, merge_into_single = false } = args;
+    let data_rows = args.data_rows;
+    if (typeof data_rows === 'string') {
+        try {
+            data_rows = JSON.parse(data_rows);
+        }
+        catch { /* keep */ }
+    }
+    let field_map = args.field_map;
+    if (typeof field_map === 'string') {
+        try {
+            field_map = JSON.parse(field_map);
+        }
+        catch { /* keep */ }
+    }
+    if (!data_rows || !Array.isArray(data_rows) || data_rows.length === 0) {
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'data_rows es requerido (array de objetos con datos)' }, null, 2) }],
+            isError: true
+        };
+    }
+    const outDir = output_dir || OUTPUT_DIR;
+    const baseName = path.basename(pdf_path, '.pdf').replace(/[^a-zA-Z0-9_\-]/g, '_');
+    const result = await PdfService.batchFillAcroForm(pdf_path, data_rows, outDir, baseName, merge_into_single, field_map);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    documents_generated: merge_into_single ? data_rows.length - result.errors.length : result.outputPaths.length,
+                    output_paths: result.outputPaths,
+                    merged_path: result.mergedPath,
+                    errors: result.errors,
+                    message: result.mergedPath
+                        ? `Generados ${data_rows.length - result.errors.length} documentos unidos en: ${result.mergedPath}`
+                        : result.outputPaths.length > 0
+                            ? `Generados ${result.outputPaths.length} documentos en ${outDir}`
+                            : `Error: ${result.errors.join(', ')}`
+                }, null, 2)
+            }]
+    };
+}

package/dist/tools/fillBatchAtCoordinates.js

@@ -8,6 +8,13 @@ export const fillBatchAtCoordinatesSchema = {
 
 CUANDO USAR: El usuario pasa un PDF (certificado, diploma, constancia) y una LISTA de datos (nombres, fechas, etc.) y quiere generar un PDF por cada fila de datos.
 
+IMPORTANTE — Codificación de texto:
+- Los datos se escriben EXACTAMENTE como los envías. NO simplifiques ni modifiques caracteres.
+- Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
+- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
+
+MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automáticamente).
+
 FLUJO:
 1. Usa autoform_get_pdf_info para obtener las dimensiones de la pagina
 2. Analiza visualmente el PDF para determinar donde van los campos

package/dist/tools/fillPdf.js

@@ -5,11 +5,16 @@ import { TemplateStore } from '../services/templateStore.js';
 const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillPdfSchema = {
     name: 'autoform_fill_pdf',
-    description: `Llena UN PDF con valores. Detecta automaticamente si tiene AcroForm o usa un template guardado.
+    description: `Llena UN SOLO PDF con valores. Detecta automaticamente si tiene AcroForm o usa un template guardado.
 
-CUANDO USAR: Quieres llenar UN SOLO documento y ya tienes AcroForm o un template guardado.
-NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.
-NO USAR SI: Quieres generar MULTIPLES documentos → usa autoform_generate_batch o autoform_fill_batch_at_coordinates.`,
+⚠️ ESTA TOOL ES PARA UN UNICO DOCUMENTO. Si necesitas generar 2 o mas documentos, USA UNA TOOL BATCH (mas eficiente, menos llamadas):
+  - PDF con AcroForm + multiples filas → autoform_fill_batch_acroform
+  - PDF estatico + multiples filas → autoform_fill_batch_at_coordinates
+  - Template guardado + multiples filas → autoform_generate_batch
+
+CUANDO USAR: Solo cuando el usuario pide llenar UN documento especifico.
+NO USAR PARA BATCH: Nunca llames esta tool en loop para generar multiples PDFs — usa las tools batch que existen para eso.
+NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.`,
     inputSchema: {
         type: 'object',
         properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoform-mcp-server",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "MCP server for bulk PDF form filling. Detect fields, fill templates, and generate hundreds of PDFs from data — directly from Claude.",
   "type": "module",
   "main": "dist/index.js",