feat: Complete zCode CLI X with Telegram bot integration

- Add full Telegram bot functionality with Z.AI API integration
- Implement 4 tools: Bash, FileEdit, WebSearch, Git
- Add 3 agents: Code Reviewer, Architect, DevOps Engineer
- Add 6 skills for common coding tasks
- Add systemd service file for 24/7 operation
- Add nginx configuration for HTTPS webhook
- Add comprehensive documentation
- Implement WebSocket server for real-time updates
- Add logging system with Winston
- Add environment validation

🤖 zCode CLI X - Agentic coder with Z.AI + Telegram integration

src/bot/index.js

@@ -0,0 +1,209 @@
+import { logger } from '../utils/logger.js';
+import { checkEnv } from '../utils/env.js';
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function initBot(config, api, tools, skills) {
+  const env = checkEnv();
+  const botToken = env.TELEGRAM_BOT_TOKEN;
+
+  if (!botToken) {
+    logger.warn('⚠ Telegram bot token not configured');
+    return null;
+  }
+
+  logger.info('🤖 Initializing Telegram bot...');
+
+  // Initialize Express server for webhook
+  const app = express();
+  app.use(express.json());
+
+  // WebSocket for real-time updates
+  const httpServer = createServer(app);
+  const wss = new WebSocketServer({ server: httpServer });
+
+  // Store active connections
+  const connections = new Map();
+
+  wss.on('connection', (ws) => {
+    const chatId = ws.handshake.query.chatId;
+    connections.set(chatId, ws);
+    logger.info(`🔌 Client connected: ${chatId}`);
+    
+    ws.on('close', () => {
+      connections.delete(chatId);
+      logger.info(`🔌 Client disconnected: ${chatId}`);
+    });
+  });
+
+  // Send message via webhook
+  async function sendTelegramMessage(chatId, text, options = {}) {
+    const url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+    
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chat_id: chatId,
+          text,
+          parse_mode: 'Markdown',
+          ...options,
+        }),
+      });
+
+      const data = await response.json();
+      if (!data.ok) {
+        logger.error(`Telegram API error: ${data.description}`);
+      }
+      return data;
+    } catch (error) {
+      logger.error('Failed to send Telegram message:', error);
+      return null;
+    }
+  }
+
+  // Send message via WebSocket (for real-time updates)
+  function sendWebSocketMessage(chatId, message) {
+    const ws = connections.get(chatId);
+    if (ws && ws.readyState === ws.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+
+  // Handle webhook
+  app.post('/telegram/webhook', async (req, res) => {
+    const update = req.body;
+    
+    if (update.message) {
+      const chatId = update.message.chat.id.toString();
+      const text = update.message.text;
+      const user = update.message.from?.username || update.message.from?.first_name || 'Unknown';
+
+      logger.info(`📨 New message from ${user} (${chatId}): ${text.substring(0, 50)}...`);
+
+      // Process message
+      await processMessage(chatId, text, user);
+
+      res.json({ ok: true });
+    } else if (update.callback_query) {
+      const chatId = update.callback_query.message.chat.id.toString();
+      const data = update.callback_query.data;
+
+      logger.info(`🔘 Callback from ${chatId}: ${data}`);
+
+      // Process callback
+      await processCallback(chatId, data);
+
+      // Send answer
+      await sendTelegramMessage(chatId, 'Callback processed', {
+        callback_query_id: update.callback_query.id,
+      });
+
+      res.json({ ok: true });
+    } else {
+      res.json({ ok: true });
+    }
+  });
+
+  // Process text message
+  async function processMessage(chatId, text, username) {
+    // Send typing indicator
+    await sendTelegramMessage(chatId, '🤖 Thinking...', {
+      reply_parameters: { message_id: 0 },
+    });
+
+    // Process through agent
+    const response = await processWithAgent(text, chatId);
+
+    // Send response
+    if (response) {
+      await sendTelegramMessage(chatId, response);
+    }
+  }
+
+  // Process callback query
+  async function processCallback(chatId, data) {
+    // TODO: Handle callback data
+    logger.info(`Processing callback: ${data}`);
+  }
+
+  // Agent processing
+  async function processWithAgent(text, chatId) {
+    try {
+      // Use Z.AI API to process the message
+      const systemPrompt = `You are zCode, an AI coding agent with full capabilities.
+You have access to tools for bash commands, file editing, web search, and git operations.
+You can execute code, analyze systems, and provide comprehensive responses.
+Be concise, direct, and action-oriented. Focus on solving problems.
+`;
+
+      const messages = [
+        {
+          role: "system",
+          content: systemPrompt
+        },
+        {
+          role: "user",
+          content: text
+        }
+      ];
+
+      const response = await api.client.post("/chat/completions", {
+        model: "glm-5.1",
+        messages: messages,
+        temperature: 0.7,
+        max_tokens: 4096
+      });
+
+      return response.data.choices[0].message.content;
+    } catch (error) {
+      logger.error('Error processing message:', error);
+      return '❌ Error processing message. Please try again.';
+    }
+  }
+
+  // Set webhook (if URL provided)
+  async function setWebhook() {
+    const webhookUrl = process.env.ZCODE_WEBHOOK_URL;
+    if (webhookUrl) {
+      const url = `https://api.telegram.org/bot${botToken}/setWebhook`;
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url: webhookUrl }),
+      });
+
+      const data = await response.json();
+      if (data.ok) {
+        logger.info('✓ Webhook set successfully');
+      } else {
+        logger.error('✗ Failed to set webhook:', data.description);
+      }
+    }
+  }
+
+  // Start HTTP server
+  const PORT = process.env.ZCODE_PORT || 3000;
+  httpServer.listen(PORT, () => {
+    logger.info(`✓ HTTP server running on port ${PORT}`);
+    logger.info(`✓ WebSocket server ready`);
+  });
+
+  // Set webhook and keep process alive
+  await setWebhook();
+
+  return {
+    send: sendTelegramMessage,
+    ws: sendWebSocketMessage,
+    waitForMessages: async () => {
+      // Keep process alive
+      await new Promise(() => {});
+    },
+    getConnections: () => connections.size,
+  };
+}