@imenam/mcp-github 1.1.45

package/dist/index.js

@@ -0,0 +1,687 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { Octokit } from "octokit";
+import { execSync } from "child_process";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+import { fork } from "child_process";
+import { logToFile, setupLogging } from "./logger.js";
+import { startConfigServer } from "./config-server.js";
+import { getConfig, updateEnvFile, setupIpcErrorHandlers } from "./utils/config.js";
+import { assertSshConfig, execRemote } from "./utils/ssh.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Initialisation du logging global
+setupLogging("MASTER");
+// Initialisation des handlers IPC
+setupIpcErrorHandlers();
+// ... plus d'import direct de dotenv.config, c'est géré par getConfig()
+/**
+ * État du processus GUI
+ */
+let currentGuiProcess = null;
+/**
+ * Instance Octokit dynamique
+ */
+let _octokit = null;
+/**
+ * Cache du dernier résultat `test` (en mémoire, perdu au redémarrage)
+ */
+let _lastTestResult = null;
+const getOctokit = () => {
+    const { GITHUB_TOKEN } = getConfig();
+    if (!GITHUB_TOKEN)
+        return null;
+    if (!_octokit) {
+        _octokit = new Octokit({ auth: GITHUB_TOKEN });
+    }
+    return _octokit;
+};
+/**
+ * Lance le serveur de configuration dans un processus séparé
+ */
+function spawnGuiProcess() {
+    const guiPath = path.join(__dirname, "gui.js");
+    logToFile(`[MASTER] Spawning GUI process: ${guiPath}`);
+    currentGuiProcess = fork(guiPath, [], {
+        stdio: ['inherit', 'pipe', 'inherit', 'ipc'],
+        env: process.env
+    });
+    // Capturer stdout du fils pour le rediriger vers stderr (protection MCP)
+    if (currentGuiProcess.stdout) {
+        currentGuiProcess.stdout.on('data', (data) => {
+            process.stderr.write(`[GUI-STDOUT] ${data}`);
+        });
+    }
+    currentGuiProcess.on('error', (err) => {
+        logToFile(`[MASTER] Failed to spawn GUI process: ${err.message}`);
+    });
+    currentGuiProcess.on('exit', (code) => {
+        logToFile(`[MASTER] GUI process exited with code ${code}.`);
+        currentGuiProcess = null;
+        if (code !== 0 && code !== null) {
+            logToFile(`[MASTER] GUI exited with error — no automatic restart.`);
+        }
+    });
+    currentGuiProcess.on('message', (msg) => {
+        if (msg && msg.type === 'RESTART') {
+            logToFile("[MASTER] Restart signal received from GUI. Exiting main process...");
+            setTimeout(() => process.exit(0), 500);
+        }
+        if (msg && msg.type === 'STOP') {
+            logToFile("[MASTER] Stop signal received from GUI. Shutting down everything...");
+            setTimeout(() => process.exit(0), 500);
+        }
+        if (msg && msg.type === 'CONFIG_UPDATED') {
+            logToFile("[MASTER] Config update signal received from GUI.");
+            // On fusionne la nouvelle config dans l'environnement du Master
+            Object.assign(process.env, msg.config);
+            // On force la recréation d'Octokit au prochain appel
+            _octokit = null;
+            logToFile("[MASTER] Local process.env updated.");
+        }
+        if (msg && msg.type === 'CLONE') {
+            logToFile("[MASTER] Clone signal received from GUI.");
+            performClone()
+                .then((result) => {
+                logToFile(`[MASTER] GUI Clone successful: ${result}`);
+            })
+                .catch((err) => {
+                logToFile(`[MASTER] GUI Clone failed: ${err.message}`);
+            });
+        }
+    });
+    return currentGuiProcess;
+}
+/**
+ * Sécurise un nom de branche pour l'utiliser comme nom de dossier
+ */
+function sanitizeBranchName(branch) {
+    // Remplace les caractères interdits par des tirets
+    // Caractères : / \ : * ? " < > | et les espaces
+    return branch.replace(/[\/\x5C\x3A\x2A\x3F\x22\x3C\x3E\x7C\s]+/g, "-")
+        .replace(/^-+|-+$/g, ""); // Nettoie les tirets au début et à la fin
+}
+/**
+ * Génère le header d'authentification Basic pour Git
+ */
+function getGitAuthHeader() {
+    const { GITHUB_TOKEN } = getConfig();
+    if (!GITHUB_TOKEN)
+        return null;
+    const auth = Buffer.from(`x-access-token:${GITHUB_TOKEN}`).toString('base64');
+    return `Authorization: Basic ${auth}`;
+}
+/**
+ * Exécute une commande git avec authentification temporaire via header
+ */
+function execGitSecure(command, options) {
+    const authHeader = getGitAuthHeader();
+    if (!authHeader) {
+        return execSync(command, options);
+    }
+    // On utilise -c http.extraHeader pour passer le token de manière éphémère
+    const secureCommand = `git -c http.extraHeader="${authHeader}" ${command.startsWith('git ') ? command.slice(4) : command}`;
+    try {
+        return execSync(secureCommand, options);
+    }
+    catch (error) {
+        // On masque le token dans l'erreur si jamais il apparaît
+        if (authHeader) {
+            error.message = error.message.replace(authHeader, "[REDACTED_AUTH_HEADER]");
+        }
+        throw error;
+    }
+}
+/**
+ * Effectue le clonage et la configuration initiale du dépôt
+ */
+async function performClone() {
+    const config = getConfig();
+    const octokit = getOctokit();
+    if (!config.GITHUB_TOKEN) {
+        throw new Error("GITHUB_TOKEN est manquant. Le clonage nécessite une authentification.");
+    }
+    if (!config.TARGET_REPO || !config.TARGET_REPO.includes("/")) {
+        throw new Error("TARGET_REPO must be defined as 'owner/repo'");
+    }
+    if (!config.TARGET_BRANCH) {
+        throw new Error("TARGET_BRANCH environment variable is not defined");
+    }
+    const branchName = config.TARGET_BRANCH;
+    const repoParts = config.TARGET_REPO.split("/");
+    const owner = repoParts[0];
+    const repo = repoParts[1];
+    if (!owner || !repo) {
+        throw new Error("Invalid TARGET_REPO format. Expected 'owner/repo'");
+    }
+    const remote = `https://github.com/${config.TARGET_REPO}.git`;
+    const sanitizedBranch = sanitizeBranchName(branchName);
+    const finalRepoPath = path.join(config.CLONE_DIR, sanitizedBranch);
+    logToFile(`[CLONE] Destination calculée : ${finalRepoPath}`);
+    try {
+        // S'assurer que le dossier parent existe
+        const parentDir = path.dirname(finalRepoPath);
+        if (!fs.existsSync(parentDir)) {
+            logToFile(`Creating parent directory: ${parentDir}`);
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        // 1. Clone into the configured path
+        logToFile(`Cloning ${remote} into ${finalRepoPath}...`);
+        execGitSecure(`clone ${remote} "${finalRepoPath}"`, {});
+        // Configurer l'identité de l'agent automatiquement après le clone
+        logToFile(`[CLONE] Configuration de l'identité Git (Agent Zero)...`);
+        execGitSecure(`config user.name "Agent Zero"`, { cwd: finalRepoPath });
+        execGitSecure(`config user.email "agentzero@arakei.net"`, { cwd: finalRepoPath });
+        // 2. Check if branch exists on remote
+        let branchExistsOnRemote = false;
+        try {
+            if (octokit) {
+                await octokit.rest.repos.getBranch({
+                    owner,
+                    repo,
+                    branch: branchName,
+                });
+                branchExistsOnRemote = true;
+                logToFile(`Branch ${branchName} found on remote.`);
+            }
+        }
+        catch (e) {
+            if (e.status === 404) {
+                logToFile(`Branch ${branchName} NOT found on remote.`);
+            }
+            else {
+                logToFile(`Error checking branch existence: ${e.message}`);
+            }
+        }
+        if (branchExistsOnRemote) {
+            // Checkout existing branch
+            const currentBranch = execGitSecure("branch --show-current", { cwd: finalRepoPath }).toString().trim();
+            if (currentBranch !== branchName) {
+                logToFile(`Checking out existing branch ${branchName}...`);
+                execGitSecure(`checkout ${branchName}`, { cwd: finalRepoPath });
+            }
+            // Pull latest changes to be sure we are up to date
+            logToFile(`Pulling latest changes for ${branchName}...`);
+            execGitSecure(`pull origin ${branchName}`, { cwd: finalRepoPath });
+            // On met à jour l'environnement ET on persiste dans le .env
+            process.env.REPO_PATH = finalRepoPath;
+            await updateEnvFile("REPO_PATH", finalRepoPath);
+            return `Successfully cloned ${config.TARGET_REPO} into ${finalRepoPath} and updated existing branch ${branchName}`;
+        }
+        else {
+            // Create and push the branch to remote
+            logToFile(`Creating and pushing new branch ${branchName}...`);
+            execGitSecure(`checkout -b ${branchName}`, { cwd: finalRepoPath });
+            execGitSecure(`push -u origin ${branchName}`, { cwd: finalRepoPath });
+            // On met à jour l'environnement ET on persiste dans le .env
+            process.env.REPO_PATH = finalRepoPath;
+            await updateEnvFile("REPO_PATH", finalRepoPath);
+            return `Successfully cloned ${config.TARGET_REPO} into ${finalRepoPath}, created and pushed new branch ${branchName} to remote`;
+        }
+    }
+    catch (error) {
+        const msg = `Clone or branch operation failed: ${error.message}`;
+        logToFile(msg);
+        throw new Error(msg);
+    }
+}
+// Lancement de la GUI dans un processus SÉPARÉ
+if (!process.env.PROXY_URL) {
+    console.error('[MASTER] PROXY_URL non défini — GUI désactivée.');
+}
+else {
+    spawnGuiProcess();
+}
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+const VERSION = pkg.version;
+// Handle --version flag without exiting
+if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    console.error(`Restricted GitHub MCP Version: ${VERSION}`);
+}
+// MCP servers must not log to stdout as it's used for the protocol.
+// Some libraries might log to stdout on initialization.
+// We redirect all console.log to console.error to avoid polluting stdout.
+// Global error handlers to catch silent crashes
+process.on('uncaughtException', (error) => {
+    const msg = `FATAL UNCAUGHT EXCEPTION [PID ${process.pid}]: ${error.message}\nStack: ${error.stack}`;
+    console.error(msg);
+    logToFile(msg);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    const msg = `FATAL UNHANDLED REJECTION [PID ${process.pid}]: ${reason}\nPromise: ${promise}`;
+    console.error(msg);
+    logToFile(msg);
+});
+process.on('exit', (code) => {
+    logToFile(`PROCESS EXITING [PID ${process.pid}] with code: ${code}`);
+});
+['SIGINT', 'SIGTERM', 'SIGQUIT'].forEach(signal => {
+    process.on(signal, () => {
+        logToFile(`PROCESS RECEIVED SIGNAL ${signal} [PID ${process.pid}]`);
+        process.exit(0);
+    });
+});
+logToFile(`--- Server starting ---`);
+logToFile(`PID: ${process.pid}`);
+logToFile(`Arguments: ${JSON.stringify(process.argv)}`);
+logToFile(`Working directory: ${process.cwd()}`);
+// Add a heartbeat to monitor life
+setInterval(() => {
+    logToFile("HEARTBEAT: Server is still alive");
+}, 30000);
+// Capture when stdin (the MCP pipe) is closed
+process.stdin.on('close', () => {
+    logToFile("STDIN CLOSED: The MCP client has disconnected.");
+    process.exit(0);
+});
+// On ne bloque plus le démarrage si le token est manquant
+if (!getConfig().GITHUB_TOKEN) {
+    const msg = "⚠️ GITHUB_TOKEN manquant. Le serveur MCP est en attente de configuration via http://localhost:3000";
+    console.error(msg);
+    logToFile(msg);
+}
+const server = new Server({
+    name: "@imenam/mcp-github",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const TOOLS = [
+    {
+        name: "commit",
+        description: "Stage all changes (git add .) and commit with the provided message. Does NOT push to remote.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                message: { type: "string", description: "The commit message" },
+            },
+            required: ["message"],
+        },
+    },
+    {
+        name: "push",
+        description: "Push the current branch to the remote origin using the configured TARGET_BRANCH. Does NOT add or commit changes.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "commit_and_push",
+        description: "Automated workflow: adds all local changes (including untracked), commits with a message, and pushes to the branch defined in TARGET_BRANCH",
+        inputSchema: {
+            type: "object",
+            properties: {
+                message: { type: "string", description: "The commit message" },
+            },
+            required: ["message"],
+        },
+    },
+    {
+        name: "pull_request",
+        description: "Create a pull request from the TARGET_BRANCH to the BASE_BRANCH",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: { type: "string", description: "The title of the pull request" },
+                body: { type: "string", description: "The body/description of the pull request" },
+            },
+            required: ["title"],
+        },
+    },
+    {
+        name: "get_info",
+        description: "Get the current configuration of the server (excluding sensitive tokens)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "clone",
+        description: "Clone the repository defined in TARGET_REPO into a subdirectory (named after TARGET_BRANCH) inside the CLONE_DIR directory configured in the environment.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "get_logs",
+        description: "Retrieve the last N lines from the server log file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lines: { type: "number", description: "Number of lines to retrieve (default: 50)", default: 50 },
+            },
+        },
+    },
+    {
+        name: "deploy",
+        description: "Sur le serveur distant configuré (SSH_HOST), exécute 'git fetch --all', 'git checkout TARGET_BRANCH' et 'git pull' dans SSH_REMOTE_PATH. Le repo doit déjà être cloné sur le serveur.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "test",
+        description: "Exécute TEST_COMMAND sur le serveur distant (cwd = SSH_REMOTE_PATH) et renvoie stdout, stderr et exit code. Stocke la sortie pour 'test_logs'.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "test_logs",
+        description: "Renvoie la sortie (stdout + stderr + exit code) du dernier 'test' exécuté, sans relancer la commande.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const config = getConfig();
+    try {
+        logToFile(`Executing tool: ${name}`);
+        switch (name) {
+            case "commit": {
+                if (config.READ_ONLY)
+                    throw new Error("Server is in read-only mode");
+                const { message } = args;
+                const finalRepoPath = config.REPO_PATH;
+                if (!finalRepoPath) {
+                    throw new Error("Repository path is not defined. You must call 'clone' first.");
+                }
+                const execOptions = { cwd: finalRepoPath };
+                try {
+                    // 1. Add all changes (including untracked)
+                    execGitSecure("git add .", execOptions);
+                    // 2. Commit
+                    try {
+                        execGitSecure(`git commit -m "${message}"`, execOptions);
+                    }
+                    catch (e) {
+                        // Check if there was nothing to commit
+                        const status = execGitSecure("git status --porcelain", execOptions).toString();
+                        if (status.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "Nothing to commit, working tree clean." }],
+                            };
+                        }
+                        throw e;
+                    }
+                    const successMsg = `Successfully committed all changes with message: "${message}"`;
+                    logToFile(successMsg);
+                    return {
+                        content: [{ type: "text", text: successMsg }],
+                    };
+                }
+                catch (error) {
+                    const msg = `Git commit failed at ${finalRepoPath}: ${error.message}`;
+                    logToFile(msg);
+                    throw new Error(msg);
+                }
+            }
+            case "push": {
+                if (config.READ_ONLY)
+                    throw new Error("Server is in read-only mode");
+                const finalRepoPath = config.REPO_PATH;
+                if (!finalRepoPath) {
+                    throw new Error("Repository path is not defined. You must call 'clone' first.");
+                }
+                if (!config.TARGET_BRANCH) {
+                    throw new Error("TARGET_BRANCH environment variable is not defined");
+                }
+                const execOptions = { cwd: finalRepoPath };
+                try {
+                    const remote = config.TARGET_REPO
+                        ? `https://github.com/${config.TARGET_REPO}.git`
+                        : "origin";
+                    execGitSecure(`push ${remote} HEAD:${config.TARGET_BRANCH}`, execOptions);
+                    const successMsg = `Successfully pushed to ${config.TARGET_BRANCH} from ${finalRepoPath}`;
+                    logToFile(successMsg);
+                    return {
+                        content: [{ type: "text", text: successMsg }],
+                    };
+                }
+                catch (error) {
+                    const msg = `Git push failed at ${finalRepoPath}: ${error.message}`;
+                    logToFile(msg);
+                    throw new Error(msg);
+                }
+            }
+            case "commit_and_push": {
+                if (config.READ_ONLY)
+                    throw new Error("Server is in read-only mode");
+                const { message } = args;
+                const finalRepoPath = config.REPO_PATH;
+                if (!finalRepoPath) {
+                    throw new Error("Repository path is not defined. You must call 'clone' first.");
+                }
+                const execOptions = { cwd: finalRepoPath };
+                if (!config.TARGET_BRANCH) {
+                    throw new Error("TARGET_BRANCH environment variable is not defined");
+                }
+                try {
+                    // 1. Add all changes (including untracked)
+                    execGitSecure("git add .", execOptions);
+                    // 2. Commit
+                    try {
+                        execGitSecure(`git commit -m "${message}"`, execOptions);
+                    }
+                    catch (e) {
+                        // Check if there was nothing to commit
+                        const status = execGitSecure("git status --porcelain", execOptions).toString();
+                        if (status.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "Nothing to commit, working tree clean." }],
+                            };
+                        }
+                        throw e;
+                    }
+                    // 3. Push to target branch
+                    const remote = config.TARGET_REPO
+                        ? `https://github.com/${config.TARGET_REPO}.git`
+                        : "origin";
+                    execGitSecure(`push ${remote} HEAD:${config.TARGET_BRANCH}`, execOptions);
+                    const successMsg = `Successfully committed and pushed all changes to branch ${config.TARGET_BRANCH} from ${finalRepoPath}`;
+                    logToFile(successMsg);
+                    return {
+                        content: [{ type: "text", text: successMsg }],
+                    };
+                }
+                catch (error) {
+                    const msg = `Git operation failed at ${finalRepoPath}: ${error.message}`;
+                    logToFile(msg);
+                    throw new Error(msg);
+                }
+            }
+            case "pull_request": {
+                const octokit = getOctokit();
+                if (!config.GITHUB_TOKEN) {
+                    throw new Error("GITHUB_TOKEN est manquant. Veuillez le configurer via l'interface graphique.");
+                }
+                if (config.READ_ONLY)
+                    throw new Error("Server is in read-only mode");
+                const { title, body } = args;
+                if (!config.TARGET_REPO || !config.TARGET_REPO.includes("/")) {
+                    throw new Error("TARGET_REPO must be defined as 'owner/repo'");
+                }
+                if (!config.TARGET_BRANCH) {
+                    throw new Error("TARGET_BRANCH is not defined");
+                }
+                const [owner, repo] = config.TARGET_REPO.split("/");
+                if (!owner || !repo) {
+                    throw new Error("Invalid TARGET_REPO format. Expected 'owner/repo'");
+                }
+                try {
+                    if (!octokit)
+                        throw new Error("Octokit non initialisé");
+                    const response = await octokit.rest.pulls.create({
+                        owner,
+                        repo,
+                        title,
+                        body,
+                        head: config.TARGET_BRANCH,
+                        base: config.BASE_BRANCH,
+                    });
+                    const successMsg = `Pull request created successfully: ${response.data.html_url}`;
+                    logToFile(successMsg);
+                    return {
+                        content: [{ type: "text", text: successMsg }],
+                    };
+                }
+                catch (error) {
+                    const msg = `Failed to create pull request: ${error.message}`;
+                    logToFile(msg);
+                    throw new Error(msg);
+                }
+            }
+            case "get_logs": {
+                const { lines = 50 } = args;
+                const logDir = process.platform === 'win32'
+                    ? 'C:\\var\\log\\restricted-github-mcp'
+                    : '/var/log/restricted-github-mcp';
+                const logFile = path.join(logDir, 'server.log');
+                if (!fs.existsSync(logFile)) {
+                    return {
+                        content: [{ type: "text", text: "Log file does not exist yet." }],
+                    };
+                }
+                try {
+                    const content = fs.readFileSync(logFile, 'utf8');
+                    const allLines = content.split('\n');
+                    const lastLines = allLines.slice(-Math.abs(lines)).join('\n');
+                    return {
+                        content: [{ type: "text", text: `Last ${lines} lines of logs:\n\n${lastLines}` }],
+                    };
+                }
+                catch (error) {
+                    const msg = `Failed to read logs: ${error.message}`;
+                    logToFile(msg);
+                    throw new Error(msg);
+                }
+            }
+            case "get_info": {
+                const info = {
+                    TARGET_REPO: config.TARGET_REPO,
+                    TARGET_BRANCH: config.TARGET_BRANCH,
+                    BASE_BRANCH: config.BASE_BRANCH,
+                    CLONE_DIR: config.CLONE_DIR,
+                    REPO_PATH: config.REPO_PATH || "Not defined (Call 'clone' first)",
+                    READ_ONLY: config.READ_ONLY,
+                    INCLUDE_PUBLIC: config.INCLUDE_PUBLIC,
+                    INCLUDE_NOT_OWNED: config.INCLUDE_NOT_OWNED,
+                    CURRENT_WORKING_DIR: process.cwd(),
+                    GITHUB_TOKEN_LAST_5: config.GITHUB_TOKEN ? `***${config.GITHUB_TOKEN.slice(-5)}` : "Non configuré",
+                };
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Current Configuration:\n${JSON.stringify(info, null, 2)}`
+                        }],
+                };
+            }
+            case "clone": {
+                const result = await performClone();
+                return {
+                    content: [{ type: "text", text: result }],
+                };
+            }
+            case "deploy": {
+                assertSshConfig();
+                if (!config.TARGET_BRANCH) {
+                    throw new Error("TARGET_BRANCH est manquant. Configurez-le via la GUI ou le .env.");
+                }
+                const authHeader = config.GITHUB_TOKEN
+                    ? `Authorization: Basic ${Buffer.from(`x-access-token:${config.GITHUB_TOKEN}`).toString("base64")}`
+                    : null;
+                const gitPrefix = authHeader
+                    ? `git -c http.extraHeader="${authHeader}" -c http.prompt=false`
+                    : `GIT_TERMINAL_PROMPT=0 git`;
+                const deployCommand = `${gitPrefix} fetch --all && ${gitPrefix} checkout ${config.TARGET_BRANCH} && ${gitPrefix} pull`;
+                const deployResult = await execRemote(deployCommand);
+                if (deployResult.code !== 0) {
+                    const msg = `Deploy échoué (exit code ${deployResult.code}):\n${deployResult.stderr || deployResult.stdout}`;
+                    logToFile(`[deploy] ${msg}`);
+                    return {
+                        content: [{ type: "text", text: msg }],
+                        isError: true,
+                    };
+                }
+                const deployMsg = `Deploy réussi sur ${config.SSH_HOST}:${config.SSH_REMOTE_PATH} (branche: ${config.TARGET_BRANCH})\n\n${deployResult.stdout}`.trim();
+                logToFile(`[deploy] ${deployMsg}`);
+                return {
+                    content: [{ type: "text", text: deployMsg }],
+                };
+            }
+            case "test": {
+                assertSshConfig();
+                if (!config.TEST_COMMAND) {
+                    throw new Error("TEST_COMMAND est manquant dans le .env.");
+                }
+                const testResult = await execRemote(config.TEST_COMMAND);
+                _lastTestResult = {
+                    command: config.TEST_COMMAND,
+                    stdout: testResult.stdout,
+                    stderr: testResult.stderr,
+                    code: testResult.code,
+                    ranAt: new Date().toISOString(),
+                };
+                const testMsg = `Command: ${config.TEST_COMMAND}\nExit code: ${testResult.code}\n--- STDOUT ---\n${testResult.stdout}\n--- STDERR ---\n${testResult.stderr}`;
+                logToFile(`[test] Exit code: ${testResult.code}`);
+                return {
+                    content: [{ type: "text", text: testMsg }],
+                };
+            }
+            case "test_logs": {
+                if (!_lastTestResult) {
+                    return {
+                        content: [{ type: "text", text: "Aucun test n'a encore été exécuté. Lance d'abord 'test'." }],
+                    };
+                }
+                const logsMsg = `(Cached, ranAt: ${_lastTestResult.ranAt})\nCommand: ${_lastTestResult.command}\nExit code: ${_lastTestResult.code}\n--- STDOUT ---\n${_lastTestResult.stdout}\n--- STDERR ---\n${_lastTestResult.stderr}`;
+                return {
+                    content: [{ type: "text", text: logsMsg }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const msg = `Error in tool ${name}: ${error.message}`;
+        logToFile(msg);
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    const msg = `GitHub MCP Server running on stdio (CWD: ${process.cwd()})`;
+    console.error(msg);
+    logToFile(msg);
+}
+main().catch((error) => {
+    const msg = `Fatal error in main(): ${error.message}`;
+    console.error(msg);
+    logToFile(msg);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map