sanook-cli 0.5.0 → 0.5.2

package/dist/gateway/matrix.js

@@ -0,0 +1,366 @@
+import { BRAND } from '../brand.js';
+import { redactKey } from '../providers/keys.js';
+import { runGatewayAgent } from './session.js';
+const MATRIX_TEXT_LIMIT = 4000;
+const MATRIX_STARTUP_GRACE_MS = 5000;
+const runningTargets = new Set();
+export function normalizeMatrixHomeserver(raw) {
+    const trimmed = raw?.trim().replace(/\/+$/, '');
+    if (!trimmed)
+        return undefined;
+    if (!/^https?:\/\//i.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+export function normalizeMatrixUserId(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    return /^@[^:\s]+:[^:\s]+$/.test(trimmed) ? trimmed : undefined;
+}
+export function normalizeMatrixRoomId(raw) {
+    const trimmed = raw?.trim();
+    if (!trimmed)
+        return undefined;
+    return /^[!#][^:\s]+:[^:\s]+(?::\d+)?$/.test(trimmed) ? trimmed : undefined;
+}
+export function redactMatrixToken(raw) {
+    const token = raw?.trim();
+    if (!token)
+        return '(not set)';
+    if (token.length <= 10)
+        return '<redacted>';
+    return `${token.slice(0, 4)}…${token.slice(-4)}`;
+}
+export function matrixClientUrl(config, path, params) {
+    const homeserver = normalizeMatrixHomeserver(config.homeserver);
+    if (!homeserver)
+        throw new Error('Matrix homeserver ต้องเป็น URL เช่น https://matrix.org');
+    const url = new URL(`${homeserver}/_matrix/client/v3/${path.replace(/^\/+/, '')}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value != null && String(value).trim())
+            url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+}
+export function matrixAuthHeaders(accessToken, extra = {}) {
+    const token = accessToken?.trim();
+    if (!token)
+        throw new Error('Matrix access token ว่าง');
+    return { authorization: `Bearer ${token}`, ...extra };
+}
+export function splitMatrixText(raw, limit = MATRIX_TEXT_LIMIT) {
+    let remaining = raw.trim() || '(ไม่มีผลลัพธ์)';
+    const chunks = [];
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit + 1);
+        let cut = window.lastIndexOf('\n');
+        if (cut < Math.floor(limit * 0.4))
+            cut = window.lastIndexOf(' ');
+        if (cut < Math.floor(limit * 0.4))
+            cut = limit;
+        chunks.push(remaining.slice(0, cut).trim());
+        remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks.length ? chunks : ['(ไม่มีผลลัพธ์)'];
+}
+async function readJsonOrThrow(response, label) {
+    const text = await response.text().catch(() => '');
+    if (!response.ok)
+        throw new Error(`${label} ${response.status}${text ? `: ${redactKey(text).slice(0, 200)}` : ''}`);
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} ${response.status}: response ไม่ใช่ JSON: ${redactKey(text).slice(0, 200)}`);
+    }
+}
+export async function loginMatrix(config) {
+    if (config.accessToken?.trim())
+        return { accessToken: config.accessToken.trim(), userId: config.userId };
+    const user = config.userId?.trim();
+    const password = config.password?.trim();
+    if (!user || !password)
+        throw new Error('Matrix config ต้องมี accessToken หรือ userId/password');
+    const r = await fetch(matrixClientUrl(config, '/login'), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            type: 'm.login.password',
+            identifier: { type: 'm.id.user', user },
+            password,
+            initial_device_display_name: `${BRAND.productName} Gateway`,
+        }),
+    });
+    const parsed = await readJsonOrThrow(r, 'Matrix login');
+    if (!parsed.access_token)
+        throw new Error('Matrix login response ไม่มี access_token');
+    return { accessToken: parsed.access_token, userId: parsed.user_id ?? user, deviceId: parsed.device_id };
+}
+export async function matrixWhoami(config) {
+    const auth = await loginMatrix(config);
+    const r = await fetch(matrixClientUrl(config, '/account/whoami'), {
+        method: 'GET',
+        headers: matrixAuthHeaders(auth.accessToken),
+    });
+    const parsed = await readJsonOrThrow(r, 'Matrix whoami');
+    return { userId: parsed.user_id ?? auth.userId, deviceId: parsed.device_id ?? auth.deviceId };
+}
+export async function sendMatrixMessage(config, roomId, text) {
+    const room = normalizeMatrixRoomId(roomId);
+    if (!room)
+        throw new Error('Matrix room id ต้องขึ้นต้นด้วย ! หรือ # และมี homeserver เช่น !abc:matrix.org');
+    const auth = await loginMatrix(config);
+    const chunks = splitMatrixText(text);
+    const eventIds = [];
+    for (const body of chunks) {
+        const txnId = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+        const r = await fetch(matrixClientUrl(config, `/rooms/${encodeURIComponent(room)}/send/m.room.message/${encodeURIComponent(txnId)}`), {
+            method: 'PUT',
+            headers: matrixAuthHeaders(auth.accessToken, { 'content-type': 'application/json' }),
+            body: JSON.stringify({ msgtype: 'm.text', body }),
+        });
+        const parsed = await readJsonOrThrow(r, 'Matrix send');
+        if (parsed.event_id)
+            eventIds.push(parsed.event_id);
+    }
+    return { roomId: room, eventIds, messageCount: chunks.length };
+}
+export async function joinMatrixRoom(config, roomId) {
+    const room = normalizeMatrixRoomId(roomId);
+    if (!room)
+        return;
+    const auth = await loginMatrix(config);
+    const r = await fetch(matrixClientUrl(config, `/join/${encodeURIComponent(room)}`), {
+        method: 'POST',
+        headers: matrixAuthHeaders(auth.accessToken, { 'content-type': 'application/json' }),
+        body: '{}',
+    });
+    await readJsonOrThrow(r, 'Matrix join');
+}
+export function matrixSyncUrl(config, since) {
+    return matrixClientUrl(config, '/sync', {
+        since,
+        timeout: config.pollTimeoutMs,
+        set_presence: 'online',
+    });
+}
+export function extractMatrixDirectRooms(sync) {
+    const rooms = new Set();
+    for (const event of sync.account_data?.events ?? []) {
+        if (event.type !== 'm.direct' || !event.content)
+            continue;
+        for (const ids of Object.values(event.content)) {
+            if (Array.isArray(ids)) {
+                for (const room of ids)
+                    if (normalizeMatrixRoomId(room))
+                        rooms.add(room);
+            }
+        }
+    }
+    return rooms;
+}
+export function extractMatrixTextEvents(sync, config, nowMs = Date.now()) {
+    const directRooms = extractMatrixDirectRooms(sync);
+    const out = [];
+    const botUserId = normalizeMatrixUserId(config.userId);
+    const staleBefore = nowMs - MATRIX_STARTUP_GRACE_MS;
+    for (const [roomId, room] of Object.entries(sync.rooms?.join ?? {})) {
+        const normalizedRoom = normalizeMatrixRoomId(roomId);
+        if (!normalizedRoom)
+            continue;
+        const isDirect = directRooms.has(normalizedRoom) || (room.summary?.['m.joined_member_count'] ?? 0) <= 2;
+        for (const event of room.timeline?.events ?? []) {
+            if (event.type !== 'm.room.message')
+                continue;
+            const sender = normalizeMatrixUserId(event.sender);
+            const text = event.content?.body?.trim();
+            const msgtype = event.content?.msgtype;
+            if (!sender || !text || !['m.text', 'm.notice'].includes(String(msgtype)))
+                continue;
+            if (botUserId && sender === botUserId)
+                continue;
+            if (event.origin_server_ts != null && event.origin_server_ts < staleBefore)
+                continue;
+            out.push({
+                roomId: normalizedRoom,
+                sender,
+                text,
+                eventId: event.event_id,
+                originServerTs: event.origin_server_ts,
+                isDirect,
+                mentionsBot: matrixMentionsBot(text, event, botUserId),
+            });
+        }
+    }
+    return out;
+}
+export function matrixMentionsBot(text, event, botUserId) {
+    if (!botUserId)
+        return false;
+    if (event.content?.['m.mentions']?.user_ids?.includes(botUserId))
+        return true;
+    const localpart = botUserId.slice(1).split(':')[0];
+    return text.includes(botUserId) || Boolean(localpart && new RegExp(`(^|\\s)@?${escapeRegExp(localpart)}(\\b|\\s|:)`, 'i').test(text));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function isAllowedMatrixEvent(config, event) {
+    if (config.allowedRooms.length && !event.isDirect && !config.allowedRooms.includes(event.roomId))
+        return false;
+    if (config.allowAllUsers)
+        return true;
+    return config.allowedUsers.includes(event.sender);
+}
+export function matrixShouldRespond(config, event) {
+    if (event.isDirect)
+        return true;
+    if (config.freeResponseRooms.includes(event.roomId))
+        return true;
+    if (!config.requireMention)
+        return true;
+    return event.mentionsBot;
+}
+function matrixSessionTarget(config, event) {
+    if (event.isDirect || !config.groupSessionsPerUser)
+        return event.roomId;
+    return `${event.roomId}:${event.sender}`;
+}
+function matrixUserText(event) {
+    return event.text.replace(/^!(new|reset|status|help)\b/i, '/$1').trim();
+}
+function matrixPrompt(event) {
+    return [`Matrix ${event.isDirect ? 'DM' : 'room'} ${event.roomId} from ${event.sender}:`, event.text].join('\n');
+}
+export async function handleMatrixEvent(opts) {
+    const event = opts.event;
+    if (!isAllowedMatrixEvent(opts.config, event)) {
+        opts.onLog?.(`Matrix: ปฏิเสธ ${event.sender} ใน ${event.roomId} (ไม่อยู่ใน allowlist)`);
+        return { handled: false, reason: 'not_allowed' };
+    }
+    if (!matrixShouldRespond(opts.config, event))
+        return { handled: false, reason: 'not_mentioned' };
+    const target = matrixSessionTarget(opts.config, event);
+    const running = opts.runningTargets ?? runningTargets;
+    if (running.has(target))
+        return { handled: false, reason: 'busy' };
+    running.add(target);
+    try {
+        const result = await runGatewayAgent({
+            platform: 'matrix',
+            target,
+            model: opts.model,
+            prompt: matrixPrompt(event),
+            userText: matrixUserText(event),
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+        });
+        if (!result.suppressDelivery)
+            await sendMatrixMessage(opts.config, event.roomId, result.text || '(ไม่มีผลลัพธ์)');
+        return { handled: true };
+    }
+    catch (e) {
+        opts.onLog?.(`Matrix run error (${event.roomId}): ${redactKey(e.message)}`);
+        await sendMatrixMessage(opts.config, event.roomId, 'เกิดข้อผิดพลาดภายใน').catch(() => { });
+        return { handled: false, reason: 'error' };
+    }
+    finally {
+        running.delete(target);
+    }
+}
+export async function handleMatrixSync(opts) {
+    let handled = 0;
+    let ignored = 0;
+    let joined = 0;
+    if (opts.config.autoJoin) {
+        for (const roomId of Object.keys(opts.sync.rooms?.invite ?? {})) {
+            try {
+                await joinMatrixRoom(opts.config, roomId);
+                joined += 1;
+            }
+            catch (e) {
+                opts.onLog?.(`Matrix join error (${roomId}): ${redactKey(e.message)}`);
+            }
+        }
+    }
+    for (const event of extractMatrixTextEvents(opts.sync, opts.config, opts.startupMs ?? Date.now())) {
+        const result = await handleMatrixEvent({ ...opts, event });
+        if (result.handled)
+            handled += 1;
+        else
+            ignored += 1;
+    }
+    return { handled, ignored, joined };
+}
+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 });
+    });
+}
+export function startMatrix(opts) {
+    if (!normalizeMatrixHomeserver(opts.config.homeserver)) {
+        opts.onLog?.('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_HOMESERVER เช่น https://matrix.org');
+        return () => { };
+    }
+    if (!opts.config.accessToken && (!opts.config.userId || !opts.config.password)) {
+        opts.onLog?.('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_ACCESS_TOKEN หรือ MATRIX_USER_ID/MATRIX_PASSWORD');
+        return () => { };
+    }
+    if (!opts.config.allowAllUsers && !opts.config.allowedUsers.length) {
+        opts.onLog?.('Matrix ไม่เริ่ม: ต้องตั้ง MATRIX_ALLOWED_USERS เพื่อ fail-closed');
+        return () => { };
+    }
+    const controller = new AbortController();
+    const reconnectMs = opts.reconnectMs ?? 5000;
+    const startupMs = opts.startupMs ?? Date.now();
+    const loop = async () => {
+        let since;
+        let runtimeConfig = opts.config;
+        opts.onLog?.(`Matrix: syncing ${opts.config.homeserver}`);
+        while (!controller.signal.aborted) {
+            try {
+                if (!runtimeConfig.userId) {
+                    const whoami = await matrixWhoami(runtimeConfig);
+                    runtimeConfig = { ...runtimeConfig, userId: whoami.userId };
+                }
+                const auth = await loginMatrix(runtimeConfig);
+                runtimeConfig = { ...runtimeConfig, accessToken: auth.accessToken, userId: runtimeConfig.userId ?? auth.userId };
+                const r = await fetch(matrixSyncUrl(runtimeConfig, since), {
+                    method: 'GET',
+                    headers: matrixAuthHeaders(auth.accessToken),
+                    signal: controller.signal,
+                });
+                const sync = await readJsonOrThrow(r, 'Matrix sync');
+                since = sync.next_batch || since;
+                await handleMatrixSync({
+                    config: runtimeConfig,
+                    sync,
+                    model: opts.model,
+                    budgetUsd: opts.budgetUsd,
+                    permissionMode: opts.permissionMode,
+                    startupMs,
+                    runningTargets,
+                    onLog: opts.onLog,
+                });
+            }
+            catch (e) {
+                if (!controller.signal.aborted)
+                    opts.onLog?.(`Matrix sync error: ${redactKey(e.message)}; reconnecting`);
+                await delay(reconnectMs, controller.signal);
+            }
+        }
+    };
+    void loop();
+    return () => controller.abort();
+}

