@ebowwa/channel-telegram 1.9.0

package/src/api/fetch-retry.ts

@@ -0,0 +1,46 @@
+/**
+ * Fetch with retry and exponential backoff for 429 handling
+ */
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+export async function fetchWithRetry(
+  url: string,
+  options: RequestInit,
+  maxRetries = 3,
+  baseDelay = 1000
+): Promise<Response> {
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+
+      if (response.status === 429) {
+        const retryAfter = response.headers.get('Retry-After');
+        const delay = retryAfter
+          ? parseInt(retryAfter) * 1000
+          : baseDelay * Math.pow(2, attempt);
+
+        console.log(`[429] Rate limited, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+        await sleep(delay);
+        continue;
+      }
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return response;
+    } catch (error) {
+      lastError = error as Error;
+      if (attempt < maxRetries - 1) {
+        const delay = baseDelay * Math.pow(2, attempt);
+        console.log(`[Retry] Attempt ${attempt + 1} failed: ${lastError.message}, retrying in ${delay}ms`);
+        await sleep(delay);
+      }
+    }
+  }
+
+  throw lastError;
+}

package/src/api/keys.ts

@@ -0,0 +1,21 @@
+/**
+ * API Key Resolution - supports rolling keys
+ */
+
+/**
+ * Get Z.AI API key from environment
+ * Supports single key or JSON array of keys for rolling key rotation
+ */
+export function getZAIKey(): string | null {
+  const keyValue = process.env.Z_AI_API_KEY || process.env.ANTHROPIC_API_KEYS;
+  if (!keyValue) return null;
+  try {
+    const keysArray = JSON.parse(keyValue);
+    if (Array.isArray(keysArray) && keysArray.length > 0) {
+      return keysArray[0];
+    }
+  } catch {
+    return keyValue;
+  }
+  return keyValue;
+}

package/src/commands/clear.ts

@@ -0,0 +1,13 @@
+/**
+ * /clear command - Reset conversation memory
+ */
+
+import type { CommandRegistrar } from './types';
+
+export const registerClearCommand: CommandRegistrar = (bot, memory) => {
+  bot.onText(/\/clear/, async (msg) => {
+    const chatId = msg.chat.id;
+    memory.clear(chatId);
+    await bot.sendMessage(chatId, '🧹 Conversation memory cleared. Starting fresh!');
+  });
+};

package/src/commands/doppler.ts

@@ -0,0 +1,74 @@
+/**
+ * /doppler command - Check Doppler config
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { execSync } from 'child_process';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+export function registerDopplerCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/doppler(?:\s+(.+))?/, async (msg: TelegramBot.Message, match: RegExpExecArray | null) => {
+    const chatId = msg.chat.id;
+    const subCommand = match?.[1]?.trim();
+
+    try {
+      if (subCommand === 'secrets') {
+        let statusMsg = 'Doppler Secrets\n\n';
+        try {
+          const secrets = execSync('doppler secrets --plain 2>&1 | cut -d\'\\t\' -f1', {
+            encoding: 'utf-8',
+            cwd: '/root'
+          });
+          const secretList = secrets.trim().split('\n').filter(s => s.length > 0);
+          statusMsg += `Found ${secretList.length} secrets:\n\n`;
+          statusMsg += secretList.slice(0, 20).join('\n');
+          if (secretList.length > 20) {
+            statusMsg += `\n... and ${secretList.length - 20} more`;
+          }
+        } catch (e) {
+          statusMsg += `Error: ${(e as Error).message}`;
+        }
+        await bot.sendMessage(chatId, statusMsg);
+      } else {
+        let statusMsg = '*Doppler Status*\n\n';
+
+        try {
+          // Get project - extract value from table output
+          const projectRaw = execSync('doppler configure get project 2>/dev/null', { encoding: 'utf-8', cwd: '/root' });
+          const projectMatch = projectRaw.match(/│\s*project\s*│\s*(\S+)\s*│/);
+          const project = projectMatch ? projectMatch[1] : 'Not set';
+
+          // Get config - extract value from table output
+          const configRaw = execSync('doppler configure get config 2>/dev/null', { encoding: 'utf-8', cwd: '/root' });
+          const configMatch = configRaw.match(/│\s*config\s*│\s*(\S+)\s*│/);
+          const config = configMatch ? configMatch[1] : 'Not set';
+
+          statusMsg += `Project: \`${project}\`\n`;
+          statusMsg += `Config: \`${config}\`\n`;
+
+          const tokenCheck = execSync('doppler me 2>&1 | head -5', { encoding: 'utf-8', cwd: '/root' });
+          if (tokenCheck.includes('WORKPLACE') || tokenCheck.includes('TOKEN PREVIEW')) {
+            statusMsg += `Token: Valid`;
+          } else {
+            statusMsg += `Token: Not configured`;
+          }
+
+          statusMsg += `\n\n_Commands:_\n`;
+          statusMsg += `/doppler secrets - List secret names`;
+        } catch {
+          statusMsg += `Not configured\n\n`;
+          statusMsg += `Run: \`doppler setup\``;
+        }
+
+        await bot.sendMessage(chatId, statusMsg, { parse_mode: 'Markdown' });
+      }
+    } catch (error) {
+      await bot.sendMessage(chatId, `Error: ${(error as Error).message}`);
+    }
+  });
+}

