sanook-cli 0.5.1 → 0.5.2

package/dist/gateway/server.js

@@ -1,6 +1,7 @@
 import { createServer } from 'node:http';
 import { listTasks, enqueueTask } from './ledger.js';
 import { parseSchedule } from './schedule.js';
+import { formatTarget, parseSendTarget } from './targets.js';
 import { tokenMatches } from './auth.js';
 import { runAgent } from '../loop.js';
 import { redactKey } from '../providers/keys.js';
@@ -9,21 +10,111 @@ function send(res, status, body) {
     res.writeHead(status, { 'content-type': 'application/json' });
     res.end(JSON.stringify(body));
 }
+function sendRaw(res, status, contentType, body) {
+    res.writeHead(status, { 'content-type': contentType });
+    res.end(body);
+}
+function sendSse(res, body) {
+    res.write(`data: ${typeof body === 'string' ? body : JSON.stringify(body)}\n\n`);
+}
+export function optionalString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+export function parseBearerToken(authorization) {
+    if (!authorization)
+        return undefined;
+    const tokenMatch = /^Bearer +(\S+)$/i.exec(authorization);
+    if (!tokenMatch)
+        return undefined;
+    return tokenMatch[1];
+}
+export function parseWebhookRouteName(pathname) {
+    if (!pathname.startsWith('/webhooks/'))
+        return undefined;
+    try {
+        const routeName = decodeURIComponent(pathname.slice('/webhooks/'.length)).replace(/^\/+|\/+$/g, '');
+        return /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(routeName) ? routeName : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseOptionalSchedule(value, now) {
+    if (value == null)
+        return { schedule: null };
+    if (typeof value !== 'string')
+        return { schedule: null, invalid: 'ต้องเป็นข้อความ' };
+    const scheduleText = optionalString(value);
+    if (!scheduleText)
+        return { schedule: null };
+    const schedule = parseSchedule(scheduleText, now);
+    return schedule ? { schedule } : { schedule: null, invalid: scheduleText };
+}
+export function parseRequiredTaskSpec(value) {
+    if (typeof value !== 'string') {
+        return value == null ? { invalid: 'ต้องมี spec' } : { invalid: 'spec ต้องเป็นข้อความ' };
+    }
+    const spec = value.trim();
+    return spec ? { spec } : { invalid: 'ต้องมี spec' };
+}
+export function parseOptionalDeliverTarget(value) {
+    if (value == null)
+        return {};
+    if (typeof value !== 'string')
+        return { invalid: 'deliver ต้องเป็นข้อความ' };
+    const deliverText = optionalString(value);
+    if (!deliverText)
+        return {};
+    try {
+        return { deliver: formatTarget(parseSendTarget(deliverText)) };
+    }
+    catch (e) {
+        return { invalid: e.message };
+    }
+}
+export function parseOptionalTaskModel(value) {
+    if (value == null)
+        return {};
+    if (typeof value !== 'string')
+        return { invalid: 'model ต้องเป็นข้อความ' };
+    const model = optionalString(value);
+    return model ? { model } : {};
+}
 const MAX_BODY = 1_000_000; // 1MB กัน memory blowup
+/** error ที่พก HTTP status — ให้ client เห็น 400/413 (client error) แทน 500 (server error) */
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
 async function readBody(req) {
+    const raw = await readRawBody(req);
+    if (!raw)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new HttpError(400, 'invalid JSON body'); // Bad Request — ไม่ leak ข้อความ parser
+    }
+    return parsed && typeof parsed === 'object' ? parsed : {};
+}
+async function readRawBody(req) {
     const chunks = [];
     let size = 0;
     for await (const c of req) {
         size += c.length;
         if (size > MAX_BODY)
-            throw new Error('request body ใหญ่เกิน');
+            throw new HttpError(413, 'request body ใหญ่เกิน'); // Payload Too Large
         chunks.push(c);
     }
-    const raw = Buffer.concat(chunks).toString('utf8');
-    if (!raw)
-        return {};
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === 'object' ? parsed : {};
+    return Buffer.concat(chunks).toString('utf8');
 }
 /**
  * gateway HTTP — bind 127.0.0.1 เท่านั้น (loopback, ไม่ expose ออกเน็ต), ทุก endpoint ยกเว้น /health ต้อง bearer token
@@ -33,7 +124,7 @@ async function readBody(req) {
 export function startServer(opts) {
     const server = createServer((req, res) => {
         // redact กัน API key/secret รั่วใน error response (provider error อาจฝัง key)
-        void handle(req, res, opts).catch((err) => send(res, 500, { error: redactKey(err.message ?? String(err)) }));
+        void handle(req, res, opts).catch((err) => send(res, err.status ?? 500, { error: redactKey(err.message ?? String(err)) }));
     });
     // '127.0.0.1' = loopback only — สำคัญ: ห้าม 0.0.0.0 (จะเปิดให้ทั้ง LAN)
     server.listen(opts.port, '127.0.0.1', () => opts.onLog?.(`http://127.0.0.1:${opts.port} (loopback)`));
@@ -45,9 +136,102 @@ async function handle(req, res, opts) {
     if (req.method === 'GET' && url.pathname === '/health') {
         return send(res, 200, { ok: true, service: BRAND.gatewayServiceName });
     }
+    if (req.method === 'GET' && url.pathname === '/line/webhook/health') {
+        return send(res, 200, { status: 'ok', platform: 'line' });
+    }
+    if (req.method === 'GET' && url.pathname === '/sms/webhook/health') {
+        return send(res, 200, { status: 'ok', platform: 'sms' });
+    }
+    if (req.method === 'GET' && url.pathname === '/whatsapp/webhook/health') {
+        const { readGatewayConfig, resolveWhatsAppConfig } = await import('./config.js');
+        const whatsapp = resolveWhatsAppConfig(await readGatewayConfig());
+        return send(res, 200, {
+            status: 'ok',
+            platform: 'whatsapp',
+            phone_number_id_configured: Boolean(whatsapp.phoneNumberId),
+            access_token_configured: Boolean(whatsapp.accessToken),
+            app_secret_configured: Boolean(whatsapp.appSecret),
+            verify_token_configured: Boolean(whatsapp.verifyToken),
+        });
+    }
+    if (req.method === 'GET' && url.pathname === '/webhooks/health') {
+        return send(res, 200, { status: 'ok', platform: 'webhook' });
+    }
+    if (req.method === 'POST' && url.pathname === '/line/webhook') {
+        const rawBody = await readRawBody(req);
+        const signature = Array.isArray(req.headers['x-line-signature']) ? req.headers['x-line-signature'][0] : req.headers['x-line-signature'];
+        const { readGatewayConfig, resolveLineConfig } = await import('./config.js');
+        const { handleLineWebhook } = await import('./line.js');
+        const result = await handleLineWebhook({
+            rawBody,
+            signature,
+            config: resolveLineConfig(await readGatewayConfig()),
+            model: opts.defaultModel,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+            onLog: opts.onLog,
+        });
+        return send(res, result.status, result.body);
+    }
+    if (req.method === 'POST' && url.pathname === '/sms/webhook') {
+        const rawBody = await readRawBody(req);
+        const signature = Array.isArray(req.headers['x-twilio-signature']) ? req.headers['x-twilio-signature'][0] : req.headers['x-twilio-signature'];
+        const { readGatewayConfig, resolveSmsConfig } = await import('./config.js');
+        const { handleSmsWebhook } = await import('./sms.js');
+        const result = await handleSmsWebhook({
+            rawBody,
+            signature,
+            config: resolveSmsConfig(await readGatewayConfig()),
+            model: opts.defaultModel,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+            onLog: opts.onLog,
+        });
+        return sendRaw(res, result.status, result.contentType, result.body);
+    }
+    if (req.method === 'GET' && url.pathname === '/whatsapp/webhook') {
+        const { readGatewayConfig, resolveWhatsAppConfig } = await import('./config.js');
+        const { handleWhatsAppChallenge } = await import('./whatsapp.js');
+        const result = handleWhatsAppChallenge(resolveWhatsAppConfig(await readGatewayConfig()), url.searchParams);
+        return sendRaw(res, result.status, result.contentType, result.body);
+    }
+    if (req.method === 'POST' && url.pathname === '/whatsapp/webhook') {
+        const rawBody = await readRawBody(req);
+        const signature = Array.isArray(req.headers['x-hub-signature-256']) ? req.headers['x-hub-signature-256'][0] : req.headers['x-hub-signature-256'];
+        const { readGatewayConfig, resolveWhatsAppConfig } = await import('./config.js');
+        const { handleWhatsAppWebhook } = await import('./whatsapp.js');
+        const result = await handleWhatsAppWebhook({
+            rawBody,
+            signature,
+            config: resolveWhatsAppConfig(await readGatewayConfig()),
+            model: opts.defaultModel,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+            onLog: opts.onLog,
+        });
+        return send(res, result.status, result.body);
+    }
+    if (req.method === 'POST' && url.pathname.startsWith('/webhooks/')) {
+        const routeName = parseWebhookRouteName(url.pathname);
+        if (!routeName)
+            return send(res, 400, { error: 'invalid_webhook_route' });
+        const rawBody = await readRawBody(req);
+        const { readGatewayConfig, resolveWebhookConfig } = await import('./config.js');
+        const { handleWebhookRequest } = await import('./webhooks.js');
+        const result = await handleWebhookRequest({
+            routeName,
+            rawBody,
+            headers: req.headers,
+            config: resolveWebhookConfig(await readGatewayConfig()),
+            model: opts.defaultModel,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+            onLog: opts.onLog,
+        });
+        return send(res, result.status, result.body);
+    }
     // ทุก endpoint อื่น → bearer token
-    const auth = req.headers.authorization ?? '';
-    const provided = auth.startsWith('Bearer ') ? auth.slice(7) : undefined;
+    const provided = parseBearerToken(req.headers.authorization);
     if (!tokenMatches(opts.token, provided)) {
         return send(res, 401, { error: 'unauthorized' });
     }
@@ -63,8 +247,51 @@ async function handle(req, res, opts) {
         const history = msgs
             .slice(0, lastUserIdx)
             .map((m) => ({ role: m.role, content: m.content }));
-        const model = typeof body.model === 'string' && body.model ? body.model : opts.defaultModel;
-        const { text } = await runAgent({
+        const { model: requestedModel, invalid: invalidModel } = parseOptionalTaskModel(body.model);
+        if (invalidModel)
+            return send(res, 400, { error: invalidModel });
+        const model = requestedModel ?? opts.defaultModel;
+        const runner = opts.runner ?? runAgent;
+        if (body.stream === true) {
+            res.writeHead(200, {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-cache, no-transform',
+                connection: 'keep-alive',
+            });
+            sendSse(res, {
+                object: 'chat.completion.chunk',
+                model,
+                choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+            });
+            try {
+                await runner({
+                    model,
+                    prompt,
+                    history,
+                    maxSteps: 20,
+                    budgetUsd: opts.budgetUsd,
+                    permissionMode: opts.permissionMode ?? 'ask',
+                    onEvent: (e) => {
+                        if (e.type !== 'text' || !e.text)
+                            return;
+                        sendSse(res, {
+                            object: 'chat.completion.chunk',
+                            model,
+                            choices: [{ index: 0, delta: { content: e.text }, finish_reason: null }],
+                        });
+                    },
+                });
+                sendSse(res, { object: 'chat.completion.chunk', model, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] });
+                sendSse(res, '[DONE]');
+            }
+            catch (e) {
+                sendSse(res, { error: redactKey(e.message ?? String(e)) });
+                sendSse(res, '[DONE]');
+            }
+            res.end();
+            return;
+        }
+        const { text } = await runner({
             model,
             prompt,
             history,
@@ -83,17 +310,24 @@ async function handle(req, res, opts) {
     }
     if (req.method === 'POST' && url.pathname === '/tasks') {
         const body = await readBody(req);
-        const spec = String(body.spec ?? '').trim();
-        if (!spec)
-            return send(res, 400, { error: 'ต้องมี spec' });
-        const sched = body.schedule ? parseSchedule(String(body.schedule), Date.now()) : null;
-        if (body.schedule && !sched)
-            return send(res, 400, { error: `schedule ไม่ถูกต้อง: ${String(body.schedule)}` });
+        const specInput = parseRequiredTaskSpec(body.spec);
+        if ('invalid' in specInput)
+            return send(res, 400, { error: specInput.invalid });
+        const { schedule: sched, invalid } = parseOptionalSchedule(body.schedule, Date.now());
+        if (invalid)
+            return send(res, 400, { error: `schedule ไม่ถูกต้อง: ${invalid}` });
+        const { model, invalid: invalidModel } = parseOptionalTaskModel(body.model);
+        if (invalidModel)
+            return send(res, 400, { error: invalidModel });
+        const { deliver, invalid: invalidDeliver } = parseOptionalDeliverTarget(body.deliver);
+        if (invalidDeliver)
+            return send(res, 400, { error: invalidDeliver });
         const task = await enqueueTask({
             kind: sched?.recurring ? 'cron' : 'once',
-            spec,
+            spec: specInput.spec,
             schedule: sched?.recurring ? sched.normalized : undefined,
-            model: typeof body.model === 'string' ? body.model : undefined,
+            model,
+            deliver,
             runAt: sched?.runAt ?? Date.now(),
         });
         return send(res, 201, { task });

package/dist/gateway/service.js

@@ -0,0 +1,224 @@
+import { spawn } from 'node:child_process';
+import { closeSync, openSync } from 'node:fs';
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { appHomePath, BRAND } from '../brand.js';
+const SERVICE_STATE_PATH = appHomePath('gateway', 'service.json');
+const SERVICE_LOG_PATH = appHomePath('gateway', 'gateway.log');
+export function gatewayServiceStatePath() {
+    return SERVICE_STATE_PATH;
+}
+export function gatewayServiceLogPath() {
+    return SERVICE_LOG_PATH;
+}
+export function processAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+export async function readGatewayServiceState() {
+    try {
+        const parsed = JSON.parse(await readFile(SERVICE_STATE_PATH, 'utf8'));
+        const pid = parsed.pid;
+        if (typeof pid !== 'number' || !Number.isInteger(pid) || !parsed.command || !Array.isArray(parsed.args))
+            return null;
+        return {
+            pid,
+            startedAt: typeof parsed.startedAt === 'string' ? parsed.startedAt : '',
+            command: parsed.command,
+            args: parsed.args.filter((a) => typeof a === 'string'),
+            cwd: typeof parsed.cwd === 'string' ? parsed.cwd : process.cwd(),
+            logPath: typeof parsed.logPath === 'string' ? parsed.logPath : SERVICE_LOG_PATH,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function gatewayServiceStatus() {
+    const state = await readGatewayServiceState();
+    return {
+        running: state ? processAlive(state.pid) : false,
+        state,
+        statePath: SERVICE_STATE_PATH,
+        logPath: SERVICE_LOG_PATH,
+    };
+}
+async function writeState(state) {
+    await mkdir(dirname(SERVICE_STATE_PATH), { recursive: true });
+    await writeFile(SERVICE_STATE_PATH, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    await chmod(SERVICE_STATE_PATH, 0o600).catch(() => { });
+}
+export async function clearGatewayServiceState() {
+    await rm(SERVICE_STATE_PATH, { force: true }).catch(() => { });
+}
+export async function startGatewayService(opts) {
+    const existing = await readGatewayServiceState();
+    if (existing && processAlive(existing.pid))
+        return { started: false, state: existing };
+    const command = opts.command ?? process.execPath;
+    const entrypoint = resolve(opts.entrypoint);
+    const args = [entrypoint, 'gateway', 'run', ...(opts.gatewayArgs ?? [])];
+    const cwd = opts.cwd ?? process.cwd();
+    await mkdir(dirname(SERVICE_LOG_PATH), { recursive: true });
+    const fd = openSync(SERVICE_LOG_PATH, 'a');
+    let child;
+    try {
+        child = (opts.spawnFn ?? spawn)(command, args, {
+            cwd,
+            detached: true,
+            env: opts.env ?? process.env,
+            stdio: ['ignore', fd, fd],
+        });
+    }
+    finally {
+        closeSync(fd);
+    }
+    child.unref();
+    if (!child.pid)
+        throw new Error('เริ่ม gateway service ไม่สำเร็จ: ไม่มี pid จาก child process');
+    const state = {
+        pid: child.pid,
+        startedAt: new Date().toISOString(),
+        command,
+        args,
+        cwd,
+        logPath: SERVICE_LOG_PATH,
+    };
+    await writeState(state);
+    return { started: true, state };
+}
+async function waitUntilStopped(pid, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!processAlive(pid))
+            return true;
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    return !processAlive(pid);
+}
+export async function stopGatewayService(timeoutMs = 3000) {
+    const state = await readGatewayServiceState();
+    if (!state)
+        return { stopped: false, state: null };
+    if (!processAlive(state.pid)) {
+        await clearGatewayServiceState();
+        return { stopped: false, state };
+    }
+    process.kill(state.pid, 'SIGTERM');
+    const stopped = await waitUntilStopped(state.pid, timeoutMs);
+    if (!stopped && processAlive(state.pid)) {
+        try {
+            process.kill(state.pid, 'SIGKILL');
+        }
+        catch {
+            /* already gone */
+        }
+    }
+    await clearGatewayServiceState();
+    return { stopped: true, state };
+}
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}
+function quoteSystemdArg(value) {
+    return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+function quoteCmdArg(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+export async function installGatewayService(entrypoint) {
+    const command = process.execPath;
+    const script = resolve(entrypoint);
+    if (process.platform === 'darwin') {
+        const path = join(homedir(), 'Library', 'LaunchAgents', `com.${BRAND.cliName}.gateway.plist`);
+        const log = SERVICE_LOG_PATH;
+        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.${BRAND.cliName}.gateway</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(command)}</string>
+    <string>${escapeXml(script)}</string>
+    <string>gateway</string>
+    <string>run</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${escapeXml(log)}</string>
+  <key>StandardErrorPath</key><string>${escapeXml(log)}</string>
+</dict>
+</plist>
+`;
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, plist, { mode: 0o644 });
+        return {
+            path,
+            kind: 'launchd',
+            instructions: [`launchctl load ${path}`, `launchctl start com.${BRAND.cliName}.gateway`],
+        };
+    }
+    if (process.platform === 'linux') {
+        const path = join(homedir(), '.config', 'systemd', 'user', `${BRAND.cliName}-gateway.service`);
+        const unit = `[Unit]
+Description=${BRAND.productName} Gateway
+
+[Service]
+ExecStart=${quoteSystemdArg(command)} ${quoteSystemdArg(script)} gateway run
+Restart=always
+WorkingDirectory=${quoteSystemdArg(process.cwd())}
+StandardOutput=${quoteSystemdArg(`append:${SERVICE_LOG_PATH}`)}
+StandardError=${quoteSystemdArg(`append:${SERVICE_LOG_PATH}`)}
+
+[Install]
+WantedBy=default.target
+`;
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, unit, { mode: 0o644 });
+        return {
+            path,
+            kind: 'systemd',
+            instructions: ['systemctl --user daemon-reload', `systemctl --user enable --now ${BRAND.cliName}-gateway.service`],
+        };
+    }
+    const path = appHomePath('gateway', `${BRAND.cliName}-gateway.cmd`);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${quoteCmdArg(command)} ${quoteCmdArg(script)} gateway run\r\n`, { mode: 0o700 });
+    return {
+        path,
+        kind: 'cmd',
+        instructions: [`Run ${path} from your preferred Windows service manager or Task Scheduler.`],
+    };
+}
+export async function uninstallGatewayService() {
+    const paths = [
+        join(homedir(), 'Library', 'LaunchAgents', `com.${BRAND.cliName}.gateway.plist`),
+        join(homedir(), '.config', 'systemd', 'user', `${BRAND.cliName}-gateway.service`),
+        appHomePath('gateway', `${BRAND.cliName}-gateway.cmd`),
+    ];
+    const removed = [];
+    for (const path of paths) {
+        try {
+            await rm(path, { force: true });
+            removed.push(path);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return removed;
+}