mintboard-mcp 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# mintboard-mcp
+
+Servidor MCP (Model Context Protocol) do MintBoard. Conecta o CRM a
+assistentes de IA — Claude Code, Claude Desktop, Gemini CLI e qualquer
+outro cliente MCP — usando a API key da organização.
+
+## Ferramentas
+
+| Tool | Descrição |
+|------|-----------|
+| `list_projects` / `create_project` / `update_project` | Projetos |
+| `list_tasks` / `create_task` / `update_task` | Tarefas |
+| `list_pipeline` / `create_lead` / `move_lead` | Funil de vendas |
+| `finance_overview` | Visão financeira |
+| `project_summary` | Resumo executivo por IA |
+
+## Configuração
+
+Variáveis de ambiente:
+
+- `MINTBOARD_API_KEY` — gere em **Configurações → Integrações** (admin)
+- `MINTBOARD_API_URL` — opcional; default produção
+
+### Claude Code
+
+```bash
+claude mcp add mintboard \
+  --env MINTBOARD_API_KEY=org_... \
+  -- npx -y mintboard-mcp
+```
+
+### Claude Desktop / Gemini CLI (JSON)
+
+```json
+{
+  "mcpServers": {
+    "mintboard": {
+      "command": "npx",
+      "args": ["-y", "mintboard-mcp"],
+      "env": { "MINTBOARD_API_KEY": "org_..." }
+    }
+  }
+}
+```
+
+### Sem publicar no npm (rodando do repositório)
+
+```bash
+cd packages/mcp-server && npm run build
+# no cliente MCP use:
+#   command: node
+#   args: ["<repo>/packages/mcp-server/dist/index.js"]
+```
+
+> Para o `npx -y mintboard-mcp` funcionar, publique o pacote:
+> `cd packages/mcp-server && npm publish --access public`

