cliskill 1.0.4 → 1.0.5

package/README.md

@@ -24,6 +24,7 @@
 - [Использование](#-использование)
 - [Конфигурация](#-конфигурация)
 - [Инструменты](#-инструменты)
+- [MCP серверы](#-mcp-серверы)
 - [Агентская система](#-агентская-система)
 - [Архитектура](#-архитектура)
 - [API провайдеры](#-api-провайдеры)
@@ -345,6 +346,71 @@ cliskill включает 15 встроенных инструментов дл
 
 ---
 
+## 🔌 MCP серверы
+
+**MCP (Model Context Protocol)** — открытый протокол для подключения внешних инструментов к AI-ассистентам. cliskill автоматически запускает MCP-серверы при старте и регистрирует их инструменты как доступные для модели.
+
+### Как это работает
+
+1. cliskill читает `mcpServers` из конфига
+2. Запускает каждый сервер как дочерний процесс (stdio transport)
+3. Получает список инструментов через `tools/list`
+4. Регистрирует их в ToolRegistry с префиксом `mcp_{serverName}_`
+5. Модель может вызывать MCP-инструменты наравне со встроенными
+
+### Настройка
+
+Добавьте массив `mcpServers` в конфиг (`~/.cliskill/config.json` или `.cliskillrc.json`):
+
+```json
+{
+  "mcpServers": [
+    {
+      "name": "filesystem",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
+      "transport": "stdio"
+    },
+    {
+      "name": "github",
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token"
+      },
+      "transport": "stdio"
+    }
+  ]
+}
+```
+
+### Поля конфигурации MCP-сервера
+
+| Поле | Тип | Обязательное | Описание |
+|------|-----|:---:|----------|
+| `name` | string | ✅ | Уникальное имя сервера |
+| `command` | string | ✅ | Команда запуска процесса |
+| `args` | string[] | — | Аргументы команды (по умолчанию `[]`) |
+| `env` | object | — | Переменные окружения для процесса |
+| `transport` | string | — | Транспорт: `"stdio"` (по умолчанию) |
+
+### Популярные MCP-серверы
+
+| Сервер | Пакет | Назначение |
+|--------|-------|------------|
+| Filesystem | `@modelcontextprotocol/server-filesystem` | Доступ к файловой системе |
+| GitHub | `@modelcontextprotocol/server-github` | Работа с GitHub API |
+| PostgreSQL | `@modelcontextprotocol/server-postgres` | Запросы к PostgreSQL |
+| Brave Search | `@modelcontextprotocol/server-brave-search` | Веб-поиск через Brave |
+| Memory | `@modelcontextprotocol/server-memory` | Память между сессиями |
+| Puppeteer | `@modelcontextprotocol/server-puppeteer` | Управление браузером |
+
+### Безопасность
+
+- MCP-инструменты наследуют `riskLevel = 'safe'` — требуют разрешения в режиме `ask`
+- Серверы запускаются с переменными окружения из конфига (не из системы)
+- При ошибке подключения сервер пропускается, остальные продолжают работу
+
 ## 🤖 Агентская система
 
 ### Auto Mode

package/dist/bootstrap/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-UJMUL64T.js";
+} from "../chunk-ETGUAK34.js";
 import "../chunk-AJENHWD3.js";
 export {
   runCli

package/dist/{chunk-UJMUL64T.js → chunk-ETGUAK34.js}

@@ -90,6 +90,18 @@ var modelsSchema = z.object({
   fallbackModel: z.string().default("glm-5.1"),
   maxContextTokens: z.number().default(5e5)
 });
+var mcpServerSchema = z.object({
+  /** Unique name for this MCP server */
+  name: z.string().min(1),
+  /** Command to start the MCP server process */
+  command: z.string().min(1),
+  /** Arguments passed to the command */
+  args: z.array(z.string()).default([]),
+  /** Environment variables for the server process */
+  env: z.record(z.string()).optional(),
+  /** Transport type (currently only stdio supported) */
+  transport: z.enum(["stdio"]).default("stdio")
+});
 var appConfigSchema = z.object({
   /** Default provider name to use */
   defaultProvider: z.string().optional(),
@@ -136,7 +148,9 @@ var appConfigSchema = z.object({
     maxHistoryAge: z.number().default(60),
     maxMemorySize: z.number().default(50),
     idleThreshold: z.number().default(3e5)
-  }).default({})
+  }).default({}),
+  /** MCP servers — external tool providers via Model Context Protocol */
+  mcpServers: z.array(mcpServerSchema).default([])
 });
 
 // src/config/constants.ts
@@ -6811,6 +6825,312 @@ function buildSystemPrompt() {
   ].join("\n\n");
 }
 
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var REQUEST_TIMEOUT = 3e4;
+var MCPClient = class {
+  config;
+  process = null;
+  rl = null;
+  connected = false;
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) return;
+    const env = {
+      ...process.env,
+      ...this.config.env
+    };
+    this.process = spawn(this.config.command, this.config.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.process.on("error", (err) => {
+      this.cleanup();
+      throw err;
+    });
+    this.process.on("exit", () => {
+      this.cleanup();
+    });
+    if (!this.process.stdout) {
+      throw new Error("MCP server stdout is not available");
+    }
+    this.rl = createInterface({ input: this.process.stdout });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    if (this.process.stderr) {
+      this.process.stderr.on("data", () => {
+      });
+    }
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "cliskill", version: "1.0.0" }
+    });
+    this.sendNotification("notifications/initialized", {});
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.process) return;
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+    this.process.kill("SIGTERM");
+    this.cleanup();
+  }
+  async listTools() {
+    const response = await this.sendRequest("tools/list", {});
+    const result = response.result;
+    return result?.tools ?? [];
+  }
+  async callTool(name, args) {
+    const response = await this.sendRequest("tools/call", { name, arguments: args });
+    return response.result;
+  }
+  async listResources() {
+    const response = await this.sendRequest("resources/list", {});
+    const result = response.result;
+    return result?.resources ?? [];
+  }
+  async readResource(uri) {
+    const response = await this.sendRequest("resources/read", { uri });
+    return response.result;
+  }
+  async listPrompts() {
+    const response = await this.sendRequest("prompts/list", {});
+    const result = response.result;
+    return result?.prompts ?? [];
+  }
+  isConnected() {
+    return this.connected;
+  }
+  sendRequest(method, params) {
+    return new Promise((resolve9, reject) => {
+      if (!this.process?.stdin) {
+        reject(new Error("MCP server not connected"));
+        return;
+      }
+      const id = this.nextId++;
+      const request = { jsonrpc: "2.0", id, method, params };
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method} (id=${id})`));
+      }, REQUEST_TIMEOUT);
+      this.pendingRequests.set(id, { resolve: resolve9, reject, timer });
+      const data = JSON.stringify(request) + "\n";
+      this.process.stdin.write(data, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pendingRequests.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  sendNotification(method, params) {
+    if (!this.process?.stdin) return;
+    const notification = { jsonrpc: "2.0", method, params };
+    const data = JSON.stringify(notification) + "\n";
+    this.process.stdin.write(data);
+  }
+  handleLine(line) {
+    this.buffer += line;
+    let response;
+    try {
+      response = JSON.parse(this.buffer);
+    } catch {
+      return;
+    } finally {
+      this.buffer = "";
+    }
+    if (response.id !== void 0 && response.id !== null) {
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response);
+      }
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.rl?.close();
+    this.rl = null;
+    this.process = null;
+    this.buffer = "";
+  }
+};
+
+// src/mcp/manager.ts
+var MCPConnectionManager = class {
+  clients = /* @__PURE__ */ new Map();
+  async addServer(config) {
+    const client = new MCPClient(config);
+    await client.connect();
+    this.clients.set(config.name, client);
+  }
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      await client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+  getConnectedServers() {
+    return Array.from(this.clients.entries()).filter(([, client]) => client.isConnected()).map(([name]) => name);
+  }
+  async getAllTools() {
+    const allTools = [];
+    for (const [, client] of this.clients) {
+      if (!client.isConnected()) continue;
+      try {
+        const tools = await client.listTools();
+        allTools.push(...tools);
+      } catch {
+      }
+    }
+    return allTools;
+  }
+  async callTool(serverName, toolName, args) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      throw new Error(`MCP server "${serverName}" not found`);
+    }
+    if (!client.isConnected()) {
+      throw new Error(`MCP server "${serverName}" is not connected`);
+    }
+    return client.callTool(toolName, args);
+  }
+  async getToolsForServer(serverName) {
+    const client = this.clients.get(serverName);
+    if (!client || !client.isConnected()) {
+      return [];
+    }
+    return client.listTools();
+  }
+  async disconnectAll() {
+    for (const [, client] of this.clients) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.clients.clear();
+  }
+};
+
+// src/mcp/mcp-tool-adapter.ts
+import { z as z20 } from "zod";
+var MCPToolAdapter = class {
+  name;
+  description;
+  inputSchema;
+  riskLevel = "safe";
+  concurrencySafe = true;
+  readOnly = true;
+  serverName;
+  mcpManager;
+  rawInputSchema;
+  constructor(serverName, toolName, description, inputSchema, mcpManager) {
+    this.name = `mcp_${serverName}_${toolName}`;
+    this.description = description;
+    this.serverName = serverName;
+    this.mcpManager = mcpManager;
+    this.rawInputSchema = inputSchema;
+    this.inputSchema = this.buildZodSchema(inputSchema);
+  }
+  async execute(input, context) {
+    const allowed = await context.checkPermission(this.name, JSON.stringify(input));
+    if (!allowed) {
+      return `Error: Permission denied for MCP tool: ${this.name}`;
+    }
+    try {
+      const result = await this.mcpManager.callTool(this.serverName, this.getOriginalName(), input);
+      return typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    } catch (err) {
+      return `Error calling MCP tool ${this.name}: ${err.message}`;
+    }
+  }
+  toToolDefinition() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.rawInputSchema
+    };
+  }
+  getOriginalName() {
+    const parts = this.name.split("_");
+    return parts.slice(2).join("_");
+  }
+  getServerName() {
+    return this.serverName;
+  }
+  buildZodSchema(jsonSchema) {
+    const properties = jsonSchema.properties ?? {};
+    const required = new Set(jsonSchema.required ?? []);
+    const shape = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      const zodType = this.jsonSchemaPropertyToZod(propSchema);
+      shape[key] = required.has(key) ? zodType : zodType.optional();
+    }
+    return z20.object(shape);
+  }
+  jsonSchemaPropertyToZod(prop) {
+    const type = prop.type;
+    switch (type) {
+      case "string":
+        if (prop.enum) return z20.enum(prop.enum);
+        return z20.string();
+      case "number":
+      case "integer":
+        return z20.number();
+      case "boolean":
+        return z20.boolean();
+      case "array":
+        if (prop.items && typeof prop.items === "object") {
+          return z20.array(this.jsonSchemaPropertyToZod(prop.items));
+        }
+        return z20.array(z20.unknown());
+      case "object":
+        if (prop.properties && typeof prop.properties === "object") {
+          return this.buildZodSchema(prop);
+        }
+        return z20.record(z20.unknown());
+      default:
+        return z20.unknown();
+    }
+  }
+};
+async function registerMCPTools(mcpManager, registerFn) {
+  const registered = [];
+  for (const serverName of mcpManager.getConnectedServers()) {
+    try {
+      const tools = await mcpManager.getToolsForServer(serverName);
+      for (const tool of tools) {
+        const adapter = new MCPToolAdapter(
+          serverName,
+          tool.name,
+          tool.description ?? `MCP tool: ${tool.name}`,
+          tool.inputSchema,
+          mcpManager
+        );
+        registerFn(adapter);
+        registered.push(adapter.name);
+      }
+    } catch {
+    }
+  }
+  return registered;
+}
+
 // src/ui/repl.ts
 var SessionSaver = class {
   filePath;
@@ -6857,6 +7177,36 @@ function buildModelRouter(adapterRegistry, config) {
     defaultModel: config.models.defaultModel
   });
 }
+async function connectMcpServers(config, toolRegistry) {
+  if (config.mcpServers.length === 0) return null;
+  const mcpManager = new MCPConnectionManager();
+  let connectedCount = 0;
+  for (const serverConfig of config.mcpServers) {
+    try {
+      await mcpManager.addServer({
+        name: serverConfig.name,
+        command: serverConfig.command,
+        args: serverConfig.args,
+        env: serverConfig.env,
+        transport: serverConfig.transport
+      });
+      connectedCount++;
+    } catch (err) {
+      console.error(`MCP server "${serverConfig.name}" connection failed: ${err.message}`);
+    }
+  }
+  if (connectedCount === 0) return mcpManager;
+  const registeredTools = await registerMCPTools(mcpManager, (tool) => {
+    try {
+      toolRegistry.register(tool);
+    } catch {
+    }
+  });
+  if (registeredTools.length > 0) {
+    console.log(`  MCP: ${connectedCount} server(s) connected, ${registeredTools.length} tool(s) loaded`);
+  }
+  return mcpManager;
+}
 async function runTuiRepl(config) {
   const adapterRegistry = new AdapterRegistry();
   for (const provider of config.providers) {
@@ -6869,6 +7219,7 @@ async function runTuiRepl(config) {
   const adapter = config.defaultProvider ? adapterRegistry.get(config.defaultProvider) : adapterRegistry.getAll()[0];
   const modelRouter = buildModelRouter(adapterRegistry, config);
   const toolRegistry = createDefaultToolRegistry(modelRouter);
+  const mcpManager = await connectMcpServers(config, toolRegistry);
   ensureDataDir();
   const sessionSaver = new SessionSaver();
   await sessionSaver.init();
@@ -6963,13 +7314,14 @@ async function runBasicRepl(config) {
 `);
   }
   const toolRegistry = createDefaultToolRegistry(modelRouter);
+  await connectMcpServers(config, toolRegistry);
   const abortController = new AbortController();
   ensureDataDir();
   const sessionSaver = new SessionSaver();
   await sessionSaver.init();
   let sessionMessages = [];
-  const { createInterface } = await import("readline");
-  const rl = createInterface({
+  const { createInterface: createInterface2 } = await import("readline");
+  const rl = createInterface2({
     input: process.stdin,
     output: process.stdout,
     prompt: "> "
@@ -10038,6 +10390,8 @@ export {
   renderInkApp,
   formatAnsiMessage,
   MessageList,
+  MCPClient,
+  MCPConnectionManager,
   runCli
 };
-//# sourceMappingURL=chunk-UJMUL64T.js.map
+//# sourceMappingURL=chunk-ETGUAK34.js.map