@ebowwa/glm-daemon-telegram 1.4.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/glm-daemon-telegram",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Telegram adapter for GLM Daemon with ButlerAgent personality",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "@ebowwa/structured-prompts": "0.2.4",
+    "@modelcontextprotocol/sdk": "^1.0.4",
     "node-telegram-bot-api": "^0.66.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,10 +1,11 @@
 /**
  * GLM Daemon Telegram Bot
  *
- * Full-featured Telegram bot with GLM-4.7 AI, git status, Doppler integration
+ * Full-featured Telegram bot with GLM-4.7 AI and MCP tool integration
  *
  * Features:
  * - GLM-4.7 AI responses via Z.AI API
+ * - Dynamic MCP tool discovery and execution
  * - 429 rate limit handling with exponential backoff
  * - /git command for git status + GitHub auth
  * - /doppler command for Doppler secrets status
@@ -15,6 +16,7 @@ import TelegramBot from 'node-telegram-bot-api';
 import { execSync } from 'child_process';
 import { getStore, seedPrompts } from '@ebowwa/structured-prompts';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { MCPClient, DEFAULT_MCP_SERVERS, MCPTool } from './mcp-client.js';
 
 const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN || '';
 const TELEGRAM_TEST_CHAT_ID = process.env.TELEGRAM_TEST_CHAT_ID || '';
@@ -272,7 +274,7 @@ const TOOLS: Tool[] = [
     parameters: { type: 'object', properties: {} },
     handler: async () => {
       try {
-        const result = execSync('doppler secrets --plain 2>&1 | cut -f1').toString();
+        const result = execSync('doppler secrets 2>&1').toString();
         return result;
       } catch (e: any) {
         if (e.message?.includes('not found')) return 'doppler CLI not installed';
@@ -286,7 +288,7 @@ const TOOLS: Tool[] = [
     parameters: { type: 'object', properties: {} },
     handler: async () => {
       try {
-        const result = execSync('doppler projects list 2>&1').toString();
+        const result = execSync('doppler projects 2>&1').toString();
         return result;
       } catch (e: any) {
         if (e.message?.includes('not found')) return 'doppler CLI not installed';
@@ -306,7 +308,7 @@ const TOOLS: Tool[] = [
     handler: async (args) => {
       try {
         const project = args.project ? `-p ${args.project}` : '';
-        const result = execSync(`doppler configs list ${project} 2>&1`).toString();
+        const result = execSync(`doppler configs ${project} 2>&1`).toString();
         return result;
       } catch (e: any) {
         return e.stdout?.toString() || e.message;
@@ -383,15 +385,44 @@ const TOOLS: Tool[] = [
   }
 ];
 
+// ====================================================================
+// MCP Client - Dynamic tool discovery from MCP servers
+// ====================================================================
+
+let mcpClient: MCPClient | null = null;
+let mcpTools: MCPTool[] = [];
+
+async function initMCP(): Promise<void> {
+  mcpClient = new MCPClient(DEFAULT_MCP_SERVERS);
+  await mcpClient.connect();
+  mcpTools = mcpClient.getTools();
+  console.log(`📦 Loaded ${mcpTools.length} MCP tools`);
+}
+
 // Convert tools to GLM API format
-const GLM_TOOLS = TOOLS.map(t => ({
-  type: 'function',
-  function: {
-    name: t.name,
-    description: t.description,
-    parameters: t.parameters
-  }
-}));
+function getGLMTools() {
+  // MCP tools
+  const mcpGLMTools = mcpTools.map(t => ({
+    type: 'function',
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }
+  }));
+
+  // Static tools as fallback
+  const staticGLMTools = TOOLS.map(t => ({
+    type: 'function',
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+
+  return [...mcpGLMTools, ...staticGLMTools];
+}
 
 // API Key Resolution - supports rolling keys
 const getZAIKey = (): string | null => {
@@ -467,6 +498,8 @@ class TelegramGLMBot {
     console.log('🤖 GLM Daemon Telegram Bot starting with GLM-4.7...');
 
     // /start command
+    //
+    // TODO: files to the telegram commands
     this.bot.onText(/\/start/, async (msg: TelegramBot.Message) => {
       const chatId = msg.chat.id;
       await this.bot.sendMessage(
@@ -722,19 +755,25 @@ class TelegramGLMBot {
       await this.bot.sendMessage(chatId, '🧹 Conversation memory cleared. Starting fresh!');
     });
 
-    // /tools command - show available LLM tools
+    // /tools command - show available MCP and static tools
     this.bot.onText(/\/tools/, async (msg: TelegramBot.Message) => {
       const chatId = msg.chat.id;
-      let toolsMsg = '*🛠️ Available Tools*\n\n';
-      toolsMsg += 'The AI can use these tools:\n\n';
+      let toolsMsg = `*🛠️ Available Tools* (${mcpTools.length + TOOLS.length})\n\n`;
 
+      if (mcpTools.length > 0) {
+        toolsMsg += '*MCP Tools:*\n';
+        for (const tool of mcpTools) {
+          toolsMsg += `• \`${tool.name}\` [${tool.serverName}]\n`;
+        }
+        toolsMsg += '\n';
+      }
+
+      toolsMsg += '*Static Tools:*\n';
       for (const tool of TOOLS) {
-        toolsMsg += `*${tool.name}*\n`;
-        toolsMsg += `${tool.description}\n\n`;
+        toolsMsg += `• \`${tool.name}\`\n`;
       }
 
-      toolsMsg += '_Just ask the AI to use them!_';
-      toolsMsg += '\nExample: "Show me system info" or "List files in /root"';
+      toolsMsg += '\n_Just ask the AI to use them!_';
 
       await this.bot.sendMessage(chatId, toolsMsg, { parse_mode: 'Markdown' });
     });
@@ -814,7 +853,7 @@ class TelegramGLMBot {
           body: JSON.stringify({
             model: 'glm-4.7',
             messages,
-            tools: GLM_TOOLS,
+            tools: getMCPTools(),
             temperature,
             max_tokens: maxTokens
           })
@@ -859,13 +898,18 @@ class TelegramGLMBot {
             const argsStr = Object.keys(args).length > 0 ? JSON.stringify(args) : '';
             await this.bot.sendMessage(chatId, `🔧 \`${toolName}\`${argsStr ? ' ' + argsStr : ''}`, { parse_mode: 'Markdown' });
 
-            // Find and execute tool
-            const tool = TOOLS.find(t => t.name === toolName);
+            // Execute tool - try MCP first, then static fallback
             let result: string;
-            if (tool) {
-              result = await tool.handler(args);
+            const mcpTool = mcpTools.find(t => t.name === toolName);
+            if (mcpClient && mcpTool) {
+              result = await mcpClient.callTool(toolName, args);
             } else {
-              result = `Unknown tool: ${toolName}`;
+              const tool = TOOLS.find(t => t.name === toolName);
+              if (tool) {
+                result = await tool.handler(args);
+              } else {
+                result = `Unknown tool: ${toolName}`;
+              }
             }
 
             console.log(`  ← ${result.slice(0, 100)}...`);
@@ -947,6 +991,10 @@ async function main() {
     seedPrompts(promptsFile);
   }
 
+  // Initialize MCP client
+  console.log('🔌 Initializing MCP client...');
+  await initMCP();
+
   console.log(`📱 Bot token loaded: ${TELEGRAM_BOT_TOKEN.substring(0, 10)}...`);
   console.log(`🤖 Bot name: @SimulationapiBot`);
 
@@ -955,11 +1003,13 @@ async function main() {
 
   process.on('SIGINT', async () => {
     await bot.stop();
+    if (mcpClient) await mcpClient.disconnect();
     process.exit(0);
   });
 
   process.on('SIGTERM', async () => {
     await bot.stop();
+    if (mcpClient) await mcpClient.disconnect();
     process.exit(0);
   });
 }

package/src/mcp-client.ts

@@ -0,0 +1,155 @@
+/**
+ * MCP Client for glm-daemon-telegram
+ *
+ * Connects to MCP servers via stdio and discovers their tools dynamically.
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  serverName: string;
+}
+
+export interface MCPServerConfig {
+  name: string;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export class MCPClient {
+  private clients: Map<string, Client> = new Map();
+  private transports: Map<string, StdioClientTransport> = new Map();
+  private tools: MCPTool[] = [];
+  private servers: MCPServerConfig[];
+
+  constructor(servers: MCPServerConfig[]) {
+    this.servers = servers;
+  }
+
+  async connect(): Promise<void> {
+    for (const server of this.servers) {
+      try {
+        const transport = new StdioClientTransport({
+          command: server.command,
+          args: server.args || [],
+          env: { ...process.env, ...server.env }
+        });
+
+        const client = new Client({ name: 'glm-daemon-telegram', version: '1.0.0' }, {
+          capabilities: { tools: {} }
+        });
+
+        await client.connect(transport);
+
+        this.clients.set(server.name, client);
+        this.transports.set(server.name, transport);
+
+        // Discover tools
+        const toolsResult = await client.listTools();
+        for (const tool of toolsResult.tools) {
+          this.tools.push({
+            name: tool.name,
+            description: tool.description || '',
+            inputSchema: tool.inputSchema as Record<string, unknown>,
+            serverName: server.name
+          });
+        }
+
+        console.log(`✓ MCP connected: ${server.name} (${toolsResult.tools.length} tools)`);
+      } catch (e) {
+        console.error(`✗ MCP failed: ${server.name} - ${(e as Error).message}`);
+      }
+    }
+  }
+
+  getTools(): MCPTool[] {
+    return this.tools;
+  }
+
+  getToolsForGLM(): Array<{ type: string; function: { name: string; description: string; parameters: Record<string, unknown> } }> {
+    return this.tools.map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: `[${t.serverName}] ${t.description}`,
+        parameters: t.inputSchema
+      }
+    }));
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<string> {
+    const tool = this.tools.find(t => t.name === name);
+    if (!tool) {
+      return `Unknown tool: ${name}`;
+    }
+
+    const client = this.clients.get(tool.serverName);
+    if (!client) {
+      return `MCP server not connected: ${tool.serverName}`;
+    }
+
+    try {
+      const result = await client.callTool({ name, arguments: args });
+
+      if (result.content && Array.isArray(result.content)) {
+        return result.content
+          .map((c: any) => c.text || JSON.stringify(c))
+          .join('\n');
+      }
+
+      return JSON.stringify(result);
+    } catch (e) {
+      return `Tool error: ${(e as Error).message}`;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    for (const [name, client] of this.clients) {
+      try {
+        await client.close();
+        console.log(`✓ MCP disconnected: ${name}`);
+      } catch (e) {
+        console.error(`✗ MCP disconnect error: ${name} - ${(e as Error).message}`);
+      }
+    }
+    this.clients.clear();
+    this.transports.clear();
+    this.tools = [];
+  }
+}
+
+// Default MCP servers configuration for VPS node
+export const DEFAULT_MCP_SERVERS: MCPServerConfig[] = [
+  {
+    name: 'hetzner',
+    command: 'bunx',
+    args: ['@ebowwa/hetzner-mcp'],
+    env: { HCLOUD_TOKEN: process.env.HCLOUD_TOKEN || '' }
+  },
+  {
+    name: 'tailscale',
+    command: 'bunx',
+    args: ['@ebowwa/tailscale'],
+  },
+  {
+    name: 'tooling',
+    command: 'bunx',
+    args: ['@ebowwa/tooling-mcp'],
+  },
+  {
+    name: 'terminal',
+    command: 'bunx',
+    args: ['@ebowwa/terminal-mcp'],
+  },
+  {
+    name: 'github-search',
+    command: 'bunx',
+    args: ['@ebowwa/github-search-mcp'],
+    env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN || '' }
+  }
+];