sanook-cli 0.5.0 → 0.5.2

package/dist/gateway/ntfy.js

@@ -0,0 +1,218 @@
+import { BRAND } from '../brand.js';
+import { redactKey } from '../providers/keys.js';
+import { runGatewayAgent } from './session.js';
+const NTFY_MESSAGE_LIMIT_BYTES = 4096;
+const NTFY_REPLY_TITLE = BRAND.productName;
+const runningTargets = new Set();
+function truthyHeader(value) {
+    return value === 'true' || value === '1' || value === 'yes';
+}
+export function ntfyAuthHeader(token) {
+    const trimmed = token?.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.includes(':'))
+        return `Basic ${Buffer.from(trimmed, 'utf8').toString('base64')}`;
+    return `Bearer ${trimmed}`;
+}
+export function ntfyTopicUrl(serverUrl, topic, suffix = '') {
+    const base = (serverUrl || 'https://ntfy.sh').replace(/\/+$/, '');
+    return `${base}/${encodeURIComponent(topic.trim())}${suffix}`;
+}
+export function truncateNtfyMessage(raw, limitBytes = NTFY_MESSAGE_LIMIT_BYTES) {
+    const text = raw.trim() || '(ไม่มีผลลัพธ์)';
+    if (Buffer.byteLength(text, 'utf8') <= limitBytes)
+        return { text, truncated: false };
+    const suffix = '...';
+    const budget = Math.max(1, limitBytes - Buffer.byteLength(suffix, 'utf8'));
+    let out = '';
+    let used = 0;
+    for (const ch of text) {
+        const next = Buffer.byteLength(ch, 'utf8');
+        if (used + next > budget)
+            break;
+        out += ch;
+        used += next;
+    }
+    return { text: `${out.trimEnd()}${suffix}`, truncated: true };
+}
+export async function sendNtfyMessage(config, topic, text, options = {}) {
+    const targetTopic = topic.trim();
+    if (!targetTopic)
+        throw new Error('ntfy topic ว่าง');
+    const body = truncateNtfyMessage(text);
+    const headers = {
+        'content-type': options.markdown ?? config.markdown ? 'text/markdown; charset=utf-8' : 'text/plain; charset=utf-8',
+        title: options.title?.trim() || NTFY_REPLY_TITLE,
+    };
+    const auth = ntfyAuthHeader(config.token);
+    if (auth)
+        headers.authorization = auth;
+    if (options.markdown ?? config.markdown)
+        headers.markdown = 'yes';
+    const r = await fetch(ntfyTopicUrl(config.serverUrl, targetTopic), {
+        method: 'POST',
+        headers,
+        body: body.text,
+    });
+    if (!r.ok) {
+        const detail = await r.text().catch(() => '');
+        throw new Error(`ntfy publish ${r.status}${detail ? `: ${redactKey(detail).slice(0, 200)}` : ''}`);
+    }
+    const parsed = (await r.json().catch(() => ({})));
+    return { topic: targetTopic, messageId: parsed.id, messageCount: 1, truncated: body.truncated };
+}
+export function parseNtfyJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const event = parsed;
+    if (event.event !== 'message')
+        return null;
+    if (typeof event.message !== 'string' || !event.message.trim())
+        return null;
+    return event;
+}
+export function isAllowedNtfyTopic(config, topic) {
+    if (config.allowAllUsers)
+        return true;
+    const target = topic?.trim();
+    if (!target)
+        return false;
+    const allowed = new Set([config.topic, config.homeChannel, ...config.allowedUsers].filter((v) => Boolean(v?.trim())));
+    return allowed.has(target);
+}
+function ntfyPrompt(event, topic) {
+    const parts = [`ntfy topic ${topic}:`, event.message?.trim() || '(empty)'];
+    if (event.title?.trim() && event.title !== NTFY_REPLY_TITLE)
+        parts.splice(1, 0, `title: ${event.title.trim()}`);
+    return parts.join('\n');
+}
+export async function handleNtfyEvent(opts) {
+    const event = opts.event;
+    if (event.event !== 'message' || !event.message?.trim())
+        return { handled: false, reason: 'ignored_event' };
+    if (event.title === NTFY_REPLY_TITLE || truthyHeader(String(event.sanookReply ?? ''))) {
+        return { handled: false, reason: 'self_message' };
+    }
+    const topic = event.topic?.trim() || opts.config.topic?.trim();
+    if (!isAllowedNtfyTopic(opts.config, topic)) {
+        opts.onLog?.(`ntfy: ปฏิเสธ topic ${topic ?? '(unknown)'} (ไม่อยู่ใน allowlist)`);
+        return { handled: false, reason: 'not_allowed' };
+    }
+    if (!topic)
+        return { handled: false, reason: 'missing_topic' };
+    const running = opts.runningTargets ?? runningTargets;
+    if (running.has(topic))
+        return { handled: false, reason: 'busy' };
+    running.add(topic);
+    try {
+        const result = await runGatewayAgent({
+            platform: 'ntfy',
+            target: topic,
+            model: opts.model,
+            prompt: ntfyPrompt(event, topic),
+            userText: event.message.trim(),
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+        });
+        if (!result.suppressDelivery) {
+            await sendNtfyMessage(opts.config, opts.config.publishTopic || topic, result.text || '(ไม่มีผลลัพธ์)', { title: NTFY_REPLY_TITLE });
+        }
+        return { handled: true };
+    }
+    catch (e) {
+        opts.onLog?.(`ntfy run error (${topic}): ${redactKey(e.message)}`);
+        await sendNtfyMessage(opts.config, opts.config.publishTopic || topic, 'เกิดข้อผิดพลาดภายใน', { title: NTFY_REPLY_TITLE }).catch(() => { });
+        return { handled: false, reason: 'error' };
+    }
+    finally {
+        running.delete(topic);
+    }
+}
+async function delay(ms, signal) {
+    if (signal.aborted)
+        return;
+    await new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+async function readNtfyStream(response, opts, signal) {
+    if (!response.body)
+        throw new Error('ntfy stream ไม่มี response body');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let pending = '';
+    for (;;) {
+        const { done, value } = await reader.read();
+        pending += decoder.decode(value, { stream: !done });
+        const lines = pending.split(/\r?\n/);
+        pending = lines.pop() ?? '';
+        for (const line of lines) {
+            if (signal.aborted)
+                return;
+            try {
+                const event = parseNtfyJsonLine(line);
+                if (event)
+                    await handleNtfyEvent({ ...opts, event, runningTargets });
+            }
+            catch (e) {
+                opts.onLog?.(`ntfy parse error: ${redactKey(e.message)}`);
+            }
+        }
+        if (done)
+            break;
+    }
+    const last = pending.trim();
+    if (last && !signal.aborted) {
+        const event = parseNtfyJsonLine(last);
+        if (event)
+            await handleNtfyEvent({ ...opts, event, runningTargets });
+    }
+}
+export function startNtfy(opts) {
+    const topic = opts.config.topic?.trim();
+    if (!topic) {
+        opts.onLog?.('ntfy ไม่เริ่ม: ต้องตั้ง NTFY_TOPIC หรือ gateway setup ntfy --topic');
+        return () => { };
+    }
+    if (!isAllowedNtfyTopic(opts.config, topic)) {
+        opts.onLog?.('ntfy ไม่เริ่ม: ต้องตั้ง NTFY_ALLOWED_USERS ให้รวม topic หรือระบุ --allow-all-users เพื่อ fail-closed');
+        return () => { };
+    }
+    const controller = new AbortController();
+    const reconnectMs = opts.reconnectMs ?? 5000;
+    const headers = { accept: 'application/x-ndjson' };
+    const auth = ntfyAuthHeader(opts.config.token);
+    if (auth)
+        headers.authorization = auth;
+    const loop = async () => {
+        opts.onLog?.(`ntfy: subscribe ${ntfyTopicUrl(opts.config.serverUrl, topic, '/json?since=1s')}`);
+        while (!controller.signal.aborted) {
+            try {
+                const r = await fetch(ntfyTopicUrl(opts.config.serverUrl, topic, '/json?since=1s'), {
+                    method: 'GET',
+                    headers,
+                    signal: controller.signal,
+                });
+                if (!r.ok)
+                    throw new Error(`ntfy subscribe ${r.status}`);
+                await readNtfyStream(r, opts, controller.signal);
+            }
+            catch (e) {
+                if (!controller.signal.aborted)
+                    opts.onLog?.(`ntfy stream error: ${redactKey(e.message)}; reconnecting`);
+            }
+            await delay(reconnectMs, controller.signal);
+        }
+    };
+    void loop();
+    return () => controller.abort();
+}

package/dist/gateway/schedule.js

@@ -2,7 +2,23 @@
 // support: interval ("every 30m" / "2h"), daily ("09:00"), ISO timestamp (one-shot), "now"
 // pure — รับ now เป็น param (ไม่เรียก Date.now ใน body หลัก) เพื่อ test ได้
 const UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+const MAX_DATE_MS = 8_640_000_000_000_000;
 const pad = (n) => String(n).padStart(2, '0');
+function isValidEpochMs(value) {
+    return Number.isSafeInteger(value) && Math.abs(value) <= MAX_DATE_MS;
+}
+function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function isValidCalendarDate(year, month, day) {
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    const daysInMonth = [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return day <= daysInMonth[month - 1];
+}
+function isValidClockTime(hour, minute) {
+    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+}
 /** next occurrence ของ HH:MM (local time) หลัง now */
 function nextDaily(minutesOfDay, now) {
     const target = new Date(now);
@@ -15,6 +31,8 @@ export function parseSchedule(input, now) {
     const s = input.trim().toLowerCase();
     if (!s)
         return null;
+    if (!isValidEpochMs(now))
+        return null;
     if (s === 'now' || s === 'immediately') {
         return { runAt: now, recurring: false, kind: 'once', normalized: 'now' };
     }
@@ -24,10 +42,11 @@ export function parseSchedule(input, now) {
         const n = parseInt(iv[1], 10);
         const unit = iv[2][0]; // s/m/h/d (ตัวแรกพอ)
         const ms = n * (UNIT_MS[unit] ?? 0);
+        const runAt = now + ms;
         // กัน overflow → runAt เป็น Invalid Date ที่ due() ไม่มีวันยิง
-        if (!Number.isSafeInteger(ms) || ms <= 0 || !Number.isFinite(now + ms))
+        if (!Number.isSafeInteger(ms) || ms <= 0 || !isValidEpochMs(runAt))
             return null;
-        return { runAt: now + ms, recurring: true, kind: 'cron', normalized: `every ${n}${unit}` };
+        return { runAt, recurring: true, kind: 'cron', normalized: `every ${n}${unit}` };
     }
     // daily time: "09:00" | "at 9:00" | "daily 09:30"
     const dt = s.match(/^(?:at\s+|daily\s+(?:at\s+)?)?(\d{1,2}):(\d{2})$/);
@@ -37,7 +56,10 @@ export function parseSchedule(input, now) {
         if (hh > 23 || mm > 59)
             return null;
         const mins = hh * 60 + mm;
-        return { runAt: nextDaily(mins, now), recurring: true, kind: 'cron', normalized: `${pad(hh)}:${pad(mm)}` };
+        const runAt = nextDaily(mins, now);
+        if (!isValidEpochMs(runAt))
+            return null;
+        return { runAt, recurring: true, kind: 'cron', normalized: `${pad(hh)}:${pad(mm)}` };
     }
     // ── NL ภาษาไทย / aliases → map เป็น canonical แล้ว parse ซ้ำ ──
     if (/^(ทุก\s*ๆ?\s*)?(ชั่วโมง|ชม\.?|hourly)$/.test(s))
@@ -57,7 +79,12 @@ export function parseSchedule(input, now) {
         return parseSchedule(`${thDaily[1]}:${thDaily[2]}`, now);
     // ISO timestamp (one-shot) — รับเฉพาะรูปแบบที่มี date จริง (กัน Date.parse รับ bare number/year-only กำกวม)
     const raw = input.trim();
-    if (/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}|$)/.test(raw)) {
+    const iso = raw.match(/^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})|$)/);
+    if (iso) {
+        if (!isValidCalendarDate(Number(iso[1]), Number(iso[2]), Number(iso[3])))
+            return null;
+        if (iso[4] !== undefined && !isValidClockTime(Number(iso[4]), Number(iso[5])))
+            return null;
         const t = Date.parse(raw);
         if (!Number.isNaN(t)) {
             if (t < now)

package/dist/gateway/serve.js

@@ -1,10 +1,10 @@
-import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { acquireSingleton } from './lock.js';
-import { loadOrCreateToken } from './auth.js';
+import { ensureGatewayDir, loadOrCreateToken } from './auth.js';
 import { startServer } from './server.js';
 import { startScheduler } from './scheduler.js';
 import { appHomePath, BRAND, BRAND_ENV, envFlag } from '../brand.js';
+import { readGatewayConfig, resolveDiscordConfig, resolveEmailConfig, resolveHomeAssistantConfig, resolveLineConfig, resolveMattermostConfig, resolveMatrixConfig, resolveNtfyConfig, resolveSignalConfig, resolveSlackConfig, resolveSmsConfig, resolveTelegramConfig, resolveWhatsAppConfig, resolveWebhookConfig, } from './config.js';
 const GATEWAY_DIR = appHomePath('gateway');
 const SERVE_LOCK = join(GATEWAY_DIR, 'serve.lock');
 /**
@@ -15,7 +15,7 @@ const SERVE_LOCK = join(GATEWAY_DIR, 'serve.lock');
  */
 export async function startGateway(opts) {
     const log = opts.onLog ?? ((m) => console.log(`[gateway] ${m}`));
-    await mkdir(GATEWAY_DIR, { recursive: true });
+    await ensureGatewayDir();
     const release = await acquireSingleton(SERVE_LOCK);
     if (!release) {
         throw new Error(`มี ${BRAND.cliName} gateway รันอยู่แล้ว (เจอ serve.lock) — ปิดตัวเดิมก่อน หรือถ้าค้างให้ลบ ${appHomePath('gateway', 'serve.lock')}`);
@@ -35,25 +35,285 @@ export async function startGateway(opts) {
         permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
         tickMs: opts.tickMs,
         onLog: log,
+        deliver: async (task, output) => {
+            if (!task.deliver)
+                return;
+            const { deliverToTarget } = await import('./deliver.js');
+            const result = await deliverToTarget(task.deliver, output, { subject: `${BRAND.productName} task ${task.id}` });
+            log(`delivered ${task.id} → ${result.target}`);
+        },
     });
-    // Telegram channel (ถ้าตั้ง TELEGRAM_BOT_TOKEN) — long-polling, ไม่ต้อง public URL
+    // Telegram channel (env หรือ ~/.sanook/gateway/config.json) — long-polling, ไม่ต้อง public URL
     let stopTelegram;
-    if (process.env.TELEGRAM_BOT_TOKEN) {
+    let stopDiscord;
+    let stopSlack;
+    let stopMattermost;
+    let stopHomeAssistant;
+    let stopEmail;
+    let stopNtfy;
+    let stopSignal;
+    let stopMatrix;
+    const gatewayConfig = await readGatewayConfig();
+    const telegram = resolveTelegramConfig(gatewayConfig);
+    if (telegram.enabled && telegram.token) {
         const { startTelegram, parseAllowedChats } = await import('./telegram.js');
         stopTelegram = startTelegram({
-            token: process.env.TELEGRAM_BOT_TOKEN,
+            token: telegram.token,
             model: opts.model,
             budgetUsd: opts.budgetUsd,
-            allowedChatIds: parseAllowedChats(process.env.TELEGRAM_ALLOWED_CHATS),
+            allowedChatIds: process.env.TELEGRAM_ALLOWED_CHATS ? parseAllowedChats(process.env.TELEGRAM_ALLOWED_CHATS) : telegram.allowedChatIds,
+            allowWrite: telegram.allowWrite,
             onLog: log,
         });
         // หมายเหตุ: log "เริ่มแล้ว" อยู่ใน startTelegram (success path) — ถ้า fail-closed จะ log "ไม่เริ่ม" แทน
     }
+    const discord = resolveDiscordConfig(gatewayConfig);
+    if (discord.enabled && discord.token) {
+        const { startDiscord } = await import('./discord.js');
+        try {
+            stopDiscord = startDiscord({
+                token: discord.token,
+                model: opts.model,
+                budgetUsd: opts.budgetUsd,
+                allowedChannelIds: discord.allowedChannelIds,
+                defaultChannelId: discord.defaultChannelId,
+                allowWrite: discord.allowWrite,
+                onLog: log,
+            });
+        }
+        catch (e) {
+            log(`Discord ไม่เริ่ม: ${e.message}`);
+        }
+    }
+    const slack = resolveSlackConfig(gatewayConfig);
+    if (slack.enabled && slack.botToken) {
+        if (!slack.appToken) {
+            log('Slack ไม่เริ่ม: ต้องตั้ง SLACK_APP_TOKEN หรือ gateway setup slack --app-token สำหรับ Socket Mode');
+        }
+        else {
+            const { startSlack } = await import('./slack.js');
+            try {
+                stopSlack = await startSlack({
+                    botToken: slack.botToken,
+                    appToken: slack.appToken,
+                    model: opts.model,
+                    budgetUsd: opts.budgetUsd,
+                    allowedChannelIds: slack.allowedChannelIds,
+                    defaultChannelId: slack.defaultChannelId,
+                    allowWrite: slack.allowWrite,
+                    onLog: log,
+                });
+            }
+            catch (e) {
+                log(`Slack ไม่เริ่ม: ${e.message}`);
+            }
+        }
+    }
+    const mattermost = resolveMattermostConfig(gatewayConfig);
+    if (mattermost.enabled && (mattermost.serverUrl || mattermost.token || mattermost.homeChannel || mattermost.allowedUsers.length || mattermost.allowedChannels.length)) {
+        if (!mattermost.serverUrl) {
+            log('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_URL เช่น https://mm.example.com');
+        }
+        else if (!mattermost.token) {
+            log('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_TOKEN');
+        }
+        else if (!mattermost.allowAllUsers && !mattermost.allowedUsers.length) {
+            log('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_ALLOWED_USERS เพื่อ fail-closed');
+        }
+        else {
+            const { startMattermost } = await import('./mattermost.js');
+            try {
+                stopMattermost = await startMattermost({
+                    config: mattermost,
+                    model: opts.model,
+                    budgetUsd: opts.budgetUsd,
+                    permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
+                    onLog: log,
+                });
+            }
+            catch (e) {
+                log(`Mattermost ไม่เริ่ม: ${e.message}`);
+            }
+        }
+    }
+    const homeassistant = resolveHomeAssistantConfig(gatewayConfig);
+    if (homeassistant.enabled && (homeassistant.token || homeassistant.homeChannel || homeassistant.watchAll || homeassistant.watchDomains.length || homeassistant.watchEntities.length)) {
+        if (!homeassistant.token) {
+            log('Home Assistant ไม่เริ่ม: ต้องตั้ง HASS_TOKEN');
+        }
+        else {
+            const { startHomeAssistant } = await import('./homeassistant.js');
+            try {
+                stopHomeAssistant = startHomeAssistant({
+                    config: homeassistant,
+                    model: opts.model,
+                    budgetUsd: opts.budgetUsd,
+                    permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
+                    onLog: log,
+                });
+            }
+            catch (e) {
+                log(`Home Assistant ไม่เริ่ม: ${e.message}`);
+            }
+        }
+    }
+    const email = resolveEmailConfig(gatewayConfig);
+    if (email.enabled && email.address) {
+        if (!email.password || !email.imapHost || !email.smtpHost) {
+            log('Email ไม่เริ่ม: ต้องตั้ง password, imapHost และ smtpHost ให้ครบ');
+        }
+        else {
+            const { startEmail } = await import('./email.js');
+            stopEmail = startEmail({
+                address: email.address,
+                password: email.password,
+                imapHost: email.imapHost,
+                imapPort: email.imapPort,
+                smtpHost: email.smtpHost,
+                smtpPort: email.smtpPort,
+                homeAddress: email.homeAddress,
+                allowedUsers: email.allowedUsers,
+                allowAllUsers: email.allowAllUsers,
+                pollIntervalSeconds: email.pollIntervalSeconds,
+                model: opts.model,
+                budgetUsd: opts.budgetUsd,
+                allowWrite: false,
+                onLog: log,
+            });
+        }
+    }
+    const line = resolveLineConfig(gatewayConfig);
+    if (line.enabled && line.channelAccessToken) {
+        if (!line.channelSecret) {
+            log('LINE webhook ไม่เริ่ม: ต้องตั้ง LINE_CHANNEL_SECRET หรือ gateway setup line --channel-secret');
+        }
+        else if (!line.homeChannel && !line.allowedUsers.length && !line.allowedGroups.length && !line.allowedRooms.length && !line.allowAllUsers) {
+            log('LINE webhook ไม่เริ่ม: ต้องตั้ง home channel หรือ allowlist เพื่อ fail-closed');
+        }
+        else {
+            const publicBase = line.publicUrl ? `${line.publicUrl.replace(/\/+$/, '')}/line/webhook` : `http://127.0.0.1:${opts.port}/line/webhook`;
+            log(`LINE: webhook ready at ${publicBase}`);
+        }
+    }
+    const sms = resolveSmsConfig(gatewayConfig);
+    if (sms.enabled && (sms.accountSid || sms.authToken || sms.phoneNumber)) {
+        if (!sms.accountSid || !sms.authToken || !sms.phoneNumber) {
+            log('SMS webhook ไม่เริ่ม: ต้องตั้ง TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN และ TWILIO_PHONE_NUMBER ให้ครบ');
+        }
+        else if (!sms.insecureNoSignature && !sms.webhookUrl) {
+            log('SMS webhook ไม่เริ่ม: ต้องตั้ง SMS_WEBHOOK_URL ให้ตรงกับ Twilio Console เพื่อ verify signature');
+        }
+        else if (!sms.homeChannel && !sms.allowedUsers.length && !sms.allowAllUsers) {
+            log('SMS webhook ไม่เริ่ม: ต้องตั้ง home channel หรือ allowlist เพื่อ fail-closed');
+        }
+        else {
+            const publicBase = sms.webhookUrl || `http://127.0.0.1:${opts.port}/sms/webhook`;
+            log(`SMS: Twilio webhook ready at ${publicBase}`);
+        }
+    }
+    const ntfy = resolveNtfyConfig(gatewayConfig);
+    if (ntfy.enabled && (ntfy.topic || ntfy.publishTopic || ntfy.homeChannel || ntfy.token)) {
+        if (!ntfy.topic) {
+            log('ntfy ไม่เริ่ม: ต้องตั้ง NTFY_TOPIC หรือ gateway setup ntfy --topic สำหรับ inbound subscribe');
+        }
+        else if (!ntfy.allowAllUsers && ![ntfy.topic, ntfy.homeChannel, ...ntfy.allowedUsers].filter(Boolean).includes(ntfy.topic)) {
+            log('ntfy ไม่เริ่ม: ต้องตั้ง NTFY_ALLOWED_USERS ให้รวม topic หรือระบุ --allow-all-users เพื่อ fail-closed');
+        }
+        else {
+            const { startNtfy } = await import('./ntfy.js');
+            stopNtfy = startNtfy({
+                config: ntfy,
+                model: opts.model,
+                budgetUsd: opts.budgetUsd,
+                permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
+                onLog: log,
+            });
+        }
+    }
+    const signal = resolveSignalConfig(gatewayConfig);
+    if (signal.enabled && (signal.account || signal.homeChannel || signal.allowedUsers.length || signal.groupAllowedUsers.length)) {
+        if (!signal.account) {
+            log('Signal ไม่เริ่ม: ต้องตั้ง SIGNAL_ACCOUNT หรือ gateway setup signal --account <+E.164>');
+        }
+        else if (!signal.allowAllUsers && !signal.homeChannel && !signal.allowedUsers.length && !signal.groupAllowedUsers.length) {
+            log('Signal ไม่เริ่ม: ต้องตั้ง home channel หรือ allowlist เพื่อ fail-closed');
+        }
+        else {
+            const { startSignal } = await import('./signal.js');
+            stopSignal = startSignal({
+                config: signal,
+                model: opts.model,
+                budgetUsd: opts.budgetUsd,
+                permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
+                onLog: log,
+            });
+        }
+    }
+    const whatsapp = resolveWhatsAppConfig(gatewayConfig);
+    if (whatsapp.enabled && (whatsapp.phoneNumberId || whatsapp.accessToken || whatsapp.homeChannel || whatsapp.allowedUsers.length)) {
+        if (!whatsapp.phoneNumberId || !whatsapp.accessToken) {
+            log('WhatsApp Cloud webhook ไม่เริ่ม: ต้องตั้ง WHATSAPP_CLOUD_PHONE_NUMBER_ID และ WHATSAPP_CLOUD_ACCESS_TOKEN ให้ครบ');
+        }
+        else if (!whatsapp.appSecret) {
+            log('WhatsApp Cloud webhook ไม่เริ่ม: ต้องตั้ง WHATSAPP_CLOUD_APP_SECRET เพื่อ verify X-Hub-Signature-256');
+        }
+        else if (!whatsapp.verifyToken) {
+            log('WhatsApp Cloud webhook ไม่เริ่ม: ต้องตั้ง WHATSAPP_CLOUD_VERIFY_TOKEN สำหรับ Meta webhook verify handshake');
+        }
+        else if (!whatsapp.homeChannel && !whatsapp.allowedUsers.length && !whatsapp.allowAllUsers) {
+            log('WhatsApp Cloud webhook ไม่เริ่ม: ต้องตั้ง home channel หรือ allowlist เพื่อ fail-closed');
+        }
+        else {
+            const publicBase = whatsapp.publicUrl ? `${whatsapp.publicUrl.replace(/\/+$/, '')}/whatsapp/webhook` : `http://127.0.0.1:${opts.port}/whatsapp/webhook`;
+            log(`WhatsApp Cloud: webhook ready at ${publicBase}`);
+        }
+    }
+    const matrix = resolveMatrixConfig(gatewayConfig);
+    if (matrix.enabled && (matrix.homeserver || matrix.accessToken || matrix.userId || matrix.homeRoom || matrix.allowedUsers.length || matrix.allowedRooms.length)) {
+        if (!matrix.homeserver) {
+            log('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_HOMESERVER เช่น https://matrix.org');
+        }
+        else if (!matrix.accessToken && (!matrix.userId || !matrix.password)) {
+            log('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_ACCESS_TOKEN หรือ MATRIX_USER_ID/MATRIX_PASSWORD');
+        }
+        else if (!matrix.allowAllUsers && !matrix.allowedUsers.length) {
+            log('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_ALLOWED_USERS เพื่อ fail-closed');
+        }
+        else {
+            const { startMatrix } = await import('./matrix.js');
+            stopMatrix = startMatrix({
+                config: matrix,
+                model: opts.model,
+                budgetUsd: opts.budgetUsd,
+                permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
+                onLog: log,
+            });
+        }
+    }
+    const webhooks = resolveWebhookConfig(gatewayConfig);
+    if (webhooks.enabled) {
+        const routes = Object.keys(webhooks.routes);
+        if (!routes.length) {
+            log('Webhooks เปิดอยู่ แต่ยังไม่มี route — เพิ่มด้วย sanook webhook subscribe <name>');
+        }
+        else {
+            const base = webhooks.publicUrl ? `${webhooks.publicUrl.replace(/\/+$/, '')}/webhooks` : `http://127.0.0.1:${opts.port}/webhooks`;
+            log(`Webhooks: ${routes.length} route(s) ready at ${base}/<route>`);
+        }
+    }
     log(`scheduler tick ทุก ${(opts.tickMs ?? 60_000) / 1000}s · token: ${appHomePath('gateway', 'token')} (chmod 600)`);
     return () => {
         stopServer();
         stopScheduler();
         stopTelegram?.();
+        stopDiscord?.();
+        stopSlack?.();
+        stopMattermost?.();
+        stopHomeAssistant?.();
+        stopEmail?.();
+        stopNtfy?.();
+        stopSignal?.();
+        stopMatrix?.();
         release(); // ปล่อย single-instance lock (sync — ทันก่อน process.exit ตัด event loop)
     };
 }