sanook-cli 0.4.0

package/dist/providers/registry.js

@@ -0,0 +1,241 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { createXai } from '@ai-sdk/xai';
+import { createMistral } from '@ai-sdk/mistral';
+import { createGroq } from '@ai-sdk/groq';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { resolveKeyFromEnv, assertDirectApiKey } from './keys.js';
+// ────────────────────────────────────────────────────────────────────────────
+// PROVIDER TABLE — เพิ่มค่าย = เพิ่ม 1 entry (loop/cost/keys ไม่ต้องแตะ)
+// auth/format/OAuth-reject verify มิ.ย. 2026 (ดู Research/provider-connect-matrix)
+// ────────────────────────────────────────────────────────────────────────────
+export const PROVIDERS = {
+    // ── ToS-sensitive: Anthropic/Google แบน OAuth/subscription reuse ────────────
+    anthropic: {
+        id: 'anthropic',
+        label: 'Anthropic (Claude)',
+        envVar: 'ANTHROPIC_API_KEY',
+        baseURL: 'https://api.anthropic.com/v1',
+        requiresKey: true,
+        keyFormat: /^sk-ant-api\d{2}-/,
+        oauthRejectPrefixes: ['sk-ant-oat'], // Claude.ai subscription OAuth → banned
+        models: {
+            default: 'claude-opus-4-8',
+            opus: 'claude-opus-4-8',
+            sonnet: 'claude-sonnet-4-6',
+            haiku: 'claude-haiku-4-5',
+            fast: 'claude-haiku-4-5',
+            fable: 'claude-fable-5',
+        },
+        create: (key, baseURL) => createAnthropic({ apiKey: key, baseURL }),
+        note: 'API key only (x-api-key, sk-ant-api03-). ห้าม reuse Claude.ai OAuth — banned',
+    },
+    google: {
+        id: 'google',
+        label: 'Google Gemini',
+        envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+        envFallbacks: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+        requiresKey: true,
+        keyFormat: /^AIza[0-9A-Za-z_-]{35}$/,
+        oauthRejectPrefixes: ['ya29.', 'AQ.'], // Google OAuth / restricted token → banned
+        models: {
+            default: 'gemini-2.5-pro',
+            pro: 'gemini-2.5-pro',
+            flash: 'gemini-2.5-flash',
+            gemini: 'gemini-2.5-pro',
+        },
+        create: (key) => createGoogleGenerativeAI({ apiKey: key }),
+        note: 'AI Studio key (AIza). restrict เป็น Gemini-only. ห้าม reuse Gemini CLI OAuth',
+    },
+    // ── Cloud BYOK: commercial OK, ไม่มี OAuth landmine ─────────────────────────
+    openai: {
+        id: 'openai',
+        label: 'OpenAI',
+        envVar: 'OPENAI_API_KEY',
+        baseURL: 'https://api.openai.com/v1',
+        requiresKey: true,
+        keyFormat: /^sk-/,
+        models: {
+            default: 'gpt-5.5',
+            smart: 'gpt-5.5',
+            fast: 'gpt-5.4-mini',
+            gpt: 'gpt-5.5',
+            codex: 'gpt-5.3-codex', // coding-tuned (gpt-5-codex deprecated มิ.ย. 2026 — doc audit); เรียกผ่าน OpenAI API ปกติ
+        },
+        create: (key, baseURL) => createOpenAI({ apiKey: key, baseURL }),
+        note: 'Bearer key. org/project ผ่าน env. ห้าม reuse ChatGPT/Codex OAuth',
+    },
+    deepseek: {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        envVar: 'DEEPSEEK_API_KEY',
+        requiresKey: true,
+        keyFormat: null, // opaque sk- → ข้าม format check
+        // V4 ids (doc audit มิ.ย. 2026): deepseek-chat/deepseek-reasoner เลิกใช้ 2026-07-24 → redirect มา V4 (dual thinking-mode)
+        models: { default: 'deepseek-v4-flash', smart: 'deepseek-v4-pro', fast: 'deepseek-v4-flash' },
+        create: (key) => createDeepSeek({ apiKey: key }),
+    },
+    xai: {
+        id: 'xai',
+        label: 'xAI Grok',
+        envVar: 'XAI_API_KEY',
+        requiresKey: true,
+        keyFormat: /^xai-[A-Za-z0-9]{16,}$/,
+        // grok-4 (snapshot grok-4-0709) retired 2026-05-15 → redirect grok-4.3 (doc audit มิ.ย. 2026)
+        models: { default: 'grok-4.3', smart: 'grok-4.3', grok: 'grok-4.3' },
+        create: (key) => createXai({ apiKey: key }),
+    },
+    mistral: {
+        id: 'mistral',
+        label: 'Mistral',
+        envVar: 'MISTRAL_API_KEY',
+        requiresKey: true,
+        keyFormat: null,
+        models: { default: 'mistral-large-latest', smart: 'mistral-large-latest', fast: 'mistral-small-latest' },
+        create: (key) => createMistral({ apiKey: key }),
+    },
+    groq: {
+        id: 'groq',
+        label: 'Groq',
+        envVar: 'GROQ_API_KEY',
+        requiresKey: true,
+        keyFormat: /^gsk_[A-Za-z0-9]{20,}$/,
+        models: { default: 'llama-3.3-70b-versatile', fast: 'llama-3.3-70b-versatile' },
+        create: (key) => createGroq({ apiKey: key }),
+    },
+    // ── Local: OpenAI-compatible, ไม่ต้อง key (placeholder ถ้า client บังคับ) ────
+    ollama: {
+        id: 'ollama',
+        label: 'Ollama (local)',
+        envVar: 'OLLAMA_BASE_URL',
+        baseURL: 'http://localhost:11434/v1', // /v1 (generic OpenAI-compat) ไม่ใช่ /api
+        requiresKey: false,
+        localPlaceholderKey: 'ollama',
+        keyFormat: null,
+        models: { default: 'qwen3', llama: 'llama3.3' },
+        create: (key, baseURL) => createOpenAICompatible({ name: 'ollama', apiKey: key, baseURL: baseURL ?? 'http://localhost:11434/v1' }),
+        note: 'OpenAI-compat /v1 endpoint. ไม่ต้อง key',
+    },
+    lmstudio: {
+        id: 'lmstudio',
+        label: 'LM Studio (local)',
+        envVar: 'LMSTUDIO_BASE_URL',
+        baseURL: 'http://localhost:1234/v1',
+        requiresKey: false,
+        localPlaceholderKey: 'lm-studio',
+        keyFormat: null,
+        models: { default: 'local-model' },
+        create: (key, baseURL) => createOpenAICompatible({ name: 'lmstudio', apiKey: key, baseURL: baseURL ?? 'http://localhost:1234/v1' }),
+        note: 'ต้อง Start Server ในแอปก่อน; โหลด model เดียว ใส่ id อะไรก็ serve ตัวนั้น',
+    },
+    // ── Cloud BYOK (OpenAI-compatible, จีน — data residency, ไม่มี OAuth landmine) ──
+    minimax: {
+        id: 'minimax',
+        label: 'MiniMax',
+        envVar: 'MINIMAX_API_KEY',
+        baseURL: 'https://api.minimax.io/v1',
+        requiresKey: true,
+        keyFormat: null, // opaque
+        models: { default: 'MiniMax-M2.7', smart: 'MiniMax-M3', fast: 'MiniMax-M2.7' },
+        create: (key, baseURL) => createOpenAICompatible({ name: 'minimax', apiKey: key, baseURL: baseURL ?? 'https://api.minimax.io/v1' }),
+        note: 'OpenAI-compat /v1. data จีน. MINIMAX_BASE_URL override (intl ↔ api.minimaxi.com/v1)',
+    },
+    glm: {
+        id: 'glm',
+        label: 'GLM (z.ai / Zhipu Coding Plan)',
+        envVar: 'ZHIPU_API_KEY',
+        envFallbacks: ['ZAI_API_KEY', 'GLM_API_KEY'],
+        // Coding Plan (subscription) ใช้ Anthropic Messages API — เหมือนที่ต่อกับ Claude Code.
+        // pay-as-you-go /paas/v4 (OpenAI-compat) มีแค่ glm-4.5-flash ฟรี ที่เหลือ 429 ถ้าไม่มี balance
+        baseURL: 'https://api.z.ai/api/anthropic/v1',
+        requiresKey: true,
+        keyFormat: null, // opaque ({id}.{secret})
+        models: { default: 'glm-4.6', smart: 'glm-5.1', air: 'glm-4.5-air', glm: 'glm-4.6' },
+        create: (key, baseURL) => createAnthropic({ apiKey: key, baseURL: baseURL ?? 'https://api.z.ai/api/anthropic/v1' }),
+        note: 'z.ai Coding Plan ผ่าน Anthropic Messages API. GLM_BASE_URL override → open.bigmodel.cn/api/anthropic/v1 (จีน)',
+    },
+    // ── Delegate: OpenAI Codex ผ่าน ChatGPT plan quota (wrap official codex CLI, ToS-safe) ──
+    codex: {
+        id: 'codex',
+        label: 'OpenAI Codex (ChatGPT plan)',
+        kind: 'delegate',
+        envVar: 'CODEX_HOME', // ไม่ใช้ API key — codex login จัดการ auth เอง
+        requiresKey: false,
+        localPlaceholderKey: 'codex',
+        keyFormat: null,
+        models: { default: 'gpt-5-codex', codex: 'gpt-5-codex' },
+        create: () => {
+            throw new Error('codex เป็น delegate provider — ใช้ผ่าน codex subprocess ไม่ใช่ Vercel AI SDK');
+        },
+        note: 'ใช้ ChatGPT plan quota ผ่าน official codex CLI (ToS-safe, ไม่เก็บ credential). ต้อง codex login ก่อน',
+    },
+};
+export const SUPPORTED_PROVIDERS = Object.keys(PROVIDERS);
+// alias สั้นข้าม provider — bare word (ไม่มี ':') map ไป provider+alias
+const GLOBAL_ALIAS = {
+    opus: { provider: 'anthropic', alias: 'opus' },
+    sonnet: { provider: 'anthropic', alias: 'sonnet' },
+    haiku: { provider: 'anthropic', alias: 'haiku' },
+    fast: { provider: 'anthropic', alias: 'fast' },
+    fable: { provider: 'anthropic', alias: 'fable' },
+    gpt: { provider: 'openai', alias: 'gpt' },
+    codex: { provider: 'codex', alias: 'default' }, // bare "codex" = ChatGPT quota (delegate); "openai:codex" = API key
+    gemini: { provider: 'google', alias: 'gemini' },
+    flash: { provider: 'google', alias: 'flash' },
+    grok: { provider: 'xai', alias: 'grok' },
+    deepseek: { provider: 'deepseek', alias: 'default' },
+    mistral: { provider: 'mistral', alias: 'default' },
+    groq: { provider: 'groq', alias: 'default' },
+    ollama: { provider: 'ollama', alias: 'default' },
+    lmstudio: { provider: 'lmstudio', alias: 'default' },
+    glm: { provider: 'glm', alias: 'default' },
+    minimax: { provider: 'minimax', alias: 'default' },
+};
+/** parse "provider:model" | "provider:alias" | alias | "model" (default anthropic) */
+export function parseSpec(spec) {
+    const idx = spec.indexOf(':');
+    if (idx !== -1) {
+        const provider = spec.slice(0, idx);
+        const rest = spec.slice(idx + 1);
+        const cfg = PROVIDERS[provider];
+        // ถ้าเป็น alias ของ provider นั้น → map เป็น model id จริง, ไม่งั้นใช้ rest เป็น raw model id
+        const model = cfg?.models[rest] ?? rest;
+        return { provider, model };
+    }
+    const g = GLOBAL_ALIAS[spec];
+    if (g)
+        return { provider: g.provider, model: PROVIDERS[g.provider].models[g.alias] };
+    // bare model id → default provider anthropic
+    return { provider: 'anthropic', model: spec };
+}
+/** normalized key สำหรับ lookup pricing เช่น "anthropic:claude-sonnet-4-6" */
+export function specKey(spec) {
+    const { provider, model } = parseSpec(spec);
+    return `${provider}:${model}`;
+}
+/** resolve spec → LanguageModel (throw ถ้าไม่มี key / provider ผิด / key เป็น OAuth) */
+export function resolveModel(spec) {
+    const { provider, model } = parseSpec(spec);
+    const cfg = PROVIDERS[provider];
+    if (!cfg) {
+        throw new Error(`provider ไม่รองรับ: "${provider}" — รองรับ: ${SUPPORTED_PROVIDERS.join('/')} (เช่น "openai:gpt-5", "sonnet", "groq:fast")`);
+    }
+    let key;
+    if (cfg.requiresKey) {
+        const found = resolveKeyFromEnv(cfg.envVar, cfg.envFallbacks);
+        if (!found) {
+            throw new Error(`ต้องตั้ง ${cfg.envVar} ก่อนใช้ provider "${provider}" (BYOK — API key ตรงจาก console)`);
+        }
+        assertDirectApiKey(cfg, found); // reject OAuth/subscription token + format ผิด
+        key = found;
+    }
+    else {
+        key = resolveKeyFromEnv(cfg.envVar) ?? cfg.localPlaceholderKey ?? 'local';
+    }
+    // <PROVIDER>_BASE_URL env → override (สลับ region intl/จีน); ไม่งั้น local อ่าน env, cloud ใช้ default
+    const baseURL = process.env[`${cfg.id.toUpperCase()}_BASE_URL`] ??
+        (cfg.requiresKey ? cfg.baseURL : process.env[cfg.envVar] ?? cfg.baseURL);
+    return cfg.create(key, baseURL)(model);
+}

