sanook-cli 0.5.0 → 0.5.2

package/dist/gateway/targets.js

@@ -0,0 +1,576 @@
+import { resolveBlueBubblesConfig, resolveDiscordConfig, resolveEmailConfig, resolveGoogleChatConfig, resolveHomeAssistantConfig, resolveLineConfig, resolveMattermostConfig, resolveMatrixConfig, resolveNtfyConfig, resolveSignalConfig, resolveSlackConfig, resolveSmsConfig, resolveTelegramConfig, resolveTeamsConfig, resolveWhatsAppConfig, } from './config.js';
+import { normalizeSignalId, redactSignalId } from './signal.js';
+import { normalizeWhatsAppId, redactWhatsAppId } from './whatsapp.js';
+export function parseNumericId(raw, label) {
+    if (!/^-?\d+$/.test(raw))
+        throw new Error(`${label} ต้องเป็น integer`);
+    const n = Number(raw);
+    if (!Number.isSafeInteger(n))
+        throw new Error(`${label} ใหญ่เกินไป`);
+    return n;
+}
+export function parseSendTarget(raw) {
+    const trimmed = raw.trim();
+    const firstColon = trimmed.indexOf(':');
+    const rawPlatform = firstColon === -1 ? trimmed : trimmed.slice(0, firstColon);
+    let platform = rawPlatform?.trim().toLowerCase();
+    if (platform === 'google-chat' || platform === 'google_chat' || platform === 'gchat')
+        platform = 'googlechat';
+    if (platform === 'blue-bubbles' || platform === 'blue_bubbles' || platform === 'imessage')
+        platform = 'bluebubbles';
+    const remainder = firstColon === -1 ? undefined : trimmed.slice(firstColon + 1);
+    let address;
+    let thread;
+    let extra = [];
+    if (platform === 'matrix' || platform === 'googlechat' || platform === 'bluebubbles' || platform === 'teams') {
+        address = remainder?.trim();
+    }
+    else if (remainder != null) {
+        const parts = remainder.split(':');
+        address = parts[0]?.trim();
+        thread = parts[1]?.trim();
+        extra = parts.slice(2);
+    }
+    if (!platform || extra.length) {
+        throw new Error('target ต้องเป็น platform, platform:chat_id, หรือ platform:chat_id:thread_id');
+    }
+    if (platform === 'signal' && address === 'group' && thread) {
+        address = `group:${thread}`;
+        thread = undefined;
+    }
+    if (![
+        'telegram',
+        'discord',
+        'slack',
+        'mattermost',
+        'homeassistant',
+        'email',
+        'line',
+        'sms',
+        'ntfy',
+        'signal',
+        'whatsapp',
+        'matrix',
+        'googlechat',
+        'bluebubbles',
+        'teams',
+    ].includes(platform)) {
+        throw new Error('platform ต้องเป็น telegram, discord, slack, mattermost, homeassistant, email, line, sms, ntfy, signal, whatsapp, matrix, googlechat, bluebubbles, หรือ teams');
+    }
+    if (address === '' || thread === '') {
+        throw new Error('target ต้องเป็น platform, platform:chat_id, หรือ platform:chat_id:thread_id');
+    }
+    if (thread && !['telegram', 'discord', 'slack', 'mattermost'].includes(platform)) {
+        throw new Error(`${platform} target ไม่รองรับ thread segment`);
+    }
+    const target = { platform, address, thread };
+    if (platform === 'telegram') {
+        if (address)
+            target.chatId = parseNumericId(address, 'chat_id');
+        if (thread) {
+            target.threadId = parseNumericId(thread, 'thread_id');
+            if (target.threadId <= 0)
+                throw new Error('thread_id ต้องเป็น integer มากกว่า 0');
+        }
+    }
+    if (platform === 'signal' && address)
+        target.address = normalizeSignalId(address);
+    if (platform === 'whatsapp' && address) {
+        const waId = normalizeWhatsAppId(address);
+        if (!waId)
+            throw new Error('WhatsApp target ต้องเป็น wa_id ตัวเลขพร้อม country code เช่น whatsapp:15551234567');
+        target.address = waId;
+    }
+    if (platform === 'matrix' && address && !/^[!#][^:\s]+:[^:\s]+(?::\d+)?$/.test(address)) {
+        throw new Error('Matrix target ต้องเป็น room id/alias เช่น matrix:!abc123:matrix.org');
+    }
+    if (platform === 'googlechat' &&
+        address &&
+        !/^https:\/\//i.test(address) &&
+        !/^(?:spaces\/[^/\s]+|space[:/][^/\s]+)(?:\/threads\/.+)?$/i.test(address)) {
+        throw new Error('Google Chat target ต้องเป็น spaces/<space-id>, spaces/<space-id>/threads/<thread-id>, หรือ HTTPS webhook URL');
+    }
+    if (platform === 'bluebubbles' && address && /\s/.test(address)) {
+        throw new Error('BlueBubbles target ต้องเป็น chat GUID, email, หรือเบอร์โทรที่ไม่มีช่องว่าง');
+    }
+    return target;
+}
+export function formatTarget(target) {
+    const address = target.address ?? (target.chatId == null ? undefined : String(target.chatId));
+    const thread = target.thread ?? (target.threadId == null ? undefined : String(target.threadId));
+    return `${target.platform}${address == null ? '' : `:${address}`}${thread == null ? '' : `:${thread}`}`;
+}
+export function listConfiguredTargets(config, env = process.env) {
+    const out = [];
+    const telegram = resolveTelegramConfig(config, env);
+    if (telegram.token) {
+        const chats = telegram.allowedChatIds;
+        if (chats.length) {
+            out.push({
+                platform: 'telegram',
+                chatId: chats[0],
+                target: 'telegram',
+                label: `Telegram home (${chats[0]})`,
+                configured: true,
+            });
+            for (const chatId of chats) {
+                out.push({
+                    platform: 'telegram',
+                    chatId,
+                    target: `telegram:${chatId}`,
+                    label: `Telegram chat ${chatId}`,
+                    configured: true,
+                });
+            }
+        }
+        else {
+            out.push({
+                platform: 'telegram',
+                target: 'telegram',
+                label: 'Telegram configured but no allowed chat (fail-closed)',
+                configured: false,
+            });
+        }
+    }
+    const discord = resolveDiscordConfig(config, env);
+    if (discord.token) {
+        if (discord.defaultChannelId) {
+            out.push({
+                platform: 'discord',
+                address: discord.defaultChannelId,
+                target: 'discord',
+                label: `Discord home (${discord.defaultChannelId})`,
+                configured: true,
+            });
+        }
+        for (const channelId of discord.allowedChannelIds) {
+            out.push({
+                platform: 'discord',
+                address: channelId,
+                target: `discord:${channelId}`,
+                label: `Discord channel ${channelId}`,
+                configured: true,
+            });
+        }
+        if (!discord.defaultChannelId && !discord.allowedChannelIds.length) {
+            out.push({
+                platform: 'discord',
+                target: 'discord',
+                label: 'Discord configured but no default/allowed channel',
+                configured: false,
+            });
+        }
+    }
+    const slack = resolveSlackConfig(config, env);
+    if (slack.botToken) {
+        if (slack.defaultChannelId) {
+            out.push({
+                platform: 'slack',
+                address: slack.defaultChannelId,
+                target: 'slack',
+                label: `Slack home (${slack.defaultChannelId})`,
+                configured: true,
+            });
+        }
+        for (const channelId of slack.allowedChannelIds) {
+            out.push({
+                platform: 'slack',
+                address: channelId,
+                target: `slack:${channelId}`,
+                label: `Slack channel ${channelId}`,
+                configured: true,
+            });
+        }
+        if (!slack.defaultChannelId && !slack.allowedChannelIds.length) {
+            out.push({
+                platform: 'slack',
+                target: 'slack',
+                label: 'Slack configured but no default/allowed channel',
+                configured: false,
+            });
+        }
+    }
+    const mattermost = resolveMattermostConfig(config, env);
+    if (mattermost.serverUrl || mattermost.token || mattermost.homeChannel || mattermost.allowedChannels.length) {
+        if (mattermost.homeChannel) {
+            out.push({
+                platform: 'mattermost',
+                address: mattermost.homeChannel,
+                target: 'mattermost',
+                label: `Mattermost ${mattermost.homeChannelName ?? 'home'} (${mattermost.homeChannel})`,
+                configured: Boolean(mattermost.serverUrl && mattermost.token),
+            });
+        }
+        const seen = new Set([mattermost.homeChannel].filter((v) => Boolean(v)));
+        for (const channel of mattermost.allowedChannels) {
+            if (seen.has(channel))
+                continue;
+            seen.add(channel);
+            out.push({
+                platform: 'mattermost',
+                address: channel,
+                target: `mattermost:${channel}`,
+                label: `Mattermost channel ${channel}`,
+                configured: Boolean(mattermost.serverUrl && mattermost.token),
+            });
+        }
+        if (!mattermost.homeChannel && !mattermost.allowedChannels.length) {
+            out.push({
+                platform: 'mattermost',
+                target: 'mattermost',
+                label: 'Mattermost configured but no home/allowed channel',
+                configured: false,
+            });
+        }
+    }
+    const homeassistant = resolveHomeAssistantConfig(config, env);
+    if (homeassistant.token || homeassistant.homeChannel || homeassistant.url !== 'http://homeassistant.local:8123') {
+        if (homeassistant.homeChannel) {
+            out.push({
+                platform: 'homeassistant',
+                address: homeassistant.homeChannel,
+                target: 'homeassistant',
+                label: `Home Assistant ${homeassistant.homeChannelName ?? 'notification'} (${homeassistant.homeChannel})`,
+                configured: Boolean(homeassistant.token),
+            });
+        }
+        else {
+            out.push({
+                platform: 'homeassistant',
+                target: 'homeassistant',
+                label: 'Home Assistant configured but no home notification id',
+                configured: Boolean(homeassistant.token),
+            });
+        }
+    }
+    const email = resolveEmailConfig(config, env);
+    if (email.address && email.smtpHost && email.password) {
+        if (email.homeAddress) {
+            out.push({
+                platform: 'email',
+                address: email.homeAddress,
+                target: 'email',
+                label: `Email home (${email.homeAddress})`,
+                configured: true,
+            });
+        }
+        for (const address of email.allowedUsers) {
+            out.push({
+                platform: 'email',
+                address,
+                target: `email:${address}`,
+                label: `Email ${address}`,
+                configured: true,
+            });
+        }
+        if (!email.homeAddress && !email.allowedUsers.length) {
+            out.push({
+                platform: 'email',
+                target: 'email',
+                label: 'Email configured but no home/allowed address',
+                configured: false,
+            });
+        }
+    }
+    const line = resolveLineConfig(config, env);
+    if (line.channelAccessToken) {
+        if (line.homeChannel) {
+            out.push({
+                platform: 'line',
+                address: line.homeChannel,
+                target: 'line',
+                label: `LINE home (${line.homeChannel})`,
+                configured: true,
+            });
+        }
+        for (const id of [...line.allowedUsers, ...line.allowedGroups, ...line.allowedRooms]) {
+            out.push({
+                platform: 'line',
+                address: id,
+                target: `line:${id}`,
+                label: `LINE ${id}`,
+                configured: true,
+            });
+        }
+        if (!line.homeChannel && !line.allowedUsers.length && !line.allowedGroups.length && !line.allowedRooms.length) {
+            out.push({
+                platform: 'line',
+                target: 'line',
+                label: 'LINE configured but no home/allowed channel',
+                configured: false,
+            });
+        }
+    }
+    const sms = resolveSmsConfig(config, env);
+    if (sms.accountSid && sms.authToken && sms.phoneNumber) {
+        if (sms.homeChannel) {
+            out.push({
+                platform: 'sms',
+                address: sms.homeChannel,
+                target: 'sms',
+                label: `SMS ${sms.homeChannelName ?? 'home'} (${sms.homeChannel})`,
+                configured: true,
+            });
+        }
+        for (const phone of sms.allowedUsers) {
+            out.push({
+                platform: 'sms',
+                address: phone,
+                target: `sms:${phone}`,
+                label: `SMS ${phone}`,
+                configured: true,
+            });
+        }
+        if (!sms.homeChannel && !sms.allowedUsers.length) {
+            out.push({
+                platform: 'sms',
+                target: 'sms',
+                label: 'SMS configured but no home/allowed phone',
+                configured: false,
+            });
+        }
+    }
+    const ntfy = resolveNtfyConfig(config, env);
+    if (ntfy.topic || ntfy.publishTopic || ntfy.token || ntfy.homeChannel) {
+        if (ntfy.homeChannel) {
+            out.push({
+                platform: 'ntfy',
+                address: ntfy.homeChannel,
+                target: 'ntfy',
+                label: `ntfy ${ntfy.homeChannelName ?? 'home'} (${ntfy.homeChannel})`,
+                configured: true,
+            });
+        }
+        const seen = new Set([ntfy.homeChannel].filter((v) => Boolean(v)));
+        for (const topic of [ntfy.topic, ntfy.publishTopic, ...ntfy.allowedUsers].filter((v) => Boolean(v?.trim()))) {
+            if (seen.has(topic))
+                continue;
+            seen.add(topic);
+            out.push({
+                platform: 'ntfy',
+                address: topic,
+                target: `ntfy:${topic}`,
+                label: `ntfy topic ${topic}`,
+                configured: true,
+            });
+        }
+        if (!ntfy.homeChannel && !ntfy.topic && !ntfy.publishTopic && !ntfy.allowedUsers.length) {
+            out.push({
+                platform: 'ntfy',
+                target: 'ntfy',
+                label: 'ntfy configured but no topic/home channel',
+                configured: false,
+            });
+        }
+    }
+    const signal = resolveSignalConfig(config, env);
+    if (signal.account || signal.httpUrl !== 'http://127.0.0.1:8080' || signal.homeChannel || signal.allowedUsers.length || signal.groupAllowedUsers.length) {
+        if (signal.homeChannel) {
+            const home = normalizeSignalId(signal.homeChannel) ?? signal.homeChannel;
+            out.push({
+                platform: 'signal',
+                address: home,
+                target: 'signal',
+                label: `Signal ${signal.homeChannelName ?? 'home'} (${redactSignalId(home)})`,
+                configured: Boolean(signal.account),
+            });
+        }
+        const seen = new Set([normalizeSignalId(signal.homeChannel)].filter((v) => Boolean(v)));
+        for (const id of signal.allowedUsers.map(normalizeSignalId).filter((v) => Boolean(v))) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({
+                platform: 'signal',
+                address: id,
+                target: `signal:${id}`,
+                label: `Signal ${redactSignalId(id)}`,
+                configured: Boolean(signal.account),
+            });
+        }
+        for (const id of signal.groupAllowedUsers) {
+            const targetId = id === '*' ? '*' : (normalizeSignalId(id)?.startsWith('group:') ? normalizeSignalId(id) : `group:${id.trim()}`);
+            if (!targetId || targetId === '*' || seen.has(targetId))
+                continue;
+            seen.add(targetId);
+            out.push({
+                platform: 'signal',
+                address: targetId,
+                target: `signal:${targetId}`,
+                label: `Signal group ${redactSignalId(targetId)}`,
+                configured: Boolean(signal.account),
+            });
+        }
+        if (!signal.homeChannel && !signal.allowedUsers.length && !signal.groupAllowedUsers.length) {
+            out.push({
+                platform: 'signal',
+                target: 'signal',
+                label: 'Signal configured but no home/allowed user',
+                configured: false,
+            });
+        }
+    }
+    const whatsapp = resolveWhatsAppConfig(config, env);
+    if (whatsapp.phoneNumberId || whatsapp.accessToken || whatsapp.homeChannel || whatsapp.allowedUsers.length) {
+        if (whatsapp.homeChannel) {
+            const home = normalizeWhatsAppId(whatsapp.homeChannel) ?? whatsapp.homeChannel;
+            out.push({
+                platform: 'whatsapp',
+                address: home,
+                target: 'whatsapp',
+                label: `WhatsApp ${whatsapp.homeChannelName ?? 'home'} (${redactWhatsAppId(home)})`,
+                configured: Boolean(whatsapp.phoneNumberId && whatsapp.accessToken),
+            });
+        }
+        const seen = new Set([normalizeWhatsAppId(whatsapp.homeChannel)].filter((v) => Boolean(v)));
+        for (const id of whatsapp.allowedUsers.map(normalizeWhatsAppId).filter((v) => Boolean(v))) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({
+                platform: 'whatsapp',
+                address: id,
+                target: `whatsapp:${id}`,
+                label: `WhatsApp ${redactWhatsAppId(id)}`,
+                configured: Boolean(whatsapp.phoneNumberId && whatsapp.accessToken),
+            });
+        }
+        if (!whatsapp.homeChannel && !whatsapp.allowedUsers.length) {
+            out.push({
+                platform: 'whatsapp',
+                target: 'whatsapp',
+                label: 'WhatsApp configured but no home/allowed user',
+                configured: false,
+            });
+        }
+    }
+    const matrix = resolveMatrixConfig(config, env);
+    if (matrix.homeserver || matrix.accessToken || matrix.userId || matrix.homeRoom || matrix.allowedRooms.length) {
+        if (matrix.homeRoom) {
+            out.push({
+                platform: 'matrix',
+                address: matrix.homeRoom,
+                target: 'matrix',
+                label: `Matrix ${matrix.homeRoomName ?? 'home'} (${matrix.homeRoom})`,
+                configured: Boolean(matrix.homeserver && (matrix.accessToken || (matrix.userId && matrix.password))),
+            });
+        }
+        const seen = new Set([matrix.homeRoom].filter((v) => Boolean(v)));
+        for (const room of matrix.allowedRooms) {
+            if (seen.has(room))
+                continue;
+            seen.add(room);
+            out.push({
+                platform: 'matrix',
+                address: room,
+                target: `matrix:${room}`,
+                label: `Matrix room ${room}`,
+                configured: Boolean(matrix.homeserver && (matrix.accessToken || (matrix.userId && matrix.password))),
+            });
+        }
+        if (!matrix.homeRoom && !matrix.allowedRooms.length) {
+            out.push({
+                platform: 'matrix',
+                target: 'matrix',
+                label: 'Matrix configured but no home/allowed room',
+                configured: false,
+            });
+        }
+    }
+    const googleChat = resolveGoogleChatConfig(config, env);
+    if (googleChat.serviceAccountJson ||
+        googleChat.incomingWebhookUrl ||
+        googleChat.homeChannel ||
+        googleChat.allowedSpaces.length ||
+        googleChat.subscriptionName) {
+        const chatApiReady = Boolean(googleChat.serviceAccountJson);
+        const webhookReady = Boolean(googleChat.incomingWebhookUrl);
+        if (googleChat.homeChannel || googleChat.incomingWebhookUrl) {
+            const address = googleChat.homeChannel || 'webhook';
+            out.push({
+                platform: 'googlechat',
+                address,
+                target: 'googlechat',
+                label: `Google Chat ${googleChat.homeChannelName ?? (googleChat.homeChannel ? `home (${googleChat.homeChannel})` : 'webhook')}`,
+                configured: address === 'webhook' ? webhookReady : chatApiReady,
+            });
+        }
+        const seen = new Set([googleChat.homeChannel].filter((v) => Boolean(v)));
+        for (const space of googleChat.allowedSpaces) {
+            if (seen.has(space))
+                continue;
+            seen.add(space);
+            out.push({
+                platform: 'googlechat',
+                address: space,
+                target: `googlechat:${space}`,
+                label: `Google Chat space ${space}`,
+                configured: chatApiReady,
+            });
+        }
+        if (!googleChat.homeChannel && !googleChat.incomingWebhookUrl && !googleChat.allowedSpaces.length) {
+            out.push({
+                platform: 'googlechat',
+                target: 'googlechat',
+                label: 'Google Chat configured but no home/allowed target',
+                configured: false,
+            });
+        }
+    }
+    const bluebubbles = resolveBlueBubblesConfig(config, env);
+    if (bluebubbles.serverUrl || bluebubbles.password || bluebubbles.homeChannel || bluebubbles.allowedUsers.length) {
+        const configured = Boolean(bluebubbles.serverUrl && bluebubbles.password);
+        if (bluebubbles.homeChannel) {
+            out.push({
+                platform: 'bluebubbles',
+                address: bluebubbles.homeChannel,
+                target: 'bluebubbles',
+                label: `BlueBubbles ${bluebubbles.homeChannelName ?? 'home'} (${bluebubbles.homeChannel})`,
+                configured,
+            });
+        }
+        const seen = new Set([bluebubbles.homeChannel].filter((v) => Boolean(v)));
+        for (const user of bluebubbles.allowedUsers) {
+            if (seen.has(user))
+                continue;
+            seen.add(user);
+            out.push({
+                platform: 'bluebubbles',
+                address: user,
+                target: `bluebubbles:${user}`,
+                label: `BlueBubbles target ${user}`,
+                configured,
+            });
+        }
+        if (!bluebubbles.homeChannel && !bluebubbles.allowedUsers.length) {
+            out.push({
+                platform: 'bluebubbles',
+                target: 'bluebubbles',
+                label: 'BlueBubbles configured but no home/allowed target',
+                configured: false,
+            });
+        }
+    }
+    const teams = resolveTeamsConfig(config, env);
+    if (teams.incomingWebhookUrl ||
+        teams.graphAccessToken ||
+        teams.chatId ||
+        teams.homeChannel ||
+        (teams.teamId && teams.channelId) ||
+        teams.clientId) {
+        const configured = teams.deliveryMode === 'graph'
+            ? Boolean(teams.graphAccessToken && (teams.chatId || teams.homeChannel || (teams.teamId && teams.channelId)))
+            : Boolean(teams.incomingWebhookUrl);
+        const address = teams.homeChannel ||
+            teams.chatId ||
+            (teams.teamId && teams.channelId ? `team/${teams.teamId}/channel/${teams.channelId}` : undefined);
+        out.push({
+            platform: 'teams',
+            address,
+            target: 'teams',
+            label: `Microsoft Teams ${teams.homeChannelName ?? (address ? `target (${address})` : 'configured')}`,
+            configured,
+        });
+    }
+    return out;
+}