package/src/commands/git.ts

@@ -0,0 +1,77 @@
+/**
+ * /git command - Check git status & GitHub auth
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { execSync } from 'child_process';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+export function registerGitCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/git(?:\s+(.+))?/, async (msg: TelegramBot.Message, match: RegExpExecArray | null) => {
+    const chatId = msg.chat.id;
+    const subCommand = match?.[1]?.trim();
+
+    try {
+      if (subCommand === 'auth') {
+        let statusMsg = 'GitHub Auth\n\n';
+        try {
+          const deviceResp = execSync('gh auth login --web --git-protocol https 2>&1 | head -20', {
+            encoding: 'utf-8',
+            timeout: 8000,
+            cwd: '/root'
+          });
+          const codeMatch = deviceResp.match(/verification code:\s*([A-Z0-9-]+)/i);
+          const urlMatch = deviceResp.match(/https:\/\/github\.com\/login\/device[^\s]*/);
+
+          if (codeMatch && urlMatch) {
+            statusMsg += `Code: ${codeMatch[1]}\n`;
+            statusMsg += `URL: ${urlMatch[0]}\n\n`;
+            statusMsg += `Open URL and enter code to authenticate.`;
+          } else {
+            statusMsg += deviceResp.slice(0, 500);
+          }
+        } catch (e) {
+          statusMsg += `Error: ${(e as Error).message}`;
+        }
+        await bot.sendMessage(chatId, statusMsg);
+      } else {
+        let statusMsg = 'Git Status\n\n';
+
+        try {
+          const authStatus = execSync('gh auth status 2>&1', { encoding: 'utf-8', cwd: '/root' });
+          const loggedIn = authStatus.includes('Logged in');
+          const accountMatch = authStatus.match(/account\s+(\w+)/i);
+
+          statusMsg += `GitHub: ${loggedIn ? 'Connected' : 'Not logged in'}\n`;
+          if (accountMatch) statusMsg += `Account: ${accountMatch[1]}\n`;
+          if (!loggedIn) statusMsg += `\nUse /git auth to authenticate`;
+        } catch {
+          statusMsg += `GitHub: Not authenticated\n`;
+          statusMsg += `Use /git auth to login\n`;
+        }
+
+        try {
+          const branch = execSync('git rev-parse --abbrev-ref HEAD 2>/dev/null', { encoding: 'utf-8', cwd: '/root' }).trim();
+          const ahead = execSync('git rev-list --count @{upstream}..HEAD 2>/dev/null || echo 0', { encoding: 'utf-8', cwd: '/root' }).trim();
+          const dirty = execSync('git status --porcelain 2>/dev/null | wc -l', { encoding: 'utf-8', cwd: '/root' }).trim();
+
+          statusMsg += `\nRepo:\n`;
+          statusMsg += `Branch: ${branch}\n`;
+          statusMsg += `Ahead: ${ahead} commits\n`;
+          statusMsg += `Modified: ${dirty} files`;
+        } catch {
+          statusMsg += `\nRepo: Not a git repo or error`;
+        }
+
+        await bot.sendMessage(chatId, statusMsg);
+      }
+    } catch (error) {
+      await bot.sendMessage(chatId, `Error: ${(error as Error).message}`);
+    }
+  });
+}

package/src/commands/help.ts

