sanook-cli 0.4.0

package/dist/commands.js

@@ -0,0 +1,66 @@
+import { PROVIDERS, parseSpec } from './providers/registry.js';
+const HELP_TEXT = `คำสั่ง:
+  /help            แสดงคำสั่งทั้งหมด
+  /model [spec]    ดู/เปลี่ยน model (เช่น /model opus, /model openai:gpt-5)
+  /tools           ดู tools ที่ agent ใช้ได้
+  /skills          ดูจำนวน skills (จัดการ: sanook skill list)
+  /cost            ดู token + cost รอบล่าสุด
+  /clear           ล้าง conversation (เริ่มใหม่)
+  /compact         บีบ context
+  /quit            ออก`;
+const TOOLS_LIST = [
+    'read_file write_file edit_file list_dir glob grep run_bash',
+    'git_status git_diff git_log git_commit',
+    'remember recall · skill find_skills create_skill',
+    'schedule_task list_scheduled cancel_scheduled · task',
+].join('\n  ');
+/** /model (ไม่มี arg) — โชว์ model ปัจจุบัน + ตัวเลือกของ provider นั้น (alias จาก registry) */
+function modelMenu(current) {
+    const { provider } = parseSpec(current);
+    const cfg = PROVIDERS[provider];
+    const list = cfg
+        ? Object.entries(cfg.models)
+            .filter(([alias]) => alias !== 'default')
+            .map(([alias, id]) => `  ${provider}:${alias}  →  ${id}`)
+            .join('\n')
+        : '';
+    return [
+        `model ปัจจุบัน: ${current}`,
+        cfg ? `\nเลือกของ ${cfg.label}:\n${list}` : '',
+        `\nเปลี่ยน: /model <spec>  (เช่น /model sonnet, /model openai:gpt-5.5)`,
+        `provider อื่น: ${Object.keys(PROVIDERS).join(' · ')}`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+/** parse input — ถ้าขึ้นต้น / = slash command, ไม่งั้น handled=false (ส่งเข้า agent) */
+export function parseCommand(input, ctx) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return { handled: false };
+    const [cmd, ...args] = trimmed.slice(1).split(/\s+/);
+    switch (cmd) {
+        case 'help':
+        case '?':
+            return { handled: true, action: 'help', message: HELP_TEXT };
+        case 'clear':
+            return { handled: true, action: 'clear', message: 'ล้าง conversation แล้ว' };
+        case 'compact':
+            return { handled: true, action: 'compact', message: 'บีบ context แล้ว' };
+        case 'quit':
+        case 'exit':
+            return { handled: true, action: 'quit' };
+        case 'model':
+            if (!args[0])
+                return { handled: true, message: modelMenu(ctx.model) };
+            return { handled: true, modelChange: args[0], message: `เปลี่ยน model → ${args[0]}` };
+        case 'tools':
+            return { handled: true, message: `tools ที่ agent ใช้ได้ (+ MCP ที่ตั้งไว้):\n  ${TOOLS_LIST}` };
+        case 'skills':
+            return { handled: true, message: 'skills โหลดจาก built-in + ~/.sanook/skills — จัดการด้วย "sanook skill list/add/remove"' };
+        case 'cost':
+            return { handled: true, message: ctx.costSummary ?? '(ยังไม่มี usage รอบนี้)' };
+        default:
+            return { handled: true, message: `ไม่รู้จักคำสั่ง /${cmd} — พิมพ์ /help` };
+    }
+}

package/dist/compaction.js

@@ -0,0 +1,85 @@
+const TRUNC_HEAD = 400;
+const TRUNC_TAIL = 600;
+const CHARS_PER_TOKEN = 4; // ประมาณคร่าวๆ (จริง ~3.5-4 ต่อ token)
+/** ตัดข้อความยาว เก็บหัว (intent) + ท้าย (error/result) */
+export function truncateText(s) {
+    if (s.length <= TRUNC_HEAD + TRUNC_TAIL + 40)
+        return s;
+    return (s.slice(0, TRUNC_HEAD) +
+        `\n... [pruned ${s.length - TRUNC_HEAD - TRUNC_TAIL} chars] ...\n` +
+        s.slice(-TRUNC_TAIL));
+}
+/**
+ * prune tool-result ที่ยาวใน message เก่า (นอก tail) ให้สั้นลง
+ * — tool transcript มักเป็น ~90%+ ของ token ในงานยาว, clear ก่อนเป็นวิธีถูกสุด
+ * เก็บ message ท้าย keepTail ไว้เต็ม (ยัง relevant ต่อ step ถัดไป)
+ */
+export function pruneToolResults(messages, keepTail = 4) {
+    const cut = Math.max(0, messages.length - keepTail);
+    return messages.map((m, i) => {
+        if (i >= cut)
+            return m;
+        if (m.role !== 'tool' || !Array.isArray(m.content))
+            return m;
+        return {
+            ...m,
+            content: m.content.map((part) => {
+                if (part.type === 'tool-result' &&
+                    part.output?.type === 'text' &&
+                    typeof part.output.value === 'string') {
+                    return { ...part, output: { ...part.output, value: truncateText(part.output.value) } };
+                }
+                return part;
+            }),
+        };
+    });
+}
+/** ประมาณ token ของ conversation (chars/4) — ไม่เป๊ะแต่พอใช้ตัดสิน compact */
+export function estimateTokens(messages) {
+    let chars = 0;
+    for (const m of messages) {
+        if (typeof m.content === 'string') {
+            chars += m.content.length;
+        }
+        else if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (typeof part.text === 'string')
+                    chars += part.text.length;
+                else if (part.type === 'tool-result' &&
+                    part.output?.type === 'text' &&
+                    typeof part.output.value === 'string') {
+                    chars += (part.output.value).length;
+                }
+                else {
+                    chars += JSON.stringify(part).length;
+                }
+            }
+        }
+    }
+    return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+/**
+ * auto-compact (zero LLM cost) — กัน context overflow ในงานยาว:
+ * 1) ถ้า token ≤ limit → คืนเดิม (no-op)
+ * 2) prune tool results เต็ม (transcript = token ส่วนใหญ่)
+ * 3) ยังเกิน → sliding window: เก็บ user แรก (intent) + N message ล่าสุด, ตัดกลาง + marker
+ */
+export function autoCompact(messages, tokenLimit, keepRecent = 20) {
+    if (estimateTokens(messages) <= tokenLimit)
+        return messages;
+    const pruned = pruneToolResults(messages, 2);
+    if (estimateTokens(pruned) <= tokenLimit)
+        return pruned;
+    if (pruned.length <= keepRecent + 1)
+        return pruned;
+    const firstUser = pruned.find((m) => m.role === 'user');
+    let recent = pruned.slice(-keepRecent);
+    // ตัด tool message ที่ค้างหัว — tool-result ที่ tool-call ถูกตัดไปแล้ว = orphan → API reject
+    while (recent.length && recent[0].role === 'tool')
+        recent = recent.slice(1);
+    const marker = {
+        role: 'user',
+        content: '[บทสนทนาเก่าถูกตัดออกเพื่อประหยัด context — รายละเอียดดูได้จาก memory/session]',
+    };
+    return firstUser && !recent.includes(firstUser) ? [firstUser, marker, ...recent] : [marker, ...recent];
+}