package/dist/gateway/mattermost.js

@@ -0,0 +1,322 @@
+import { BRAND } from '../brand.js';
+import { redactKey } from '../providers/keys.js';
+import { runGatewayAgent } from './session.js';
+const MATTERMOST_TEXT_LIMIT = 4000;
+const runningTargets = new Set();
+export function normalizeMattermostUrl(raw) {
+    const trimmed = raw?.trim().replace(/\/+$/, '');
+    if (!trimmed)
+        return undefined;
+    if (!/^https?:\/\//i.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+export function mattermostApiUrl(config, path, params) {
+    const base = normalizeMattermostUrl(config.serverUrl);
+    if (!base)
+        throw new Error('Mattermost URL ต้องเป็น URL เช่น https://mm.example.com');
+    const url = new URL(`${base}/api/v4/${path.replace(/^\/+/, '')}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+        if (value != null && String(value).trim())
+            url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+}
+export function mattermostWebSocketUrl(serverUrl) {
+    const base = normalizeMattermostUrl(serverUrl);
+    if (!base)
+        throw new Error('Mattermost URL ต้องเป็น URL เช่น https://mm.example.com');
+    const url = new URL(base);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    const pathBase = url.pathname.replace(/\/+$/, '');
+    url.pathname = `${pathBase}/api/v4/websocket`;
+    url.search = '';
+    return url.toString();
+}
+export function mattermostAuthHeaders(token, extra = {}) {
+    const clean = token?.trim();
+    if (!clean)
+        throw new Error('Mattermost token ว่าง');
+    return { authorization: `Bearer ${clean}`, ...extra };
+}
+export function splitMattermostText(raw, limit = MATTERMOST_TEXT_LIMIT) {
+    let remaining = raw.trim() || '(ไม่มีผลลัพธ์)';
+    const chunks = [];
+    while (remaining.length > limit) {
+        const window = remaining.slice(0, limit + 1);
+        let cut = window.lastIndexOf('\n');
+        if (cut < Math.floor(limit * 0.4))
+            cut = window.lastIndexOf(' ');
+        if (cut < Math.floor(limit * 0.4))
+            cut = limit;
+        chunks.push(remaining.slice(0, cut).trim());
+        remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks.length ? chunks : ['(ไม่มีผลลัพธ์)'];
+}
+async function readJsonOrThrow(response, label) {
+    const text = await response.text().catch(() => '');
+    if (!response.ok)
+        throw new Error(`${label} ${response.status}${text ? `: ${redactKey(text).slice(0, 200)}` : ''}`);
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} ${response.status}: response ไม่ใช่ JSON: ${redactKey(text).slice(0, 200)}`);
+    }
+}
+export async function mattermostMe(config) {
+    const r = await fetch(mattermostApiUrl(config, '/users/me'), {
+        method: 'GET',
+        headers: mattermostAuthHeaders(config.token),
+    });
+    return readJsonOrThrow(r, 'Mattermost users/me');
+}
+export async function sendMattermostMessage(config, channelId, text, rootId) {
+    const channel = channelId.trim();
+    if (!channel)
+        throw new Error('Mattermost channel id ว่าง');
+    const chunks = splitMattermostText(text);
+    const postIds = [];
+    for (const chunk of chunks) {
+        const r = await fetch(mattermostApiUrl(config, '/posts'), {
+            method: 'POST',
+            headers: mattermostAuthHeaders(config.token, { 'content-type': 'application/json' }),
+            body: JSON.stringify({
+                channel_id: channel,
+                message: chunk,
+                ...(rootId?.trim() ? { root_id: rootId.trim() } : {}),
+            }),
+        });
+        const parsed = await readJsonOrThrow(r, 'Mattermost create post');
+        if (parsed.id)
+            postIds.push(parsed.id);
+    }
+    return { channelId: channel, postIds, messageCount: chunks.length };
+}
+function parsePost(raw) {
+    if (!raw)
+        return undefined;
+    if (typeof raw === 'string') {
+        try {
+            const parsed = JSON.parse(raw);
+            return parsed && typeof parsed === 'object' ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof raw === 'object' ? raw : undefined;
+}
+function parseMentions(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw))
+        return raw.filter((v) => typeof v === 'string');
+    if (typeof raw !== 'string')
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed.filter((v) => typeof v === 'string');
+    }
+    catch {
+        // Some Mattermost-compatible gateways emit comma-separated mention IDs.
+    }
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+export function mattermostMentionsBot(text, envelope, botUsername, botUserId) {
+    const mentions = parseMentions(envelope.data?.mentions);
+    if (botUserId && mentions.includes(botUserId))
+        return true;
+    const username = botUsername?.trim().replace(/^@/, '');
+    if (!username)
+        return false;
+    return new RegExp(`(^|\\s)@${escapeRegExp(username)}(\\b|\\s|:)`, 'i').test(text);
+}
+export function parseMattermostPostedEvent(raw, bot = {}) {
+    let envelope;
+    try {
+        envelope = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (envelope.event !== 'posted')
+        return null;
+    const post = parsePost(envelope.data?.post);
+    const userId = post?.user_id?.trim();
+    const channelId = (post?.channel_id ?? envelope.broadcast?.channel_id)?.trim();
+    const text = post?.message?.trim();
+    if (!userId || !channelId || !text)
+        return null;
+    if (bot.userId && userId === bot.userId)
+        return null;
+    const channelType = envelope.data?.channel_type?.trim();
+    return {
+        channelId,
+        userId,
+        text,
+        postId: post?.id,
+        rootId: post?.root_id || undefined,
+        channelType,
+        createAt: post?.create_at,
+        isDirect: channelType === 'D',
+        mentionsBot: mattermostMentionsBot(text, envelope, bot.username, bot.userId),
+    };
+}
+export function isAllowedMattermostEvent(config, event) {
+    if (!event.isDirect && config.allowedChannels.length && !config.allowedChannels.includes(event.channelId))
+        return false;
+    if (config.allowAllUsers)
+        return true;
+    return config.allowedUsers.includes(event.userId);
+}
+export function mattermostShouldRespond(config, event) {
+    if (event.isDirect)
+        return true;
+    if (config.freeResponseChannels.includes(event.channelId))
+        return true;
+    if (!config.requireMention)
+        return true;
+    return event.mentionsBot;
+}
+export function mattermostUserText(event, botUsername) {
+    let text = event.text.replace(/^!(new|reset|status|help)\b/i, '/$1').trim();
+    const username = botUsername?.trim().replace(/^@/, '');
+    if (username)
+        text = text.replace(new RegExp(`(^|\\s)@${escapeRegExp(username)}(\\b|\\s|:)`, 'gi'), ' ').trim();
+    return text || event.text;
+}
+function mattermostPrompt(event) {
+    return [`Mattermost ${event.isDirect ? 'DM' : 'channel'} ${event.channelId} from ${event.userId}:`, event.text].join('\n');
+}
+function mattermostReplyRootId(config, event) {
+    return event.rootId || (config.replyMode === 'thread' ? event.postId : undefined);
+}
+function mattermostSessionTarget(config, event) {
+    if (event.isDirect)
+        return event.channelId;
+    const threadId = event.rootId || (config.replyMode === 'thread' ? event.postId : undefined);
+    if (threadId)
+        return config.groupSessionsPerUser ? `${event.channelId}:${threadId}:${event.userId}` : `${event.channelId}:${threadId}`;
+    return config.groupSessionsPerUser ? `${event.channelId}:${event.userId}` : event.channelId;
+}
+export async function handleMattermostEvent(opts) {
+    const event = opts.event;
+    if (!isAllowedMattermostEvent(opts.config, event)) {
+        opts.onLog?.(`Mattermost: ปฏิเสธ ${event.userId} ใน ${event.channelId} (ไม่อยู่ใน allowlist)`);
+        return { handled: false, reason: 'not_allowed' };
+    }
+    if (!mattermostShouldRespond(opts.config, event))
+        return { handled: false, reason: 'not_mentioned' };
+    const target = mattermostSessionTarget(opts.config, event);
+    const running = opts.runningTargets ?? runningTargets;
+    if (running.has(target))
+        return { handled: false, reason: 'busy' };
+    running.add(target);
+    try {
+        const result = await runGatewayAgent({
+            platform: 'mattermost',
+            target,
+            model: opts.model,
+            prompt: mattermostPrompt(event),
+            userText: mattermostUserText(event, opts.botUsername),
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+        });
+        if (!result.suppressDelivery) {
+            await sendMattermostMessage(opts.config, event.channelId, result.text || '(ไม่มีผลลัพธ์)', mattermostReplyRootId(opts.config, event));
+        }
+        return { handled: true };
+    }
+    catch (e) {
+        opts.onLog?.(`Mattermost run error (${event.channelId}): ${redactKey(e.message)}`);
+        await sendMattermostMessage(opts.config, event.channelId, 'เกิดข้อผิดพลาดภายใน', mattermostReplyRootId(opts.config, event)).catch(() => { });
+        return { handled: false, reason: 'error' };
+    }
+    finally {
+        running.delete(target);
+    }
+}
+function defaultWebSocketFactory(url) {
+    const WS = globalThis.WebSocket;
+    if (!WS)
+        throw new Error('WebSocket runtime ไม่พร้อมใช้งานใน Node นี้');
+    return new WS(url);
+}
+export async function startMattermost(opts) {
+    if (!normalizeMattermostUrl(opts.config.serverUrl)) {
+        opts.onLog?.('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_URL เช่น https://mm.example.com');
+        return () => { };
+    }
+    if (!opts.config.token?.trim()) {
+        opts.onLog?.('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_TOKEN');
+        return () => { };
+    }
+    if (!opts.config.allowAllUsers && !opts.config.allowedUsers.length) {
+        opts.onLog?.('Mattermost ไม่เริ่ม: ต้องตั้ง MATTERMOST_ALLOWED_USERS เพื่อ fail-closed');
+        return () => { };
+    }
+    const me = await mattermostMe(opts.config);
+    if (!me.id)
+        throw new Error('Mattermost users/me response ไม่มี id');
+    const ws = (opts.webSocketFactory ?? defaultWebSocketFactory)(mattermostWebSocketUrl(opts.config.serverUrl));
+    const bot = { userId: me.id, username: me.username };
+    let stopped = false;
+    ws.addEventListener('open', () => {
+        opts.onLog?.(`Mattermost: websocket connecting as @${me.username ?? me.id}`);
+        ws.send(JSON.stringify({
+            seq: 1,
+            action: 'authentication_challenge',
+            data: { token: opts.config.token },
+        }));
+    });
+    ws.addEventListener('message', (event) => {
+        const raw = String(event.data ?? '');
+        if (!raw)
+            return;
+        try {
+            const envelope = JSON.parse(raw);
+            if (envelope.status === 'OK' && envelope.seq_reply === 1) {
+                opts.onLog?.('Mattermost: websocket authenticated');
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+        const inbound = parseMattermostPostedEvent(raw, bot);
+        if (!inbound)
+            return;
+        void handleMattermostEvent({
+            config: opts.config,
+            event: inbound,
+            model: opts.model,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode,
+            botUsername: bot.username,
+            runningTargets,
+            onLog: opts.onLog,
+        });
+    });
+    ws.addEventListener('close', () => {
+        if (!stopped)
+            opts.onLog?.('Mattermost: websocket closed');
+    });
+    ws.addEventListener('error', () => opts.onLog?.('Mattermost: websocket error'));
+    return () => {
+        stopped = true;
+        ws.close();
+    };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}