feat: add telegram mcp and skill controls

Author: MackDing

README.md

@@ -131,6 +131,9 @@ General:
 - `/auto <task>` - force a one-off `codex exec --full-auto`
 - `/plan <task>` - ask Codex for a plan only, without direct file modification intent
 - `/model [name|reset]` - show or set the model override for the current chat
+- `/skill list` - show skill switches for the current chat
+- `/skill on <name>` - enable a skill for the current chat
+- `/skill off <name>` - disable a skill for the current chat
 - `/sh <command>` - run a safe allowlisted Linux command in the current project (disabled by default)
 - `/sh --confirm <command>` - confirm a dangerous command when writable mode is enabled
 - `/interrupt` - send `Ctrl+C` to current PTY session
@@ -139,6 +142,11 @@ General:
 
 MCP skill:
 
+- `/mcp list`
+- `/mcp status [server]`
+- `/mcp reconnect <server>`
+- `/mcp enable <server>`
+- `/mcp disable <server>`
 - `/mcp tools <server>`
 - `/mcp call <server> <tool> {"query":"..."}`
 
@@ -158,6 +166,7 @@ Telegram adaptation notes:
 - `/new` is implemented by the bot and resets the current chat session
 - `/status` is implemented by the bot and reports local runtime state
 - `/repo` is implemented by the bot and switches the per-chat working directory inside `WORKSPACE_ROOT`
+- `/skill` is implemented by the bot and keeps per-chat skill switches in runtime state
 - `/sh` is implemented by the bot, never invokes a shell interpreter, and only accepts configured command prefixes
 - `/sh` is read-only by default; dangerous prefixes can be configured and require `--confirm` when writable mode is enabled
 - `/plan` translates to a planning-only prompt instead of passing a raw `/plan` slash command to Codex
@@ -257,6 +266,14 @@ It is useful when you need deterministic operator actions from Telegram, such as
 
 Treat it as an admin-only ops channel, not a general-purpose remote shell.
 
+## MCP and Skill Control Plane
+
+Telegram can manage runtime usage of Bot-side MCP and skills, but not install arbitrary new servers from chat.
+
+- MCP servers are process-level runtime resources: list, inspect, reconnect, enable, disable
+- Skills are chat-level routing switches: each chat can enable or disable `github` and `mcp` independently
+- Codex's own MCP remains separate and is not managed through these bot commands
+
 ## Troubleshooting
 
 - **Bot not responding**: verify `BOT_TOKEN` and `ALLOWED_USER_IDS`

src/bot/handlers.js

@@ -44,15 +44,27 @@ function formatProjectLines(projects, currentWorkdir) {
   });
 }
 
