sanook-cli 0.5.1 → 0.5.5

package/dist/gateway/line.js

@@ -0,0 +1,171 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { redactKey } from '../providers/keys.js';
+import { runGatewayAgent } from './session.js';
+const LINE_PUSH_URL = 'https://api.line.me/v2/bot/message/push';
+const LINE_REPLY_URL = 'https://api.line.me/v2/bot/message/reply';
+const LINE_TEXT_LIMIT = 5000;
+const LINE_PUSH_MESSAGE_LIMIT = 5;
+const runningTargets = new Set();
+export function splitLineText(text) {
+    const trimmed = text.trim() || '(ไม่มีผลลัพธ์)';
+    const chunks = [];
+    for (let i = 0; i < trimmed.length && chunks.length < LINE_PUSH_MESSAGE_LIMIT; i += LINE_TEXT_LIMIT) {
+        chunks.push(trimmed.slice(i, i + LINE_TEXT_LIMIT));
+    }
+    return chunks.length ? chunks : ['(ไม่มีผลลัพธ์)'];
+}
+function lineTextMessages(text) {
+    return splitLineText(text).map((chunk) => ({ type: 'text', text: chunk }));
+}
+export async function sendLineMessage(channelAccessToken, to, text) {
+    const messages = lineTextMessages(text);
+    const r = await fetch(LINE_PUSH_URL, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${channelAccessToken}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({ to, messages }),
+    });
+    if (!r.ok)
+        throw new Error(`LINE push message ${r.status}`);
+    return { to, messageCount: messages.length };
+}
+export async function replyLineMessage(channelAccessToken, replyToken, text) {
+    const messages = lineTextMessages(text);
+    const r = await fetch(LINE_REPLY_URL, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${channelAccessToken}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({ replyToken, messages }),
+    });
+    if (!r.ok)
+        throw new Error(`LINE reply message ${r.status}`);
+    return { to: replyToken, messageCount: messages.length };
+}
+export function verifyLineSignature(channelSecret, rawBody, signature) {
+    if (!channelSecret || !signature)
+        return false;
+    const expected = createHmac('sha256', channelSecret).update(rawBody).digest('base64');
+    const a = Buffer.from(signature);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+export function lineSourceTarget(source) {
+    if (!source)
+        return undefined;
+    if (source.type === 'user')
+        return source.userId;
+    if (source.type === 'group')
+        return source.groupId;
+    if (source.type === 'room')
+        return source.roomId;
+    return source.userId ?? source.groupId ?? source.roomId;
+}
+export function isAllowedLineSource(config, source) {
+    if (config.allowAllUsers)
+        return true;
+    const target = lineSourceTarget(source);
+    if (!target)
+        return false;
+    if (target === config.homeChannel)
+        return true;
+    if (source?.type === 'user')
+        return config.allowedUsers.includes(target);
+    if (source?.type === 'group')
+        return config.allowedGroups.includes(target);
+    if (source?.type === 'room')
+        return config.allowedRooms.includes(target);
+    return [...config.allowedUsers, ...config.allowedGroups, ...config.allowedRooms].includes(target);
+}
+function parseWebhookPayload(rawBody) {
+    const parsed = JSON.parse(rawBody);
+    if (!parsed || typeof parsed !== 'object')
+        return {};
+    const payload = parsed;
+    return Array.isArray(payload.events) ? payload : {};
+}
+function linePrompt(event, target) {
+    const text = event.message?.text?.trim() || '';
+    const source = event.source;
+    const actor = source?.userId && source.userId !== target ? ` from user ${source.userId}` : '';
+    return [`LINE ${source?.type ?? 'unknown'} ${target}${actor}:`, text].join('\n');
+}
+async function replyOrPush(config, event, target, text) {
+    if (!config.channelAccessToken)
+        throw new Error('LINE channel access token is not configured');
+    if (event.replyToken) {
+        try {
+            await replyLineMessage(config.channelAccessToken, event.replyToken, text);
+            return;
+        }
+        catch {
+            // Reply tokens can expire; fall through to Push so long runs can still deliver.
+        }
+    }
+    await sendLineMessage(config.channelAccessToken, target, text);
+}
+export async function handleLineWebhook(opts) {
+    if (!opts.config.channelAccessToken || !opts.config.channelSecret) {
+        return { status: 503, body: { error: 'line_not_configured' } };
+    }
+    if (!verifyLineSignature(opts.config.channelSecret, opts.rawBody, opts.signature)) {
+        return { status: 401, body: { error: 'invalid_signature' } };
+    }
+    let payload;
+    try {
+        payload = parseWebhookPayload(opts.rawBody);
+    }
+    catch {
+        return { status: 400, body: { error: 'invalid_json' } };
+    }
+    let accepted = 0;
+    let ignored = 0;
+    for (const event of payload.events ?? []) {
+        const target = lineSourceTarget(event.source);
+        const text = event.type === 'message' && event.message?.type === 'text' ? event.message.text?.trim() : undefined;
+        if (!target || !text) {
+            ignored += 1;
+            continue;
+        }
+        if (!isAllowedLineSource(opts.config, event.source)) {
+            ignored += 1;
+            opts.onLog?.(`LINE: ปฏิเสธ target ${target} (ไม่อยู่ใน allowlist)`);
+            if (event.replyToken)
+                await replyLineMessage(opts.config.channelAccessToken, event.replyToken, 'ไม่ได้รับอนุญาตให้ใช้ bot นี้').catch(() => { });
+            continue;
+        }
+        if (runningTargets.has(target)) {
+            ignored += 1;
+            if (event.replyToken)
+                await replyLineMessage(opts.config.channelAccessToken, event.replyToken, 'กำลังทำงานก่อนหน้าอยู่ รอสักครู่').catch(() => { });
+            continue;
+        }
+        accepted += 1;
+        runningTargets.add(target);
+        try {
+            const result = await runGatewayAgent({
+                platform: 'line',
+                target,
+                model: opts.model,
+                prompt: linePrompt(event, target),
+                userText: text,
+                budgetUsd: opts.budgetUsd,
+                permissionMode: opts.permissionMode ?? 'ask',
+            });
+            if (!result.suppressDelivery)
+                await replyOrPush(opts.config, event, target, result.text || '(ไม่มีผลลัพธ์)');
+        }
+        catch (e) {
+            opts.onLog?.(`LINE run error (${target}): ${redactKey(e.message)}`);
+            if (event.replyToken)
+                await replyLineMessage(opts.config.channelAccessToken, event.replyToken, 'เกิดข้อผิดพลาดภายใน').catch(() => { });
+        }
+        finally {
+            runningTargets.delete(target);
+        }
+    }
+    return { status: 200, body: { ok: true, accepted, ignored } };
+}

package/dist/gateway/lock.js

@@ -6,12 +6,14 @@ import { unlinkSync } from 'node:fs';
 // แคบมาก (ต้องมี 2 mutator พร้อมกัน + holder ตายเป๊ะจังหวะ) ซึ่งแทบเป็นไปไม่ได้ใน workload นี้
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const LOCK_TTL_MS = 5 * 60_000; // mutate สั้นระดับ ms — lock เก่ากว่านี้ = ค้างแน่ → ยึดได้ (กัน pid-reuse deadlock)
+const LOCK_WRITE_GRACE_MS = 1_000; // open('wx') สร้างไฟล์ก่อนเขียน pid; อย่า evict lock สดที่ยังเขียนไม่จบ
 /** holder ตายไหม — เช็คจาก pid อย่างเดียว (ใช้กับ singleton ที่ถือยาว, ไม่มี TTL) */
 async function holderDead(lockPath) {
     try {
+        const st = await stat(lockPath);
         const pid = parseInt((await readFile(lockPath, 'utf8')).trim(), 10);
         if (!Number.isInteger(pid) || pid <= 0)
-            return true; // pid พัง → ยึดได้
+            return Date.now() - st.mtimeMs > LOCK_WRITE_GRACE_MS; // pid ยังไม่ถูกเขียน/พัง → รอ grace สั้นๆ ก่อนยึด
         try {
             process.kill(pid, 0); // เช็คว่ามี process นี้ (ไม่ส่ง signal จริง)
             return false;

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();
+}