jlink-mcp/out/jlink/gdb-server.js

MCP server for SEGGER J-Link debug probes — LLM-driven embedded debugging with RTT, GDB server, and Trice/Pigweed support

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GDBServerManager = void 0;
const config_1 = require("../utils/config");
const logger_1 = require("../utils/logger");
const GDB_SERVER_PROCESS_NAME = "jlink-gdb-server";
/**
 * Manages the JLinkGDBServer lifecycle.
 * When running, RTT is accessible via telnet on the configured RTT port.
 */
class GDBServerManager {
    processManager;
    outputBuffer = [];
    maxOutputLines = 1000;
    constructor(processManager) {
        this.processManager = processManager;
    }
    /** Start JLinkGDBServer */
    start() {
        const existing = this.processManager.get(GDB_SERVER_PROCESS_NAME);
        if (existing) {
            return { success: true, message: "GDB Server is already running" };
        }
        const config = (0, config_1.getConfig)();
        const gdbServerPath = (0, config_1.getJLinkGDBServerPath)(config.jlink);
        const args = [
            "-device", config.jlink.device,
            "-if", config.jlink.interface,
            "-speed", String(config.jlink.speed),
            "-port", String(config.jlink.gdbPort),
            "-RTTTelnetPort", String(config.jlink.rttTelnetPort),
            "-SWOPort", String(config.jlink.swoTelnetPort),
            "-vd",
            "-noir",
            "-LocalhostOnly", "1",
            "-singlerun",
        ];
        if (config.jlink.serialNumber) {
            args.push("-select", `USB=${config.jlink.serialNumber}`);
        }
        try {
            const managed = this.processManager.spawn(GDB_SERVER_PROCESS_NAME, gdbServerPath, args);
            managed.process.stdout?.on("data", (data) => {
                const lines = data.toString().split("\n").filter(Boolean);
                for (const line of lines) {
                    (0, logger_1.log)(`[GDB Server] ${line}`);
                    this.outputBuffer.push(line);
                    if (this.outputBuffer.length > this.maxOutputLines) {
                        this.outputBuffer.shift();
                    }
                }
            });
            managed.process.stderr?.on("data", (data) => {
                const lines = data.toString().split("\n").filter(Boolean);
                for (const line of lines) {
                    (0, logger_1.logError)(`[GDB Server] ${line}`);
                    this.outputBuffer.push(`[ERR] ${line}`);
                }
            });
            return {
                success: true,
                message: `GDB Server started on port ${config.jlink.gdbPort}, RTT telnet on port ${config.jlink.rttTelnetPort}`,
            };
        }
        catch (err) {
            (0, logger_1.logError)("Failed to start GDB Server", err);
            return {
                success: false,
                message: `Failed to start GDB Server: ${err instanceof Error ? err.message : String(err)}`,
            };
        }
    }
    /** Stop the GDB Server */
    stop() {
        const killed = this.processManager.kill(GDB_SERVER_PROCESS_NAME);
        this.outputBuffer = [];
        return {
            success: true,
            message: killed ? "GDB Server stopped" : "GDB Server was not running",
        };
    }
    /** Check if running */
    isRunning() {
        return !!this.processManager.get(GDB_SERVER_PROCESS_NAME);
    }
    /** Get recent output */
    getRecentOutput(lines = 50) {
        return this.outputBuffer.slice(-lines);
    }
    /** Get status info */
    getStatus() {
        const config = (0, config_1.getConfig)();
        return {
            running: this.isRunning(),
            gdbPort: config.jlink.gdbPort,
            rttTelnetPort: config.jlink.rttTelnetPort,
            swoTelnetPort: config.jlink.swoTelnetPort,
        };
    }
}
exports.GDBServerManager = GDBServerManager;
//# sourceMappingURL=gdb-server.js.map