-export function registerHandlers({ bot, router, ptyManager, shellManager, skills, scheduler }) {
+function formatSkillLines(skillStates) {
+  return skillStates.map((skill) => `- ${skill.name}: ${skill.enabled ? "on" : "off"}`);
+}
+
+export function registerHandlers({
+  bot,
+  router,
+  ptyManager,
+  shellManager,
+  skills,
+  skillRegistry,
+  scheduler
+}) {
   bot.start(async (ctx) => {
     await sendChunkedMarkdown(
       ctx,
       [
         "codex-telegram-claws ready.",
         "普通消息和编码任务会路由到 Codex。",
         "MCP 只在显式 /mcp 命令下调用。",
-        "试试: /status, /repo, /pwd, /exec, /auto, /plan, /model, /new, /sh",
+        "试试: /status, /repo, /pwd, /exec, /auto, /plan, /model, /skill, /new, /sh",
         "GitHub 指令示例: /gh commit \"feat: init\""
       ].join("\n")
     );
@@ -76,19 +88,24 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
         "/auto <task> - 强制用 codex exec --full-auto 运行任务",
         "/plan <task> - 仅生成执行计划，不直接修改代码",
         "/model [name|reset] - 查看或设置当前 chat 的模型",
+        "/skill list - 查看当前 chat 的 skill 开关",
+        "/skill on <name> - 启用 skill",
+        "/skill off <name> - 禁用 skill",
         "/sh <command> - 运行受限 Linux 命令 (默认关闭)",
         "/sh --confirm <command> - 确认执行高风险命令",
         "/interrupt - 向 Codex CLI 发送 Ctrl+C",
         "/stop - 终止当前 chat 的 PTY 会话",
         "/cron_now - 立即触发一次日报推送",
         "/gh ... - GitHub skill",
-        "/mcp ... - MCP skill (显式调用)"
+        "/mcp ... - MCP skill 管理与显式调用"
       ].join("\n")
     );
   });
 
   bot.command("status", async (ctx) => {
     const status = ptyManager.getStatus(ctx.chat.id);
+    const skillStates = skillRegistry.list(ctx.chat.id);
+    const mcpServers = skills.mcp.mcpClient.listServers();
     await sendChunkedMarkdown(
       ctx,
       [
@@ -110,7 +127,12 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
             ? `enabled, ${shellManager.isReadOnly() ? "read-only" : "writable"} (${shellManager.getAllowedCommands().length} prefixes)`
             : "disabled"
         }`,
-        `mcp servers: ${status.mcpServers.length ? status.mcpServers.join(", ") : "none"}`
+        `skills: ${skillStates.map((skill) => `${skill.name}:${skill.enabled ? "on" : "off"}`).join(", ") || "none"}`,
+        `mcp servers: ${
+          mcpServers.length
+            ? mcpServers.map((server) => `${server.name}:${server.enabled ? "on" : "off"}/${server.connected ? "up" : "down"}`).join(", ")
+            : "none"
+        }`
       ].join("\n")
     );
   });
@@ -220,6 +242,46 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
     }
   });
 
+  bot.command("skill", async (ctx) => {
+    const payload = extractCommandPayload(ctx.message.text, "skill");
+    if (!payload || /^list$/i.test(payload)) {
+      await sendChunkedMarkdown(
+        ctx,
+        [
+          "Skills:",
+          ...formatSkillLines(skillRegistry.list(ctx.chat.id)),
+          "",
+          "Usage: /skill list | /skill on <name> | /skill off <name>"
+        ].join("\n")
+      );
+      return;
+    }
+
+    const [action, rawName] = payload.split(/\s+/, 2);
+    if (!/^(on|off)$/i.test(action) || !rawName) {
+      await sendChunkedMarkdown(ctx, "用法: /skill list | /skill on <name> | /skill off <name>");
+      return;
+    }
+
+    try {
+      if (/^on$/i.test(action)) {
+        skillRegistry.enable(ctx.chat.id, rawName);
+      } else {
+        skillRegistry.disable(ctx.chat.id, rawName);
+      }
+
+      await sendChunkedMarkdown(
+        ctx,
+        [
+          `skill ${rawName} 已${/^on$/i.test(action) ? "启用" : "禁用"}。`,
+          ...formatSkillLines(skillRegistry.list(ctx.chat.id))
+        ].join("\n")
+      );
+    } catch (error) {
+      await sendChunkedMarkdown(ctx, `Skill 管理失败: ${error.message}`);
+    }
+  });
+
   bot.command("new", async (ctx) => {
     const closed = ptyManager.closeSession(ctx.chat.id);
     await sendChunkedMarkdown(
@@ -412,6 +474,11 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
   });
 
   bot.command("gh", async (ctx) => {
+    if (!skillRegistry.isEnabled(ctx.chat.id, "github")) {
+      await sendChunkedMarkdown(ctx, "GitHub skill 当前 chat 已禁用。使用 /skill on github 重新启用。");
+      return;
+    }
+
     try {
       const text = extractCommandPayload(ctx.message.text, "gh") || "help";
       const result = await skills.github.execute({
@@ -426,6 +493,11 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
   });
 
   bot.command("mcp", async (ctx) => {
+    if (!skillRegistry.isEnabled(ctx.chat.id, "mcp")) {
+      await sendChunkedMarkdown(ctx, "MCP skill 当前 chat 已禁用。使用 /skill on mcp 重新启用。");
+      return;
+    }
+
     try {
       const text = ctx.message.text.trim();
       const result = await skills.mcp.execute({ text, ctx });
@@ -456,7 +528,9 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
     if (!text || text.startsWith("/")) return;
 
     try {
-      const route = await router.routeMessage(text);
+      const route = await router.routeMessage(text, {
+        chatId: ctx.chat.id
+      });
       if (route.target === "pty") {
         const result = await ptyManager.sendPrompt(ctx, route.prompt);
         if (!result.started) {
@@ -476,7 +550,8 @@ export function registerHandlers({ bot, router, ptyManager, shellManager, skills
 
       const result = await skill.execute({
         text: route.payload,
-        ctx
+        ctx,
+        workdir: ptyManager.getStatus(ctx.chat.id).workdir
       });
       await sendSkillResult(ctx, result);
     } catch (error) {

src/index.js

@@ -4,6 +4,7 @@ import { createAuthMiddleware } from "./bot/middleware.js";
 import { registerHandlers } from "./bot/handlers.js";
 import { Router } from "./orchestrator/router.js";
 import { McpClient } from "./orchestrator/mcpClient.js";
+import { SkillRegistry } from "./orchestrator/skillRegistry.js";
 import { McpSkill } from "./orchestrator/skills/mcpSkill.js";
 import { GitHubSkill } from "./orchestrator/skills/githubSkill.js";
 import { PtyManager } from "./runner/ptyManager.js";
@@ -28,9 +29,11 @@ const skills = {
   github: githubSkill,
   mcp: mcpSkill
 };
+const skillRegistry = new SkillRegistry(skills);
 
 const router = new Router({
-  skills
+  skills,
+  isSkillEnabled: (chatId, skillName) => skillRegistry.isEnabled(chatId, skillName)
 });
 
 const ptyManager = new PtyManager({
@@ -53,6 +56,7 @@ registerHandlers({
   ptyManager,
   shellManager,
   skills,
+  skillRegistry,
   scheduler
 });
 

src/orchestrator/mcpClient.js

@@ -28,19 +28,51 @@ export class McpClient {
   constructor(config) {
     this.config = config;
     this.connections = new Map();
+    this.disabledServers = new Set();
   }
 
   hasServers() {
     return this.config.mcp.servers.length > 0;
   }
 
+  getServerConfig(serverName) {
+    return this.config.mcp.servers.find((server) => server.name === serverName) || null;
+  }
+
+  hasServer(serverName) {
+    return Boolean(this.getServerConfig(serverName));
+  }
+
+  isServerEnabled(serverName) {
+    return this.hasServer(serverName) && !this.disabledServers.has(serverName);
+  }
+
+  isServerConnected(serverName) {
+    return this.connections.has(serverName);
+  }
+
+  listServers() {
+    return this.config.mcp.servers.map((server) => ({
+      name: server.name,
+      command: server.command,
+      args: server.args,
+      cwd: server.cwd,
+      enabled: this.isServerEnabled(server.name),
+      connected: this.isServerConnected(server.name)
+    }));
+  }
+
   async connectAll() {
     for (const server of this.config.mcp.servers) {
       await this.connectServer(server);
     }
   }
 
   async connectServer(server) {
+    if (this.disabledServers.has(server.name)) {
+      return;
+    }
+
     if (this.connections.has(server.name)) return;
 
     const transport = new StdioClientTransport({
@@ -67,6 +99,67 @@ export class McpClient {
     this.connections.set(server.name, { client, transport });
   }
 
+  async connectServerByName(serverName) {
+    const server = this.getServerConfig(serverName);
+    if (!server) {
+      throw new Error(`Unknown MCP server: ${serverName}`);
+    }
+
+    if (this.disabledServers.has(serverName)) {
+      throw new Error(`MCP server is disabled: ${serverName}`);
+    }
+
+    await this.connectServer(server);
+  }
+
+  async disconnectServer(serverName) {
+    const conn = this.connections.get(serverName);
+    if (!conn) return false;
+
+    try {
+      await conn.transport?.close?.();
+    } catch {
+      // Ignore close errors on runtime disconnect.
+    }
+
+    this.connections.delete(serverName);
+    return true;
+  }
+
+  async reconnectServer(serverName) {
+    if (!this.hasServer(serverName)) {
+      throw new Error(`Unknown MCP server: ${serverName}`);
+    }
+
+    if (this.disabledServers.has(serverName)) {
+      throw new Error(`MCP server is disabled: ${serverName}`);
+    }
+
+    await this.disconnectServer(serverName);
+    await this.connectServerByName(serverName);
+    return this.listServers().find((server) => server.name === serverName) || null;
+  }
+
+  async disableServer(serverName) {
+    if (!this.hasServer(serverName)) {
+      throw new Error(`Unknown MCP server: ${serverName}`);
+    }
+
+    this.disabledServers.add(serverName);
+    await this.disconnectServer(serverName);
+    return this.listServers().find((server) => server.name === serverName) || null;
+  }
+
+  async enableServer(serverName) {
+    if (!this.hasServer(serverName)) {
+      throw new Error(`Unknown MCP server: ${serverName}`);
+    }
+
+    this.disabledServers.delete(serverName);
+    await this.connectServerByName(serverName);
+    return this.listServers().find((server) => server.name === serverName) || null;
+  }
+
   async listTools(serverName) {
     const conn = this.connections.get(serverName);
     if (!conn) throw new Error(`MCP server not connected: ${serverName}`);

src/orchestrator/router.js

@@ -28,24 +28,26 @@ function likelyCodingTask(text) {
 }
 
 export class Router {
-  constructor({ skills }) {
+  constructor({ skills, isSkillEnabled = () => true }) {
     this.skills = skills;
+    this.isSkillEnabled = isSkillEnabled;
   }
 
-  async routeMessage(text) {
+  async routeMessage(text, options = {}) {
     const raw = text.trim();
+    const chatId = options.chatId;
     const githubSkill = this.skills.github;
     const mcpSkill = this.skills.mcp;
 
-    if (githubSkill && githubSkill.supports(raw)) {
+    if (githubSkill && this.isSkillEnabled(chatId, "github") && githubSkill.supports(raw)) {
       return {
         target: "skill",
         skill: "github",
         payload: raw
       };
     }
 
-    if (mcpSkill && mcpSkill.supports(raw)) {
+    if (mcpSkill && this.isSkillEnabled(chatId, "mcp") && mcpSkill.supports(raw)) {
       return {
         target: "skill",
         skill: "mcp",