sanook-cli 0.5.1 → 0.5.5

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

package/dist/gateway/session.js

@@ -0,0 +1,362 @@
+import { createHash } from 'node:crypto';
+import { chmod, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { appHomePath, persistenceEnabled } from '../brand.js';
+import { runAgent } from '../loop.js';
+import { redactKey, redactUnknown } from '../providers/keys.js';
+import { canonicalSpec, parseSpec, PROVIDERS } from '../providers/registry.js';
+import { autoCompact, estimateTokens } from '../compaction.js';
+import { patchGlobalConfig } from '../config.js';
+import { parseInsightsDays } from '../insights-args.js';
+import { normalizePersonalityName, personalityListText } from '../personality.js';
+import { patchGatewayConfig, readGatewayConfig } from './config.js';
+const SESSION_DIR = appHomePath('gateway', 'sessions');
+function safePlatformSegment(platform) {
+    const safe = platform.trim().replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+    return safe || 'gateway';
+}
+export function gatewaySessionId(platform, target) {
+    const digest = createHash('sha256').update(`${platform}:${target}`).digest('hex').slice(0, 24);
+    return `${safePlatformSegment(platform)}-${digest}`;
+}
+function sessionPath(id) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(id) || id.includes('..')) {
+        throw new Error(`gateway session id ไม่ถูกต้อง: ${id}`);
+    }
+    return join(SESSION_DIR, `${id}.json`);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isModelMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.role === 'system')
+        return typeof value.content === 'string';
+    if (value.role === 'tool')
+        return Array.isArray(value.content);
+    if (value.role === 'user' || value.role === 'assistant') {
+        return typeof value.content === 'string' || Array.isArray(value.content);
+    }
+    return false;
+}
+function isGatewaySession(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        typeof value.platform === 'string' &&
+        typeof value.target === 'string' &&
+        typeof value.created === 'string' &&
+        typeof value.updated === 'string' &&
+        typeof value.model === 'string' &&
+        Array.isArray(value.messages) &&
+        value.messages.every(isModelMessage));
+}
+export function shouldSuppressDelivery(text) {
+    const normalized = text.trim().toUpperCase().replace(/[\s_-]+/g, ' ');
+    return normalized === '[SILENT]' || normalized === 'SILENT' || normalized === 'NO REPLY';
+}
+export async function loadGatewaySession(platform, target) {
+    try {
+        const id = gatewaySessionId(platform, target);
+        const parsed = JSON.parse(await readFile(sessionPath(id), 'utf8'));
+        return isGatewaySession(parsed) && parsed.id === id ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function listGatewaySessions() {
+    try {
+        const files = (await readdir(SESSION_DIR)).filter((f) => f.endsWith('.json'));
+        const sessions = await Promise.all(files.map(async (file) => {
+            try {
+                const parsed = JSON.parse(await readFile(join(SESSION_DIR, file), 'utf8'));
+                return isGatewaySession(parsed) ? parsed : null;
+            }
+            catch {
+                return null;
+            }
+        }));
+        return sessions.filter((s) => s !== null).sort((a, b) => b.updated.localeCompare(a.updated));
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveGatewaySession(session) {
+    if (!persistenceEnabled())
+        return;
+    await mkdir(SESSION_DIR, { recursive: true });
+    const safeSession = {
+        ...session,
+        messages: redactUnknown(session.messages),
+    };
+    await writeFile(sessionPath(session.id), `${JSON.stringify(safeSession, null, 2)}\n`, { mode: 0o600 });
+    await chmod(sessionPath(session.id), 0o600).catch(() => { });
+}
+export async function removeGatewaySession(platform, target) {
+    try {
+        await rm(sessionPath(gatewaySessionId(platform, target)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function gatewayCommandHelp() {
+    return [
+        'Messaging commands:',
+        '/new หรือ /reset — เริ่มบทสนทนาใหม่',
+        '/model [spec] — ดู/เปลี่ยน model ของ chat นี้',
+        '/personality [name] — ดู/ตั้ง personality overlay',
+        '/retry — รัน user turn ล่าสุดอีกครั้ง',
+        '/undo — ลบ exchange ล่าสุดจาก history',
+        '/compress — compact history ของ chat นี้',
+        '/usage — ดู usage โดยประมาณของ chat นี้',
+        '/insights [days] — ดู usage/session insights',
+        '/stop — หยุด turn ที่กำลังรัน (ถ้ามี)',
+        '/status — ดู session ปัจจุบัน',
+        '/sethome — ตั้ง chat นี้เป็น home target สำหรับ delivery/cron',
+        '/help — ดูคำสั่งที่รองรับ',
+    ].join('\n');
+}
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
+                return part.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+function lastUserIndex(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'user')
+            return i;
+    }
+    return -1;
+}
+function trimLastExchange(messages) {
+    const userIdx = lastUserIndex(messages);
+    return userIdx === -1 ? messages : messages.slice(0, userIdx);
+}
+async function saveGatewayState(opts, existing, model, messages) {
+    const now = new Date().toISOString();
+    const session = {
+        id: gatewaySessionId(opts.platform, opts.target),
+        platform: opts.platform,
+        target: opts.target,
+        created: existing?.created ?? now,
+        updated: now,
+        model,
+        messages,
+    };
+    await saveGatewaySession(session);
+    return session;
+}
+async function runAndSaveGatewayTurn(opts, existing, prompt, history, model) {
+    const { text, messages } = await runAgent({
+        model,
+        prompt,
+        history,
+        maxSteps: opts.maxSteps ?? 20,
+        budgetUsd: opts.budgetUsd,
+        permissionMode: opts.permissionMode ?? 'ask',
+    });
+    await saveGatewayState(opts, existing, model, messages);
+    return { text, messages, suppressDelivery: shouldSuppressDelivery(text) };
+}
+function addFirst(items, item) {
+    return [item, ...(items ?? []).filter((x) => x !== item)];
+}
+async function setHomeTarget(platform, target) {
+    const cfg = await readGatewayConfig();
+    switch (platform) {
+        case 'telegram': {
+            const chatId = Number(target);
+            if (!Number.isInteger(chatId))
+                return 'Telegram /sethome ต้องมาจาก numeric chat id';
+            await patchGatewayConfig({ telegram: { allowedChatIds: addFirst(cfg.telegram?.allowedChatIds, chatId) } });
+            return `ตั้ง Telegram home/allowed chat เป็น ${chatId} แล้ว`;
+        }
+        case 'discord':
+            await patchGatewayConfig({ discord: { defaultChannelId: target, allowedChannelIds: addFirst(cfg.discord?.allowedChannelIds, target) } });
+            return `ตั้ง Discord home channel เป็น ${target} แล้ว`;
+        case 'slack':
+            await patchGatewayConfig({ slack: { defaultChannelId: target, allowedChannelIds: addFirst(cfg.slack?.allowedChannelIds, target) } });
+            return `ตั้ง Slack home channel เป็น ${target} แล้ว`;
+        case 'mattermost':
+            await patchGatewayConfig({ mattermost: { homeChannel: target, allowedChannels: addFirst(cfg.mattermost?.allowedChannels, target) } });
+            return `ตั้ง Mattermost home channel เป็น ${target} แล้ว`;
+        case 'homeassistant':
+            await patchGatewayConfig({ homeassistant: { homeChannel: target } });
+            return `ตั้ง Home Assistant home notification เป็น ${target} แล้ว`;
+        case 'email':
+            await patchGatewayConfig({ email: { homeAddress: target, allowedUsers: addFirst(cfg.email?.allowedUsers, target.toLowerCase()) } });
+            return `ตั้ง Email home address เป็น ${target} แล้ว`;
+        case 'line':
+            await patchGatewayConfig({ line: { homeChannel: target, allowedUsers: addFirst(cfg.line?.allowedUsers, target) } });
+            return `ตั้ง LINE home channel เป็น ${target} แล้ว`;
+        case 'sms':
+            await patchGatewayConfig({ sms: { homeChannel: target, allowedUsers: addFirst(cfg.sms?.allowedUsers, target) } });
+            return `ตั้ง SMS home channel เป็น ${target} แล้ว`;
+        case 'ntfy':
+            await patchGatewayConfig({ ntfy: { homeChannel: target, allowedUsers: addFirst(cfg.ntfy?.allowedUsers, target) } });
+            return `ตั้ง ntfy home topic เป็น ${target} แล้ว`;
+        case 'signal':
+            await patchGatewayConfig({ signal: { homeChannel: target, allowedUsers: addFirst(cfg.signal?.allowedUsers, target) } });
+            return `ตั้ง Signal home channel เป็น ${target} แล้ว`;
+        case 'whatsapp':
+            await patchGatewayConfig({ whatsapp: { homeChannel: target, allowedUsers: addFirst(cfg.whatsapp?.allowedUsers, target) } });
+            return `ตั้ง WhatsApp home channel เป็น ${target} แล้ว`;
+        case 'matrix':
+            await patchGatewayConfig({ matrix: { homeRoom: target, allowedRooms: addFirst(cfg.matrix?.allowedRooms, target) } });
+            return `ตั้ง Matrix home room เป็น ${target} แล้ว`;
+        case 'googlechat':
+            await patchGatewayConfig({ googleChat: { homeChannel: target, allowedSpaces: addFirst(cfg.googleChat?.allowedSpaces, target) } });
+            return `ตั้ง Google Chat home channel เป็น ${target} แล้ว`;
+        case 'bluebubbles':
+            await patchGatewayConfig({ bluebubbles: { homeChannel: target, allowedUsers: addFirst(cfg.bluebubbles?.allowedUsers, target) } });
+            return `ตั้ง BlueBubbles home channel เป็น ${target} แล้ว`;
+        case 'teams':
+            await patchGatewayConfig({ teams: { homeChannel: target, chatId: target } });
+            return `ตั้ง Teams home channel เป็น ${target} แล้ว`;
+        default:
+            return `platform ${platform} ยังไม่รองรับ /sethome`;
+    }
+}
+async function handleGatewayCommand(opts) {
+    const input = opts.userText?.trim();
+    if (!input?.startsWith('/'))
+        return null;
+    const [command, ...args] = input.slice(1).trim().split(/\s+/);
+    const normalized = command?.toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'new' || normalized === 'reset') {
+        await removeGatewaySession(opts.platform, opts.target);
+        return { text: 'เริ่มบทสนทนาใหม่แล้ว', messages: [], suppressDelivery: false };
+    }
+    if (normalized === 'status') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const turns = existing?.messages.length ?? 0;
+        const text = existing
+            ? [
+                `Session: ${existing.id}`,
+                `Platform: ${existing.platform}`,
+                `Target: ${existing.target}`,
+                `Model: ${existing.model}`,
+                `Messages: ${turns}`,
+                `Updated: ${existing.updated}`,
+            ].join('\n')
+            : `ยังไม่มี session สำหรับ ${opts.platform}:${opts.target}`;
+        return { text, messages: existing?.messages ?? [], suppressDelivery: false };
+    }
+    if (normalized === 'help') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        return { text: gatewayCommandHelp(), messages: existing?.messages ?? [], suppressDelivery: false };
+    }
+    if (normalized === 'sethome') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        return { text: await setHomeTarget(opts.platform, opts.target), messages: existing?.messages ?? [], suppressDelivery: false };
+    }
+    if (normalized === 'stop') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        return { text: 'ไม่มี turn ที่กำลังทำงานให้หยุดใน command นี้', messages: existing?.messages ?? [], suppressDelivery: false };
+    }
+    if (normalized === 'model') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const currentModel = existing?.model ?? opts.model;
+        const spec = args[0];
+        if (!spec)
+            return { text: `model ปัจจุบัน: ${currentModel}`, messages: existing?.messages ?? [], suppressDelivery: false };
+        const canonical = canonicalSpec(spec);
+        const parsed = parseSpec(canonical);
+        if (!PROVIDERS[parsed.provider] || !parsed.model) {
+            return { text: `model spec ไม่รองรับ: ${spec}`, messages: existing?.messages ?? [], suppressDelivery: false };
+        }
+        const session = await saveGatewayState(opts, existing, canonical, existing?.messages ?? []);
+        return { text: `เปลี่ยน model ของ chat นี้ → ${canonical}`, messages: session.messages, suppressDelivery: false };
+    }
+    if (normalized === 'personality') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const raw = args.join(' ').trim();
+        if (!raw)
+            return { text: personalityListText(), messages: existing?.messages ?? [], suppressDelivery: false };
+        const name = normalizePersonalityName(raw);
+        if (!name)
+            return { text: `ไม่รู้จัก personality: ${raw}\n\n${personalityListText()}`, messages: existing?.messages ?? [], suppressDelivery: false };
+        await patchGlobalConfig({ personality: name === 'none' ? undefined : name });
+        return {
+            text: name === 'none' ? 'ปิด personality overlay แล้ว' : `ตั้ง personality → ${name}`,
+            messages: existing?.messages ?? [],
+            suppressDelivery: false,
+        };
+    }
+    if (normalized === 'usage') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const messages = existing?.messages ?? [];
+        return {
+            text: [
+                `messages: ${messages.length}`,
+                `approx tokens: ~${estimateTokens(messages)}`,
+                `model: ${existing?.model ?? opts.model}`,
+            ].join('\n'),
+            messages,
+            suppressDelivery: false,
+        };
+    }
+    if (normalized === 'insights') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const days = parseInsightsDays(args);
+        if (days === null)
+            return { text: 'ใช้: /insights [days]', messages: existing?.messages ?? [], suppressDelivery: false };
+        const { renderInsights } = await import('../insights.js');
+        return { text: await renderInsights({ days, cwd: null, includeGateway: true }), messages: existing?.messages ?? [], suppressDelivery: false };
+    }
+    if (normalized === 'compress') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        if (!existing?.messages.length)
+            return { text: 'ยังไม่มี history ให้ compact', messages: [], suppressDelivery: false };
+        const before = estimateTokens(existing.messages);
+        const messages = autoCompact(existing.messages, 40_000, 20);
+        await saveGatewayState(opts, existing, existing.model, messages);
+        return { text: `compact แล้ว: ~${before} → ~${estimateTokens(messages)} tokens`, messages, suppressDelivery: false };
+    }
+    if (normalized === 'undo') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        if (!existing?.messages.length)
+            return { text: 'ยังไม่มี turn ให้ undo', messages: [], suppressDelivery: false };
+        const messages = trimLastExchange(existing.messages);
+        await saveGatewayState(opts, existing, existing.model, messages);
+        return { text: 'undo exchange ล่าสุดแล้ว', messages, suppressDelivery: false };
+    }
+    if (normalized === 'retry') {
+        const existing = await loadGatewaySession(opts.platform, opts.target);
+        const idx = existing ? lastUserIndex(existing.messages) : -1;
+        if (!existing || idx === -1)
+            return { text: 'ยังไม่มี user turn ให้ retry', messages: existing?.messages ?? [], suppressDelivery: false };
+        const prompt = messageText(existing.messages[idx].content).trim();
+        if (!prompt)
+            return { text: 'user turn ล่าสุดว่าง retry ไม่ได้', messages: existing.messages, suppressDelivery: false };
+        return runAndSaveGatewayTurn(opts, existing, prompt, existing.messages.slice(0, idx), existing.model);
+    }
+    return null;
+}
+export async function runGatewayAgent(opts) {
+    const command = await handleGatewayCommand(opts);
+    if (command)
+        return command;
+    const existing = await loadGatewaySession(opts.platform, opts.target);
+    return runAndSaveGatewayTurn(opts, existing, opts.prompt, existing?.messages ?? [], existing?.model ?? opts.model);
+}