@dalcontak/blogger-mcp-server 1.0.0 → 1.0.2

package/Dockerfile

@@ -1,64 +0,0 @@
-# Dockerfile amélioré pour blogger-mcp-server (compatibilité Glama)
-
-# Étape 1: Construction de l'application
-FROM node:20-alpine AS builder
-
-# Définir le répertoire de travail
-WORKDIR /app
-
-# Copier les fichiers de manifeste et de verrouillage des dépendances
-COPY package.json package-lock.json* ./
-
-# Installer les dépendances de production et de développement pour la compilation
-RUN npm install
-
-# Copier le reste des fichiers sources de l'application
-COPY . .
-
-# Compiler le projet TypeScript
-RUN npm run build
-
-# Supprimer les dépendances de développement après la compilation
-RUN npm prune --production
-
-# Étape 2: Création de l'image de production
-FROM node:20-alpine
-
-# Définir le répertoire de travail
-WORKDIR /app
-
-# Créer un utilisateur non-root pour exécuter l'application
-RUN addgroup -S appgroup && adduser -S appuser -G appgroup
-
-# Copier les dépendances de production et les fichiers compilés depuis l'étape de construction
-COPY --from=builder /app/node_modules ./node_modules
-COPY --from=builder /app/dist ./dist
-COPY --from=builder /app/package.json ./
-
-# Définir les variables d'environnement
-# BLOGGER_API_KEY doit être fournie à l'exécution (docker run -e BLOGGER_API_KEY=VOTRE_CLE)
-ENV MCP_MODE=http
-ENV MCP_HTTP_HOST=0.0.0.0
-ENV MCP_HTTP_PORT=3000
-ENV BLOGGER_MAX_RESULTS=10
-ENV BLOGGER_API_TIMEOUT=30000
-ENV LOG_LEVEL=info
-# NODE_ENV=production est souvent une bonne pratique pour les applications Node.js
-ENV NODE_ENV=production
-
-# Exposer le port sur lequel l'application écoute
-EXPOSE 3000
-
-# Changer le propriétaire des fichiers de l'application pour l'utilisateur non-root
-RUN chown -R appuser:appgroup /app
-
-# Basculer vers l'utilisateur non-root
-USER appuser
-
-# Commande pour démarrer le serveur
-CMD ["node", "dist/index.js"]
-
-# Métadonnées de l'image (optionnel, mais recommandé)
-LABEL maintainer="niyonabil"
-LABEL description="Serveur MCP pour interagir avec l'API Blogger de Google."
-LABEL version="1.0.4" # Se baser sur la version du package.json si possible

package/dist/mcp-sdk-mock.d.ts

@@ -1,57 +0,0 @@
-/**
- * Mock du SDK MCP pour éviter les problèmes de dépendances
- * Cette implémentation simplifiée fournit les fonctionnalités essentielles
- * du SDK MCP sans dépendre de la version exacte du package
- */
-import { z } from 'zod';
-import { ServerMode } from './types';
-export interface MCPTool<T extends z.ZodType> {
-    name: string;
-    description: string;
-    parameters: T;
-    handler: (params: z.infer<T>) => Promise<any>;
-}
-export interface MCPServerOptions {
-    name: string;
-    version: string;
-    mode: ServerMode;
-}
-export interface ServerTransport {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    onRequest?: (handler: (request: any) => Promise<any>) => void;
-}
-export declare class MCPServer {
-    private options;
-    private tools;
-    private transport;
-    constructor(options: MCPServerOptions);
-    addTool<T extends z.ZodType>(tool: MCPTool<T>): void;
-    connect(transport: ServerTransport): Promise<void>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}
-export declare class StdioServerTransport implements ServerTransport {
-    private requestHandler;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    onRequest(handler: (request: any) => Promise<any>): void;
-}
-export declare class HttpServerTransport implements ServerTransport {
-    private server;
-    private requestHandler;
-    private host;
-    private port;
-    constructor(options: {
-        host: string;
-        port: number;
-    });
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    onRequest(handler: (request: any) => Promise<any>): void;
-}
-export declare class ResourceTemplate<T> {
-    private resource;
-    constructor(resource: T);
-    get(): T;
-}

package/dist/mcp-sdk-mock.js

