sanook-cli 0.5.1 → 0.5.5

package/dist/gateway/googlechat.js

@@ -0,0 +1,207 @@
+import { createSign } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { redactKey } from '../providers/keys.js';
+const GOOGLE_CHAT_API_BASE_URL = 'https://chat.googleapis.com';
+const GOOGLE_OAUTH_TOKEN_URI = 'https://oauth2.googleapis.com/token';
+const GOOGLE_CHAT_SCOPE = 'https://www.googleapis.com/auth/chat.bot';
+const GOOGLE_CHAT_TEXT_LIMIT = 4_000;
+function redactGoogleChatDetail(raw, secrets) {
+    let safe = redactKey(raw);
+    for (const secret of secrets) {
+        const value = secret?.trim();
+        if (value)
+            safe = safe.split(value).join('<secret>');
+    }
+    return safe;
+}
+function base64Url(input) {
+    return Buffer.from(input).toString('base64url');
+}
+export function normalizeGoogleChatApiBaseUrl(raw) {
+    const value = raw?.trim() || GOOGLE_CHAT_API_BASE_URL;
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:')
+            return undefined;
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+export function normalizeGoogleChatWebhookUrl(raw) {
+    const value = raw?.trim();
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'https:')
+            return undefined;
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function chunkGoogleChatText(raw, limit = GOOGLE_CHAT_TEXT_LIMIT) {
+    const text = raw.trim() || '(ไม่มีผลลัพธ์)';
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    for (let index = 0; index < text.length; index += limit) {
+        chunks.push(text.slice(index, index + limit));
+    }
+    return chunks;
+}
+export function parseGoogleChatTarget(config, explicitTarget) {
+    const target = explicitTarget?.trim() || config.homeChannel?.trim();
+    if (!target) {
+        const webhook = normalizeGoogleChatWebhookUrl(config.incomingWebhookUrl);
+        if (webhook)
+            return { type: 'webhook', value: webhook };
+        throw new Error('ต้องระบุ Google Chat space/webhook target หรือ home channel ใน gateway config');
+    }
+    if (/^https:\/\//i.test(target)) {
+        const webhookUrl = normalizeGoogleChatWebhookUrl(target);
+        if (!webhookUrl)
+            throw new Error('Google Chat incoming webhook target ต้องเป็น HTTPS URL ที่ถูกต้อง');
+        return { type: 'webhook', value: webhookUrl };
+    }
+    if (target.toLowerCase() === 'webhook') {
+        const webhookUrl = normalizeGoogleChatWebhookUrl(config.incomingWebhookUrl);
+        if (!webhookUrl)
+            throw new Error('ยังไม่ได้ตั้ง Google Chat incoming webhook URL');
+        return { type: 'webhook', value: webhookUrl };
+    }
+    const cleaned = target.replace(/^space[:/](?:spaces\/)?/i, 'spaces/').trim();
+    const match = /^(spaces\/[^/\s]+)(?:\/threads\/(.+))?$/.exec(cleaned);
+    if (!match)
+        throw new Error('Google Chat target ต้องเป็น spaces/<space-id> หรือ spaces/<space-id>/threads/<thread-id>');
+    const space = match[1];
+    const thread = match[2] ? `${space}/threads/${match[2]}` : undefined;
+    return { type: 'space', value: thread ?? space, space, thread };
+}
+export function googleChatApiUrl(config, path) {
+    const baseUrl = normalizeGoogleChatApiBaseUrl(config.apiBaseUrl);
+    if (!baseUrl)
+        throw new Error('Google Chat API base URL ต้องเป็น https:// URL');
+    return new URL(path, `${baseUrl}/`).toString();
+}
+export async function readGoogleServiceAccount(path) {
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object')
+        throw new Error('Google Chat service account JSON ไม่ถูกต้อง');
+    return parsed;
+}
+export function googleServiceAccountJwt(serviceAccount, now = Math.floor(Date.now() / 1000)) {
+    const issuer = serviceAccount.client_email?.trim();
+    const privateKey = serviceAccount.private_key;
+    const audience = serviceAccount.token_uri?.trim() || GOOGLE_OAUTH_TOKEN_URI;
+    if (!issuer || !privateKey)
+        throw new Error('Google Chat service account JSON ต้องมี client_email และ private_key');
+    const header = base64Url(JSON.stringify({ alg: 'RS256', typ: 'JWT' }));
+    const payload = base64Url(JSON.stringify({
+        iss: issuer,
+        scope: GOOGLE_CHAT_SCOPE,
+        aud: audience,
+        iat: now,
+        exp: now + 3600,
+    }));
+    const unsigned = `${header}.${payload}`;
+    const signature = createSign('RSA-SHA256').update(unsigned).sign(privateKey);
+    return `${unsigned}.${base64Url(signature)}`;
+}
+async function readGoogleChatJsonOrThrow(response, label, secrets = []) {
+    const text = await response.text().catch(() => '');
+    if (!response.ok)
+        throw new Error(`${label} ${response.status}${text ? `: ${redactGoogleChatDetail(text, secrets).slice(0, 240)}` : ''}`);
+    let json;
+    try {
+        json = (text ? JSON.parse(text) : {});
+    }
+    catch {
+        throw new Error(`${label} ${response.status}: response ไม่ใช่ JSON: ${redactGoogleChatDetail(text, secrets).slice(0, 240)}`);
+    }
+    const maybe = json;
+    const error = maybe.error;
+    if (error) {
+        const detail = typeof error === 'string'
+            ? maybe.error_description || error
+            : error.message || error.status || String(error.code ?? 'unknown');
+        throw new Error(`${label}: ${redactGoogleChatDetail(detail, secrets).slice(0, 200)}`);
+    }
+    return json;
+}
+export async function googleChatAccessToken(config) {
+    const serviceAccountPath = config.serviceAccountJson?.trim();
+    if (!serviceAccountPath)
+        throw new Error('ยังไม่ได้ตั้ง Google Chat service account JSON');
+    const serviceAccount = await readGoogleServiceAccount(serviceAccountPath);
+    const tokenUri = serviceAccount.token_uri?.trim() || GOOGLE_OAUTH_TOKEN_URI;
+    const assertion = googleServiceAccountJwt(serviceAccount);
+    const body = new URLSearchParams({
+        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+        assertion,
+    });
+    const r = await fetch(tokenUri, {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    const json = await readGoogleChatJsonOrThrow(r, 'Google Chat OAuth token', [
+        serviceAccount.private_key,
+        assertion,
+    ]);
+    const token = json.access_token?.trim();
+    if (!token)
+        throw new Error('Google Chat OAuth token response ไม่มี access_token');
+    return token;
+}
+async function sendGoogleChatWebhook(webhookUrl, text) {
+    const messageIds = [];
+    for (const chunk of chunkGoogleChatText(text)) {
+        const r = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ text: chunk }),
+        });
+        const json = await readGoogleChatJsonOrThrow(r, 'Google Chat incoming webhook', [webhookUrl]);
+        if (json.name)
+            messageIds.push(json.name);
+    }
+    return { mode: 'incoming_webhook', target: 'webhook', messageIds, messageCount: messageIds.length || chunkGoogleChatText(text).length };
+}
+async function sendGoogleChatApi(config, target, text) {
+    if (!target.space)
+        throw new Error('Google Chat API target ต้องเป็น space');
+    const token = await googleChatAccessToken(config);
+    const messageIds = [];
+    for (const chunk of chunkGoogleChatText(text)) {
+        const r = await fetch(googleChatApiUrl(config, `/v1/${target.space}/messages`), {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${token}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                text: chunk,
+                ...(target.thread ? { thread: { name: target.thread } } : {}),
+            }),
+        });
+        const json = await readGoogleChatJsonOrThrow(r, 'Google Chat API message', [token]);
+        if (json.name)
+            messageIds.push(json.name);
+    }
+    return {
+        mode: 'chat_api',
+        target: target.value,
+        messageIds,
+        messageCount: messageIds.length || chunkGoogleChatText(text).length,
+    };
+}
+export async function sendGoogleChatMessage(config, text, explicitTarget) {
+    const target = parseGoogleChatTarget(config, explicitTarget);
+    if (target.type === 'webhook')
+        return sendGoogleChatWebhook(target.value, text);
+    return sendGoogleChatApi(config, target, text);
+}

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,11 +9,38 @@ 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');
+const TASK_KINDS = new Set(['cron', 'message', 'once']);
+const TASK_STATUSES = new Set(['queued', 'running', 'done', 'failed']);
+function normalizeOptionalModel(model) {
+    const trimmed = model?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeOptionalText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function isTask(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const task = value;
+    return (typeof task.id === 'string' &&
+        TASK_KINDS.has(task.kind) &&
+        TASK_STATUSES.has(task.status) &&
+        typeof task.spec === 'string' &&
+        Number.isFinite(task.runAt) &&
+        Number.isFinite(task.createdAt) &&
+        (task.schedule === undefined || typeof task.schedule === 'string') &&
+        (task.model === undefined || typeof task.model === 'string') &&
+        (task.deliver === undefined || typeof task.deliver === 'string') &&
+        (task.lastRun === undefined || Number.isFinite(task.lastRun)) &&
+        (task.lastResult === undefined || typeof task.lastResult === 'string') &&
+        (task.lastError === undefined || typeof task.lastError === 'string'));
+}
 // ── low-level: read ตรงจากไฟล์ทุกครั้ง (ไม่ cache snapshot → ไม่มี stale-overwrite) ──
 async function readTasks() {
     try {
         const parsed = JSON.parse(await readFile(TASKS_FILE, 'utf8'));
-        return Array.isArray(parsed) ? parsed : [];
+        return Array.isArray(parsed) ? parsed.filter(isTask) : [];
     }
     catch {
         return []; // ไม่มีไฟล์/พัง → empty (write แบบ atomic จึงไม่ทำลายของเดิม)
@@ -49,6 +76,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 };