@@ -0,0 +1,38 @@
+/**
+ * /help command - Show help message
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+export function registerHelpCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/help/, async (msg: TelegramBot.Message) => {
+    const chatId = msg.chat.id;
+    await bot.sendMessage(
+      chatId,
+      '📚 *GLM Daemon Bot Help*\n\n' +
+      '🧠 Powered by GLM-4.7 via Z.AI API\n\n' +
+      '*Commands:*\n' +
+      '/start - Show welcome message\n' +
+      '/status - Check API status\n' +
+      '/git - Check git status & GitHub auth\n' +
+      '/git auth - Start GitHub auth flow\n' +
+      '/doppler - Check Doppler config\n' +
+      '/doppler secrets - List secret names\n' +
+      '/tools - Show available AI tools\n' +
+      '/clear - Clear conversation memory\n' +
+      '/resources - Show system resources\n' +
+      '/logs [n] - Show last n log lines\n' +
+      '/toolsoutput [on|off] - Toggle tool output messages\n' +
+      '/help - Show this help\n\n' +
+      '*Usage:*\n' +
+      'Just send any message and I\\\'ll respond with AI assistance!',
+      { parse_mode: 'Markdown' }
+    );
+  });
+}

package/src/commands/index.ts

@@ -0,0 +1,46 @@
+/**
+ * Command index - Exports all command registrars
+ */
+
+export { registerStartCommand } from './start';
+export { registerStatusCommand } from './status';
+export { registerHelpCommand } from './help';
+export { registerGitCommand } from './git';
+export { registerDopplerCommand } from './doppler';
+export { registerLogsCommand } from './logs';
+export { registerClearCommand } from './clear';
+export { registerToolsCommand } from './tools';
+export { registerResourcesCommand } from './resources';
+
+export type { CommandRegistrar, CommandContext } from './types';
+
+import type TelegramBot from 'node-telegram-bot-api';
+import type { CommandRegistrar } from './types';
+import { registerStartCommand } from './start';
+import { registerStatusCommand } from './status';
+import { registerHelpCommand } from './help';
+import { registerGitCommand } from './git';
+import { registerDopplerCommand } from './doppler';
+import { registerLogsCommand } from './logs';
+import { registerClearCommand } from './clear';
+import { registerToolsCommand } from './tools';
+import { registerResourcesCommand } from './resources';
+
+/**
+ * Register all commands with the bot
+ */
+export function registerAllCommands(
+  bot: TelegramBot,
+  memory: import('../conversation-memory').ConversationMemory,
+  tools: import('../index').Tool[]
+): void {
+  registerStartCommand(bot, memory, tools);
+  registerStatusCommand(bot, memory, tools);
+  registerHelpCommand(bot, memory, tools);
+  registerGitCommand(bot, memory, tools);
+  registerDopplerCommand(bot, memory, tools);
+  registerLogsCommand(bot, memory, tools);
+  registerClearCommand(bot, memory, tools);
+  registerToolsCommand(bot, memory, tools);
+  registerResourcesCommand(bot, memory, tools);
+}

package/src/commands/logs.ts

