@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/lib/im/adapters/telegram.ts

@@ -0,0 +1,156 @@
+// ─── Telegram Adapter ─────────────────────────────────────────────────────────
+// Implements IMAdapter using grammY (dynamic import, lazy init).
+
+import type { IMAdapter, IMMessage, IMSendResult, TelegramConfig } from '../types';
+import { markdownToTelegramV2 } from '../format';
+
+const SEND_TIMEOUT_MS = 10_000;
+
+export class TelegramAdapter implements IMAdapter {
+  readonly platform = 'telegram' as const;
+
+  private bot: Awaited<ReturnType<typeof createBot>> | null = null;
+  private config: TelegramConfig;
+  private botInfoCache: { id: number; username: string } | null = null;
+
+  constructor(config: TelegramConfig) {
+    this.config = config;
+  }
+
+  async send(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
+    const bot = await this.ensureBot();
+    const chatId = message.recipientId;
+    const opts: Record<string, unknown> = {};
+
+    if (message.threadId) {
+      opts.message_thread_id = Number(message.threadId);
+    }
+
+    try {
+      let result: { message_id: number };
+
+      if (message.format === 'html') {
+        result = await callWithTimeout(
+          () => bot.api.sendMessage(chatId, message.text, { ...opts, parse_mode: 'HTML' }),
+          SEND_TIMEOUT_MS, signal,
+        );
+      } else if (message.format === 'markdown') {
+        // Try MarkdownV2 first, fallback to plain text on parse error
+        try {
+          const converted = markdownToTelegramV2(message.text);
+          result = await callWithTimeout(
+            () => bot.api.sendMessage(chatId, converted, { ...opts, parse_mode: 'MarkdownV2' }),
+            SEND_TIMEOUT_MS, signal,
+          );
+        } catch (mdErr) {
+          // If Telegram can't parse the markdown, fallback to plain text
+          if (isParseError(mdErr)) {
+            result = await callWithTimeout(
+              () => bot.api.sendMessage(chatId, message.text, opts),
+              SEND_TIMEOUT_MS, signal,
+            );
+          } else {
+            throw mdErr;
+          }
+        }
+      } else {
+        result = await callWithTimeout(
+          () => bot.api.sendMessage(chatId, message.text, opts),
+          SEND_TIMEOUT_MS, signal,
+        );
+      }
+
+      return {
+        ok: true,
+        messageId: String(result.message_id),
+        timestamp: new Date().toISOString(),
+      };
+    } catch (err) {
+      return {
+        ok: false,
+        error: formatTelegramError(err),
+        timestamp: new Date().toISOString(),
+      };
+    }
+  }
+
+  async verify(): Promise<boolean> {
+    try {
+      const bot = await this.ensureBot();
+      const me = await bot.api.getMe();
+      this.botInfoCache = { id: me.id, username: me.username ?? '' };
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /** Get cached bot info (available after verify()). */
+  getBotInfo(): { id: number; username: string } | null {
+    return this.botInfoCache;
+  }
+
+  async dispose(): Promise<void> {
+    this.bot = null;
+    this.botInfoCache = null;
+  }
+
+  // ─── Internal ───────────────────────────────────────────────────────────────
+
+  private async ensureBot() {
+    if (this.bot) return this.bot;
+    this.bot = await createBot(this.config.bot_token);
+    return this.bot;
+  }
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function createBot(token: string) {
+  try {
+    const { Bot } = await import('grammy');
+    return new Bot(token);
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes('Cannot find module') || err.message.includes('MODULE_NOT_FOUND'))) {
+      throw new Error('grammy package not installed. Run: npm install grammy');
+    }
+    throw err;
+  }
+}
+
+function callWithTimeout<T>(
+  fn: () => Promise<T>,
+  timeoutMs: number,
+  signal?: AbortSignal,
+): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    if (signal?.aborted) { reject(new DOMException('Aborted', 'AbortError')); return; }
+
+    const timer = setTimeout(() => reject(new Error('Send timed out')), timeoutMs);
+    const onAbort = () => { clearTimeout(timer); reject(new DOMException('Aborted', 'AbortError')); };
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    fn().then(
+      (val) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); resolve(val); },
+      (err) => { clearTimeout(timer); signal?.removeEventListener('abort', onAbort); reject(err); },
+    );
+  });
+}
+
+function isParseError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("can't parse entities") || msg.includes('bad request') && msg.includes('parse');
+}
+
+function formatTelegramError(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  if (err.name === 'AbortError') return 'Send cancelled';
+  const msg = err.message;
+  if (msg.includes('Forbidden')) return 'Bot blocked by user or removed from group';
+  if (msg.includes('chat not found') || msg.includes('404')) return `Chat not found: check recipient_id`;
+  if (msg.includes('429') || msg.includes('Too Many Requests')) return 'Rate limited by Telegram, try again later';
+  if (msg.includes('timed out')) return 'Send timed out (10s)';
+  if (msg.includes('grammy package not installed')) return msg;
+  return `Telegram error: ${msg}`;
+}

