aegis-bridge 2.2.2

package/dist/channels/telegram-style.js

@@ -0,0 +1,203 @@
+/**
+ * channels/telegram-style.ts — Telegram Message Style Guide
+ *
+ * 6 standard message types for clean, consistent Telegram UX.
+ * Rule: readable in 2 seconds. Max 2 button rows. Always an escape hatch.
+ *
+ * Types:
+ *   ① quickUpdate  — one-liner (70% of messages)
+ *   ② taskComplete — post-merge quality gate card
+ *   ③ alert        — error/crash requiring action
+ *   ④ yesNo        — binary question
+ *   ⑤ decision     — technical choice with context + escape hatch
+ *   ⑥ progress     — pipeline/deploy with ASCII progress bar
+ */
+// ── HTML Helpers (re-exported for channel use) ──────────────────────────────
+export function esc(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+export function bold(text) {
+    return `<b>${esc(text)}</b>`;
+}
+export function code(text) {
+    return `<code>${esc(text)}</code>`;
+}
+export function italic(text) {
+    return `<i>${esc(text)}</i>`;
+}
+const STATUS_EMOJI = {
+    ok: '🟢',
+    done: '✅',
+    warn: '⚠️',
+    error: '🔴',
+    fail: '❌',
+    progress: '🔄',
+    work: '🔨',
+    deploy: '🚀',
+};
+export function statusEmoji(status) {
+    return STATUS_EMOJI[status] ?? '🔄';
+}
+// ── ① Quick Update ──────────────────────────────────────────────────────────
+/**
+ * One-liner status update. 70% of all messages.
+ * No buttons, no separators. Emoji + text + optional data.
+ */
+export function quickUpdate(emoji, message) {
+    return {
+        text: `${emoji} ${esc(message)}`,
+        parse_mode: 'HTML',
+    };
+}
+/**
+ * Quick update with inline code for technical data.
+ * e.g. quickUpdateCode('🟢', 'CI verde su', 'main', '— 150/150 test ✅')
+ */
+export function quickUpdateCode(emoji, prefix, codeText, suffix) {
+    const parts = [emoji, esc(prefix), code(codeText)];
+    if (suffix)
+        parts.push(esc(suffix));
+    return {
+        text: parts.join(' '),
+        parse_mode: 'HTML',
+    };
+}
+/**
+ * Post-merge/completion card with quality gate.
+ * 3 lines max + 1 row of buttons.
+ */
+export function taskComplete(data, buttons) {
+    const checksStr = data.checks
+        .map(([label, passed]) => `${passed ? '✅' : '❌'} ${esc(label)}`)
+        .join(' · ');
+    const text = [
+        `✅ ${bold(data.taskRef)} — ${esc(data.title)}`,
+        `⏱ ${code(data.duration)} · 🌿 ${code(data.branch)}`,
+        checksStr,
+    ].join('\n');
+    const msg = { text, parse_mode: 'HTML' };
+    if (buttons) {
+        const row = [];
+        if (buttons.merge)
+            row.push({ text: '✅ Merge', callback_data: buttons.merge });
+        if (buttons.review)
+            row.push({ text: '👀 Review', callback_data: buttons.review });
+        if (buttons.close)
+            row.push({ text: '❌ Chiudi', callback_data: buttons.close });
+        if (row.length)
+            msg.reply_markup = { inline_keyboard: [row] };
+    }
+    return msg;
+}
+/**
+ * Error/crash alert requiring action.
+ * Monospace block for technical details + 1 row of buttons.
+ */
+export function alert(data, buttons) {
+    // Limit details to 3 lines
+    const detailLines = data.details.split('\n').slice(0, 3).join('\n');
+    const text = [
+        `🔴 ${bold(data.title)} — ${code(data.resourceId)}`,
+        `<pre>${esc(detailLines)}</pre>`,
+    ].join('\n');
+    const msg = { text, parse_mode: 'HTML' };
+    if (buttons) {
+        const row = [];
+        if (buttons.restart)
+            row.push({ text: '🔄 Riavvia', callback_data: buttons.restart });
+        if (buttons.log)
+            row.push({ text: '📜 Log', callback_data: buttons.log });
+        if (buttons.ignore)
+            row.push({ text: '⏸ Ignora', callback_data: buttons.ignore });
+        if (row.length)
+            msg.reply_markup = { inline_keyboard: [row] };
+    }
+    return msg;
+}
+// ── ④ Yes/No ────────────────────────────────────────────────────────────────
+/**
+ * Binary question. 2 buttons, zero ambiguity.
+ * The "no" label should describe what happens if declined.
+ */
+export function yesNo(question, yesLabel, noLabel, yesCallback, noCallback) {
+    return {
+        text: esc(question),
+        parse_mode: 'HTML',
+        reply_markup: {
+            inline_keyboard: [
+                [
+                    { text: `✅ ${yesLabel}`, callback_data: yesCallback },
+                    { text: `❌ ${noLabel}`, callback_data: noCallback },
+                ],
+            ],
+        },
+    };
+}
+/**
+ * Technical decision with context + escape hatch.
+ * The ONLY type allowed 2 rows of buttons.
+ * Max 3 options + always "Decidi tu" / "Parliamone".
+ */
+export function decision(question, options, escapeCallbacks) {
+    const opts = options.slice(0, 3); // Max 3
+    const optionLines = opts.map((o) => `${bold(o.label)} — ${esc(o.description)}`);
+    const text = [esc(question), '', ...optionLines].join('\n');
+    const optionRow = opts.map((o) => ({
+        text: `${o.emoji} ${o.label}`,
+        callback_data: o.callback,
+    }));
+    const escapeRow = [];
+    if (escapeCallbacks?.decideTu) {
+        escapeRow.push({ text: '🤷 Decidi tu', callback_data: escapeCallbacks.decideTu });
+    }
+    if (escapeCallbacks?.parliamone) {
+        escapeRow.push({ text: '💬 Parliamone', callback_data: escapeCallbacks.parliamone });
+    }
+    const keyboard = [optionRow];
+    if (escapeRow.length)
+        keyboard.push(escapeRow);
+    return {
+        text,
+        parse_mode: 'HTML',
+        reply_markup: { inline_keyboard: keyboard },
+    };
+}
+/**
+ * Progress/pipeline card with ASCII bar.
+ * Updates via editMessageText — never send a new message for refresh.
+ */
+export function progress(title, steps, percent, buttons) {
+    const doneSteps = steps.filter((s) => s.done);
+    const currentStep = steps.find((s) => !s.done);
+    // Done steps on one line with · separator
+    const doneStr = doneSteps
+        .map((s) => `✅ ${esc(s.label)}${s.duration ? ' ' + code(s.duration) : ''}`)
+        .join(' · ');
+    // ASCII progress bar
+    const barLen = 14;
+    const filled = Math.round((percent / 100) * barLen);
+    const bar = '█'.repeat(filled) + '░'.repeat(barLen - filled);
+    const lines = [
+        `🔄 ${bold(title)}`,
+    ];
+    if (doneStr)
+        lines.push(doneStr);
+    if (currentStep)
+        lines.push(`🔄 ${esc(currentStep.label)}...`);
+    lines.push(`${code(bar)} ${percent}%`);
+    const msg = { text: lines.join('\n'), parse_mode: 'HTML' };
+    if (buttons) {
+        const row = [];
+        if (buttons.pause)
+            row.push({ text: '⏸ Pausa', callback_data: buttons.pause });
+        if (buttons.cancel)
+            row.push({ text: '❌ Annulla', callback_data: buttons.cancel });
+        if (row.length)
+            msg.reply_markup = { inline_keyboard: [row] };
+    }
+    return msg;
+}
+//# sourceMappingURL=telegram-style.js.map

package/dist/channels/telegram.d.ts

@@ -0,0 +1,76 @@
+/**
+ * channels/telegram.ts — Telegram notification channel.
+ *
+ * Creates one topic per CC session in a Telegram supergroup.
+ * Bidirectional: reads replies from topics and fires inbound commands.
+ *
+ * Formatting: HTML parse_mode with structured, clean messages.
+ */
+import type { Channel, SessionEventPayload, InboundHandler } from './types.js';
+import type { SwarmMonitor } from '../swarm-monitor.js';
+import { type StyledMessage } from './telegram-style.js';
+export interface TelegramChannelConfig {
+    botToken: string;
+    groupChatId: string;
+    allowedUserIds: number[];
+}
+export declare class TelegramChannel implements Channel {
+    private config;
+    readonly name = "telegram";
+    private topics;
+    private progress;
+    private pollOffset;
+    private polling;
+    private onInbound;
+    private messageQueue;
+    private lastSent;
+    private flushTimers;
+    private pendingTool;
+    static readonly MAX_IN_FLIGHT = 10;
+    private inFlightCount;
+    private preTopicBuffer;
+    private pendingReads;
+    private readTimer;
+    private lastUserMessage;
+    private swarmMonitor;
+    /** Set the swarm monitor for /swarm command support. */
+    setSwarmMonitor(monitor: SwarmMonitor): void;
+    constructor(config: TelegramChannelConfig);
+    private pollLoopPromise;
+    init(onInbound: InboundHandler): Promise<void>;
+    destroy(): Promise<void>;
+    onSessionCreated(payload: SessionEventPayload): Promise<void>;
+    onSessionEnded(payload: SessionEventPayload): Promise<void>;
+    onMessage(payload: SessionEventPayload): Promise<void>;
+    onStatusChange(payload: SessionEventPayload): Promise<void>;
+    private addPendingRead;
+    private flushReads;
+    /**
+     * Send a StyledMessage (from telegram-style.ts) with inline keyboard support.
+     * This is the primary way to send the 6 standard message types.
+     */
+    sendStyled(sessionId: string, styled: StyledMessage): Promise<number | null>;
+    private sendStyledToTopic;
+    /**
+     * Edit a message in-place with a StyledMessage (for progress updates with buttons).
+     */
+    editStyled(sessionId: string, messageId: number, styled: StyledMessage): Promise<boolean>;
+    private editMessage;
+    private sendImmediate;
+    private sendToTopic;
+    /** Issue #89 L12: Decrement in-flight counter, clamped to 0. */
+    private decrementInFlight;
+    private queueMessage;
+    private flushQueue;
+    private cleanup;
+    private handleSwarmCommand;
+    private pollLoop;
+    /** Issue #348: Redact bot token from error messages before logging. */
+    private redactError;
+    private handleUpdate;
+    private handleCallbackQuery;
+    /**
+     * Remove inline keyboard from a message after button click (one-shot actions).
+     */
+    private removeReplyMarkup;
+}