@@ -0,0 +1,38 @@
+/**
+ * /logs command - Show systemd journal logs
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { execSync } from 'child_process';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+export function registerLogsCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/logs(?:\s+(\d+))?/, async (msg: TelegramBot.Message, match: RegExpExecArray | null) => {
+    const chatId = msg.chat.id;
+    const lines = match?.[1] ? parseInt(match[1]) : 20;
+
+    try {
+      const logs = execSync(`journalctl -u telegram-bot -n ${Math.min(lines, 100)} --no-pager 2>&1`, {
+        encoding: 'utf-8',
+        cwd: '/root'
+      });
+
+      // Truncate if too long for Telegram
+      const maxLen = 4000;
+      let output = logs.trim();
+      if (output.length > maxLen) {
+        output = '...\n' + output.slice(-maxLen);
+      }
+
+      // Send without Markdown to avoid parsing errors with log content
+      await bot.sendMessage(chatId, `System Logs (last ${lines} lines)\n\n${output}`);
+    } catch (error) {
+      await bot.sendMessage(chatId, `Error reading logs: ${(error as Error).message}`);
+    }
+  });
+}

package/src/commands/resources.ts

@@ -0,0 +1,44 @@
+/**
+ * /resources command - Show system resources
+ */
+
+import { execSync } from 'child_process';
+import type { CommandRegistrar } from './types';
+
+export const registerResourcesCommand: CommandRegistrar = (bot) => {
+  bot.onText(/\/resources/, async (msg) => {
+    const chatId = msg.chat.id;
+
+    try {
+      const loadAvg = execSync('cat /proc/loadavg', { encoding: 'utf-8' }).trim().split(' ').slice(0, 3).join(', ');
+      const cpuCount = execSync('nproc', { encoding: 'utf-8' }).trim();
+
+      const memInfo = execSync('free -m | grep Mem', { encoding: 'utf-8' });
+      const memMatch = memInfo.match(/Mem:\s+(\d+)\s+(\d+)\s+(\d+)/);
+      const memTotal = memMatch ? Math.round(parseInt(memMatch[1]) / 1024) : 0;
+      const memUsed = memMatch ? Math.round(parseInt(memMatch[2]) / 1024) : 0;
+      const memPercent = memMatch ? Math.round((parseInt(memMatch[2]) / parseInt(memMatch[1])) * 100) : 0;
+
+      const diskInfo = execSync('df -h / | tail -1', { encoding: 'utf-8' });
+      const diskMatch = diskInfo.match(/\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+(\d+%)/);
+      const diskUsed = diskMatch ? diskMatch[2] : '?';
+      const diskTotal = diskMatch ? diskMatch[1] : '?';
+      const diskPercent = diskMatch ? diskMatch[4] : '?';
+
+      const uptime = execSync('uptime -p 2>/dev/null || uptime', { encoding: 'utf-8' }).trim().replace('up ', '');
+
+      await bot.sendMessage(
+        chatId,
+        `*System Resources*\n\n` +
+        `*CPU:* ${cpuCount} cores\n` +
+        `*Load:* ${loadAvg}\n\n` +
+        `*Memory:* ${memUsed}/${memTotal}GB (${memPercent}%)\n` +
+        `*Disk:* ${diskUsed}/${diskTotal} (${diskPercent})\n\n` +
+        `*Uptime:* ${uptime}`,
+        { parse_mode: 'Markdown' }
+      );
+    } catch (error) {
+      await bot.sendMessage(chatId, `Error reading resources: ${(error as Error).message}`);
+    }
+  });
+};

package/src/commands/start.ts

@@ -0,0 +1,31 @@
+/**
+ * /start command - Show welcome message
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+export function registerStartCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/start/, async (msg: TelegramBot.Message) => {
+    const chatId = msg.chat.id;
+    await bot.sendMessage(
+      chatId,
+      '👋 Hello! I\'m GLM Daemon Telegram Bot.\n\n' +
+      '🧠 Powered by GLM-4.7 via Z.AI API\n\n' +
+      'Commands:\n' +
+      '/start - Show this message\n' +
+      '/status - Check API status\n' +
+      '/git - Check git status & GitHub auth\n' +
+      '/doppler - Check Doppler config\n' +
+      '/tools - Show available AI tools\n' +
+      '/clear - Clear conversation memory\n' +
+      '/help - Show help\n\n' +
+      'Or just send any message for AI assistance!'
+    );
+  });
+}

package/src/commands/status.ts

@@ -0,0 +1,26 @@
+/**
+ * /status command - Check API status
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+import { getZAIKey } from '../api/keys';
+
+export function registerStatusCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/status/, async (msg: TelegramBot.Message) => {
+    const chatId = msg.chat.id;
+    const apiKey = getZAIKey();
+    await bot.sendMessage(
+      chatId,
+      `*Bot Status*\n\n` +
+      `*AI:* GLM-4.7 via Z.AI\n` +
+      `*API:* ${apiKey ? 'Connected' : 'Disconnected'}`,
+      { parse_mode: 'Markdown' }
+    );
+  });
+}

package/src/commands/tools.ts

@@ -0,0 +1,23 @@
+/**
+ * /tools command - Show available LLM tools
+ */
+
+import type { CommandRegistrar } from './types';
+
+export const registerToolsCommand: CommandRegistrar = (bot, _memory, tools) => {
+  bot.onText(/\/tools/, async (msg) => {
+    const chatId = msg.chat.id;
+    let toolsMsg = '*🛠️ Available Tools*\n\n';
+    toolsMsg += 'The AI can use these tools:\n\n';
+
+    for (const tool of tools) {
+      toolsMsg += `*${tool.name}*\n`;
+      toolsMsg += `${tool.description}\n\n`;
+    }
+
+    toolsMsg += '_Just ask the AI to use them!_';
+    toolsMsg += '\nExample: "Show me system info" or "List files in /root"';
+
+    await bot.sendMessage(chatId, toolsMsg, { parse_mode: 'Markdown' });
+  });
+};

