kafox-cli 0.3.0 → 0.7.0

package/src/mcp.js

@@ -0,0 +1,557 @@
+/**
+ * Cliente MCP do kafox: conecta servidores configurados e transforma as tools
+ * deles em tools do modelo (prefixo `mcp__servidor__ferramenta`).
+ *
+ * Config (mesclada, o projeto vence a home):
+ *   ~/.kafox/mcp.json            { "mcp": { "playwright": { "type": "local", "command": ["npx","-y","@playwright/mcp@latest"] } } }
+ *   <cwd>/mcp.json               mesma forma (ou { "servers": { ... } })
+ *   ~/.kafox/config.json         { "mcp": { ... } }
+ *
+ * Servidor remoto: { "type": "remote", "url": "https://...", "headers": { } }.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const PROTOCOL_VERSION = "2024-11-05";
+const CONNECT_TIMEOUT_MS = 20_000;
+const CALL_TIMEOUT_MS = 180_000;
+const MAX_TOOL_NAME = 64;
+const MAX_ERROR_CHARS = 300;
+const CLIENT_VERSION = (() => {
+  try {
+    return require("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+})();
+
+function shorten(text, max = MAX_ERROR_CHARS) {
+  const value = String(text || "").replace(/\s+/g, " ").trim();
+  return value.length > max ? `${value.slice(0, max)}...` : value;
+}
+
+function sanitize(value) {
+  return String(value || "")
+    .trim()
+    .replace(/[^A-Za-z0-9_-]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_|_$/g, "");
+}
+
+/** Nome exposto ao modelo: cabe no limite de 64 caracteres do backend. */
+function toolName(server, tool) {
+  const name = `mcp__${sanitize(server)}__${sanitize(tool)}`;
+  return name.length <= MAX_TOOL_NAME ? name : name.slice(0, MAX_TOOL_NAME);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function collectServers(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const source = raw.mcp || raw.servers || raw;
+  const servers = {};
+  for (const [name, value] of Object.entries(source)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    if (value.command || value.url || value.type) servers[name] = value;
+  }
+  return servers;
+}
+
+function configPaths(cwd = process.cwd()) {
+  return [
+    path.join(os.homedir(), ".kafox", "mcp.json"),
+    path.join(os.homedir(), ".kafox", "config.json"),
+    path.join(cwd, "mcp.json"),
+    path.join(cwd, ".kafox", "mcp.json"),
+  ];
+}
+
+/** Junta os arquivos de config; o ultimo a definir um servidor vence. */
+function loadConfig(cwd = process.cwd()) {
+  const merged = {};
+  const found = [];
+  for (const file of configPaths(cwd)) {
+    const data = readJson(file);
+    if (!data) continue;
+    const servers = collectServers(data);
+    if (!Object.keys(servers).length) continue;
+    found.push(file);
+    Object.assign(merged, servers);
+  }
+  return { servers: merged, files: found };
+}
+
+function normalizeServer(name, raw) {
+  const disabled = raw.enabled === false || raw.disabled === true;
+  const type = String(raw.type || (raw.url ? "remote" : "local")).toLowerCase();
+
+  if (type === "remote" || type === "sse" || type === "http" || type === "streamable-http") {
+    if (!raw.url) return null;
+    return {
+      name,
+      kind: "remote",
+      url: String(raw.url),
+      headers: { ...(raw.headers || {}) },
+      disabled,
+    };
+  }
+
+  const command = Array.isArray(raw.command)
+    ? raw.command.map(String)
+    : String(raw.command || "")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+  if (!command.length) return null;
+  return {
+    name,
+    kind: "stdio",
+    command,
+    env: { ...(raw.environment || raw.env || {}) },
+    cwd: raw.cwd || null,
+    disabled,
+  };
+}
+
+/* ------------------------------------------------------------------ transporte */
+
+function quoteWin(parts) {
+  return parts
+    .map((part) => (/\s/.test(part) && !part.startsWith('"') ? `"${part}"` : part))
+    .join(" ");
+}
+
+class StdioTransport {
+  constructor(server, handlers) {
+    this.server = server;
+    this.handlers = handlers;
+    this.child = null;
+    this.buffer = "";
+    this.stderr = "";
+    this.exited = false;
+  }
+
+  start() {
+    const cwd = this.server.cwd ? path.resolve(this.server.cwd) : process.cwd();
+    const env = { ...process.env, ...this.server.env, KAFOX_CLI: "1" };
+    const options = { cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true };
+
+    if (process.platform === "win32") {
+      this.child = spawn(quoteWin(this.server.command), { ...options, shell: true });
+    } else {
+      const [bin, ...args] = this.server.command;
+      this.child = spawn(bin, args, options);
+    }
+
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.onData(chunk));
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => {
+      this.stderr = (this.stderr + chunk).slice(-2000);
+    });
+    this.child.on("error", (error) => {
+      this.exited = true;
+      this.handlers.onExit(`nao consegui iniciar: ${error.message}`);
+    });
+    this.child.on("exit", (code, signal) => {
+      this.exited = true;
+      const detail = this.stderr ? ` (${shorten(this.stderr, 160)})` : "";
+      this.handlers.onExit(`processo encerrou (${signal || code})${detail}`);
+    });
+    return Promise.resolve();
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    let index = this.buffer.indexOf("\n");
+    while (index >= 0) {
+      const line = this.buffer.slice(0, index).trim();
+      this.buffer = this.buffer.slice(index + 1);
+      if (line) {
+        try {
+          this.handlers.onMessage(JSON.parse(line));
+        } catch {
+          // Linha de log do servidor: ignora.
+        }
+      }
+      index = this.buffer.indexOf("\n");
+    }
+  }
+
+  send(message) {
+    if (!this.child || this.exited) throw new Error("servidor MCP nao esta rodando");
+    this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    return Promise.resolve(null);
+  }
+
+  close() {
+    if (!this.child) return;
+    try {
+      this.child.stdin.end();
+      this.child.kill();
+    } catch {}
+    this.child = null;
+  }
+}
+
+function parseSse(text) {
+  const events = [];
+  for (const block of String(text).split(/\n\n+/)) {
+    const data = block
+      .split(/\n/)
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trim())
+      .join("");
+    if (!data) continue;
+    try {
+      events.push(JSON.parse(data));
+    } catch {}
+  }
+  return events;
+}
+
+class HttpTransport {
+  constructor(server) {
+    this.server = server;
+    this.sessionId = null;
+    this.closed = false;
+  }
+
+  start() {
+    return Promise.resolve();
+  }
+
+  async post(message) {
+    const headers = {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+      ...this.server.headers,
+    };
+    if (this.sessionId) headers["mcp-session-id"] = this.sessionId;
+
+    const response = await fetch(this.server.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(message),
+    });
+    const session = response.headers.get("mcp-session-id");
+    if (session) this.sessionId = session;
+
+    const type = response.headers.get("content-type") || "";
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${shorten(text, 160)}`);
+    }
+    if (type.includes("text/event-stream")) return parseSse(text);
+    try {
+      return [JSON.parse(text)];
+    } catch {
+      return [];
+    }
+  }
+
+  send(message) {
+    if (this.closed) throw new Error("servidor MCP foi encerrado");
+    return this.post(message);
+  }
+
+  close() {
+    this.closed = true;
+  }
+}
+
+/* --------------------------------------------------------------------- cliente */
+
+class McpClient {
+  constructor(server, options = {}) {
+    this.server = server;
+    this.options = {
+      connectTimeoutMs: options.connectTimeoutMs || CONNECT_TIMEOUT_MS,
+      callTimeoutMs: options.callTimeoutMs || CALL_TIMEOUT_MS,
+    };
+    this.status = server.disabled ? "disabled" : "idle";
+    this.error = null;
+    this.tools = [];
+    this.serverInfo = null;
+    this.pending = new Map();
+    this.nextId = 1;
+    this.transport = null;
+    this.exitError = null;
+  }
+
+  onMessage(message) {
+    if (!message || typeof message !== "object") return;
+    const id = message.id;
+    if (id == null || !this.pending.has(id)) return;
+    const entry = this.pending.get(id);
+    this.pending.delete(id);
+    clearTimeout(entry.timer);
+
+    if (message.error) {
+      entry.reject(new Error(shorten(message.error.message || JSON.stringify(message.error))));
+      return;
+    }
+    entry.resolve(message.result ?? {});
+  }
+
+  request(method, params = {}, timeoutMs) {
+    const id = this.nextId++;
+    const message = { jsonrpc: "2.0", id, method, params };
+    const timeout = timeoutMs || this.options.callTimeoutMs;
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} demorou mais de ${Math.round(timeout / 1000)}s`));
+      }, timeout);
+      timer.unref?.();
+
+      const settle = (fn) => (value) => {
+        clearTimeout(timer);
+        fn(value);
+      };
+
+      if (this.server.kind === "stdio") {
+        this.pending.set(id, { resolve: settle(resolve), reject: settle(reject), timer });
+        try {
+          this.transport.send(message);
+        } catch (error) {
+          this.pending.delete(id);
+          clearTimeout(timer);
+          reject(error);
+        }
+        return;
+      }
+
+      this.transport
+        .send(message)
+        .then((responses) => {
+          clearTimeout(timer);
+          const match = (responses || []).find((item) => item && item.id === id);
+          if (!match) {
+            reject(new Error(`${method} sem resposta do servidor`));
+            return;
+          }
+          if (match.error) {
+            reject(new Error(shorten(match.error.message || "erro no servidor")));
+            return;
+          }
+          resolve(match.result ?? {});
+        })
+        .catch(settle(reject));
+    });
+  }
+
+  notify(method, params = {}) {
+    return this.transport.send({ jsonrpc: "2.0", method, params }).catch(() => null);
+  }
+
+  async connect() {
+    if (this.server.disabled) return this;
+    this.status = "connecting";
+
+    try {
+      this.transport =
+        this.server.kind === "stdio"
+          ? new StdioTransport(this.server, {
+              onMessage: (message) => this.onMessage(message),
+              onExit: (reason) => this.fail(reason),
+            })
+          : new HttpTransport(this.server);
+
+      await this.transport.start();
+
+      const result = await this.request(
+        "initialize",
+        {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: "kafox-cli", version: CLIENT_VERSION },
+        },
+        this.options.connectTimeoutMs
+      );
+
+      this.serverInfo = result?.serverInfo || null;
+      await this.notify("notifications/initialized");
+      this.tools = await this.fetchTools();
+      this.status = "connected";
+      this.error = null;
+    } catch (error) {
+      this.fail(error.message || String(error));
+    }
+    return this;
+  }
+
+  fail(reason) {
+    if (this.status === "error") return;
+    this.status = "error";
+    this.error = shorten(reason);
+    this.exitError = this.error;
+    for (const [id, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error(this.error));
+      this.pending.delete(id);
+    }
+    this.close();
+  }
+
+  async fetchTools() {
+    const tools = [];
+    let cursor = null;
+    for (let page = 0; page < 20; page += 1) {
+      const result = await this.request(
+        "tools/list",
+        cursor ? { cursor } : {},
+        this.options.connectTimeoutMs
+      );
+      for (const tool of result?.tools || []) {
+        if (tool?.name) tools.push(tool);
+      }
+      cursor = result?.nextCursor;
+      if (!cursor) break;
+    }
+    return tools;
+  }
+
+  async call(tool, args) {
+    if (this.status === "error") throw new Error(this.error || "servidor MCP com erro");
+    const result = await this.request("tools/call", { name: tool, arguments: args || {} });
+    return flattenResult(result);
+  }
+
+  close() {
+    try {
+      this.transport?.close();
+    } catch {}
+  }
+}
+
+function flattenResult(result) {
+  const parts = [];
+  for (const item of result?.content || []) {
+    if (item?.type === "text" && typeof item.text === "string") parts.push(item.text);
+    else if (typeof item?.text === "string") parts.push(item.text);
+    else if (item?.type) parts.push(`[${item.type}]`);
+  }
+  if (result?.structuredContent) {
+    try {
+      parts.push(JSON.stringify(result.structuredContent, null, 2));
+    } catch {}
+  }
+  const text = parts.join("\n").trim() || "(sem saida)";
+  return result?.isError ? `erro: ${text}` : text;
+}
+
+/* ------------------------------------------------------------------ agregador */
+
+class McpHub {
+  constructor({ cwd = process.cwd(), servers = null, options = {} } = {}) {
+    const config = servers ? { servers, files: [] } : loadConfig(cwd);
+    this.cwd = cwd;
+    this.files = config.files;
+    this.clients = new Map();
+    this.toolMap = new Map();
+    for (const [name, raw] of Object.entries(config.servers)) {
+      const server = normalizeServer(name, raw);
+      if (!server) continue;
+      this.clients.set(name, new McpClient(server, options));
+    }
+  }
+
+  get size() {
+    return this.clients.size;
+  }
+
+  async connectAll() {
+    await Promise.all([...this.clients.values()].map((client) => client.connect()));
+    this.rebuild();
+    return this;
+  }
+
+  rebuild() {
+    this.toolMap.clear();
+    for (const client of this.clients.values()) {
+      for (const tool of client.tools) {
+        this.toolMap.set(toolName(client.server.name, tool.name), {
+          server: client.server.name,
+          tool: tool.name,
+          client,
+        });
+      }
+    }
+  }
+
+  /** Especificacoes no formato OpenAI para mandar ao modelo. */
+  specs() {
+    const specs = [];
+    for (const [name, entry] of this.toolMap) {
+      const tool = entry.client.tools.find((item) => item.name === entry.tool) || {};
+      specs.push({
+        type: "function",
+        function: {
+          name,
+          description: shorten(
+            tool.description || `Ferramenta "${entry.tool}" do servidor MCP "${entry.server}".`,
+            900
+          ),
+          parameters:
+            tool.inputSchema && typeof tool.inputSchema === "object"
+              ? tool.inputSchema
+              : { type: "object", properties: {} },
+        },
+      });
+    }
+    return specs;
+  }
+
+  has(name) {
+    return this.toolMap.has(name);
+  }
+
+  describe(name) {
+    const entry = this.toolMap.get(name);
+    if (!entry) return null;
+    return { server: entry.server, tool: entry.tool };
+  }
+
+  async call(name, args) {
+    const entry = this.toolMap.get(name);
+    if (!entry) throw new Error(`ferramenta MCP desconhecida: ${name}`);
+    return entry.client.call(entry.tool, args);
+  }
+
+  statuses() {
+    return [...this.clients.values()].map((client) => ({
+      name: client.server.name,
+      kind: client.server.kind,
+      status: client.status,
+      error: client.error,
+      tools: client.tools.length,
+      toolNames: client.tools.map((tool) => toolName(client.server.name, tool.name)),
+      serverInfo: client.serverInfo,
+    }));
+  }
+
+  close() {
+    for (const client of this.clients.values()) client.close();
+  }
+}
+
+module.exports = {
+  McpHub,
+  McpClient,
+  loadConfig,
+  configPaths,
+  normalizeServer,
+  toolName,
+  flattenResult,
+  parseSse,
+};