package/_standalone/lib/im/adapters/wechat.ts

@@ -0,0 +1,127 @@
+// ─── WeChat Personal Adapter ──────────────────────────────────────────────────
+// Implements IMAdapter using the official WeChat ClawBot iLink Bot HTTP JSON protocol.
+// Reference: @tencent-weixin/openclaw-weixin (Tencent official plugin)
+//
+// Protocol:
+//   - Base URL: https://ilinkai.weixin.qq.com
+//   - Auth: Bearer {bot_token} (obtained via QR code scan)
+//   - Send: POST /sendmessage
+//   - Receive: Long polling GET /getupdates (Phase 2 — not implemented here)
+//
+// This adapter implements sending only (no message receiving).
+// No external SDK required — uses native fetch.
+
+import type { IMAdapter, IMMessage, IMSendResult, WeChatConfig } from '../types';
+
+const WECHAT_API_BASE = 'https://ilinkai.weixin.qq.com';
+const SEND_TIMEOUT_MS = 10_000;
+
+export class WeChatAdapter implements IMAdapter {
+  readonly platform = 'wechat' as const;
+
+  private config: WeChatConfig;
+
+  constructor(config: WeChatConfig) {
+    this.config = config;
+  }
+
+  async send(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
+    try {
+      const url = `${WECHAT_API_BASE}/sendmessage`;
+
+      const body = {
+        chat_id: message.recipientId,
+        text: message.text,
+        // WeChat ClawBot only supports plain text for now
+        // context_token would be needed for threaded replies (Phase 2)
+      };
+
+      const res = await fetchWithTimeout(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.config.bot_token}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+      }, SEND_TIMEOUT_MS);
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        return { ok: false, error: `WeChat API error (${res.status}): ${text || res.statusText}`, timestamp: new Date().toISOString() };
+      }
+
+      const data = await res.json().catch(() => ({})) as Record<string, unknown>;
+      return {
+        ok: true,
+        messageId: data.message_id ? String(data.message_id) : undefined,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (err) {
+      return { ok: false, error: formatWeChatError(err), timestamp: new Date().toISOString() };
+    }
+  }
+
+  async verify(): Promise<boolean> {
+    try {
+      const res = await fetchWithTimeout(`${WECHAT_API_BASE}/getme`, {
+        headers: { 'Authorization': `Bearer ${this.config.bot_token}` },
+      }, SEND_TIMEOUT_MS);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async dispose(): Promise<void> {
+    // No persistent connections to clean up
+  }
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function fetchWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+
+  return await new Promise<Response>((resolve, reject) => {
+    if (init.signal?.aborted) {
+      reject(new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error('Request timed out'));
+    }, timeoutMs);
+
+    const onAbort = () => {
+      clearTimeout(timer);
+      controller.abort();
+      reject(new DOMException('Aborted', 'AbortError'));
+    };
+
+    init.signal?.addEventListener('abort', onAbort, { once: true });
+
+    fetch(url, { ...init, signal: controller.signal }).then(
+      (response) => {
+        clearTimeout(timer);
+        init.signal?.removeEventListener('abort', onAbort);
+        resolve(response);
+      },
+      (error) => {
+        clearTimeout(timer);
+        init.signal?.removeEventListener('abort', onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
+function formatWeChatError(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  if (err.name === 'AbortError') return 'Send cancelled';
+  const msg = err.message;
+  if (msg.includes('timed out') || msg.includes('abort')) return 'WeChat request timed out (10s)';
+  if (msg.includes('401') || msg.includes('Unauthorized')) return 'Invalid bot_token. Re-scan QR code to refresh.';
+  return `WeChat error: ${msg}`;
+}

package/_standalone/lib/im/adapters/wecom.ts

@@ -0,0 +1,160 @@
+// ─── WeCom (企业微信) Adapter ─────────────────────────────────────────────────
+// Implements IMAdapter using direct HTTP API (no external SDK needed).
+// Supports two modes:
+//   1. Webhook bot (simple, one-way, group chat only)
+//   2. App bot (full, two-way, requires corp_id + corp_secret)
+
+import type { IMAdapter, IMMessage, IMSendResult, WeComConfig } from '../types';
+
+const SEND_TIMEOUT_MS = 10_000;
+const TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000; // refresh 5 min before expiry
+
+export class WeComAdapter implements IMAdapter {
+  readonly platform = 'wecom' as const;
+
+  private config: WeComConfig;
+  private accessToken: string | null = null;
+  private tokenExpiresAt = 0;
+
+  constructor(config: WeComConfig) {
+    this.config = config;
+  }
+
+  async send(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
+    try {
+      // Webhook mode: simple POST to webhook URL
+      if (this.config.webhook_key) {
+        return this.sendViaWebhook(message, signal);
+      }
+
+      // App mode: use access_token + message API
+      if (this.config.corp_id && this.config.corp_secret) {
+        return this.sendViaApp(message, signal);
+      }
+
+      return { ok: false, error: 'WeCom not configured: provide webhook_key or corp_id + corp_secret', timestamp: new Date().toISOString() };
+    } catch (err) {
+      return { ok: false, error: formatWeComError(err), timestamp: new Date().toISOString() };
+    }
+  }
+
+  async verify(): Promise<boolean> {
+    if (this.config.webhook_key) return true; // webhook mode has no verify endpoint
+
+    if (this.config.corp_id && this.config.corp_secret) {
+      try {
+        await this.ensureAccessToken();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  async dispose(): Promise<void> {
+    this.accessToken = null;
+    this.tokenExpiresAt = 0;
+  }
+
+  // ─── Webhook Mode ───────────────────────────────────────────────────────────
+
+  private async sendViaWebhook(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
+    const url = `https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=${this.config.webhook_key}`;
+
+    const body = message.format === 'markdown'
+      ? { msgtype: 'markdown', markdown: { content: message.text } }
+      : { msgtype: 'text', text: { content: message.text } };
+
+    const res = await fetchWithTimeout(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal,
+    }, SEND_TIMEOUT_MS);
+
+    const data = await res.json() as { errcode: number; errmsg: string };
+    if (data.errcode !== 0) {
+      return { ok: false, error: `WeCom webhook error: ${data.errmsg} (code ${data.errcode})`, timestamp: new Date().toISOString() };
+    }
+    return { ok: true, timestamp: new Date().toISOString() };
+  }
+
+  // ─── App Mode ───────────────────────────────────────────────────────────────
+
+  private async sendViaApp(message: IMMessage, signal?: AbortSignal): Promise<IMSendResult> {
+    const token = await this.ensureAccessToken();
+    const url = `https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=${token}`;
+
+    const body: Record<string, unknown> = {
+      touser: message.recipientId, // can also be toparty / totag
+      agentid: 1000002, // default agent, user can override via config in future
+      msgtype: message.format === 'markdown' ? 'markdown' : 'text',
+    };
+
+    if (message.format === 'markdown') {
+      body.markdown = { content: message.text };
+    } else {
+      body.text = { content: message.text };
+    }
+
+    const res = await fetchWithTimeout(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal,
+    }, SEND_TIMEOUT_MS);
+
+    const data = await res.json() as { errcode: number; errmsg: string; msgid?: string };
+    if (data.errcode !== 0) {
+      return { ok: false, error: `WeCom error: ${data.errmsg} (code ${data.errcode})`, timestamp: new Date().toISOString() };
+    }
+    return { ok: true, messageId: data.msgid ? String(data.msgid) : undefined, timestamp: new Date().toISOString() };
+  }
+
+  // ─── Token Management ───────────────────────────────────────────────────────
+
+  private async ensureAccessToken(): Promise<string> {
+    if (this.accessToken && Date.now() < this.tokenExpiresAt - TOKEN_REFRESH_BUFFER_MS) {
+      return this.accessToken;
+    }
+
+    const url = `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${this.config.corp_id}&corpsecret=${this.config.corp_secret}`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(SEND_TIMEOUT_MS) });
+    const data = await res.json() as { errcode: number; errmsg: string; access_token?: string; expires_in?: number };
+
+    if (data.errcode !== 0 || !data.access_token) {
+      throw new Error(`WeCom token error: ${data.errmsg} (code ${data.errcode})`);
+    }
+
+    this.accessToken = data.access_token;
+    this.tokenExpiresAt = Date.now() + (data.expires_in ?? 7200) * 1000;
+    return this.accessToken;
+  }
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+async function fetchWithTimeout(url: string, init: RequestInit, timeoutMs: number): Promise<Response> {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  // Merge external signal
+  if (init.signal) {
+    init.signal.addEventListener('abort', () => controller.abort(), { once: true });
+  }
+
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function formatWeComError(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  if (err.name === 'AbortError') return 'Send cancelled';
+  const msg = err.message;
+  if (msg.includes('timed out') || msg.includes('abort')) return 'Send timed out (10s)';
+  return `WeCom error: ${msg}`;
+}

package/_standalone/lib/im/index.ts

@@ -0,0 +1,122 @@
+// ─── IM Extension Entry Point ─────────────────────────────────────────────────
+// Registers IM tools via the pi Extension API.
+// This file is loaded as an extension by DefaultResourceLoader in ask/route.ts.
+//
+// When no IM platforms are configured (~/.mindos/im.json empty or missing),
+// the extension silently does nothing — no tools, no commands.
+
+import type { ExtensionAPI, ToolDefinition } from '@mariozechner/pi-coding-agent';
+import type { AgentToolResult } from '@mariozechner/pi-agent-core';
+import { Type, type TSchema } from '@sinclair/typebox';
+import { hasAnyIMConfig, getConfiguredPlatforms } from './config';
+import { sendIMMessage, listConfiguredIM } from './executor';
+import { maskForLog } from './format';
+import type { IMPlatform } from './types';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function textResult(text: string): AgentToolResult<unknown> {
+  return { content: [{ type: 'text', text }], details: undefined };
+}
+
+// ─── Extension Factory ────────────────────────────────────────────────────────
+
+export default function imExtension(pi: ExtensionAPI) {
+  if (!hasAnyIMConfig()) return;
+
+  const platforms = getConfiguredPlatforms();
+  if (platforms.length === 0) return;
+
+  // ── send_im_message tool ──────────────────────────────────────────────────
+
+  const sendSchema = Type.Object({
+    platform: Type.Union(
+      platforms.map((p) => Type.Literal(p)),
+      { description: 'Target IM platform (only configured platforms shown)' },
+    ),
+    recipient_id: Type.String({
+      description: 'Chat/Channel/Group ID on the platform. Use list_im_channels to discover available targets.',
+    }),
+    message: Type.String({
+      description: 'Message content to send. Supports markdown if the platform allows it.',
+    }),
+    format: Type.Optional(
+      Type.Union([Type.Literal('text'), Type.Literal('markdown')], {
+        description: 'Message format. Default: text.',
+      }),
+    ),
+    thread_id: Type.Optional(
+      Type.String({ description: 'Thread/Topic ID for threaded replies (platform-dependent).' }),
+    ),
+  });
+
+  pi.registerTool({
+    name: 'send_im_message',
+    label: 'Send IM',
+    description: 'Send a message to a configured IM platform (Telegram, Discord, Feishu, Slack, WeChat, QQ, etc.).',
+    promptSnippet: 'send_im_message: Send messages to IM platforms',
+    parameters: sendSchema,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    execute: async (_toolCallId: string, params: any, signal?: AbortSignal): Promise<AgentToolResult<unknown>> => {
+      const { platform, recipient_id, message, format, thread_id } = params as { platform: string; recipient_id: string; message: string; format?: string; thread_id?: string };
+      const result = await sendIMMessage(
+        {
+          platform: platform as IMPlatform,
+          recipientId: recipient_id,
+          text: message,
+          format: (format as 'text' | 'markdown' | undefined) ?? 'text',
+          threadId: thread_id,
+        },
+        signal,
+        { activityType: 'agent' },
+      );
+
+      if (result.ok) {
+        return textResult(
+          `Message sent to ${platform} chat ${maskForLog(recipient_id)}.\nMessage ID: ${result.messageId ?? 'N/A'}\nTimestamp: ${result.timestamp}`,
+        );
+      }
+      return textResult(`Failed to send message to ${platform}: ${result.error}`);
+    },
+  } as ToolDefinition<TSchema>);
+
+  // ── list_im_channels tool ─────────────────────────────────────────────────
+
+  pi.registerTool({
+    name: 'list_im_channels',
+    label: 'List IM',
+    description: 'List all configured IM platforms, their connection status, and capabilities.',
+    parameters: Type.Object({}),
+    execute: async (): Promise<AgentToolResult<unknown>> => {
+      const results = await listConfiguredIM();
+      if (results.length === 0) {
+        return textResult(
+          'No IM platforms configured.\nUsers can configure IM platforms by editing ~/.mindos/im.json.\n\nSupported: telegram, feishu, discord, slack, wecom, dingtalk, wechat, qq',
+        );
+      }
+      const lines = results.map((p) => {
+        const status = p.connected ? '\u2713 connected' : '\u2717 disconnected';
+        const name = p.botName ? `  Bot: ${p.botName}` : '';
+        return `- ${p.platform}: ${status} (supports ${p.capabilities.join(', ')})${name}`;
+      });
+      return textResult(`Configured IM platforms:\n\n${lines.join('\n')}`);
+    },
+  } as ToolDefinition<TSchema>);
+
+  // ── /im command ───────────────────────────────────────────────────────────
+
+  pi.registerCommand('im', {
+    description: 'Show configured IM platforms and their status',
+    handler: async (_args: string, ctx) => {
+      const results = await listConfiguredIM();
+      if (results.length === 0) {
+        ctx.ui.notify('No IM platforms configured. Edit ~/.mindos/im.json to add platforms.', 'info');
+        return;
+      }
+      const summary = results
+        .map((p) => `${p.connected ? '\u2713' : '\u2717'} ${p.platform}${p.botName ? ` (${p.botName})` : ''}`)
+        .join('\n');
+      ctx.ui.notify(`IM Channels:\n${summary}`, 'info');
+    },
+  });
+}