package/dist/config.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const CONFIG_DIR = join(homedir(), '.sanook');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+const AUTH_PATH = join(CONFIG_DIR, 'auth.json'); // API keys (chmod 0600)
+export const ConfigSchema = z.object({
+    model: z.string().default('sonnet'),
+    budgetUsd: z.number().positive().optional(),
+    maxSteps: z.number().int().positive().default(20),
+    // auto = รัน tool เลย (act-first) · ask = ขออนุมัติก่อน write/bash/commit
+    permissionMode: z.enum(['auto', 'ask']).default('auto'),
+    // path ของ second-brain workspace ที่ scaffold ไว้ (sanook brain) — optional
+    brainPath: z.string().optional(),
+});
+async function readJson(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {}; // ไม่มีไฟล์ / parse ไม่ได้ = ใช้ default
+    }
+}
+/**
+ * โหลด config แบบ layered: global (~/.sanook) < project (.sanook) < CLI overrides
+ * merge raw ทุกชั้นก่อน แล้ว validate zod ทีเดียวที่ merged สุดท้าย
+ * (config flat — shallow merge พอ; strip undefined ใน overrides กัน override ทับ default)
+ */
+export async function loadConfig(overrides = {}, cwd = process.cwd()) {
+    const global = await readJson(join(homedir(), '.sanook', 'config.json'));
+    const project = await readJson(join(cwd, '.sanook', 'config.json'));
+    const cleanOverrides = {};
+    for (const [k, v] of Object.entries(overrides)) {
+        if (v !== undefined)
+            cleanOverrides[k] = v;
+    }
+    const merged = { ...global, ...project, ...cleanOverrides };
+    return ConfigSchema.parse(merged);
+}
+/** ครั้งแรกที่รัน (ยังไม่มี global config) → ต้องทำ setup wizard */
+export async function isFirstRun() {
+    try {
+        await readFile(CONFIG_PATH, 'utf8');
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/** บันทึก global config (model/provider ที่เลือกตอน setup) */
+export async function saveGlobalConfig(cfg) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const existing = await readJson(CONFIG_PATH);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, ...cfg }, null, 2)}\n`);
+}
+/** บันทึก path ของ second-brain workspace ลง global config (merge — ไม่ทับ field อื่น) */
+export async function saveBrainPath(path) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const existing = await readJson(CONFIG_PATH);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, brainPath: path }, null, 2)}\n`);
+}
+/** อ่าน config.json ดิบ (ไม่ apply default/schema) — สำหรับ `sanook config` */
+export async function readGlobalConfigRaw() {
+    return readJson(CONFIG_PATH);
+}
+/** merge patch ลง config.json (สำหรับ `sanook config set`) */
+export async function patchGlobalConfig(patch) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    const existing = await readJson(CONFIG_PATH);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, ...patch }, null, 2)}\n`);
+}
+/** บันทึก API key ลง ~/.sanook/auth.json (chmod 0600) + set env ทันทีสำหรับ session นี้ */
+export async function saveKey(envVar, key) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    let auth = {};
+    try {
+        auth = JSON.parse(await readFile(AUTH_PATH, 'utf8'));
+    }
+    catch {
+        /* ยังไม่มีไฟล์ */
+    }
+    auth[envVar] = key;
+    await writeFile(AUTH_PATH, `${JSON.stringify(auth, null, 2)}\n`);
+    await chmod(AUTH_PATH, 0o600); // เจ้าของอ่าน/เขียนเท่านั้น
+    process.env[envVar] = key;
+}
+/** โหลด key จาก auth.json เข้า env ตอน boot (ไม่ override env ที่ตั้งไว้แล้ว) */
+export async function loadKeysIntoEnv() {
+    try {
+        const auth = JSON.parse(await readFile(AUTH_PATH, 'utf8'));
+        for (const [k, v] of Object.entries(auth)) {
+            if (!process.env[k] && typeof v === 'string')
+                process.env[k] = v;
+        }
+    }
+    catch {
+        /* ไม่มี auth.json = ข้าม */
+    }
+}

package/dist/cost.js

@@ -0,0 +1,59 @@
+// key = specKey() = "anthropic:<curated model id>" — ต้องตรงกับ id ใน registry (มี test กัน drift)
+export const PRICING = {
+    'anthropic:claude-opus-4-8': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+    'anthropic:claude-sonnet-4-6': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+    'anthropic:claude-haiku-4-5': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+    'anthropic:claude-fable-5': { input: 10, output: 50, cacheWrite: 12.5, cacheRead: 1 },
+};
+export class CostMeter {
+    specKey;
+    budgetUsd;
+    inTok = 0;
+    outTok = 0;
+    cacheReadTok = 0;
+    cacheWriteTok = 0;
+    spent = 0;
+    constructor(specKey, budgetUsd) {
+        this.specKey = specKey;
+        this.budgetUsd = budgetUsd;
+    }
+    /**
+     * บวก usage ของ 1 step. cacheWriteTokens ดึงจาก providerMetadata แยก (default 0)
+     * AI SDK 6: usage.inputTokens = total → ต้องหัก cacheRead/cacheWrite ออกก่อนคิดราคา input
+     * ไม่งั้น double-count cacheRead (cache hit จะกลายเป็นแพงกว่า no-cache)
+     */
+    add(usage, cacheWriteTokens = 0) {
+        const totalInput = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        const cacheRead = usage.cachedInputTokens ?? 0;
+        const noCacheInput = Math.max(0, totalInput - cacheRead - cacheWriteTokens);
+        this.inTok += noCacheInput;
+        this.outTok += output;
+        this.cacheReadTok += cacheRead;
+        this.cacheWriteTok += cacheWriteTokens;
+        const p = PRICING[this.specKey];
+        if (p) {
+            this.spent +=
+                (noCacheInput / 1e6) * p.input +
+                    (output / 1e6) * p.output +
+                    (cacheRead / 1e6) * p.cacheRead +
+                    (cacheWriteTokens / 1e6) * p.cacheWrite;
+        }
+    }
+    get totalUsd() {
+        return this.spent;
+    }
+    get hasPricing() {
+        return this.specKey in PRICING;
+    }
+    /** true เมื่อใช้เกิน budget (เช็คก่อนยิง request ถัดไป) */
+    get overBudget() {
+        return this.budgetUsd != null && this.spent >= this.budgetUsd;
+    }
+    summary() {
+        const total = this.inTok + this.outTok + this.cacheReadTok + this.cacheWriteTok;
+        const cost = this.hasPricing ? `$${this.spent.toFixed(4)}` : '(ไม่มี pricing สำหรับ model นี้)';
+        const budget = this.budgetUsd != null ? ` / budget $${this.budgetUsd}` : '';
+        return `tokens: ${total} (in ${this.inTok} · out ${this.outTok} · cache-read ${this.cacheReadTok} · cache-write ${this.cacheWriteTok}) · cost ${cost}${budget}`;
+    }
+}

package/dist/diff.js

@@ -0,0 +1,36 @@
+// minimal unified-ish diff (zero dep) — โชว์ให้เห็นว่าแก้อะไรก่อน/หลัง โปร่งใส
+const MAX_LINES = 14;
+/** diff ของ edit (old block → new block) — render เป็น -old / +new */
+export function renderEditDiff(oldStr, newStr) {
+    const oldL = oldStr.split('\n');
+    const newL = newStr.split('\n');
+    // ตัด common prefix/suffix lines ที่เหมือนกัน เพื่อโชว์เฉพาะส่วนที่เปลี่ยน
+    let pre = 0;
+    while (pre < oldL.length && pre < newL.length && oldL[pre] === newL[pre])
+        pre++;
+    let suf = 0;
+    while (suf < oldL.length - pre &&
+        suf < newL.length - pre &&
+        oldL[oldL.length - 1 - suf] === newL[newL.length - 1 - suf])
+        suf++;
+    const oldMid = oldL.slice(pre, oldL.length - suf);
+    const newMid = newL.slice(pre, newL.length - suf);
+    const lines = [];
+    for (const l of oldMid.slice(0, MAX_LINES))
+        lines.push(`- ${l}`);
+    if (oldMid.length > MAX_LINES)
+        lines.push(`  …(-${oldMid.length - MAX_LINES} บรรทัด)`);
+    for (const l of newMid.slice(0, MAX_LINES))
+        lines.push(`+ ${l}`);
+    if (newMid.length > MAX_LINES)
+        lines.push(`  …(+${newMid.length - MAX_LINES} บรรทัด)`);
+    return lines.join('\n');
+}
+/** สรุปการ write — จำนวนบรรทัด/ตัวอักษร + ถ้าเขียนทับ บอก before→after */
+export function summarizeWrite(content, previous) {
+    const lines = content === '' ? 0 : content.split('\n').length;
+    if (previous === undefined)
+        return `เขียนใหม่ ${lines} บรรทัด (${content.length} ตัวอักษร)`;
+    const prevLines = previous === '' ? 0 : previous.split('\n').length;
+    return `เขียนทับ ${prevLines} → ${lines} บรรทัด (${content.length} ตัวอักษร)`;
+}

package/dist/gateway/auth.js

@@ -0,0 +1,32 @@
+import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+const GATEWAY_DIR = join(homedir(), '.sanook', 'gateway');
+const TOKEN_FILE = join(GATEWAY_DIR, 'token');
+/** โหลด bearer token ของ gateway; ไม่มี → สร้าง 256-bit ใหม่ เก็บ chmod 600 */
+export async function loadOrCreateToken() {
+    try {
+        const t = (await readFile(TOKEN_FILE, 'utf8')).trim();
+        if (t)
+            return t;
+    }
+    catch {
+        /* ยังไม่มี → สร้างใหม่ */
+    }
+    const token = randomBytes(32).toString('hex');
+    await mkdir(GATEWAY_DIR, { recursive: true });
+    await writeFile(TOKEN_FILE, `${token}\n`, { mode: 0o600 });
+    await chmod(TOKEN_FILE, 0o600).catch(() => { });
+    return token;
+}
+/** constant-time compare กัน timing attack (length เทียบก่อนเพราะ timingSafeEqual ต้อง len เท่ากัน) */
+export function tokenMatches(expected, provided) {
+    if (!provided)
+        return false;
+    const a = Buffer.from(expected);
+    const b = Buffer.from(provided);
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}

package/dist/gateway/ledger.js

@@ -0,0 +1,94 @@
+import { readFile, writeFile, rename, mkdir, chmod } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { withFileLock } from './lock.js';
+// task-ledger = งานที่ gateway ต้องทำ (cron / message / one-shot) — Hermes "Kanban" / OpenClaw "Task Brain"
+// เก็บเป็น JSON (zero native dep) แทน SQLite; ทุก mutation = locked read-modify-write (atomic ต่อ op)
+// → กัน lost-write จากหลาย writer (server enqueue / scheduler update / cron CLI) ที่ยิงไฟล์เดียวกัน
+const GATEWAY_DIR = join(homedir(), '.sanook', 'gateway');
+const TASKS_FILE = join(GATEWAY_DIR, 'tasks.json');
+const LOCK_FILE = join(GATEWAY_DIR, 'tasks.lock');
+// ── 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 : [];
+    }
+    catch {
+        return []; // ไม่มีไฟล์/พัง → empty (write แบบ atomic จึงไม่ทำลายของเดิม)
+    }
+}
+async function writeTasks(tasks) {
+    await mkdir(GATEWAY_DIR, { recursive: true });
+    const tmp = `${TASKS_FILE}.${randomUUID()}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(tasks, null, 2)}\n`, { mode: 0o600 });
+    await rename(tmp, TASKS_FILE); // atomic — reader ไม่เห็นไฟล์ครึ่งๆ
+    await chmod(TASKS_FILE, 0o600).catch(() => { });
+}
+/** mutation ทุกตัววิ่งผ่านนี่: lock → re-read สด → แก้ → write (ไม่ trust snapshot เก่า) */
+async function mutate(fn) {
+    await mkdir(GATEWAY_DIR, { recursive: true });
+    return withFileLock(LOCK_FILE, async () => {
+        const tasks = await readTasks();
+        const { tasks: next, result } = fn(tasks);
+        await writeTasks(next);
+        return result;
+    });
+}
+// ── reads (lock-free — atomic rename กัน torn read อยู่แล้ว) ──
+export function listTasks() {
+    return readTasks();
+}
+export async function getTask(id) {
+    return (await readTasks()).find((t) => t.id === id);
+}
+export async function dueTasks(now = Date.now()) {
+    return (await readTasks()).filter((t) => t.status === 'queued' && t.runAt <= now);
+}
+// ── mutations (locked, atomic, re-read สด) ──
+export async function enqueueTask(t) {
+    const task = { id: randomUUID().slice(0, 8), status: 'queued', createdAt: Date.now(), ...t };
+    await mutate((tasks) => {
+        tasks.push(task);
+        return { tasks, result: undefined };
+    });
+    return task;
+}
+export async function updateTask(id, patch) {
+    await mutate((tasks) => {
+        const t = tasks.find((x) => x.id === id);
+        if (t)
+            Object.assign(t, patch);
+        return { tasks, result: undefined };
+    });
+}
+export async function removeTask(id) {
+    return mutate((tasks) => {
+        const next = tasks.filter((t) => t.id !== id);
+        return { tasks: next, result: next.length !== tasks.length };
+    });
+}
+/** atomic claim: queued → running. false ถ้าโดน claim ไปแล้ว (กัน 2 writer รัน task เดียวกัน) */
+export async function claimTask(id) {
+    return mutate((tasks) => {
+        const t = tasks.find((x) => x.id === id);
+        if (!t || t.status !== 'queued')
+            return { tasks, result: false };
+        t.status = 'running';
+        return { tasks, result: true };
+    });
+}
+/** recover task ที่ค้าง 'running' (จาก crash/shutdown กลางคัน) → 'queued'. เรียกตอน gateway start */
+export async function recoverStaleRunning() {
+    return mutate((tasks) => {
+        let n = 0;
+        for (const t of tasks) {
+            if (t.status === 'running') {
+                t.status = 'queued';
+                n++;
+            }
+        }
+        return { tasks, result: n };
+    });
+}

package/dist/gateway/lock.js

@@ -0,0 +1,114 @@
+import { open, unlink, readFile, rename, stat } from 'node:fs/promises';
+import { unlinkSync } from 'node:fs';
+// advisory file lock ผ่าน O_EXCL lockfile — กัน lost-write จากหลาย writer (server/scheduler/CLI) ยิงไฟล์เดียว
+// robustness (จาก adversarial re-review): TTL กัน pid-reuse deadlock · rename-evict ลด TOCTOU · fh-safe acquire
+// หมายเหตุ: นี่คือ best-effort lock สำหรับ single-user local — ไม่ใช่ distributed lock; residual TOCTOU window
+// แคบมาก (ต้องมี 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)
+/** holder ตายไหม — เช็คจาก pid อย่างเดียว (ใช้กับ singleton ที่ถือยาว, ไม่มี TTL) */
+async function holderDead(lockPath) {
+    try {
+        const pid = parseInt((await readFile(lockPath, 'utf8')).trim(), 10);
+        if (!Number.isInteger(pid) || pid <= 0)
+            return true; // pid พัง → ยึดได้
+        try {
+            process.kill(pid, 0); // เช็คว่ามี process นี้ (ไม่ส่ง signal จริง)
+            return false;
+        }
+        catch (e) {
+            return e.code === 'ESRCH'; // ไม่มี process → ตาย
+        }
+    }
+    catch {
+        return false; // อ่าน lock ไม่ได้ (อาจเพิ่งถูกย้าย) → ยังไม่ถือว่า stale
+    }
+}
+/** สำหรับ mutate lock (สั้น): pid ตาย OR lock เก่าเกิน TTL (กัน pid-reuse ทำ deadlock ถาวร) */
+async function expiredOrDead(lockPath) {
+    try {
+        const st = await stat(lockPath);
+        if (Date.now() - st.mtimeMs > LOCK_TTL_MS)
+            return true; // อายุเกิน TTL → stale แน่
+    }
+    catch {
+        return false; // ไม่มีไฟล์แล้ว
+    }
+    return holderDead(lockPath);
+}
+/** ยึด stale lock แบบ atomic: rename ออกก่อน (winner เดียวที่ rename สำเร็จ) แล้วลบ tomb — ไม่ unlink path ตรงๆ */
+async function evict(lockPath) {
+    const tomb = `${lockPath}.tomb.${process.pid}`;
+    try {
+        await rename(lockPath, tomb); // atomic — ถ้าคนอื่น evict ไปก่อน rename จะ ENOENT
+        await unlink(tomb).catch(() => { });
+    }
+    catch {
+        /* คนอื่นชิง evict ไปแล้ว — ไม่ทำอะไร */
+    }
+}
+/** สร้าง lockfile แบบ fh-safe (writeFile/close throw → close fd + ลบ lock ที่ตัวเองสร้าง ไม่ทิ้ง orphan) */
+async function tryCreate(lockPath) {
+    let fh;
+    try {
+        fh = await open(lockPath, 'wx'); // O_EXCL — fail ถ้ามีอยู่
+    }
+    catch (e) {
+        if (e.code === 'EEXIST')
+            return false;
+        throw e;
+    }
+    try {
+        await fh.writeFile(String(process.pid));
+    }
+    catch (e) {
+        await fh.close().catch(() => { });
+        await unlink(lockPath).catch(() => { }); // ลบ orphan ที่ตัวเองสร้าง
+        throw e;
+    }
+    await fh.close().catch(() => { });
+    return true;
+}
+const backoff = (i) => Math.min(250, 10 * 2 ** Math.min(i, 5)) + Math.floor(Math.random() * 20);
+/** ทำ fn ภายใต้ exclusive lock — serialize read-modify-write. capped-exponential backoff + jitter */
+export async function withFileLock(lockPath, fn, retries = 300) {
+    for (let i = 0; i < retries; i++) {
+        if (await tryCreate(lockPath)) {
+            try {
+                return await fn();
+            }
+            finally {
+                await unlink(lockPath).catch(() => { });
+            }
+        }
+        if (await expiredOrDead(lockPath)) {
+            await evict(lockPath);
+            continue; // ลองยึดทันที
+        }
+        await sleep(backoff(i)); // มี writer อื่น alive ถืออยู่
+    }
+    throw new Error(`lock timeout: ${lockPath}`);
+}
+/**
+ * ยึด lock ระยะยาว (singleton เช่น gateway) — fail-safe: pid-reuse → ถือว่า busy (ปฏิเสธ start ดีกว่ารัน 2 ตัว)
+ * คืน release() แบบ sync (unlinkSync) เพื่อให้ปล่อย lock ทันก่อน process.exit, หรือ null ถ้ามี instance อื่น alive
+ */
+export async function acquireSingleton(lockPath) {
+    for (;;) {
+        if (await tryCreate(lockPath)) {
+            return () => {
+                try {
+                    unlinkSync(lockPath); // sync — เสร็จก่อน process.exit ตัด event loop
+                }
+                catch {
+                    /* ลบไปแล้ว */
+                }
+            };
+        }
+        if (await holderDead(lockPath)) {
+            await evict(lockPath);
+            continue; // stale → ยึดต่อ
+        }
+        return null; // instance อื่น alive
+    }
+}

package/dist/gateway/schedule.js

@@ -0,0 +1,74 @@
+// แปลง schedule string ของมนุษย์ → เวลา (epoch ms) + recurring
+// support: interval ("every 30m" / "2h"), daily ("09:00"), ISO timestamp (one-shot), "now"
+// pure — รับ now เป็น param (ไม่เรียก Date.now ใน body หลัก) เพื่อ test ได้
+const UNIT_MS = { s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+const pad = (n) => String(n).padStart(2, '0');
+/** next occurrence ของ HH:MM (local time) หลัง now */
+function nextDaily(minutesOfDay, now) {
+    const target = new Date(now);
+    target.setHours(Math.floor(minutesOfDay / 60), minutesOfDay % 60, 0, 0);
+    if (target.getTime() <= now)
+        target.setDate(target.getDate() + 1);
+    return target.getTime();
+}
+export function parseSchedule(input, now) {
+    const s = input.trim().toLowerCase();
+    if (!s)
+        return null;
+    if (s === 'now' || s === 'immediately') {
+        return { runAt: now, recurring: false, kind: 'once', normalized: 'now' };
+    }
+    // interval: "every 30m" | "30m" | "every 2 h" | "2hours"
+    const iv = s.match(/^(?:every\s+)?(\d+)\s*(s|m|h|d|sec|secs|min|mins|hour|hours|day|days)$/);
+    if (iv) {
+        const n = parseInt(iv[1], 10);
+        const unit = iv[2][0]; // s/m/h/d (ตัวแรกพอ)
+        const ms = n * (UNIT_MS[unit] ?? 0);
+        // กัน overflow → runAt เป็น Invalid Date ที่ due() ไม่มีวันยิง
+        if (!Number.isSafeInteger(ms) || ms <= 0 || !Number.isFinite(now + ms))
+            return null;
+        return { runAt: now + ms, recurring: true, kind: 'cron', normalized: `every ${n}${unit}` };
+    }
+    // daily time: "09:00" | "at 9:00" | "daily 09:30"
+    const dt = s.match(/^(?:at\s+|daily\s+(?:at\s+)?)?(\d{1,2}):(\d{2})$/);
+    if (dt) {
+        const hh = parseInt(dt[1], 10);
+        const mm = parseInt(dt[2], 10);
+        if (hh > 23 || mm > 59)
+            return null;
+        const mins = hh * 60 + mm;
+        return { runAt: nextDaily(mins, now), recurring: true, kind: 'cron', normalized: `${pad(hh)}:${pad(mm)}` };
+    }
+    // ── NL ภาษาไทย / aliases → map เป็น canonical แล้ว parse ซ้ำ ──
+    if (/^(ทุก\s*ๆ?\s*)?(ชั่วโมง|ชม\.?|hourly)$/.test(s))
+        return parseSchedule('every 1h', now);
+    if (/^(ทุก\s*ๆ?\s*)?(นาที|minutely)$/.test(s))
+        return parseSchedule('every 1m', now);
+    // "ทุก 30 นาที" / "ทุกๆ 2 ชั่วโมง" / "ทุก 1 ชม"
+    const thIv = s.match(/^ทุก\s*ๆ?\s*(\d+)\s*(นาที|ชม\.?|ชั่วโมง|วัน)$/);
+    if (thIv) {
+        const u = thIv[2];
+        const unit = u.startsWith('นาที') ? 'm' : u.startsWith('วัน') ? 'd' : 'h'; // ชม/ชั่วโมง → h
+        return parseSchedule(`every ${thIv[1]}${unit}`, now);
+    }
+    // "ทุกวัน 9:00" / "ทุกวัน 21.30"
+    const thDaily = s.match(/^ทุกวัน\s*(\d{1,2})[:.](\d{2})$/);
+    if (thDaily)
+        return parseSchedule(`${thDaily[1]}:${thDaily[2]}`, now);
+    // ISO timestamp (one-shot) — รับเฉพาะรูปแบบที่มี date จริง (กัน Date.parse รับ bare number/year-only กำกวม)
+    const raw = input.trim();
+    if (/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}|$)/.test(raw)) {
+        const t = Date.parse(raw);
+        if (!Number.isNaN(t)) {
+            if (t < now)
+                return null; // one-shot ในอดีต → ปฏิเสธ (ไม่ยิงย้อนหลังเงียบๆ)
+            return { runAt: t, recurring: false, kind: 'once', normalized: new Date(t).toISOString() };
+        }
+    }
+    return null; // parse ไม่ได้
+}
+/** เวลารอบถัดไปของ recurring task (re-parse normalized จากเวลาที่เพิ่งรันเสร็จ) */
+export function nextRun(normalized, from) {
+    const p = parseSchedule(normalized, from);
+    return p?.recurring ? p.runAt : null;
+}