Нотификации из Claude Code и OpenCode в ваш Telegram

curl https://api.telegram.org/bot<BOT_TOKEN>/getUpdates

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "agent",
            "prompt": "Check the last result of the session, remember it as a <LAST_MESSAGE> (make sure it is not more then 4000 symbols). And then run in the shell: curl -s -X POST https://api.telegram.org/bot<TOKEN>/sendMessage -H "Content-Type: application/json" -d '{"chat_id": "<CHAT_ID>", "text": "<LAST_MESSAGE>"}' "
          }
        ]
      }
    ],
    "PermissionRequest": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "curl -s -X POST https://api.telegram.org/bot<TOKEN>/sendMessage -H "Content-Type: application/json" -d '{"chat_id": "<CHAT_ID>", "text": "⚠️Permission requeired!"}'"
          }          
        ]
      }
    ]
  }
}

/**
 * TelegramNotifyPlugin for OpenCode
 * 
 * Sends Telegram notifications with the final agent response when sessions complete.
 * Uses OpenCode API: GET /session/:id/message/:messageID
 */

const MIN_TEXT_LENGTH = 10;
const TELEGRAM_MAX_LENGTH = 4096;
const TELEGRAM_TIMEOUT_MS = 5000;

const pendingOperations: Promise<void>[] = [];

function addPendingOperation(promise: Promise<void>): void {
  pendingOperations.push(promise);
  promise.then(() => {
    const idx = pendingOperations.indexOf(promise);
    if (idx > -1) pendingOperations.splice(idx, 1);
  });
}

process.on('beforeExit', async () => {
  if (pendingOperations.length > 0) {
    await Promise.all(pendingOperations);
  }
});

interface OpenCodeClient {
  _client: {
    request: (config: { method: string; url: string }) => Promise<{ data: MessageListResponse }>;
  };
}

interface MessageListResponse {
  info?: { id: string };
}

interface MessagePart {
  type: string;
  text?: string;
}

interface MessageDetailResponse {
  parts?: MessagePart[];
}

interface SessionIdleEvent {
  type: "session.idle";
  properties?: { sessionID: string };
}

function escapeTelegramMarkdown(text: string): string {
  return text
    .replace(/\\/g, '\\\\')
    .replace(/_/g, '\\_')
    .replace(/\*/g, '\\*')
    .replace(/`/g, '\\`')
    .replace(/\[/g, '\\[')
    .replace(/\]/g, '\\]')
    .replace(/\(/g, '\\(')
    .replace(/\)/g, '\\)')
    .replace(/~/g, '\\~')
    .replace(/>/g, '\\>')
    .replace(/#/g, '\\#')
    .replace(/\+/g, '\\+')
    .replace(/-/g, '\\-')
    .replace(/=/g, '\\=')
    .replace(/\|/g, '\\|')
    .replace(/{/g, '\\{')
    .replace(/}/g, '\\}')
    .replace(/\./g, '\\.')
    .replace(/!/g, '\\!');
}

export const TelegramNotifyPlugin = async ({ client }: { client: OpenCodeClient }) => {
  const token = process.env.OP_TELEGRAM_TOKEN;
  const chatId = process.env.OP_TELEGRAM_CHAT_ID;

  if (!token || !chatId) {
    console.error('[TelegramNotifyPlugin] Missing OP_TELEGRAM_TOKEN or OP_TELEGRAM_CHAT_ID, notifications disabled');
    return { event: async () => {} };
  }

  return {
    event: async ({ event }) => {
      if (event.type === "session.idle") {
        const sid = (event as SessionIdleEvent).properties?.sessionID;
        if (!sid) return;

        const text = await getLastMessageContent(client, sid);
        if (!text) return;

        const prefix = "✅ *OpenCode session finished:*";
        const suffix = "\n\n\.\.\.read full message in OpenCode";
        
        // Calculate max length for raw text (accounting for prefix and suffix)
        const maxRawTextLength = TELEGRAM_MAX_LENGTH - prefix.length - suffix.length;
        
        // Truncate raw text BEFORE escaping to avoid breaking Markdown entities
        let truncatedText = text;
        if (truncatedText.length > maxRawTextLength) {
          truncatedText = truncatedText.slice(0, maxRawTextLength);
        }
        
        const finalEscapedText = escapeTelegramMarkdown(truncatedText);
        let finalText = `${prefix}\n\n${finalEscapedText}`;
        
        if (text.length > maxRawTextLength) {
          finalText += suffix;
        }

        const payload = JSON.stringify({ 
          chat_id: chatId, 
          text: finalText,
          parse_mode: "MarkdownV2"
        });

        addPendingOperation(sendTelegramMessage(token, payload));
      }
    },
  };
};

async function getLastMessageContent(client: OpenCodeClient, sessionId: string): Promise<string | null> {
  try {
    const listResponse = await client._client.request({
      method: 'GET',
      url: `/session/${sessionId}/message`,
    });

    const messages = listResponse?.data || [];
    if (messages.length === 0) return null;

    const lastMsgId = messages[messages.length - 1]?.info?.id;
    if (!lastMsgId) return null;

    const msgResponse = await client._client.request({
      method: 'GET',
      url: `/session/${sessionId}/message/${lastMsgId}`,
    });

    return extractTextFromParts((msgResponse as any).data || msgResponse);
  } catch (error) {
    console.error('[TelegramNotifyPlugin] Failed to fetch message:', error);
    return null;
  }
}

function extractTextFromParts(msgData: MessageDetailResponse): string | null {
  const parts = msgData?.parts || [];
  const textContent = parts
    .filter(p => p.type !== "reasoning" && p.type !== "thought" && p.text)
    .map(p => p.text)
    .join("\n\n");
  
  return textContent.length > MIN_TEXT_LENGTH ? textContent : null;
}

async function sendTelegramMessage(token: string, payload: string): Promise<void> {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), TELEGRAM_TIMEOUT_MS);

  try {
    const response = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: payload,
      signal: controller.signal
    });

    if (!response.ok) {
      const errorText = await response.text();
      console.error(`[TelegramNotifyPlugin] Telegram API error: ${response.status}`, errorText);
    }
  } catch (error) {
    console.error('[TelegramNotifyPlugin] Telegram notification failed:', error);
  } finally {
    clearTimeout(timeout);
  }
}