import { spawn } from 'child_process';
import path from 'path';
import fs from 'fs';
import { fileURLToPath } from 'url';
// Get current file directory (ESM equivalent of __dirname)
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
/**
* Test script for the schematic generation functionality
*
* This script tests the KiCAD MCP server's schematic generation capabilities by:
* 1. Creating a new schematic
* 2. Adding components (resistors, capacitors)
* 3. Adding connections between them
* 4. Exporting the schematic to PDF
*/
// Directory for test outputs
const TEST_OUTPUT_DIR = path.join(__dirname, 'schematic_test_output');
if (!fs.existsSync(TEST_OUTPUT_DIR)) {
fs.mkdirSync(TEST_OUTPUT_DIR, { recursive: true });
}
// Function to send a command to the KiCAD MCP server
function sendCommand(serverProcess, command, params) {
return new Promise((resolve, reject) => {
// Create request object
const request = {
command,
params
};
// Convert to JSON and add newline
const requestStr = JSON.stringify(request) + '\n';
// Write to stdin of server process
console.log(`Sending request to server: ${requestStr}`);
serverProcess.stdin.write(requestStr);
// Set up response handler
let responseData = '';
const responseHandler = (data) => {
const chunk = data.toString();
console.log(`Received data: ${chunk}`);
responseData += chunk;
try {
// Try to parse as JSON
const response = JSON.parse(responseData);
// Got a complete response
console.log(`Parsed complete response: ${JSON.stringify(response)}`);
serverProcess.stdout.removeListener('data', responseHandler);
resolve(response);
} catch (e) {
// Not complete JSON yet, keep collecting
console.log(`JSON parsing failed, continuing to collect data: ${e.message}`);
}
};
// Set a timeout to prevent hanging indefinitely
const timeoutId = setTimeout(() => {
console.log("Command timeout after 10 seconds");
serverProcess.stdout.removeListener('data', responseHandler);
resolve({
success: false,
message: "Timeout waiting for response from server"
});
}, 10000); // 10 second timeout
// Listen for response
serverProcess.stdout.on('data', responseHandler);
// Handle errors
serverProcess.stderr.on('data', (data) => {
console.error(`Server stderr: ${data.toString()}`);
});
});
}
async function runTest() {
console.log('\n=== TESTING SCHEMATIC GENERATION ===\n');
// Start the KiCAD MCP server
console.log('Starting KiCAD MCP server...');
// Use shell: true to ensure proper command execution in Windows
const serverProcess = spawn('node', ['dist/kicad-server.js'], {
stdio: ['pipe', 'pipe', 'pipe'],
shell: true
});
// Log server startup messages
serverProcess.stderr.on('data', (data) => {
console.log(`Server startup: ${data.toString()}`);
});
// Give server time to start
console.log('Waiting for server to start...');
await new Promise(resolve => setTimeout(resolve, 5000));
console.log('Server should be ready now');
try {
// 1. Create a new schematic
const schematicName = 'TestCircuit';
const schematicPath = path.join(TEST_OUTPUT_DIR, `${schematicName}.kicad_sch`);
console.log(`Creating schematic: ${schematicName}...`);
const createResult = await sendCommand(serverProcess, 'create_schematic', {
projectName: schematicName,
path: TEST_OUTPUT_DIR,
metadata: {
description: 'Test circuit schematic',
author: 'KiCAD MCP Test'
}
});
console.log('Create schematic result:', createResult);
if (!createResult.success) {
throw new Error(`Failed to create schematic: ${createResult.message}`);
}
// 2. Add components: resistors, capacitor, and power/ground connections
console.log('Adding components to schematic...');
// Add resistor R1
const addR1Result = await sendCommand(serverProcess, 'add_schematic_component', {
schematicPath: schematicPath,
component: {
type: 'R',
reference: 'R1',
value: '10k',
library: 'Device',
x: 100,
y: 100
}
});
console.log('Add R1 result:', addR1Result);
// Add resistor R2
const addR2Result = await sendCommand(serverProcess, 'add_schematic_component', {
schematicPath: schematicPath,
component: {
type: 'R',
reference: 'R2',
value: '4.7k',
library: 'Device',
x: 100,
y: 200
}
});
console.log('Add R2 result:', addR2Result);
// Add capacitor C1
const addC1Result = await sendCommand(serverProcess, 'add_schematic_component', {
schematicPath: schematicPath,
component: {
type: 'C',
reference: 'C1',
value: '0.1uF',
library: 'Device',
x: 200,
y: 150
}
});
console.log('Add C1 result:', addC1Result);
// 3. Add wires to connect components
console.log('Adding wires to connect components...');
// Connect R1 to R2
const addWire1Result = await sendCommand(serverProcess, 'add_schematic_wire', {
schematicPath: schematicPath,
startPoint: [150, 100],
endPoint: [150, 200]
});
console.log('Add wire 1 result:', addWire1Result);
// Connect R2 to C1
const addWire2Result = await sendCommand(serverProcess, 'add_schematic_wire', {
schematicPath: schematicPath,
startPoint: [150, 200],
endPoint: [200, 200]
});
console.log('Add wire 2 result:', addWire2Result);
// Connect C1 to R1
const addWire3Result = await sendCommand(serverProcess, 'add_schematic_wire', {
schematicPath: schematicPath,
startPoint: [200, 100],
endPoint: [150, 100]
});
console.log('Add wire 3 result:', addWire3Result);
// 4. Export to PDF
console.log('Exporting schematic to PDF...');
const pdfPath = path.join(TEST_OUTPUT_DIR, `${schematicName}.pdf`);
const exportResult = await sendCommand(serverProcess, 'export_schematic_pdf', {
schematicPath: schematicPath,
outputPath: pdfPath
});
console.log('Export PDF result:', exportResult);
if (exportResult.success) {
console.log(`PDF successfully created at: ${pdfPath}`);
} else {
console.log(`Failed to create PDF: ${exportResult.message}`);
}
console.log('\n=== SCHEMATIC GENERATION TEST COMPLETED ===\n');
console.log(`Schematic file: ${schematicPath}`);
console.log(`PDF file: ${pdfPath}`);
} catch (error) {
console.error('Test error:', error);
} finally {
// Kill the server process
serverProcess.kill();
}
}
// Run the test
runTest().catch(console.error);