package/dist/index.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * Servidor MCP do MintBoard (stdio).
+ *
+ * Expõe o CRM como ferramentas para qualquer cliente MCP (Claude Code,
+ * Claude Desktop, Gemini CLI, etc). Autentica na API REST com a API key
+ * da organização:
+ *
+ *   MINTBOARD_API_KEY  — chave da org (Configurações → Integrações)
+ *   MINTBOARD_API_URL  — base da API (default: produção)
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+const API_URL = process.env.MINTBOARD_API_URL ?? "https://mintboard-production.up.railway.app/api/v1";
+const API_KEY = process.env.MINTBOARD_API_KEY;
+if (!API_KEY) {
+    console.error("MINTBOARD_API_KEY ausente. Gere a chave em Configurações → Integrações no MintBoard.");
+    process.exit(1);
+}
+async function call(method, path, body) {
+    const res = await fetch(`${API_URL}${path}`, {
+        method,
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`MintBoard API ${res.status}: ${text.slice(0, 400)}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function asResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+const server = new McpServer({ name: "mintboard", version: "0.1.0" });
+/* ── Projetos ── */
+server.tool("list_projects", "Lista os projetos da agência (nome, status, prioridade, progresso, prazo)", { status: z.enum(["PLANNING", "ACTIVE", "PAUSED", "COMPLETED", "CANCELLED"]).optional() }, async ({ status }) => asResult(await call("GET", `/projects${status ? `?status=${status}` : ""}`)));
+server.tool("create_project", "Cria um projeto novo", {
+    name: z.string().min(2),
+    description: z.string().optional(),
+    priority: z.enum(["P0", "P1", "P2", "P3"]).optional(),
+    deadline: z.string().describe("ISO date, ex: 2026-07-15").optional(),
+}, async (args) => asResult(await call("POST", "/projects", args)));
+server.tool("update_project", "Atualiza um projeto (status, prioridade, progresso 0-100, prazo)", {
+    project_id: z.string().uuid(),
+    status: z.enum(["PLANNING", "ACTIVE", "PAUSED", "COMPLETED", "CANCELLED"]).optional(),
+    priority: z.enum(["P0", "P1", "P2", "P3"]).optional(),
+    progress: z.number().int().min(0).max(100).optional(),
+    deadline: z.string().optional(),
+}, async ({ project_id, ...rest }) => asResult(await call("PATCH", `/projects/${project_id}`, rest)));
+/* ── Tarefas ── */
+server.tool("list_tasks", "Lista tarefas, com filtros opcionais (projeto, status, atrasadas)", {
+    project_id: z.string().uuid().optional(),
+    status: z.enum(["BACKLOG", "TODO", "IN_PROGRESS", "IN_REVIEW", "DONE"]).optional(),
+    overdue: z.boolean().optional(),
+}, async ({ project_id, status, overdue }) => {
+    const qs = new URLSearchParams();
+    if (project_id)
+        qs.set("project_id", project_id);
+    if (status)
+        qs.set("status", status);
+    if (overdue)
+        qs.set("overdue", "true");
+    return asResult(await call("GET", `/tasks${qs.size ? `?${qs}` : ""}`));
+});
+server.tool("create_task", "Cria uma tarefa em um projeto", {
+    title: z.string().min(1),
+    project_id: z.string().uuid(),
+    description: z.string().optional(),
+    priority: z.enum(["P0", "P1", "P2", "P3"]).optional(),
+    status: z.enum(["BACKLOG", "TODO", "IN_PROGRESS", "IN_REVIEW", "DONE"]).optional(),
+    deadline: z.string().optional(),
+}, async (args) => asResult(await call("POST", "/tasks", args)));
+server.tool("update_task", "Atualiza uma tarefa (status, prioridade, prazo, título)", {
+    task_id: z.string().uuid(),
+    title: z.string().optional(),
+    status: z.enum(["BACKLOG", "TODO", "IN_PROGRESS", "IN_REVIEW", "DONE"]).optional(),
+    priority: z.enum(["P0", "P1", "P2", "P3"]).optional(),
+    deadline: z.string().optional(),
+}, async ({ task_id, ...rest }) => asResult(await call("PATCH", `/tasks/${task_id}`, rest)));
+/* ── Pipeline (CRM) ── */
+server.tool("list_pipeline", "Lista os estágios do funil e os leads em cada um, com valores", {}, async () => {
+    const [stages, leads] = await Promise.all([
+        call("GET", "/pipeline/stages"),
+        call("GET", "/pipeline/leads"),
+    ]);
+    return asResult({ stages, leads });
+});
+server.tool("create_lead", "Cria um lead no funil de vendas", {
+    name: z.string().min(1),
+    stage_id: z.string().uuid().describe("ID do estágio (use list_pipeline)"),
+    email: z.string().optional(),
+    company: z.string().optional(),
+    value: z.number().optional().describe("Valor estimado em reais"),
+    source: z.enum(["WEBSITE", "REFERRAL", "SOCIAL_MEDIA", "COLD_OUTREACH", "EVENT", "OTHER"]).optional(),
+    notes: z.string().optional(),
+}, async (args) => asResult(await call("POST", "/pipeline/leads", args)));
+server.tool("move_lead", "Move um lead para outro estágio do funil", {
+    lead_id: z.string().uuid(),
+    stage_id: z.string().uuid(),
+}, async ({ lead_id, stage_id }) => asResult(await call("PATCH", `/pipeline/leads/${lead_id}/stage`, { stage_id })));
+/* ── Financeiro ── */
+server.tool("finance_overview", "Visão financeira da agência: a receber, recebido, parcelas em atraso", {}, async () => asResult(await call("GET", "/finance/overview")));
+/* ── Meta Ads ──
+   Fluxo pensado para rodar junto com o MCP oficial da Meta no mesmo
+   cliente: o assistente lê as métricas das campanhas pelo MCP da Meta
+   e grava aqui, no dashboard do cliente certo. Gasto é manual (a API
+   da Meta não compartilha), preenchido na aba Meta Ads do MintBoard. */
+server.tool("meta_list_ad_accounts", "Lista as contas de anúncio Meta Ads cadastradas, com o cliente de cada uma", {}, async () => asResult(await call("GET", "/meta-ads/accounts")));
+server.tool("meta_import_metrics", "Importa métricas diárias de campanhas para uma conta de anúncios do MintBoard (upsert por data+campanha). Use depois de ler os insights pelo MCP oficial da Meta.", {
+    account_id: z.string().uuid().describe("ID da conta no MintBoard (use meta_list_ad_accounts)"),
+    items: z
+        .array(z.object({
+        date: z.string().describe("ISO date do dia, ex: 2026-06-10"),
+        campaign: z.string().optional(),
+        impressions: z.number().int().optional(),
+        clicks: z.number().int().optional(),
+        leads: z.number().int().optional(),
+        reach: z.number().int().optional(),
+    }))
+        .max(500),
+}, async ({ account_id, items }) => asResult(await call("POST", `/meta-ads/accounts/${account_id}/metrics`, { items })));
+server.tool("meta_account_overview", "Dashboard de uma conta de anúncios: totais (impressões, cliques, leads, gasto, CTR, CPL) e série diária", {
+    account_id: z.string().uuid(),
+    days: z.number().int().min(1).max(180).optional(),
+}, async ({ account_id, days }) => asResult(await call("GET", `/meta-ads/accounts/${account_id}/overview${days ? `?days=${days}` : ""}`)));
+/* ── IA ── */
+server.tool("project_summary", "Gera (via IA do MintBoard) um resumo executivo do projeto pronto para enviar ao cliente", { project_id: z.string().uuid() }, async ({ project_id }) => asResult(await call("POST", `/ai/projects/${project_id}/summary`)));
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error(`mintboard-mcp conectado — API: ${API_URL}`);

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mintboard-mcp",
+  "version": "0.1.0",
+  "description": "Servidor MCP do MintBoard — conecta o CRM a Claude, Gemini e outros assistentes via Model Context Protocol",
+  "license": "MIT",
+  "author": "NexMint Labs",
+  "homepage": "https://taskflow-lilac-zeta-82.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MiguelRibasBerlese/CRM-SaaS.git",
+    "directory": "packages/mcp-server"
+  },
+  "keywords": ["mcp", "model-context-protocol", "crm", "mintboard", "claude", "gemini"],
+  "type": "module",
+  "bin": {
+    "mintboard-mcp": "dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": { "node": ">=20" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^22.0.0"
+  }
+}