@proteo-mcp/cli 0.1.0

package/dist/bridge.js

@@ -0,0 +1,81 @@
+/**
+ * bridge.ts — stdio ↔ HTTP bridge para o mcp-proteo
+ *
+ * Quando o CLI é invocado sem subcomando (ex: `npx @proteo/mcp-proteo`),
+ * actua como servidor MCP via stdio, encaminhando cada mensagem JSON-RPC
+ * para POST /mcp no servidor remoto com a API key armazenada.
+ *
+ * O servidor remoto opera em modo stateless (uma instância McpServer por
+ * request), portanto cada mensagem pode ser enviada independentemente.
+ */
+import { createInterface } from "node:readline";
+import { loadCredentials } from "./store.js";
+import { normalizeMcpUrl } from "./mcpUrl.js";
+const BRIDGE_USER_AGENT = "mcp-proteo-cli/0.1.0";
+function writeJsonRpcError(id, code, message) {
+    const payload = JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+    process.stdout.write(payload + "\n");
+}
+export async function runBridge() {
+    const creds = loadCredentials();
+    if (!creds) {
+        writeJsonRpcError(null, -32001, "Nao autenticado. Execute: npx @proteo/mcp-proteo login");
+        process.exit(1);
+    }
+    const mcpUrl = `${normalizeMcpUrl(creds.url)}/mcp`;
+    const authHeader = `Bearer ${creds.apiKey}`;
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Extrai id da mensagem para erros formatados
+        let msgId = null;
+        try {
+            const parsed = JSON.parse(trimmed);
+            msgId = parsed.id ?? null;
+        }
+        catch {
+            // ignora parse error — encaminha mesmo assim
+        }
+        try {
+            const res = await fetch(mcpUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json, text/event-stream",
+                    Authorization: authHeader,
+                    "User-Agent": BRIDGE_USER_AGENT,
+                },
+                body: trimmed,
+            });
+            const contentType = res.headers.get("content-type") ?? "";
+            if (contentType.includes("text/event-stream")) {
+                // SSE: extrai campos `data:` e escreve cada um como linha JSON
+                const text = await res.text();
+                for (const sseLineRaw of text.split("\n")) {
+                    const sseLine = sseLineRaw.trim();
+                    if (sseLine.startsWith("data: ") && sseLine.length > 6) {
+                        process.stdout.write(sseLine.slice(6) + "\n");
+                    }
+                }
+            }
+            else {
+                const body = await res.text();
+                const trimmedBody = body.trim();
+                if (!res.ok && !trimmedBody.startsWith("{")) {
+                    // Resposta de erro não-JSON (ex: 401 sem body JSON-RPC)
+                    writeJsonRpcError(msgId, -32001, `Servidor respondeu ${res.status}: ${trimmedBody.slice(0, 200)}`);
+                    continue;
+                }
+                if (trimmedBody) {
+                    process.stdout.write(trimmedBody + "\n");
+                }
+            }
+        }
+        catch (err) {
+            writeJsonRpcError(msgId, -32603, `Bridge error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/commands/login.js

@@ -0,0 +1,46 @@
+import kleur from "kleur";
+import { saveCredentials } from "../store.js";
+import { promptHidden, promptLine } from "../prompt.js";
+import { normalizeMcpUrl } from "../mcpUrl.js";
+const DEFAULT_MCP_URL = "https://mcp.proteo.tech";
+export async function loginCommand(options) {
+    const mcpUrl = normalizeMcpUrl(options.url ?? process.env.MCP_PROTEO_URL ?? DEFAULT_MCP_URL);
+    console.log("");
+    console.log(kleur.bold().blue("  Proteo MCP — Login"));
+    console.log("");
+    console.log(`  ${kleur.dim("Servidor:")} ${mcpUrl}`);
+    console.log("");
+    const username = (options.username?.trim() || (await promptLine("  Usuário: "))).trim();
+    if (!username) {
+        throw new Error("Informe o usuário Proteo.");
+    }
+    const password = (await promptHidden("  Senha: ")).replace(/\r/g, "");
+    if (!password) {
+        throw new Error("Informe a senha Proteo.");
+    }
+    console.log("");
+    console.log("  " + kleur.dim("Autenticando..."));
+    const res = await fetch(`${mcpUrl}/v1/clients/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify({ username, password }),
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        throw new Error(body.error_description ?? body.error ?? `Falha ao autenticar (${res.status}).`);
+    }
+    const apiKey = body.apiKey;
+    if (!apiKey?.startsWith("mcp_live_")) {
+        throw new Error("Resposta inválida do servidor: apiKey ausente.");
+    }
+    const tenantId = body.tenantId?.trim() || username;
+    saveCredentials({ url: mcpUrl, apiKey, tenantId, username });
+    console.log("");
+    console.log(kleur.green("  ✔ Autenticado com sucesso!"));
+    console.log(`  ${kleur.dim("Usuário:")} ${kleur.bold(username)}`);
+    console.log(`  ${kleur.dim("Servidor:")} ${kleur.bold(mcpUrl)}`);
+    console.log("");
+    console.log(`  ${kleur.dim("Sessão salva em")} ${kleur.bold("~/.proteo/mcp-proteo.json")}`);
+    console.log("");
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/logout.js

@@ -0,0 +1,18 @@
+import kleur from "kleur";
+import { clearCredentials, configFilePath } from "../store.js";
+export function logoutCommand() {
+    const removed = clearCredentials();
+    if (removed) {
+        console.log("");
+        console.log(kleur.green("  ✔ Credenciais removidas."));
+        console.log(`  ${kleur.dim("Arquivo excluído:")} ${kleur.bold(configFilePath())}`);
+        console.log("");
+    }
+    else {
+        console.log("");
+        console.log(kleur.yellow("  Nenhuma credencial encontrada."));
+        console.log(`  ${kleur.dim("Execute")} ${kleur.bold("npx @proteo/mcp-proteo login")} ${kleur.dim("para autenticar.")}`);
+        console.log("");
+    }
+}
+//# sourceMappingURL=logout.js.map

package/dist/commands/whoami.js

@@ -0,0 +1,24 @@
+import kleur from "kleur";
+import { loadCredentials, configFilePath } from "../store.js";
+export function whoamiCommand() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log("");
+        console.log(kleur.yellow("  Não autenticado."));
+        console.log(`  ${kleur.dim("Execute")} ${kleur.bold("npx @proteo/mcp-proteo login")} ${kleur.dim("para autenticar.")}`);
+        console.log("");
+        process.exitCode = 1;
+        return;
+    }
+    const savedAt = new Date(creds.savedAt).toLocaleString("pt-BR");
+    console.log("");
+    console.log(kleur.bold().blue("  Proteo MCP — sessão ativa"));
+    console.log("");
+    console.log(`  ${kleur.dim("Tenant:")}  ${kleur.bold(creds.tenantId)}`);
+    console.log(`  ${kleur.dim("Usuário:")} ${kleur.bold(creds.username)}`);
+    console.log(`  ${kleur.dim("Servidor:")} ${kleur.bold(creds.url)}`);
+    console.log(`  ${kleur.dim("Autenticado em:")} ${kleur.bold(savedAt)}`);
+    console.log(`  ${kleur.dim("Config:")} ${kleur.bold(configFilePath())}`);
+    console.log("");
+}
+//# sourceMappingURL=whoami.js.map