package/dist/gateway/teams.js

@@ -0,0 +1,106 @@
+import { redactKey } from '../providers/keys.js';
+const TEAMS_TEXT_LIMIT = 28_000;
+const GRAPH_ROOT = 'https://graph.microsoft.com/v1.0';
+export function normalizeTeamsWebhookUrl(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol !== 'https:')
+            return undefined;
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function truncateTeamsText(raw, limit = TEAMS_TEXT_LIMIT) {
+    const text = raw.trim() || '(ไม่มีผลลัพธ์)';
+    return text.length <= limit ? text : `${text.slice(0, Math.max(1, limit - 3)).trimEnd()}...`;
+}
+export function teamsGraphAuthHeaders(token, extra = {}) {
+    const clean = token?.trim();
+    if (!clean)
+        throw new Error('Microsoft Teams Graph access token ว่าง');
+    return { authorization: `Bearer ${clean}`, ...extra };
+}
+function escapeHtml(raw) {
+    return raw
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+export function teamsGraphHtml(raw) {
+    return escapeHtml(truncateTeamsText(raw)).replace(/\n/g, '<br>');
+}
+export function teamsGraphMessageUrl(config, explicitTarget) {
+    const target = explicitTarget?.trim();
+    if (target?.startsWith('team/')) {
+        const match = /^team\/([^/]+)\/channel\/(.+)$/.exec(target);
+        if (!match)
+            throw new Error('Teams target ต้องเป็น teams:team/<team-id>/channel/<channel-id>');
+        return {
+            url: `${GRAPH_ROOT}/teams/${encodeURIComponent(match[1])}/channels/${encodeURIComponent(match[2])}/messages`,
+            target,
+        };
+    }
+    const chatId = target || config.chatId || config.homeChannel;
+    if (chatId)
+        return { url: `${GRAPH_ROOT}/chats/${encodeURIComponent(chatId)}/messages`, target: chatId };
+    if (config.teamId && config.channelId) {
+        return {
+            url: `${GRAPH_ROOT}/teams/${encodeURIComponent(config.teamId)}/channels/${encodeURIComponent(config.channelId)}/messages`,
+            target: `team/${config.teamId}/channel/${config.channelId}`,
+        };
+    }
+    throw new Error('Teams Graph delivery ต้องมี TEAMS_CHAT_ID หรือ TEAMS_TEAM_ID + TEAMS_CHANNEL_ID');
+}
+async function readTeamsJsonOrThrow(response, label) {
+    const text = await response.text().catch(() => '');
+    if (!response.ok)
+        throw new Error(`${label} ${response.status}${text ? `: ${redactKey(text).slice(0, 240)}` : ''}`);
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} ${response.status}: response ไม่ใช่ JSON: ${redactKey(text).slice(0, 240)}`);
+    }
+}
+export async function sendTeamsMessage(config, text, explicitTarget) {
+    const target = explicitTarget?.trim();
+    const targetLooksLikeWebhook = /^https:\/\//i.test(target ?? '');
+    const targetWebhookUrl = targetLooksLikeWebhook ? normalizeTeamsWebhookUrl(target) : undefined;
+    if (targetLooksLikeWebhook && !targetWebhookUrl)
+        throw new Error('Teams incoming webhook target ต้องเป็น HTTPS URL ที่ถูกต้อง');
+    const useWebhook = Boolean(targetWebhookUrl) || (!target && config.deliveryMode === 'incoming_webhook');
+    if (useWebhook) {
+        const webhookUrl = targetWebhookUrl ?? config.incomingWebhookUrl;
+        if (!webhookUrl)
+            throw new Error('ยังไม่ได้ตั้ง Microsoft Teams incoming webhook URL');
+        const r = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ text: truncateTeamsText(text) }),
+        });
+        await readTeamsJsonOrThrow(r, 'Microsoft Teams incoming webhook');
+        return { mode: 'incoming_webhook', target: targetWebhookUrl ? 'webhook' : config.homeChannel || 'webhook', messageCount: 1 };
+    }
+    const graph = teamsGraphMessageUrl(config, target);
+    const r = await fetch(graph.url, {
+        method: 'POST',
+        headers: teamsGraphAuthHeaders(config.graphAccessToken, { 'content-type': 'application/json' }),
+        body: JSON.stringify({
+            body: {
+                contentType: 'html',
+                content: teamsGraphHtml(text),
+            },
+        }),
+    });
+    const json = await readTeamsJsonOrThrow(r, 'Microsoft Teams Graph message');
+    return { mode: 'graph', target: graph.target, messageId: json.id, messageCount: 1 };
+}