@imenam/mcp-github 1.1.45

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# Restricted GitHub MCP Server
+
+Un serveur MCP (Model Context Protocol) spécialisé pour automatiser le workflow Git local vers GitHub, avec délégation des compilations/tests à un serveur distant via SSH. Conçu pour être minimaliste et sécurisé.
+
+## 🚀 Outils disponibles
+
+### Git local → GitHub
+
+- **`commit`** : Exécute `git add .` puis crée un commit avec le message fourni. *Ne pousse pas vers le remote.*
+- **`push`** : Pousse la branche actuelle vers `TARGET_BRANCH`. *Ne fait pas de commit.*
+- **`commit_and_push`** : Enchaîne `git add .`, commit et push vers `TARGET_BRANCH`.
+- **`pull_request`** : Crée une Pull Request GitHub de `TARGET_BRANCH` vers `BASE_BRANCH`.
+- **`clone`** : Clone `TARGET_REPO` dans `CLONE_DIR/<TARGET_BRANCH>/`. Crée la branche distante si elle n'existe pas encore.
+- **`get_info`** : Affiche la configuration active (dépôt, branches, chemins) sans exposer les secrets.
+- **`get_logs`** : Récupère les dernières lignes du fichier de log serveur. Argument optionnel : `lines` (défaut : 50).
+
+### Serveur distant via SSH
+
+- **`deploy`** : Sur le serveur SSH configuré, exécute `git fetch --all`, `git checkout TARGET_BRANCH`, `git pull` dans `SSH_REMOTE_PATH`. Le repo doit être préalablement cloné manuellement sur le serveur.
+- **`test`** : 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`.
+- **`test_logs`** : Renvoie la sortie du dernier `test` exécuté sans relancer la commande.
+
+### Flux typique agent
+
+```
+clone → (modifier des fichiers) → commit_and_push → deploy → test
+                                        ↑                       |
+                                        └─── (corriger) ────────┘ (si exit code ≠ 0)
+```
+
+## 🖥️ Interface de Configuration (GUI)
+
+Le serveur lance automatiquement une interface graphique au démarrage (si `PROXY_URL` est défini). Elle permet de :
+
+- Gérer plusieurs configurations nommées (multi-projets).
+- Sélectionner le dépôt et les branches via des menus déroulants GitHub.
+- Visualiser la configuration active en temps réel.
+
+> **Proxy dynamique** : La GUI s'enregistre auprès du reverse proxy défini dans `PROXY_URL` et reçoit un port dynamique. Elle est alors accessible via `http://[PROXY_URL][GUI_PATH]/`.
+
+## ⚙️ Configuration
+
+Toutes les variables sont définies dans un fichier `.env` ou dans la section `env` du client MCP.
+
+### Variables GitHub
+
+| Variable | Description | Exemple |
+| :--- | :--- | :--- |
+| `GITHUB_TOKEN` | Personal Access Token GitHub (PAT) | `github_pat_...` |
+| `MCP_DATA_DIR` | Dossier contenant `configs.json` (multi-configs) | `./data` |
+| `CLONE_DIR` | Dossier racine dans lequel les branches seront clonées | `./cloned_repos` |
+
+> Les configurations par projet (dépôt, branches, mode lecture seule…) sont gérées dans l'interface GUI et stockées dans `configs.json`.
+
+### Variables SSH (outils `deploy` / `test`)
+
+| Variable | Description | Exemple |
+| :--- | :--- | :--- |
+| `SSH_HOST` | Adresse IP ou hostname du serveur distant | `195.35.24.113` |
+| `SSH_USER` | Utilisateur SSH | `root` |
+| `SSH_PORT` | Port SSH (défaut : 22) | `22` |
+| `SSH_KEY_PATH` | Chemin absolu vers la clé privée SSH | `C:/Users/.../.ssh/id_ed25519` |
+| `SSH_REMOTE_PATH` | Chemin du repo sur le serveur distant | `/var/www/mon-projet` |
+| `TEST_COMMAND` | Commande de test à exécuter sur le serveur | `npx tsc --noEmit --pretty` |
+
+> **Note** : Pour `tsc`, utilisez `--pretty` pour obtenir la sortie complète avec contexte de code (sans cette option, `tsc` passe en format compact une ligne par erreur quand il n'y a pas de TTY).
+
+### Variables GUI / Proxy
+
+| Variable | Description | Exemple |
+| :--- | :--- | :--- |
+| `PROXY_URL` | URL du reverse proxy central | `http://localhost:3000` |
+| `GUI_PATH` | Chemin d'accès via le proxy | `/github-mcp` (défaut) |
+| `GUI_NAME` | Nom affiché dans le proxy | `GitHub MCP Config` (défaut) |
+| `AGENT_NAME` | Nom de l'agent affiché dans la GUI | `Agent Zero` |
+
+## 📝 Journalisation (Logs)
+
+- **Windows** : `C:\var\log\restricted-github-mcp\server.log`
+- **Linux/macOS** : `/var/log/restricted-github-mcp/server.log`
+
+Le dossier est créé automatiquement. Les logs du processus principal (`[MASTER]`) et de la GUI (`[GUI]`) sont centralisés dans le même fichier.
+
+## 🖥️ Exemple de Configuration MCP
+
+### Via npx (Recommandé)
+
+```json
+{
+  "mcpServers": {
+    "@imenam/mcp-github": {
+      "command": "npx",
+      "args": ["-y", "@imenam/mcp-github"],
+      "env": {
+        "GITHUB_TOKEN": "votre_token_github_ici",
+        "CLONE_DIR": "/chemin/vers/dossier-de-clonage",
+        "MCP_DATA_DIR": "./data",
+        "PROXY_URL": "http://localhost:3000",
+        "GUI_PATH": "/github-mcp",
+        "GUI_NAME": "GitHub MCP Config",
+        "AGENT_NAME": "Mon Agent",
+        "SSH_HOST": "mon-serveur.example.com",
+        "SSH_USER": "ubuntu",
+        "SSH_PORT": "22",
+        "SSH_KEY_PATH": "/chemin/vers/.ssh/id_ed25519",
+        "SSH_REMOTE_PATH": "/var/www/mon-projet",
+        "TEST_COMMAND": "npx tsc --noEmit --pretty"
+      }
+    }
+  }
+}
+```
+
+> Les variables `PROXY_URL`, `GUI_*`, `AGENT_NAME` et SSH sont optionnelles selon votre usage.
+
+### Via installation locale
+
+```json
+{
+  "mcpServers": {
+    "@imenam/mcp-github": {
+      "command": "node",
+      "args": ["C:/chemin/vers/gitHubMCP/dist/index.js"],
+      "env": {
+        "GITHUB_TOKEN": "votre_token_github_ici",
+        "CLONE_DIR": "./cloned_repos"
+      }
+    }
+  }
+}
+```
+
+## 🛠️ Installation locale & build
+
+```bash
+git clone https://github.com/votre-pseudo/gitHubMCP.git
+cd gitHubMCP
+npm install
+cp .env.example .env
+# Éditez .env avec vos valeurs
+npm run build
+```
+
+## 📦 Publication Automatisée
+
+Ce projet est configuré pour être publié sur npm via **GitHub Actions** à chaque nouvelle Release :
+
+1. Mettez à jour la version dans `package.json`.
+2. Poussez sur GitHub et créez une Release.
+3. Le workflow OIDC publie automatiquement sur npm.
+
+## 📄 Licence
+
+ISC

package/dist/config-server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Se désenregistre du proxy dynamique (si enregistré).
+ */
+export declare function unregisterFromProxy(): Promise<void>;
+export declare function startConfigServer(): Promise<void>;
+//# sourceMappingURL=config-server.d.ts.map

package/dist/config-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-server.d.ts","sourceRoot":"","sources":["../src/config-server.ts"],"names":[],"mappings":"AAyEA;;GAEG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAczD;AAED,wBAAsB,iBAAiB,kBAobtC"}

package/dist/config-server.js

@@ -0,0 +1,465 @@
+import express from "express";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { Octokit } from "octokit";
+import { logToFile } from "./logger.js";
+import { getConfig, updateEnvFile, safeSend, migrateFromLegacyEnv, getAllConfigNames, getConfigByName, saveConfiguration, deleteConfiguration, setCurrentConfiguration, getCurrentConfigName, } from "./utils/config.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+if (!getConfig().PROXY_URL) {
+    process.stderr.write('[GUI] PROXY_URL non défini — arrêt.\n');
+    process.exit(0);
+}
+// État du proxy pour le désenregistrement
+let registeredPath = null;
+/**
+ * Tente de s'enregistrer auprès du proxy dynamique.
+ * @returns Le port attribué par le proxy, ou null en cas d'échec.
+ */
+async function tryProxyRegistration() {
+    const { PROXY_URL, GUI_PATH, GUI_NAME } = getConfig();
+    if (!PROXY_URL) {
+        logToFile("[GUI] PROXY_URL non défini, utilisation du port par défaut");
+        return null;
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(`${PROXY_URL}/proxy/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path: GUI_PATH, name: GUI_NAME }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            logToFile(`[GUI] Échec enregistrement proxy: ${errorData.error || response.statusText}`);
+            return null;
+        }
+        const data = await response.json();
+        registeredPath = GUI_PATH;
+        logToFile(`[GUI] Enregistré auprès du proxy (path: ${GUI_PATH}, port: ${data.port})`);
+        return data.port;
+    }
+    catch (error) {
+        const reason = error.name === "AbortError" ? "timeout" : error.message;
+        logToFile(`[GUI] Échec enregistrement proxy: ${reason}`);
+        return null;
+    }
+}
+/**
+ * Se désenregistre du proxy dynamique (si enregistré).
+ */
+export async function unregisterFromProxy() {
+    const { PROXY_URL } = getConfig();
+    if (!PROXY_URL || !registeredPath)
+        return;
+    try {
+        await fetch(`${PROXY_URL}/proxy/unregister`, {
+            method: "DELETE",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path: registeredPath }),
+        });
+        logToFile(`[GUI] Désenregistré du proxy (path: ${registeredPath})`);
+    }
+    catch {
+        // Ignorer les erreurs de désenregistrement
+    }
+}
+export async function startConfigServer() {
+    logToFile("[GUI] Initializing config server...");
+    // Migrate legacy .env to multi-config format on startup
+    migrateFromLegacyEnv();
+    // Enregistrement auprès du proxy (obligatoire)
+    const port = await tryProxyRegistration();
+    if (!port) {
+        process.stderr.write('[GUI] Enregistrement proxy échoué — arrêt.\n');
+        process.exit(1);
+    }
+    const app = express();
+    app.use(express.json());
+    // Logging middleware for GUI requests
+    app.use((req, res, next) => {
+        logToFile(`[GUI] Request: ${req.method} ${req.url}`);
+        next();
+    });
+    // Health check route (requise par le proxy)
+    app.get("/proxy/health", (req, res) => {
+        res.status(200).json({ status: "healthy" });
+    });
+    // Utilise un chemin relatif au fichier compilé pour trouver public
+    const publicPath = path.join(__dirname, "..", "public");
+    logToFile(`[GUI] Looking for static files in: ${publicPath}`);
+    if (!fs.existsSync(publicPath)) {
+        const errorMsg = `[GUI] CRITICAL ERROR: Public directory NOT FOUND at ${publicPath}`;
+        console.error(errorMsg);
+        logToFile(errorMsg);
+    }
+    app.use(express.static(publicPath));
+    app.get("/api/config", (req, res) => {
+        logToFile("[GUI] GET /api/config called");
+        try {
+            const config = getConfig();
+            res.json({
+                TARGET_REPO: config.TARGET_REPO,
+                TARGET_BRANCH: config.TARGET_BRANCH,
+                BASE_BRANCH: config.BASE_BRANCH,
+                REPO_PATH: config.REPO_PATH,
+                CLONE_DIR: config.CLONE_DIR,
+                READ_ONLY: config.READ_ONLY,
+                INCLUDE_PUBLIC: config.INCLUDE_PUBLIC,
+                INCLUDE_NOT_OWNED: config.INCLUDE_NOT_OWNED,
+                AGENT_NAME: config.AGENT_NAME,
+            });
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to get configuration: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/delete-working-dir", async (req, res) => {
+        logToFile("[GUI] POST /api/delete-working-dir called");
+        try {
+            const config = getConfig();
+            const repoPath = config.REPO_PATH;
+            if (repoPath && fs.existsSync(repoPath)) {
+                logToFile(`[GUI] Suppression du dossier de travail : ${repoPath}`);
+                fs.rmSync(repoPath, { recursive: true, force: true });
+                logToFile(`[GUI] Dossier de travail supprimé.`);
+            }
+            else {
+                logToFile(`[GUI] Tentative de suppression d'un dossier inexistant ou non défini : ${repoPath}`);
+            }
+            // Vider REPO_PATH dans .env et process.env
+            await updateEnvFile("REPO_PATH", "");
+            process.env.REPO_PATH = "";
+            // Notifier le master
+            safeSend(process, { type: "CONFIG_UPDATED", config: { REPO_PATH: "" } });
+            res.status(200).json({ message: "Dossier de travail supprimé et configuration mise à jour" });
+        }
+        catch (error) {
+            const msg = `[GUI] Échec de la suppression du dossier : ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/clone", async (req, res) => {
+        logToFile("[GUI] POST /api/clone called");
+        try {
+            const config = getConfig();
+            if (!config.TARGET_REPO) {
+                return res.status(400).json({ error: "TARGET_REPO non défini." });
+            }
+            if (!config.TARGET_BRANCH) {
+                return res.status(400).json({ error: "TARGET_BRANCH non défini." });
+            }
+            logToFile(`[GUI] Envoi du signal CLONE au master process (CLONE_DIR: ${config.CLONE_DIR})`);
+            const sent = safeSend(process, { type: "CLONE" });
+            if (sent) {
+                res.status(200).json({ message: "Clonage démarré..." });
+            }
+            else {
+                throw new Error("Impossible de communiquer avec le processus Master");
+            }
+        }
+        catch (error) {
+            const msg = `[GUI] Échec du lancement du clonage : ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.get("/api/repositories", async (req, res) => {
+        logToFile("[GUI] GET /api/repositories called");
+        try {
+            const config = getConfig();
+            const token = config.GITHUB_TOKEN;
+            if (!token) {
+                logToFile("[GUI] Repositories endpoint: Token non configuré");
+                return res.status(400).json({ error: "Token GitHub non configuré" });
+            }
+            const octokit = new Octokit({ auth: token });
+            const user = await octokit.rest.users.getAuthenticated();
+            logToFile(`[GUI] Authenticated as: ${user.data.login}`);
+            const includePublic = config.INCLUDE_PUBLIC;
+            const includeNotOwned = config.INCLUDE_NOT_OWNED;
+            const search = req.query.search;
+            let accessibleRepos = [];
+            if (search && search.length > 0) {
+                // Mode Recherche : Utilise l'API de recherche
+                const user = await octokit.rest.users.getAuthenticated();
+                // Si on n'inclut pas les "non-owned", on restreint la recherche à l'utilisateur actuel
+                const query = includeNotOwned
+                    ? `${search} in:name fork:true`
+                    : `${search} user:${user.data.login} in:name fork:true`;
+                const { data: searchResults } = await octokit.rest.search.repos({
+                    q: query,
+                    sort: "updated",
+                    per_page: 10,
+                });
+                accessibleRepos = searchResults.items.map(repo => repo.full_name);
+                logToFile(`[GUI] Search for "${search}" found ${accessibleRepos.length} repos`);
+            }
+            else {
+                // Mode Liste : Utilise l'API de listing classique (top 10 récents)
+                const { data } = await octokit.rest.repos.listForAuthenticatedUser({
+                    affiliation: includeNotOwned ? "owner,collaborator,organization_member" : "owner",
+                    visibility: includePublic ? "all" : "private",
+                    sort: "updated",
+                    per_page: 10,
+                });
+                accessibleRepos = data.map(repo => repo.full_name);
+                logToFile(`[GUI] Default list found ${accessibleRepos.length} repos`);
+            }
+            res.json(accessibleRepos);
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to fetch repositories: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.get("/api/branches", async (req, res) => {
+        logToFile("[GUI] GET /api/branches called");
+        try {
+            const config = getConfig();
+            const repo = req.query.repo;
+            const token = config.GITHUB_TOKEN;
+            if (!repo) {
+                logToFile("[GUI] Branches endpoint: Paramètre repo manquant");
+                return res.status(400).json({ error: "Paramètre repo manquant" });
+            }
+            if (!token) {
+                logToFile("[GUI] Branches endpoint: Token non configuré");
+                return res.status(400).json({ error: "Token GitHub non configuré" });
+            }
+            const [owner, repoName] = repo.split("/");
+            if (!owner || !repoName) {
+                logToFile("[GUI] Branches endpoint: Format de repo invalide");
+                return res.status(400).json({ error: "Format de repo invalide (owner/repo)" });
+            }
+            const octokit = new Octokit({ auth: token });
+            const { data } = await octokit.rest.repos.listBranches({
+                owner,
+                repo: repoName,
+                per_page: 100,
+            });
+            const branches = data.map((branch) => branch.name).reverse();
+            logToFile(`[GUI] Branches endpoint: ${branches.length} branches retournées pour ${repo}`);
+            res.json(branches);
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to fetch branches: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/config", async (req, res) => {
+        logToFile("[GUI] POST /api/config called");
+        const newConfig = req.body;
+        try {
+            // Update current process env
+            Object.assign(process.env, newConfig);
+            // Persist each key to .env without destroying other existing keys
+            for (const [key, value] of Object.entries(newConfig)) {
+                await updateEnvFile(key, value);
+            }
+            // Notify master process about the update
+            logToFile("[GUI] Sending CONFIG_UPDATED to master process");
+            safeSend(process, { type: "CONFIG_UPDATED", config: newConfig });
+            logToFile("[GUI] Configuration updated and master notified");
+            res.sendStatus(200);
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to save .env: ${error.message}`;
+            console.error(msg);
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    // =========================================================================
+    // Multi-configuration management endpoints
+    // =========================================================================
+    app.get("/api/configs", (req, res) => {
+        logToFile("[GUI] GET /api/configs called");
+        try {
+            const names = getAllConfigNames();
+            const current = getCurrentConfigName();
+            res.json({ names, current });
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to get configs: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.get("/api/configs/:name", (req, res) => {
+        logToFile(`[GUI] GET /api/configs/${req.params.name} called`);
+        try {
+            const config = getConfigByName(req.params.name);
+            if (config) {
+                res.json(config);
+            }
+            else {
+                res.status(404).json({ error: "Configuration not found" });
+            }
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to get config: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/configs", async (req, res) => {
+        logToFile("[GUI] POST /api/configs called");
+        const { name, config } = req.body;
+        if (!name || !config) {
+            return res.status(400).json({ error: "Name and config are required" });
+        }
+        try {
+            saveConfiguration(name, config);
+            // Set as current if no current config
+            if (!getCurrentConfigName()) {
+                setCurrentConfiguration(name);
+            }
+            safeSend(process, { type: "CONFIG_UPDATED" });
+            res.json({ message: `Configuration "${name}" saved` });
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to save config: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.delete("/api/configs/:name", (req, res) => {
+        logToFile(`[GUI] DELETE /api/configs/${req.params.name} called`);
+        try {
+            const success = deleteConfiguration(req.params.name);
+            if (success) {
+                safeSend(process, { type: "CONFIG_UPDATED" });
+                res.json({ message: `Configuration "${req.params.name}" deleted` });
+            }
+            else {
+                res.status(404).json({ error: "Configuration not found" });
+            }
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to delete config: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/configs/:name/activate", (req, res) => {
+        logToFile(`[GUI] POST /api/configs/${req.params.name}/activate called`);
+        try {
+            const success = setCurrentConfiguration(req.params.name);
+            if (success) {
+                safeSend(process, { type: "CONFIG_UPDATED" });
+                res.json({ message: `Switched to configuration "${req.params.name}"` });
+            }
+            else {
+                res.status(404).json({ error: "Configuration not found" });
+            }
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to activate config: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    // GET /api/configurations — Convention méta-config proxy
+    app.get("/api/configurations", (req, res) => {
+        const names = getAllConfigNames();
+        const current = getCurrentConfigName();
+        const configurations = names.map(name => {
+            const cfg = getConfigByName(name);
+            return {
+                id: name,
+                name: name,
+                description: cfg ? `GitHub config: ${name}` : "",
+                active: name === current
+            };
+        });
+        res.json({ configurations });
+    });
+    // POST /api/configurations/apply — Convention méta-config proxy
+    app.post("/api/configurations/apply", (req, res) => {
+        const { configId } = req.body;
+        if (!configId) {
+            return res.status(400).json({ success: false, error: "configId is required" });
+        }
+        const success = setCurrentConfiguration(configId);
+        if (!success) {
+            return res.status(404).json({ success: false, error: `Configuration "${configId}" not found` });
+        }
+        if (process.send && process.connected) {
+            process.send({ type: "CONFIG_UPDATED" });
+        }
+        return res.json({ success: true, appliedConfig: configId });
+    });
+    // =========================================================================
+    app.post("/api/restart", (req, res) => {
+        logToFile("[GUI] POST /api/restart called (Full MCP)");
+        try {
+            res.json({ message: "Restarting GitHub MCP server..." });
+            setTimeout(() => {
+                logToFile("[GUI] Sending RESTART signal to master process");
+                if (!safeSend(process, { type: "RESTART" })) {
+                    logToFile("[GUI] ERROR: process.send failed or not connected");
+                    process.exit(0);
+                }
+            }, 500);
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to restart: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    app.post("/api/stop", (req, res) => {
+        logToFile("[GUI] POST /api/stop called (Full MCP)");
+        try {
+            res.json({ message: "Stopping GitHub MCP server..." });
+            setTimeout(() => {
+                logToFile("[GUI] Sending STOP signal to master process");
+                if (!safeSend(process, { type: "STOP" })) {
+                    logToFile("[GUI] ERROR: process.send failed or not connected");
+                    process.exit(0);
+                }
+            }, 500);
+        }
+        catch (error) {
+            const msg = `[GUI] Failed to stop: ${error.message}`;
+            logToFile(msg);
+            res.status(500).json({ error: msg });
+        }
+    });
+    try {
+        logToFile(`[GUI] Attempting to listen on port ${port}...`);
+        const serverListener = app.listen(port, () => {
+            const config = getConfig();
+            const msg = `[GUI] Config GUI disponible sur http://localhost:${port} - via proxy (${config.PROXY_URL}${config.GUI_PATH})`;
+            console.error(msg);
+            logToFile(msg);
+        });
+        serverListener.on('error', (err) => {
+            let msg = `[GUI] SERVER ERROR (on port ${port}): ${err.message}`;
+            if (err.code === 'EADDRINUSE') {
+                msg = `[GUI] PORT CONFLICT: Port ${port} is already in use by another process.`;
+            }
+            console.error(msg);
+            logToFile(msg);
+        });
+        serverListener.on('close', () => {
+            logToFile(`[GUI] Server listener CLOSED unexpectedly.`);
+        });
+    }
+    catch (error) {
+        const msg = `[GUI] UNEXPECTED EXCEPTION during app.listen: ${error.message}`;
+        console.error(msg);
+        logToFile(msg);
+    }
+}
+//# sourceMappingURL=config-server.js.map