@mesaque/apikibot-mcp 1.1.0

package/README.md

@@ -0,0 +1,43 @@
+# ApikiBot MCP Server
+
+MCP server para integração do Claude Code com o ApikiBot. Permite executar comandos de infraestrutura diretamente pelo Claude Code com controle de acesso por role (RBAC).
+
+## Instalação
+
+```bash
+npx -y @mesaque/apikibot-mcp
+```
+
+## Configuração
+
+Solicite ao administrador sua API key e adicione ao `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "apikibot": {
+      "command": "npx",
+      "args": ["-y", "@mesaque/apikibot-mcp"],
+      "env": {
+        "BOT_API_URL": "URL_FORNECIDA_PELO_ADMIN",
+        "BOT_API_KEY": "SUA_CHAVE_AQUI"
+      }
+    }
+  }
+}
+```
+
+## Variáveis de ambiente
+
+| Variável | Descrição |
+|---|---|
+| `BOT_API_URL` | URL da API do bot (fornecida pelo admin) |
+| `BOT_API_KEY` | Sua API key pessoal (fornecida pelo admin) |
+
+## Tools disponíveis
+
+As tools visíveis dependem da role associada à sua API key. O admin gerencia as permissões.
+
+## Para o administrador
+
+Consulte a documentação interna em `.claude/knowledge/apikibot.md` para instruções de configuração de keys e roles.

package/client.js

@@ -0,0 +1,105 @@
+import https from 'node:https';
+import http from 'node:http';
+
+export class BotClient {
+    constructor(apiUrl, apiKey) {
+        this.apiUrl = apiUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+        this.jwtToken = null;
+        this.tokenExpiry = 0;
+    }
+
+    async authenticate() {
+        const body = JSON.stringify({
+            command: 'auth',
+            function: 'generateToken',
+            apiKey: this.apiKey,
+        });
+
+        const data = await this._request(body, false);
+
+        if (!data.token) {
+            throw new Error('Falha na autenticação: resposta inválida do bot');
+        }
+
+        this.jwtToken = data.token;
+        this.tokenExpiry = Date.now() + (23 * 60 * 60 * 1000); // 23h
+    }
+
+    async listTools() {
+        if (Date.now() >= this.tokenExpiry) {
+            await this.authenticate();
+        }
+        return this._request(
+            JSON.stringify({ command: 'auth', function: 'listTools' }),
+            true
+        );
+    }
+
+    async call(command, fn, params = {}) {
+        if (Date.now() >= this.tokenExpiry) {
+            await this.authenticate();
+        }
+
+        const body = JSON.stringify({ command, function: fn, ...params });
+
+        try {
+            return await this._request(body, true);
+        } catch (err) {
+            if (err.statusCode === 401) {
+                await this.authenticate();
+                return this._request(body, true);
+            }
+            throw err;
+        }
+    }
+
+    _request(body, withAuth) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.apiUrl);
+            const isHttps = url.protocol === 'https:';
+            const lib = isHttps ? https : http;
+
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: url.pathname || '/',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            };
+
+            if (withAuth && this.jwtToken) {
+                options.headers['Authorization'] = `Bearer ${this.jwtToken}`;
+            }
+
+            const req = lib.request(options, (res) => {
+                let raw = '';
+                res.on('data', chunk => { raw += chunk; });
+                res.on('end', () => {
+                    if (res.statusCode === 403) {
+                        const err = new Error('Proibido pelo servidor (403)');
+                        err.statusCode = 403;
+                        return reject(err);
+                    }
+                    if (res.statusCode === 401) {
+                        const err = new Error('Não autorizado (401)');
+                        err.statusCode = 401;
+                        return reject(err);
+                    }
+                    try {
+                        resolve(JSON.parse(raw));
+                    } catch {
+                        reject(new Error(`Resposta inválida do bot: ${raw.slice(0, 200)}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+}

package/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { BotClient } from './client.js';
+
+const BOT_API_URL = process.env.BOT_API_URL;
+const BOT_API_KEY = process.env.BOT_API_KEY;
+
+if (!BOT_API_URL || !BOT_API_KEY) {
+    process.stderr.write(
+        'ERRO: As variáveis de ambiente BOT_API_URL e BOT_API_KEY são obrigatórias.\n' +
+        'Configure no settings.json do Claude Code:\n' +
+        '  "env": { "BOT_API_URL": "https://example.com", "BOT_API_KEY": "apk_..." }\n'
+    );
+    process.exit(1);
+}
+
+const client = new BotClient(BOT_API_URL, BOT_API_KEY);
+
+try {
+    await client.authenticate();
+} catch (err) {
+    process.stderr.write(`ERRO ao autenticar com o bot: ${err.message}\n`);
+    process.exit(1);
+}
+
+let tools;
+try {
+    tools = await client.listTools();
+} catch (err) {
+    process.stderr.write(`ERRO ao buscar lista de tools do bot: ${err.message}\n`);
+    process.exit(1);
+}
+
+const server = new McpServer({
+    name: 'apikibot',
+    version: '1.0.0',
+});
+
+// Constrói schema zod a partir da definição de params do manifest
+function buildSchema(params) {
+    if (!params?.length) return {};
+    const shape = {};
+    for (const p of params) {
+        let field = p.type === 'object'
+            ? z.object({}).passthrough()
+            : z.string();
+        if (p.description) field = field.describe(p.description);
+        if (!p.required) field = field.optional();
+        shape[p.name] = field;
+    }
+    return shape;
+}
+
+// Registrar todas as tools dinamicamente a partir do manifest remoto
+for (const tool of tools) {
+    const schema = buildSchema(tool.params);
+    server.tool(tool.name, tool.description, schema, async (params) => {
+        try {
+            const result = await client.call(tool.command, tool.function, params);
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        } catch (e) {
+            return { content: [{ type: 'text', text: `Erro: ${e.message}` }], isError: true };
+        }
+    });
+}
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@mesaque/apikibot-mcp",
+  "version": "1.1.0",
+  "description": "MCP server para integração do Claude Code com o ApikiBot",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "apikibot-mcp": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.0"
+  }
+}