package/src/models.js

@@ -16,12 +16,9 @@ async function listModels() {
   const data = await res.json();
   console.log(chalk.cyan("\nKafox models:\n"));
   for (const p of data.pricing) {
-    const inp = (p.input_micros_per_1m / 1_000_000).toFixed(2);
-    const out = (p.output_micros_per_1m / 1_000_000).toFixed(2);
     console.log(`  ${chalk.bold(p.model)}`);
-    console.log(`    in: ${inp} R$/1M  out: ${out} R$/1M`);
   }
-  console.log(`\nGateway: ${chalk.dim(data.gateway_url)}`);
+  console.log(chalk.dim(`\nGateway: ${data.gateway_url}`));
 }
 
 async function showBalance() {

package/src/runner.js

@@ -0,0 +1,98 @@
+const chalk = require("chalk");
+const { runAgent } = require("./agent");
+
+/**
+ * Roda o agente sem TUI: serve para script, CI e para usar o kafox como
+ * "agente auditor" de outro processo.
+ *
+ *   kafox agent "revise src/x.js e aponte bugs" [-m modelo] [-y] [--max-steps 12]
+ *
+ * Sem --max-steps o agente roda ate terminar (Ctrl+C aborta).
+ */
+async function runHeadless({
+  prompt,
+  model,
+  allowAll = false,
+  maxSteps = Infinity,
+  cwd = process.cwd(),
+  quiet = false,
+  json = false,
+} = {}) {
+  if (!prompt || !String(prompt).trim()) {
+    throw new Error("informe o objetivo do agente");
+  }
+
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  process.once("SIGINT", abort);
+  process.once("SIGTERM", abort);
+
+  const log = (line) => {
+    if (!quiet && !json) process.stderr.write(`${line}\n`);
+  };
+
+  const events = [];
+  const denied = [];
+  const subagents = [];
+
+  const result = await runAgent({
+    messages: [{ role: "user", content: String(prompt) }],
+    model,
+    cwd,
+    maxSteps,
+    signal: controller.signal,
+    autoApprove: () => allowAll,
+    approve: async (name, args, context) => {
+      if (allowAll) return true;
+      denied.push(name);
+      log(chalk.dim(`[${name}] negado (use --allow-all para liberar)`));
+      return false;
+    },
+    onText: (chunk) => {
+      if (!json) process.stdout.write(chunk);
+    },
+    onToolStart: ({ name, label, subagent }) => {
+      events.push({ type: "tool-start", name, label });
+      log(
+        chalk.dim(
+          `[${name}] ${String(label || "").slice(0, 140)}${
+            subagent ? ` (${subagent.count} subagente(s))` : ""
+          }`
+        )
+      );
+    },
+    onToolResult: ({ name, ok, ms, summary }) => {
+      events.push({ type: "tool-result", name, ok, ms });
+      log(chalk.dim(`[${name}] ${ok ? "ok" : "falhou"} · ${ms}ms · ${String(summary || "").slice(0, 120)}`));
+    },
+    onSubagentEvent: (event) => {
+      if (event.phase === "start") {
+        subagents.push({ objective: event.objective, tools: event.tools });
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.objective}`));
+      } else if (event.phase === "tool") {
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.tool}: ${String(event.text || "").slice(0, 100)}`));
+      } else if (event.phase === "done") {
+        log(chalk.dim(`[subagente ${event.index}/${event.total}] ${event.ok ? "concluído" : "falhou"} em ${event.ms}ms`));
+      }
+    },
+  });
+
+  if (!json && !quiet && result.text) process.stdout.write("\n");
+
+  const payload = {
+    ok: Boolean(result.ok),
+    text: result.text || "",
+    steps: result.steps || 0,
+    ms: result.ms || 0,
+    error: result.error || null,
+    aborted: Boolean(result.aborted),
+    tools: events,
+    subagents,
+    denied,
+  };
+  if (json) process.stdout.write(`${JSON.stringify(payload)}\n`);
+
+  return payload;
+}
+
+module.exports = { runHeadless };