package/dist/session.js

@@ -0,0 +1,36 @@
+import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// session store — จำ conversation + ความคืบหน้า เพื่อ "ทำงานต่อได้" ไม่ลืมว่าทำถึงไหน
+const SESSION_DIR = join(homedir(), '.sanook', 'sessions');
+export function newSessionId() {
+    // CLI runtime — ใช้ Date/random ได้ (ไม่ใช่ workflow context)
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    return `${ts}-${Math.random().toString(36).slice(2, 8)}`;
+}
+export async function saveSession(s) {
+    await mkdir(SESSION_DIR, { recursive: true });
+    await writeFile(join(SESSION_DIR, `${s.id}.json`), `${JSON.stringify(s, null, 2)}\n`);
+}
+export async function loadSession(id) {
+    try {
+        return JSON.parse(await readFile(join(SESSION_DIR, `${id}.json`), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** session ล่าสุด (สำหรับ --continue) */
+export async function latestSession() {
+    try {
+        const ids = (await readdir(SESSION_DIR)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5));
+        if (!ids.length)
+            return null;
+        const sessions = (await Promise.all(ids.map(loadSession))).filter((s) => s !== null);
+        sessions.sort((a, b) => b.updated.localeCompare(a.updated));
+        return sessions[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/skill-install.js

@@ -0,0 +1,190 @@
+import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { join, basename, resolve, sep, dirname } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { randomUUID } from 'node:crypto';
+import { lookup } from 'node:dns/promises';
+import { isIP } from 'node:net';
+import { parseFrontmatter, isValidSkillName } from './skills.js';
+const execFileAsync = promisify(execFile);
+const USER_SKILLS = join(homedir(), '.sanook', 'skills');
+const MAX_FILES = 300;
+const MAX_BYTES = 20 * 1024 * 1024; // 20MB ต่อ skill
+const MAX_MD = 2 * 1024 * 1024; // 2MB ต่อ SKILL.md จาก URL
+const exists = async (p) => {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
+    if (depth < 0)
+        return;
+    let entries;
+    try {
+        entries = await readdir(srcDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith('.'))
+            continue; // skip .git/dotfiles
+        const s = join(srcDir, e.name);
+        const st = await lstat(s);
+        if (st.isSymbolicLink())
+            continue; // ห้าม copy symlink (กัน planted symlink หลุด ~/.sanook)
+        if (st.isDirectory()) {
+            await copyTreeSafe(s, join(destDir, e.name), budget, depth - 1);
+        }
+        else if (st.isFile()) {
+            if (--budget.files < 0)
+                throw new Error('skill มีไฟล์เยอะเกินไป');
+            budget.bytes -= st.size;
+            if (budget.bytes < 0)
+                throw new Error('skill ใหญ่เกินไป (เกิน 20MB)');
+            await mkdir(dirname(join(destDir, e.name)), { recursive: true });
+            await copyFile(s, join(destDir, e.name));
+        }
+    }
+}
+/** copy skill dir (SKILL.md + references/scripts ที่เป็น regular file) → ~/.sanook/skills/<name> */
+async function installFromDir(srcDir) {
+    const md = join(srcDir, 'SKILL.md');
+    const stMd = await lstat(md);
+    if (stMd.isSymbolicLink() || !stMd.isFile())
+        throw new Error('SKILL.md ไม่ใช่ไฟล์ปกติ');
+    const { meta } = parseFrontmatter(await readFile(md, 'utf8'));
+    const name = meta.name || basename(srcDir);
+    if (!isValidSkillName(name))
+        throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
+    const dest = join(USER_SKILLS, name);
+    await rm(dest, { recursive: true, force: true });
+    await mkdir(dest, { recursive: true });
+    await copyTreeSafe(srcDir, dest, { files: MAX_FILES, bytes: MAX_BYTES });
+    return { name, path: dest };
+}
+/** เขียน SKILL.md เดียว (จาก URL) → ~/.sanook/skills/<name> */
+async function installFromContent(content, fallbackName) {
+    const { meta } = parseFrontmatter(content);
+    const name = meta.name || fallbackName;
+    if (!isValidSkillName(name))
+        throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
+    const dest = join(USER_SKILLS, name);
+    await mkdir(dest, { recursive: true });
+    await writeFile(join(dest, 'SKILL.md'), content);
+    return { name, path: dest };
+}
+/** หา SKILL.md ใน dir (ตรงๆ, ทุก subdir, หรือ skills/ subdir) → ติดตั้งทั้งหมด */
+async function installFromLocal(path, onLog) {
+    if (await exists(join(path, 'SKILL.md')))
+        return [await installFromDir(path)];
+    const out = [];
+    for (const root of [path, join(path, 'skills')]) {
+        let entries;
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.isDirectory() && (await exists(join(root, e.name, 'SKILL.md')))) {
+                try {
+                    out.push(await installFromDir(join(root, e.name)));
+                }
+                catch (err) {
+                    onLog?.(`ข้าม ${e.name}: ${err.message}`); // skip ตัวที่ fail ติดตั้งที่เหลือต่อ
+                }
+            }
+        }
+    }
+    if (!out.length)
+        throw new Error(`ไม่เจอ SKILL.md ใน ${path} (รองรับ root, */SKILL.md, skills/*/SKILL.md)`);
+    return out;
+}
+/** clone GitHub repo (shallow) → ติดตั้ง skill — subPath ต้องอยู่ใต้ clone dir (กัน traversal escape) */
+async function installFromGitHub(repoUrl, subPath, onLog) {
+    const tmp = join(tmpdir(), `sanook-skill-${randomUUID().slice(0, 8)}`);
+    try {
+        onLog?.(`clone ${repoUrl} …`);
+        // execFile (no shell) + '--' กัน url ขึ้นต้น '-' ถูกตีเป็น git option + timeout
+        await execFileAsync('git', ['clone', '--depth', '1', '--quiet', '--', repoUrl, tmp], { timeout: 90_000 });
+        // subPath traversal guard — target ต้องอยู่ใต้ tmp
+        const target = subPath ? resolve(tmp, subPath) : tmp;
+        if (subPath && target !== tmp && !target.startsWith(tmp + sep)) {
+            throw new Error(`sub-path ไม่ปลอดภัย: ${subPath}`);
+        }
+        return await installFromLocal(target, onLog);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            throw new Error('ต้องติดตั้ง git ก่อนใช้ skill add จาก GitHub');
+        }
+        throw e;
+    }
+    finally {
+        await rm(tmp, { recursive: true, force: true }).catch(() => { });
+    }
+}
+const PRIVATE_IP = /^(127\.|10\.|192\.168\.|169\.254\.|172\.(1[6-9]|2\d|3[01])\.|::1$|fe80:|f[cd])/i;
+/** fetch SKILL.md จาก URL — block internal/private (SSRF) + timeout + cap ขนาด */
+async function fetchSkillMd(url) {
+    const u = new URL(url);
+    if (u.protocol !== 'https:')
+        throw new Error('รองรับเฉพาะ https สำหรับ URL ของ SKILL.md');
+    // resolve hostname → block private/loopback IP (กัน SSRF ยิง internal/cloud-metadata)
+    let ip = u.hostname;
+    if (!isIP(u.hostname)) {
+        const res = await lookup(u.hostname).catch(() => null);
+        ip = res?.address ?? '';
+    }
+    if (!ip || PRIVATE_IP.test(ip))
+        throw new Error(`URL ชี้ไป internal/private address — ปฏิเสธ (${u.hostname})`);
+    const r = await fetch(url, { signal: AbortSignal.timeout(30_000) });
+    if (!r.ok)
+        throw new Error(`fetch ไม่สำเร็จ: HTTP ${r.status}`);
+    if (Number(r.headers.get('content-length') ?? 0) > MAX_MD)
+        throw new Error('SKILL.md ใหญ่เกิน 2MB');
+    const text = await r.text();
+    if (text.length > MAX_MD)
+        throw new Error('SKILL.md ใหญ่เกิน 2MB');
+    return text;
+}
+/**
+ * ติดตั้ง skill จาก source — local path · URL ของ SKILL.md (https) · GitHub ("user/repo" หรือ "user/repo/sub/path")
+ * ⚠️ skill = instruction ที่ agent จะ trust (ไม่ใช่ data) — ติดตั้งจาก source ที่เชื่อถือเท่านั้น
+ */
+export async function installSkill(source, onLog) {
+    if (await exists(source))
+        return installFromLocal(source, onLog);
+    if (/^https?:\/\//.test(source)) {
+        if (source.endsWith('.md')) {
+            const parts = source.split('/');
+            return [await installFromContent(await fetchSkillMd(source), parts[parts.length - 2] ?? 'skill')];
+        }
+        const m = source.match(/^(https:\/\/github\.com\/[\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/tree\/[^/]+\/(.+))?$/);
+        if (m)
+            return installFromGitHub(`${m[1]}.git`, m[2] ?? '', onLog);
+        throw new Error(`URL ไม่รองรับ: ${source} (ใช้ลิงก์ SKILL.md ตรง หรือ GitHub repo)`);
+    }
+    const seg = source.split('/');
+    if (seg.length >= 2 && /^[\w.-]+$/.test(seg[0]) && /^[\w.-]+$/.test(seg[1])) {
+        return installFromGitHub(`https://github.com/${seg[0]}/${seg[1]}.git`, seg.slice(2).join('/'), onLog);
+    }
+    throw new Error(`ไม่รู้จัก source: "${source}" — ใช้ GitHub "user/repo", URL ของ SKILL.md, หรือ local path`);
+}
+/** ลบ skill ที่ติดตั้งไว้ (เฉพาะ ~/.sanook/skills — ไม่แตะ bundled) */
+export async function removeInstalledSkill(name) {
+    if (!isValidSkillName(name))
+        return false;
+    const dir = join(USER_SKILLS, name);
+    if (!(await exists(dir)))
+        return false;
+    await rm(dir, { recursive: true, force: true });
+    return true;
+}

package/dist/skills.js

@@ -0,0 +1,111 @@
+import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// skills = วิธีทำงานเฉพาะทาง/runbook ที่โหลด on-demand (progressive disclosure)
+// agent เห็นแค่ name+description ใน system prompt → โหลดเต็มด้วย `skill` tool เมื่อ task ตรง
+// self-improvement: agent สร้าง skill เองด้วย `create_skill` เมื่อเจอ procedure ที่ reuse ได้
+// 3 ชั้น: bundled (ship กับ CLI) → global (~/.sanook) → project (.sanook) — ชั้นหลัง override ชื่อซ้ำ
+const BUNDLED_SKILLS = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
+const GLOBAL_SKILLS = join(homedir(), '.sanook', 'skills');
+const projectSkills = () => join(process.cwd(), '.sanook', 'skills');
+/** minimal frontmatter parser (key: value ใน --- block) — ไม่พึ่ง YAML dep */
+export function parseFrontmatter(content) {
+    const m = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m)
+        return { meta: {}, body: content };
+    const meta = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const i = line.indexOf(':');
+        if (i === -1)
+            continue;
+        const k = line.slice(0, i).trim();
+        const v = line
+            .slice(i + 1)
+            .trim()
+            .replace(/^["']|["']$/g, '');
+        if (k)
+            meta[k] = v;
+    }
+    return { meta, body: m[2] };
+}
+/** ป้องกัน path traversal — ชื่อ skill ต้องเป็น slug ปลอดภัย */
+export function isValidSkillName(name) {
+    return /^[a-z0-9][a-z0-9-]{0,63}$/.test(name);
+}
+/** scan project + global skills → list (name+description เท่านั้น สำหรับ inject). project ทับ global ชื่อซ้ำ */
+export async function loadSkills() {
+    const out = new Map();
+    // bundled ก่อน → global → project ทับ (specific กว่าอยู่ท้าย)
+    for (const dir of [BUNDLED_SKILLS, GLOBAL_SKILLS, projectSkills()]) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue; // ไม่มีโฟลเดอร์ = ข้าม
+        }
+        for (const e of entries) {
+            if (!e.isDirectory() || !isValidSkillName(e.name))
+                continue;
+            const p = join(dir, e.name, 'SKILL.md');
+            try {
+                const { meta } = parseFrontmatter(await readFile(p, 'utf8'));
+                out.set(meta.name || e.name, {
+                    name: meta.name || e.name,
+                    description: meta.description ?? '',
+                    whenToUse: meta.when_to_use,
+                    path: p,
+                });
+            }
+            catch {
+                // ไม่มี SKILL.md = ข้าม
+            }
+        }
+    }
+    return [...out.values()];
+}
+/** อ่านเนื้อหา SKILL.md เต็ม (skill tool เรียกเมื่อ agent ตัดสินใจใช้) */
+export async function getSkillBody(name) {
+    if (!isValidSkillName(name))
+        return null;
+    for (const dir of [projectSkills(), GLOBAL_SKILLS, BUNDLED_SKILLS]) {
+        try {
+            return await readFile(join(dir, name, 'SKILL.md'), 'utf8');
+        }
+        catch {
+            /* ลอง dir ถัดไป */
+        }
+    }
+    return null;
+}
+/** สร้าง/อัปเดต skill (create_skill tool เรียก) — เขียนลง global skills */
+export async function saveSkill(name, description, body, whenToUse) {
+    if (!isValidSkillName(name)) {
+        throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}" — ใช้ a-z 0-9 - เท่านั้น`);
+    }
+    const dir = join(GLOBAL_SKILLS, name);
+    await mkdir(dir, { recursive: true });
+    const fm = [
+        '---',
+        `name: ${name}`,
+        `description: ${description.replace(/\n/g, ' ').trim()}`,
+        ...(whenToUse ? [`when_to_use: ${whenToUse.replace(/\n/g, ' ').trim()}`] : []),
+        '---',
+        '',
+        body.trim(),
+        '',
+    ].join('\n');
+    const p = join(dir, 'SKILL.md');
+    await writeFile(p, fm);
+    return p;
+}
+/** render รายชื่อ skill (name+desc) สำหรับ inject เข้า system prompt */
+export function renderAvailableSkills(skills) {
+    if (!skills.length)
+        return '';
+    // truncate description กัน system prompt บวมเมื่อ skill เยอะ (whenToUse/body เต็มอ่านผ่าน skill/find_skills tool)
+    const trunc = (s, n) => (s.length > n ? `${s.slice(0, n).trimEnd()}…` : s);
+    const lines = skills.map((s) => `- ${s.name}: ${trunc(s.description, 140)}`);
+    return `<available_skills note="โหลดเต็มด้วย skill tool · ค้นด้วย find_skills เมื่อไม่แน่ใจว่าตัวไหนตรง">\n${lines.join('\n')}\n</available_skills>`;
+}

package/dist/tools/bash.js

@@ -0,0 +1,26 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { clamp } from './util.js';
+import { checkBash } from './permission.js';
+const execAsync = promisify(exec);
+export const bashTool = tool({
+    description: 'รันคำสั่ง shell (ls/grep/find/cat/test/npm ฯลฯ) เพื่อค้นหา ตรวจสอบ หรือรัน build/test',
+    inputSchema: z.object({
+        cmd: z.string().describe('คำสั่ง shell ที่จะรัน'),
+    }),
+    execute: async ({ cmd }) => {
+        const guard = checkBash(cmd);
+        if (!guard.ok)
+            return `BLOCKED: ${guard.reason}`;
+        try {
+            const { stdout, stderr } = await execAsync(cmd, { timeout: 120_000, maxBuffer: 10 * 1024 * 1024 });
+            const out = (stdout + (stderr ? `\n[stderr]\n${stderr}` : '')).trim();
+            return clamp(out) || '(no output)';
+        }
+        catch (err) {
+            return `ERROR: คำสั่งล้มเหลว — ${err.message}`;
+        }
+    },
+});