package/src/commands/toolsoutput.ts

@@ -0,0 +1,50 @@
+/**
+ * /toolsoutput command - Toggle tool output messages
+ * 
+ * When disabled, tools still execute but their output isn't sent to Telegram
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { ConversationMemory } from '../conversation-memory';
+import type { Tool } from '../types';
+
+// Global state for tool output visibility
+let toolOutputEnabled = true;
+
+export function isToolOutputEnabled(): boolean {
+  return toolOutputEnabled;
+}
+
+export function registerToolsOutputCommand(
+  bot: TelegramBot,
+  _memory: ConversationMemory,
+  _tools: Tool[]
+): void {
+  bot.onText(/\/toolsoutput(?:\s+(on|off|toggle))?/, async (msg: TelegramBot.Message, match: RegExpExecArray | null) => {
+    const chatId = msg.chat.id;
+    const subCommand = match?.[1]?.toLowerCase();
+
+    if (subCommand === 'on') {
+      toolOutputEnabled = true;
+    } else if (subCommand === 'off') {
+      toolOutputEnabled = false;
+    } else {
+      // toggle or no arg = toggle
+      toolOutputEnabled = !toolOutputEnabled;
+    }
+
+    const status = toolOutputEnabled ? 'ON' : 'OFF';
+    const emoji = toolOutputEnabled ? '🔊' : '🔇';
+    
+    await bot.sendMessage(
+      chatId,
+      `${emoji} *Tool Output: ${status}*\n\n` +
+      `Tool execution messages are now ${toolOutputEnabled ? 'visible' : 'hidden'}.\n\n` +
+      `Commands:\n` +
+      `/toolsoutput on - Enable tool messages\n` +
+      `/toolsoutput off - Disable tool messages\n` +
+      `/toolsoutput toggle - Toggle`,
+      { parse_mode: 'Markdown' }
+    );
+  });
+}

package/src/commands/types.ts

@@ -0,0 +1,24 @@
+/**
+ * Types for Telegram command handlers
+ */
+
+import TelegramBot from 'node-telegram-bot-api';
+import { ConversationMemory } from '../conversation-memory';
+
+/**
+ * Command registration function signature
+ */
+export type CommandRegistrar = (
+  bot: TelegramBot,
+  memory: ConversationMemory,
+  tools: import('../index').Tool[]
+) => void;
+
+/**
+ * Context passed to command handlers
+ */
+export interface CommandContext {
+  bot: TelegramBot;
+  memory: ConversationMemory;
+  tools: import('../index').Tool[];
+}

package/src/conversation-memory.ts

@@ -0,0 +1,57 @@
+/**
+ * Conversation Memory - tracks chat history per user
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+
+interface Message { role: 'user' | 'assistant' | 'system' | 'tool'; content: string; name?: string }
+
+export class ConversationMemory {
+  private conversations = new Map<number, Message[]>();
+  private maxMessages = 10; // Keep last N messages
+  private file: string;
+
+  constructor(file?: string) {
+    this.file = file || '/root/conversations.json';
+    this.load();
+  }
+
+  private load() {
+    if (!existsSync(this.file)) return;
+    try {
+      const data = JSON.parse(readFileSync(this.file, 'utf-8'));
+      for (const [chatId, messages] of Object.entries(data)) {
+        this.conversations.set(Number(chatId), messages as Message[]);
+      }
+    } catch {}
+  }
+
+  private save() {
+    const data = Object.fromEntries(this.conversations);
+    writeFileSync(this.file, JSON.stringify(data, null, 2));
+  }
+
+  add(chatId: number, role: 'user' | 'assistant' | 'system' | 'tool', content: string, name?: string) {
+    if (!this.conversations.has(chatId)) {
+      this.conversations.set(chatId, []);
+    }
+    const history = this.conversations.get(chatId)!;
+    const msg: Message = { role, content };
+    if (name) msg.name = name;
+    history.push(msg);
+    // Keep only last N messages
+    if (history.length > this.maxMessages) {
+      history.splice(0, history.length - this.maxMessages);
+    }
+    this.save();
+  }
+
+  get(chatId: number): Message[] {
+    return this.conversations.get(chatId) || [];
+  }
+
+  clear(chatId: number) {
+    this.conversations.delete(chatId);
+    this.save();
+  }
+}