package/dist/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { loginCommand } from "./commands/login.js";
+import { logoutCommand } from "./commands/logout.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { runBridge } from "./bridge.js";
+program
+    .name("mcp-proteo")
+    .description("CLI do Proteo MCP — autenticação e bridge stdio")
+    .version("0.1.0");
+program
+    .command("login")
+    .description("Autenticar com usuário e senha Proteo")
+    .option("-u, --url <url>", "URL do servidor mcp-proteo", process.env.MCP_PROTEO_URL)
+    .option("--username <username>", "Usuário Proteo (senão, pergunta no terminal)")
+    .action((options) => {
+    loginCommand({ url: options.url, username: options.username }).catch((err) => {
+        process.stderr.write(`\n  Erro: ${err instanceof Error ? err.message : String(err)}\n\n`);
+        process.exit(1);
+    });
+});
+program
+    .command("logout")
+    .description("Remover credenciais salvas")
+    .action(() => {
+    logoutCommand();
+});
+program
+    .command("whoami")
+    .description("Exibir a sessão ativa")
+    .action(() => {
+    whoamiCommand();
+});
+// Comando padrão (sem subcomando): bridge stdio → HTTP
+// Usado pelo host MCP (Cursor, Claude, etc.) ao iniciar via `command: npx @proteo/mcp-proteo`
+if (process.argv.length === 2 || (process.argv.length === 3 && process.argv[2] === "start")) {
+    runBridge().catch((err) => {
+        process.stderr.write(`Bridge fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}
+else {
+    program.parse();
+}
+//# sourceMappingURL=index.js.map

package/dist/mcpUrl.js

@@ -0,0 +1,29 @@
+/**
+ * Garante que o CLI só envie usuário/senha/API key para um servidor MCP
+ * em HTTPS. HTTP fica restrito a localhost (dev).
+ */
+export function normalizeMcpUrl(raw) {
+    const trimmed = raw.trim().replace(/\/$/, "");
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        throw new Error("URL do servidor MCP inválida.");
+    }
+    if (url.username || url.password) {
+        throw new Error("A URL do servidor não pode conter credenciais.");
+    }
+    const isLocal = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+    if (url.protocol === "http:") {
+        if (!isLocal) {
+            throw new Error("O servidor MCP precisa usar HTTPS (HTTP só é aceito em localhost).");
+        }
+        return trimmed;
+    }
+    if (url.protocol !== "https:") {
+        throw new Error("O servidor MCP precisa usar HTTPS.");
+    }
+    return trimmed;
+}
+//# sourceMappingURL=mcpUrl.js.map

package/dist/prompt.js

@@ -0,0 +1,48 @@
+import { createInterface } from "node:readline";
+export async function promptLine(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer.trim()));
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Lê senha no terminal mostrando asteriscos. Evita `setRawMode`, que no
+ * Windows (especialmente no terminal integrado do Cursor) engole as teclas
+ * e faz parecer que a senha não pode ser digitada.
+ */
+export async function promptHidden(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: Boolean(process.stdin.isTTY),
+    });
+    const mutable = rl;
+    mutable._writeToOutput = (s) => {
+        if (s === question) {
+            process.stdout.write(s);
+            return;
+        }
+        if (s === "\n" || s === "\r" || s === "\r\n") {
+            process.stdout.write("\n");
+            return;
+        }
+        const printable = s.replace(/[\r\n]/g, "");
+        if (printable.length > 0) {
+            process.stdout.write("*".repeat(printable.length));
+        }
+    };
+    try {
+        return await new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer));
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=prompt.js.map

package/dist/store.js

@@ -0,0 +1,40 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync, chmodSync } from "node:fs";
+const CONFIG_DIR = join(homedir(), ".proteo");
+const CONFIG_FILE = join(CONFIG_DIR, "mcp-proteo.json");
+export function loadCredentials() {
+    if (!existsSync(CONFIG_FILE))
+        return undefined;
+    try {
+        const raw = readFileSync(CONFIG_FILE, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveCredentials(creds) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    const full = { ...creds, savedAt: new Date().toISOString() };
+    writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2), { encoding: "utf8", mode: 0o600 });
+    try {
+        chmodSync(CONFIG_DIR, 0o700);
+        chmodSync(CONFIG_FILE, 0o600);
+    }
+    catch {
+        // Windows ignora POSIX mode; a sessão ainda não contém a senha Proteo.
+    }
+}
+export function clearCredentials() {
+    if (!existsSync(CONFIG_FILE))
+        return false;
+    unlinkSync(CONFIG_FILE);
+    return true;
+}
+export function configFilePath() {
+    return CONFIG_FILE;
+}
+//# sourceMappingURL=store.js.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@proteo-mcp/cli",
+  "version": "0.1.0",
+  "description": "CLI e bridge stdio do mcp-proteo. Use `npx @proteo/mcp-proteo login` para autenticar e configure no seu cliente MCP.",
+  "type": "module",
+  "bin": {
+    "mcp-proteo": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/**/*.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "pack:check": "node scripts/verify-pack.mjs",
+    "prepublishOnly": "npm run build && npm run pack:check"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18.17"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.19.1",
+    "commander": "^12.1.0",
+    "kleur": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}