@@ -1,227 +0,0 @@
-"use strict";
-/**
- * Mock du SDK MCP pour éviter les problèmes de dépendances
- * Cette implémentation simplifiée fournit les fonctionnalités essentielles
- * du SDK MCP sans dépendre de la version exacte du package
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceTemplate = exports.HttpServerTransport = exports.StdioServerTransport = exports.MCPServer = void 0;
-const zod_1 = require("zod");
-const http = __importStar(require("http"));
-// Classe principale du serveur MCP
-class MCPServer {
-    constructor(options) {
-        this.tools = new Map();
-        this.transport = null;
-        this.options = options;
-    }
-    // Ajoute un outil au serveur
-    addTool(tool) {
-        this.tools.set(tool.name, tool);
-    }
-    // Connecte le serveur à un transport
-    async connect(transport) {
-        this.transport = transport;
-        if (this.transport.onRequest) {
-            this.transport.onRequest(async (request) => {
-                try {
-                    const { tool, params } = request;
-                    if (!this.tools.has(tool)) {
-                        return {
-                            error: `Outil non trouvé: ${tool}`
-                        };
-                    }
-                    const mcpTool = this.tools.get(tool);
-                    try {
-                        const validatedParams = mcpTool.parameters.parse(params);
-                        const result = await mcpTool.handler(validatedParams);
-                        return result;
-                    }
-                    catch (error) {
-                        if (error instanceof zod_1.z.ZodError) {
-                            return {
-                                error: `Paramètres invalides: ${error.message}`
-                            };
-                        }
-                        return {
-                            error: `Erreur lors de l'exécution de l'outil: ${error}`
-                        };
-                    }
-                }
-                catch (error) {
-                    return {
-                        error: `Erreur interne du serveur: ${error}`
-                    };
-                }
-            });
-        }
-    }
-    // Démarre le serveur
-    async start() {
-        if (!this.transport) {
-            throw new Error('Le serveur doit être connecté à un transport avant de démarrer');
-        }
-        await this.transport.start();
-    }
-    // Arrête le serveur
-    async stop() {
-        if (this.transport) {
-            await this.transport.stop();
-        }
-    }
-}
-exports.MCPServer = MCPServer;
-// Transport pour le mode stdio
-class StdioServerTransport {
-    constructor() {
-        this.requestHandler = null;
-    }
-    async start() {
-        process.stdin.setEncoding('utf-8');
-        process.stdin.on('data', async (data) => {
-            try {
-                const request = JSON.parse(data.toString());
-                if (this.requestHandler) {
-                    const response = await this.requestHandler(request);
-                    process.stdout.write(JSON.stringify(response) + '\n');
-                }
-            }
-            catch (error) {
-                process.stdout.write(JSON.stringify({ error: `Erreur de parsing: ${error}` }) + '\n');
-            }
-        });
-    }
-    async stop() {
-        // Rien à faire pour le mode stdio
-    }
-    onRequest(handler) {
-        this.requestHandler = handler;
-    }
-}
-exports.StdioServerTransport = StdioServerTransport;
-// Transport pour le mode HTTP
-class HttpServerTransport {
-    constructor(options) {
-        this.server = null;
-        this.requestHandler = null;
-        this.host = options.host;
-        this.port = options.port;
-    }
-    async start() {
-        this.server = http.createServer(async (req, res) => {
-            res.setHeader('Content-Type', 'application/json');
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-            if (req.method === 'OPTIONS') {
-                res.statusCode = 200;
-                res.end();
-                return;
-            }
-            if (req.method !== 'POST') {
-                res.statusCode = 405;
-                res.end(JSON.stringify({ error: 'Méthode non autorisée' }));
-                return;
-            }
-            try {
-                let body = '';
-                req.on('data', (chunk) => {
-                    body += chunk.toString();
-                });
-                req.on('end', async () => {
-                    try {
-                        const request = JSON.parse(body);
-                        if (this.requestHandler) {
-                            const response = await this.requestHandler(request);
-                            res.statusCode = 200;
-                            res.end(JSON.stringify(response));
-                        }
-                        else {
-                            res.statusCode = 500;
-                            res.end(JSON.stringify({ error: 'Gestionnaire de requêtes non configuré' }));
-                        }
-                    }
-                    catch (error) {
-                        res.statusCode = 400;
-                        res.end(JSON.stringify({ error: `Erreur de parsing: ${error}` }));
-                    }
-                });
-            }
-            catch (error) {
-                res.statusCode = 500;
-                res.end(JSON.stringify({ error: `Erreur interne du serveur: ${error}` }));
-            }
-        });
-        return new Promise((resolve) => {
-            if (this.server) {
-                this.server.listen(this.port, this.host, () => {
-                    resolve();
-                });
-            }
-        });
-    }
-    async stop() {
-        return new Promise((resolve, reject) => {
-            if (this.server) {
-                this.server.close((err) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-    onRequest(handler) {
-        this.requestHandler = handler;
-    }
-}
-exports.HttpServerTransport = HttpServerTransport;
-// Classe pour les templates de ressources
-class ResourceTemplate {
-    constructor(resource) {
-        this.resource = resource;
-    }
-    get() {
-        return this.resource;
-    }
-}
-exports.ResourceTemplate = ResourceTemplate;