sanook-cli 0.5.0 → 0.5.2

package/dist/gateway/homeassistant.js

@@ -0,0 +1,256 @@
+import { BRAND } from '../brand.js';
+import { redactKey } from '../providers/keys.js';
+import { runGatewayAgent } from './session.js';
+const HA_TEXT_LIMIT = 4096;
+const HA_DEFAULT_NOTIFICATION_ID = 'sanook_agent';
+const runningTargets = new Set();
+const lastEventTime = new Map();
+export function normalizeHomeAssistantUrl(raw) {
+    const trimmed = raw?.trim().replace(/\/+$/, '');
+    if (!trimmed)
+        return undefined;
+    if (!/^https?:\/\//i.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+export function homeAssistantApiUrl(config, path) {
+    const base = normalizeHomeAssistantUrl(config.url);
+    if (!base)
+        throw new Error('Home Assistant URL ต้องเป็น URL เช่น http://homeassistant.local:8123');
+    return `${base}/api/${path.replace(/^\/+/, '')}`;
+}
+export function homeAssistantWebSocketUrl(url) {
+    const base = normalizeHomeAssistantUrl(url);
+    if (!base)
+        throw new Error('Home Assistant URL ต้องเป็น URL เช่น http://homeassistant.local:8123');
+    const parsed = new URL(base);
+    parsed.protocol = parsed.protocol === 'https:' ? 'wss:' : 'ws:';
+    parsed.pathname = `${parsed.pathname.replace(/\/+$/, '')}/api/websocket`;
+    parsed.search = '';
+    return parsed.toString();
+}
+export function homeAssistantAuthHeaders(token, extra = {}) {
+    const clean = token?.trim();
+    if (!clean)
+        throw new Error('Home Assistant token ว่าง');
+    return { authorization: `Bearer ${clean}`, ...extra };
+}
+export function truncateHomeAssistantMessage(raw, limit = HA_TEXT_LIMIT) {
+    const text = raw.trim() || '(ไม่มีผลลัพธ์)';
+    return text.length <= limit ? text : `${text.slice(0, Math.max(1, limit - 3)).trimEnd()}...`;
+}
+export async function readHomeAssistantJsonResponse(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 sendHomeAssistantNotification(config, text, notificationId) {
+    const id = notificationId?.trim() || config.homeChannel?.trim() || HA_DEFAULT_NOTIFICATION_ID;
+    const r = await fetch(homeAssistantApiUrl(config, '/services/persistent_notification/create'), {
+        method: 'POST',
+        headers: homeAssistantAuthHeaders(config.token, { 'content-type': 'application/json' }),
+        body: JSON.stringify({
+            title: BRAND.productName,
+            message: truncateHomeAssistantMessage(text),
+            notification_id: id,
+        }),
+    });
+    await readHomeAssistantJsonResponse(r, 'Home Assistant persistent_notification.create');
+    return { notificationId: id, messageId: `${id}:${Date.now()}`, messageCount: 1 };
+}
+export function homeAssistantDomain(entityId) {
+    return entityId.includes('.') ? entityId.split('.')[0] : '';
+}
+export function shouldForwardHomeAssistantEvent(config, event, state = {}) {
+    const entityId = event.data?.entity_id?.trim();
+    if (!entityId)
+        return { ok: false, reason: 'missing_entity' };
+    if (config.ignoreEntities.includes(entityId))
+        return { ok: false, reason: 'ignored_entity', entityId };
+    const domain = homeAssistantDomain(entityId);
+    if (config.watchDomains.length || config.watchEntities.length) {
+        const domainMatch = config.watchDomains.includes(domain);
+        const entityMatch = config.watchEntities.includes(entityId);
+        if (!domainMatch && !entityMatch)
+            return { ok: false, reason: 'not_watched', entityId };
+    }
+    else if (!config.watchAll) {
+        return { ok: false, reason: 'not_watched', entityId };
+    }
+    const oldValue = event.data?.old_state?.state ?? 'unknown';
+    const newValue = event.data?.new_state?.state ?? 'unknown';
+    if (oldValue === newValue)
+        return { ok: false, reason: 'unchanged', entityId };
+    const seen = state.lastEventTime;
+    if (seen) {
+        const now = state.nowSeconds ?? Date.now() / 1000;
+        const last = seen.get(entityId) ?? 0;
+        if (now - last < config.cooldownSeconds)
+            return { ok: false, reason: 'cooldown', entityId };
+        seen.set(entityId, now);
+    }
+    return { ok: true, entityId };
+}
+export function formatHomeAssistantStateChange(event) {
+    const entityId = event.data?.entity_id?.trim();
+    const newState = event.data?.new_state;
+    if (!entityId || !newState)
+        return undefined;
+    const oldValue = event.data?.old_state?.state ?? 'unknown';
+    const newValue = newState.state ?? 'unknown';
+    if (oldValue === newValue)
+        return undefined;
+    const attrs = newState.attributes ?? {};
+    const friendly = String(attrs.friendly_name ?? entityId);
+    const domain = homeAssistantDomain(entityId);
+    if (domain === 'climate') {
+        const current = attrs.current_temperature ?? '?';
+        const target = attrs.temperature ?? '?';
+        return `[Home Assistant] ${friendly}: HVAC mode changed from '${oldValue}' to '${newValue}' (current: ${current}, target: ${target})`;
+    }
+    if (domain === 'sensor') {
+        const unit = String(attrs.unit_of_measurement ?? '');
+        return `[Home Assistant] ${friendly}: changed from ${oldValue}${unit} to ${newValue}${unit}`;
+    }
+    if (domain === 'binary_sensor') {
+        const oldText = oldValue === 'on' ? 'triggered' : 'cleared';
+        const newText = newValue === 'on' ? 'triggered' : 'cleared';
+        return `[Home Assistant] ${friendly}: ${newText} (was ${oldText})`;
+    }
+    if (['light', 'switch', 'fan'].includes(domain)) {
+        return `[Home Assistant] ${friendly}: turned ${newValue === 'on' ? 'on' : 'off'}`;
+    }
+    if (domain === 'alarm_control_panel') {
+        return `[Home Assistant] ${friendly}: alarm state changed from '${oldValue}' to '${newValue}'`;
+    }
+    return `[Home Assistant] ${friendly} (${entityId}): changed from '${oldValue}' to '${newValue}'`;
+}
+export async function handleHomeAssistantEvent(opts) {
+    const allowed = shouldForwardHomeAssistantEvent(opts.config, opts.event, {
+        lastEventTime: opts.lastEventTime,
+        nowSeconds: opts.nowSeconds,
+    });
+    if (!allowed.ok)
+        return { handled: false, reason: allowed.reason };
+    const text = formatHomeAssistantStateChange(opts.event);
+    if (!text)
+        return { handled: false, reason: 'empty_message' };
+    const target = opts.config.homeChannel || 'ha_events';
+    const running = opts.runningTargets ?? runningTargets;
+    if (running.has(target))
+        return { handled: false, reason: 'busy' };
+    running.add(target);
+    try {
+        const result = await runGatewayAgent({
+            platform: 'homeassistant',
+            target,
+            model: opts.model,
+            prompt: text,
+            userText: text,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+        });
+        if (!result.suppressDelivery)
+            await sendHomeAssistantNotification(opts.config, result.text || '(ไม่มีผลลัพธ์)', target);
+        return { handled: true };
+    }
+    catch (e) {
+        opts.onLog?.(`Home Assistant run error (${allowed.entityId ?? 'event'}): ${redactKey(e.message)}`);
+        await sendHomeAssistantNotification(opts.config, 'เกิดข้อผิดพลาดภายใน', target).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 function startHomeAssistant(opts) {
+    if (!normalizeHomeAssistantUrl(opts.config.url)) {
+        opts.onLog?.('Home Assistant ไม่เริ่ม: ต้องตั้ง HASS_URL เช่น http://homeassistant.local:8123');
+        return () => { };
+    }
+    if (!opts.config.token?.trim()) {
+        opts.onLog?.('Home Assistant ไม่เริ่ม: ต้องตั้ง HASS_TOKEN');
+        return () => { };
+    }
+    if (!opts.config.watchAll && !opts.config.watchDomains.length && !opts.config.watchEntities.length) {
+        opts.onLog?.('Home Assistant: ยังไม่มี watch_domains/watch_entities/watch_all — จะเชื่อมต่อแต่ drop state_changed ทั้งหมด');
+    }
+    const reconnectMs = opts.reconnectMs ?? 5000;
+    const webSocketFactory = opts.webSocketFactory ?? defaultWebSocketFactory;
+    let stopped = false;
+    let ws;
+    let reconnect;
+    let subscribeId = 0;
+    const connect = () => {
+        if (stopped)
+            return;
+        ws = webSocketFactory(homeAssistantWebSocketUrl(opts.config.url));
+        ws.addEventListener('open', () => opts.onLog?.(`Home Assistant: websocket connecting ${opts.config.url}`));
+        ws.addEventListener('message', (event) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(event.data ?? '{}'));
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'auth_required') {
+                ws?.send(JSON.stringify({ type: 'auth', access_token: opts.config.token }));
+                return;
+            }
+            if (msg.type === 'auth_ok') {
+                subscribeId += 1;
+                ws?.send(JSON.stringify({ id: subscribeId, type: 'subscribe_events', event_type: 'state_changed' }));
+                return;
+            }
+            if (msg.type === 'auth_invalid') {
+                opts.onLog?.(`Home Assistant auth failed: ${redactKey(msg.message ?? 'auth_invalid')}`);
+                return;
+            }
+            if (msg.id === subscribeId && msg.success === true) {
+                opts.onLog?.('Home Assistant: subscribed to state_changed');
+                return;
+            }
+            if (msg.type === 'event' && msg.event) {
+                void handleHomeAssistantEvent({
+                    config: opts.config,
+                    event: msg.event,
+                    model: opts.model,
+                    budgetUsd: opts.budgetUsd,
+                    permissionMode: opts.permissionMode,
+                    runningTargets,
+                    lastEventTime,
+                    onLog: opts.onLog,
+                });
+            }
+        });
+        ws.addEventListener('close', () => {
+            if (stopped)
+                return;
+            opts.onLog?.(`Home Assistant: websocket closed; reconnecting in ${Math.round(reconnectMs / 1000)}s`);
+            reconnect = setTimeout(connect, reconnectMs);
+        });
+        ws.addEventListener('error', () => opts.onLog?.('Home Assistant: websocket error'));
+    };
+    connect();
+    return () => {
+        stopped = true;
+        if (reconnect)
+            clearTimeout(reconnect);
+        ws?.close();
+    };
+}

package/dist/gateway/ledger.js

@@ -9,6 +9,14 @@ import { appHomePath } from '../brand.js';
 const GATEWAY_DIR = appHomePath('gateway');
 const TASKS_FILE = join(GATEWAY_DIR, 'tasks.json');
 const LOCK_FILE = join(GATEWAY_DIR, 'tasks.lock');
+function normalizeOptionalModel(model) {
+    const trimmed = model?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeOptionalText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
 // ── low-level: read ตรงจากไฟล์ทุกครั้ง (ไม่ cache snapshot → ไม่มี stale-overwrite) ──
 async function readTasks() {
     try {
@@ -49,6 +57,16 @@ export async function dueTasks(now = Date.now()) {
 // ── mutations (locked, atomic, re-read สด) ──
 export async function enqueueTask(t) {
     const task = { id: randomUUID().slice(0, 8), status: 'queued', createdAt: Date.now(), ...t };
+    const model = normalizeOptionalModel(t.model);
+    const deliver = normalizeOptionalText(t.deliver);
+    if (model)
+        task.model = model;
+    else
+        delete task.model;
+    if (deliver)
+        task.deliver = deliver;
+    else
+        delete task.deliver;
     await mutate((tasks) => {
         tasks.push(task);
         return { tasks, result: undefined };

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;