sanook-cli 0.4.0 → 0.5.0

package/dist/config.js

@@ -1,19 +1,72 @@
 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');
+import { appHomePath, appProjectPath, BRAND } from './brand.js';
+import { projectRoot, projectTrustStatus } from './trust.js';
+import { registerPricing } from './cost.js';
+export const CONFIG_DIR = appHomePath();
 const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
 const AUTH_PATH = join(CONFIG_DIR, 'auth.json'); // API keys (chmod 0600)
+export const PricingOverrideSchema = z.record(z.string(), z
+    .object({
+    input: z.number().finite().nonnegative().optional(),
+    output: z.number().finite().nonnegative().optional(),
+    cacheWrite: z.number().finite().nonnegative().optional(),
+    cacheRead: z.number().finite().nonnegative().optional(),
+})
+    .strict()
+    .refine((v) => Object.keys(v).length > 0, 'ต้องใส่ราคาอย่างน้อยหนึ่ง field'));
 export const ConfigSchema = z.object({
     model: z.string().default('sonnet'),
+    /** model สำรองเมื่อ model หลักล้ม (rate-limit/billing) — ตั้งด้วย sanook config set fallbackModel <spec> */
+    fallbackModel: z.string().optional(),
     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'),
+    permissionMode: z.enum(['auto', 'ask']).default('ask'),
     // path ของ second-brain workspace ที่ scaffold ไว้ (sanook brain) — optional
     brainPath: z.string().optional(),
+    // pricing override/extension per "provider:model" → ทำให้ budget cap ใช้ได้กับ model ที่ยังไม่มีในตาราง
+    pricing: PricingOverrideSchema.optional(),
+    // ── token/cost tuning (ดู agentTuning) — .catch กันค่า config.json ผิดทำ boot พัง (agentTuning อ่าน raw + coerce เองด้วย) ──
+    // prompt-cache TTL: '5m' (default, ephemeral) · '1h' (จ่าย write 2x แต่ cache อยู่ยาว — คุ้มเมื่อ session หยุดๆทำๆ)
+    cacheTtl: z.enum(['5m', '1h']).catch('5m').default('5m'),
+    // วิธีบีบ context ตอนยาว: 'truncate' (default, zero-LLM) · 'summarize' (ใช้ model ถูกย่อ — จำ context ได้ดีกว่า)
+    compaction: z.enum(['truncate', 'summarize']).catch('truncate').default('truncate'),
+    // extended thinking (Anthropic): false/ไม่ตั้ง = ปิด · true = budget default · number = budget tokens
+    thinking: z.union([z.boolean(), z.number().int().positive()]).optional().catch(undefined),
+    // model สำหรับย่อ (compaction=summarize) — ไม่ตั้ง = ใช้ fast-sibling ของ model หลัก (ค่ายเดียวกัน ถูกกว่า)
+    summaryModel: z.string().optional().catch(undefined),
 });
+const DEFAULT_THINKING_BUDGET = 4096;
+/** parse thinking config (config field หรือ env) → budget tokens (undefined = ปิด) */
+function parseThinking(v) {
+    if (typeof v === 'number' && v > 0)
+        return Math.floor(v);
+    if (v === true)
+        return DEFAULT_THINKING_BUDGET;
+    if (typeof v === 'string') {
+        if (/^\d+$/.test(v))
+            return Number.parseInt(v, 10);
+        if (['on', 'true', '1', 'yes'].includes(v.toLowerCase()))
+            return DEFAULT_THINKING_BUDGET;
+    }
+    return undefined;
+}
+/**
+ * อ่าน tuning knobs (cache TTL / thinking / compaction / summary model) จาก global config.json
+ * + env override (SANOOK_CACHE_TTL / SANOOK_THINKING / SANOOK_COMPACTION / SANOOK_SUMMARY_MODEL).
+ * อ่านตรงจาก config.json (เลี่ยง thread ผ่าน call stack ลึก) — เบา, เรียกครั้งเดียวต่อ turn.
+ */
+export async function agentTuning() {
+    const raw = await readGlobalConfigRaw();
+    const envTtl = process.env.SANOOK_CACHE_TTL;
+    const cacheTtl = envTtl === '1h' || (envTtl !== '5m' && raw.cacheTtl === '1h') ? '1h' : '5m';
+    const thinkingBudget = parseThinking(process.env.SANOOK_THINKING ?? raw.thinking);
+    const compaction = (process.env.SANOOK_COMPACTION ?? raw.compaction) === 'summarize' ? 'summarize' : 'truncate';
+    const summaryModel = process.env.SANOOK_SUMMARY_MODEL ?? (typeof raw.summaryModel === 'string' ? raw.summaryModel : undefined);
+    return { cacheTtl, thinkingBudget, compaction, summaryModel };
+}
 async function readJson(path) {
     try {
         const parsed = JSON.parse(await readFile(path, 'utf8'));
@@ -23,21 +76,53 @@ async function readJson(path) {
         return {}; // ไม่มีไฟล์ / parse ไม่ได้ = ใช้ default
     }
 }
+function sanitizeUntrustedProjectConfig(cfg) {
+    const out = { ...cfg };
+    delete out.permissionMode;
+    return out;
+}
 /**
- * โหลด config แบบ layered: global (~/.sanook) < project (.sanook) < CLI overrides
+ * โหลด config แบบ layered: global (~/.sanook) < project (.sanook) < env < 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 global = await readJson(CONFIG_PATH);
+    const root = await projectRoot(cwd);
+    const projectRaw = await readJson(appProjectPath(root, 'config.json'));
+    const trust = await projectTrustStatus(root);
+    const project = trust.trusted ? projectRaw : sanitizeUntrustedProjectConfig(projectRaw);
+    const envConfig = {};
+    if (process.env[BRAND.modelEnvVar])
+        envConfig.model = process.env[BRAND.modelEnvVar];
     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);
+    const merged = { ...global, ...project, ...envConfig, ...cleanOverrides };
+    const config = ConfigSchema.parse(merged);
+    // pricing override: config.pricing + env SANOOK_PRICING (JSON) → ลงทะเบียนเข้า cost table
+    registerPricing(config.pricing);
+    registerPricing(parseEnvPricing());
+    return config;
+}
+/** env SANOOK_PRICING = JSON ของ { "provider:model": { input, output, ... } } */
+function parseEnvPricing() {
+    const raw = process.env.SANOOK_PRICING;
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        const res = PricingOverrideSchema.safeParse(parsed);
+        return res.success ? res.data : undefined;
+    }
+    catch {
+        return undefined; // JSON ไม่ถูก = ข้าม (ไม่ทำให้ boot ล้ม)
+    }
+}
+export function parsePricingOverride(raw) {
+    return PricingOverrideSchema.parse(JSON.parse(raw));
 }
 /** ครั้งแรกที่รัน (ยังไม่มี global config) → ต้องทำ setup wizard */
 export async function isFirstRun() {
@@ -53,13 +138,15 @@ export async function isFirstRun() {
 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`);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, ...cfg }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(CONFIG_PATH, 0o600).catch(() => { });
 }
 /** บันทึก 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`);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, brainPath: path }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(CONFIG_PATH, 0o600).catch(() => { });
 }
 /** อ่าน config.json ดิบ (ไม่ apply default/schema) — สำหรับ `sanook config` */
 export async function readGlobalConfigRaw() {
@@ -69,7 +156,8 @@ export async function readGlobalConfigRaw() {
 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`);
+    await writeFile(CONFIG_PATH, `${JSON.stringify({ ...existing, ...patch }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(CONFIG_PATH, 0o600).catch(() => { });
 }
 /** บันทึก API key ลง ~/.sanook/auth.json (chmod 0600) + set env ทันทีสำหรับ session นี้ */
 export async function saveKey(envVar, key) {
@@ -82,7 +170,7 @@ export async function saveKey(envVar, key) {
         /* ยังไม่มีไฟล์ */
     }
     auth[envVar] = key;
-    await writeFile(AUTH_PATH, `${JSON.stringify(auth, null, 2)}\n`);
+    await writeFile(AUTH_PATH, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
     await chmod(AUTH_PATH, 0o600); // เจ้าของอ่าน/เขียนเท่านั้น
     process.env[envVar] = key;
 }

package/dist/cost.js

@@ -1,10 +1,59 @@
-// key = specKey() = "anthropic:<curated model id>" — ต้องตรงกับ id ใน registry (มี test กัน drift)
+// key = specKey() = "<provider>:<model id>" — ต้องตรงกับ id ใน registry (มี test กัน drift)
+// Anthropic = ราคา verified (มิ.ย. 2026). ที่เหลือ = published list price โดยประมาณ — override ได้
 export const PRICING = {
+    // ── Anthropic (verified) ────────────────────────────────────────────────
     '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 },
+    // ── ราคาประมาณ (published list price ต่อ 1M tokens) — อาจคลาดเคลื่อน, override ได้ด้วย
+    //    `sanook config set pricing '{"openai:gpt-5.5":{"input":1.25,...}}'` หรือ env SANOOK_PRICING
+    // OpenAI
+    'openai:gpt-5.5': { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.125 },
+    'openai:gpt-5.4-mini': { input: 0.25, output: 2, cacheWrite: 0.25, cacheRead: 0.025 },
+    'openai:gpt-5.3-codex': { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.125 },
+    // Google Gemini (≤200k context tier)
+    'google:gemini-2.5-pro': { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.31 },
+    'google:gemini-2.5-flash': { input: 0.3, output: 2.5, cacheWrite: 0.3, cacheRead: 0.075 },
+    // DeepSeek V4
+    'deepseek:deepseek-v4-flash': { input: 0.28, output: 0.42, cacheWrite: 0.28, cacheRead: 0.028 },
+    'deepseek:deepseek-v4-pro': { input: 0.55, output: 2.19, cacheWrite: 0.55, cacheRead: 0.055 },
+    // xAI Grok
+    'xai:grok-4.3': { input: 3, output: 15, cacheWrite: 3, cacheRead: 0.75 },
+    // Mistral
+    'mistral:mistral-large-latest': { input: 2, output: 6, cacheWrite: 2, cacheRead: 0.2 },
+    'mistral:mistral-small-latest': { input: 0.2, output: 0.6, cacheWrite: 0.2, cacheRead: 0.02 },
+    // Groq
+    'groq:llama-3.3-70b-versatile': { input: 0.59, output: 0.79, cacheWrite: 0.59, cacheRead: 0.059 },
 };
+/** true ถ้ามี pricing สำหรับ specKey นี้ (ใช้เตือนตอน budget cap ตั้งไว้แต่คิดเงินไม่ได้) */
+export function hasPricingForKey(specKey) {
+    return specKey in PRICING;
+}
+/**
+ * merge pricing เพิ่ม/override (จาก config `pricing` หรือ env SANOOK_PRICING)
+ * — ให้ budget cap ใช้ได้กับ provider ที่ยังไม่มีในตาราง โดยไม่ต้องแก้โค้ด
+ */
+export function registerPricing(extra) {
+    if (!extra)
+        return;
+    for (const [key, p] of Object.entries(extra)) {
+        if (p == null || typeof p !== 'object')
+            continue;
+        const base = PRICING[key] ?? { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
+        const inputRate = Number(p.input ?? base.input);
+        const next = {
+            input: inputRate,
+            output: Number(p.output ?? base.output),
+            // override ที่ใส่แค่ input/output (ตามที่ hint แนะนำ) → cache rate อนุมานจาก input แทน 0 (กัน undercount)
+            cacheWrite: Number(p.cacheWrite ?? p.input ?? base.cacheWrite),
+            cacheRead: Number(p.cacheRead ?? (base.cacheRead || inputRate * 0.1)),
+        };
+        if (Object.values(next).some((n) => !Number.isFinite(n) || n < 0))
+            continue;
+        PRICING[key] = next;
+    }
+}
 export class CostMeter {
     specKey;
     budgetUsd;
@@ -40,15 +89,23 @@ export class CostMeter {
                     (cacheWriteTokens / 1e6) * p.cacheWrite;
         }
     }
+    /** รวม token + cost จาก meter อีกตัว (เช่น primary model ก่อน fallback) — กัน usage หาย/budget reset */
+    merge(other) {
+        this.inTok += other.inTok;
+        this.outTok += other.outTok;
+        this.cacheReadTok += other.cacheReadTok;
+        this.cacheWriteTok += other.cacheWriteTok;
+        this.spent += other.spent;
+    }
     get totalUsd() {
         return this.spent;
     }
     get hasPricing() {
         return this.specKey in PRICING;
     }
-    /** true เมื่อใช้เกิน budget (เช็คก่อนยิง request ถัดไป) */
+    /** true เมื่อใช้เกิน budget (เช็คก่อนยิง request ถัดไป) — no-op ถ้าไม่มี pricing (เตือนที่ entry point) */
     get overBudget() {
-        return this.budgetUsd != null && this.spent >= this.budgetUsd;
+        return this.budgetUsd != null && this.hasPricing && this.spent >= this.budgetUsd;
     }
     summary() {
         const total = this.inTok + this.outTok + this.cacheReadTok + this.cacheWriteTok;

package/dist/doctor.js

@@ -0,0 +1,92 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+import { join, resolve, delimiter } from 'node:path';
+import { BRAND } from './brand.js';
+const execFileP = promisify(execFile);
+function normDir(d) {
+    try {
+        const r = resolve(d).replace(/[\\/]+$/, '');
+        return process.platform === 'win32' ? r.toLowerCase() : r; // Windows PATH is case-insensitive
+    }
+    catch {
+        return process.platform === 'win32' ? d.toLowerCase() : d;
+    }
+}
+/** binDir อยู่ใน PATH ไหม — normalize (ตัด trailing slash, case-insensitive บน Windows) ก่อนเทียบ */
+export function isOnPath(binDir, pathEnv) {
+    if (!binDir)
+        return false;
+    const target = normDir(binDir);
+    return (pathEnv ?? '')
+        .split(delimiter)
+        .filter(Boolean)
+        .map(normDir)
+        .includes(target);
+}
+/** เก็บข้อมูลการติดตั้งจริงจากเครื่อง (Node version, npm global bin, shim, PATH, local install) */
+export async function diagnose() {
+    const isWin = process.platform === 'win32';
+    const major = Number(process.versions.node.split('.')[0]);
+    let prefix = '';
+    try {
+        // Windows: npm = npm.cmd → ต้อง shell:true ไม่งั้น ENOENT
+        prefix = (await execFileP('npm', ['config', 'get', 'prefix'], { shell: isWin })).stdout.trim();
+    }
+    catch {
+        /* npm หาไม่เจอใน PATH */
+    }
+    // global bin: บน Windows = prefix เอง (มี npx.cmd อยู่ตรงนั้น), บน Unix = prefix/bin
+    const binDir = prefix ? (isWin ? prefix : join(prefix, 'bin')) : '';
+    const shimNames = isWin ? [`${BRAND.cliName}.cmd`, `${BRAND.cliName}.ps1`, BRAND.cliName] : [BRAND.cliName];
+    const globalInstalled = !!binDir && shimNames.some((s) => existsSync(join(binDir, s)));
+    const localInstall = shimNames.some((s) => existsSync(join(process.cwd(), 'node_modules', '.bin', s)));
+    return {
+        node: process.version,
+        nodeOk: Number.isFinite(major) && major >= 22,
+        binDir,
+        globalInstalled,
+        onPath: isOnPath(binDir, process.env.PATH),
+        localInstall,
+        isWin,
+    };
+}
+/** รายงาน + วิธีแก้ที่ปลอดภัยต่อ OS (ไม่ใช้ setx %PATH% ซึ่งเป็น footgun ตัด PATH 1024 ตัว) */
+export function formatReport(r, pkgName) {
+    const ok = (b) => (b ? '✓' : '✗');
+    const lines = [
+        `${BRAND.productName} doctor — ตรวจการติดตั้ง`,
+        '',
+        `  ${ok(r.nodeOk)} Node ${r.node}${r.nodeOk ? '' : '  ← ต้อง ≥ 22 (อัปเดตที่ https://nodejs.org)'}`,
+        `  ${ok(!!r.binDir)} npm global bin: ${r.binDir || '(หาไม่เจอ — npm อยู่ใน PATH ไหม?)'}`,
+        `  ${ok(r.globalInstalled)} ติดตั้ง global "${BRAND.cliName}": ${r.globalInstalled ? 'ใช่' : 'ยัง'}`,
+        `  ${ok(r.onPath)} bin อยู่ใน PATH: ${r.onPath ? 'ใช่' : 'ไม่'}`,
+    ];
+    if (r.localInstall)
+        lines.push(`  ℹ เจอ local install ที่โฟลเดอร์นี้ → ใช้ได้เลยด้วย: npx ${BRAND.cliName}`);
+    lines.push('', 'สรุป:');
+    if (r.globalInstalled && r.onPath) {
+        lines.push(`  ✅ พร้อมใช้ — พิมพ์ "${BRAND.cliName}" ได้เลย (ยังไม่เจอ? ปิด-เปิด terminal ใหม่)`);
+        return lines.join('\n');
+    }
+    if (!r.globalInstalled) {
+        lines.push(`  • ลงแบบ global:  npm install -g ${pkgName}   →  แล้วพิมพ์ "${BRAND.cliName}" ได้`);
+    }
+    if (r.globalInstalled && !r.onPath && r.binDir) {
+        if (r.isWin) {
+            lines.push('  • bin ไม่อยู่ใน PATH — เพิ่มเข้า user PATH (วางใน PowerShell · ปลอดภัย แก้เฉพาะ user):');
+            lines.push(`      [Environment]::SetEnvironmentVariable('Path',[Environment]::GetEnvironmentVariable('Path','User')+';${r.binDir}','User')`);
+            lines.push('    แล้วปิด-เปิด terminal ใหม่');
+        }
+        else {
+            const rc = process.env.SHELL?.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+            lines.push(`  • bin ไม่อยู่ใน PATH — เพิ่มใน ${rc}:  export PATH="$PATH:${r.binDir}"  (แล้วเปิด shell ใหม่)`);
+        }
+    }
+    if (r.localInstall)
+        lines.push(`  • หรือใช้ทันทีโดยไม่แก้ PATH:  npx ${BRAND.cliName}`);
+    return lines.join('\n');
+}
+export async function runDoctor(pkgName) {
+    return formatReport(await diagnose(), pkgName);
+}

package/dist/gateway/auth.js

@@ -1,8 +1,8 @@
 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');
+import { appHomePath } from '../brand.js';
+const GATEWAY_DIR = appHomePath('gateway');
 const TOKEN_FILE = join(GATEWAY_DIR, 'token');
 /** โหลด bearer token ของ gateway; ไม่มี → สร้าง 256-bit ใหม่ เก็บ chmod 600 */
 export async function loadOrCreateToken() {

package/dist/gateway/ledger.js

@@ -1,12 +1,12 @@
 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';
+import { appHomePath } from '../brand.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 GATEWAY_DIR = appHomePath('gateway');
 const TASKS_FILE = join(GATEWAY_DIR, 'tasks.json');
 const LOCK_FILE = join(GATEWAY_DIR, 'tasks.lock');
 // ── low-level: read ตรงจากไฟล์ทุกครั้ง (ไม่ cache snapshot → ไม่มี stale-overwrite) ──

package/dist/gateway/scheduler.js

@@ -9,6 +9,7 @@ async function runTask(task, opts) {
         prompt: task.spec,
         maxSteps: 20,
         budgetUsd: opts.budgetUsd,
+        permissionMode: opts.permissionMode ?? 'ask',
     });
     return text;
 }

package/dist/gateway/serve.js

@@ -1,11 +1,11 @@
 import { mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { acquireSingleton } from './lock.js';
 import { loadOrCreateToken } from './auth.js';
 import { startServer } from './server.js';
 import { startScheduler } from './scheduler.js';
-const GATEWAY_DIR = join(homedir(), '.sanook', 'gateway');
+import { appHomePath, BRAND, BRAND_ENV, envFlag } from '../brand.js';
+const GATEWAY_DIR = appHomePath('gateway');
 const SERVE_LOCK = join(GATEWAY_DIR, 'serve.lock');
 /**
  * จุดเดียวที่ start ทั้ง gateway: HTTP server (รับ request 24/7) + scheduler (cron tick)
@@ -18,7 +18,7 @@ export async function startGateway(opts) {
     await mkdir(GATEWAY_DIR, { recursive: true });
     const release = await acquireSingleton(SERVE_LOCK);
     if (!release) {
-        throw new Error('มี sanook gateway รันอยู่แล้ว (เจอ serve.lock) — ปิดตัวเดิมก่อน หรือถ้าค้างให้ลบ ~/.sanook/gateway/serve.lock');
+        throw new Error(`มี ${BRAND.cliName} gateway รันอยู่แล้ว (เจอ serve.lock) — ปิดตัวเดิมก่อน หรือถ้าค้างให้ลบ ${appHomePath('gateway', 'serve.lock')}`);
     }
     const token = await loadOrCreateToken();
     const stopServer = startServer({
@@ -26,11 +26,13 @@ export async function startGateway(opts) {
         token,
         defaultModel: opts.model,
         budgetUsd: opts.budgetUsd,
+        permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
         onLog: log,
     });
     const stopScheduler = startScheduler({
         defaultModel: opts.model,
         budgetUsd: opts.budgetUsd,
+        permissionMode: opts.permissionMode ?? (envFlag(BRAND_ENV.gatewayAllowWrite) ? 'auto' : 'ask'),
         tickMs: opts.tickMs,
         onLog: log,
     });
@@ -47,7 +49,7 @@ export async function startGateway(opts) {
         });
         // หมายเหตุ: log "เริ่มแล้ว" อยู่ใน startTelegram (success path) — ถ้า fail-closed จะ log "ไม่เริ่ม" แทน
     }
-    log(`scheduler tick ทุก ${(opts.tickMs ?? 60_000) / 1000}s · token: ~/.sanook/gateway/token (chmod 600)`);
+    log(`scheduler tick ทุก ${(opts.tickMs ?? 60_000) / 1000}s · token: ${appHomePath('gateway', 'token')} (chmod 600)`);
     return () => {
         stopServer();
         stopScheduler();

package/dist/gateway/server.js

@@ -4,6 +4,7 @@ import { parseSchedule } from './schedule.js';
 import { tokenMatches } from './auth.js';
 import { runAgent } from '../loop.js';
 import { redactKey } from '../providers/keys.js';
+import { BRAND } from '../brand.js';
 function send(res, status, body) {
     res.writeHead(status, { 'content-type': 'application/json' });
     res.end(JSON.stringify(body));
@@ -42,7 +43,7 @@ async function handle(req, res, opts) {
     const url = new URL(req.url ?? '/', 'http://127.0.0.1');
     // /health = public (เช็คว่า process alive โดยไม่ต้องมี token)
     if (req.method === 'GET' && url.pathname === '/health') {
-        return send(res, 200, { ok: true, service: 'sanook-gateway' });
+        return send(res, 200, { ok: true, service: BRAND.gatewayServiceName });
     }
     // ทุก endpoint อื่น → bearer token
     const auth = req.headers.authorization ?? '';
@@ -63,7 +64,14 @@ async function handle(req, res, opts) {
             .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({ model, prompt, history, maxSteps: 20, budgetUsd: opts.budgetUsd });
+        const { text } = await runAgent({
+            model,
+            prompt,
+            history,
+            maxSteps: 20,
+            budgetUsd: opts.budgetUsd,
+            permissionMode: opts.permissionMode ?? 'ask',
+        });
         return send(res, 200, {
             object: 'chat.completion',
             model,

package/dist/git.js

@@ -3,8 +3,17 @@ import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 // git helper — execFile('git', args[]) ไม่ผ่าน shell (บทเรียนจาก grep RCE: ไม่ interpolate เข้า shell string)
 export async function runGit(args, cwd = process.cwd()) {
-    const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
-    return stdout;
+    try {
+        const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+        return stdout;
+    }
+    catch (e) {
+        // git ไม่ได้ติดตั้ง/ไม่อยู่ใน PATH → ข้อความชัดแทน "spawn git ENOENT" งงๆ (ทุกแพลตฟอร์ม)
+        if (e.code === 'ENOENT') {
+            throw new Error('ไม่พบ git ใน PATH — ติดตั้งจาก https://git-scm.com แล้วเปิด terminal ใหม่');
+        }
+        throw e;
+    }
 }
 export async function isGitRepo(cwd = process.cwd()) {
     try {

package/dist/hooks.js

@@ -1,20 +1,43 @@
 import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
 import { spawn } from 'node:child_process';
-export async function loadHooksConfig() {
+import { appHomePath, BRAND_ENV, envFlag } from './brand.js';
+import { hasUntrustedProjectConfig, projectConfigPathIfTrusted, projectRoot } from './trust.js';
+const SAFE_ENV_KEYS = ['PATH', 'HOME', 'TMPDIR', 'TEMP', 'LANG', 'LC_ALL', 'USER', 'SHELL', 'TERM', 'NODE_PATH', 'NVM_DIR', 'APPDATA'];
+function safeEnv() {
+    const out = {};
+    for (const k of SAFE_ENV_KEYS) {
+        const v = process.env[k];
+        if (v != null)
+            out[k] = v;
+    }
+    return out;
+}
+async function readHooksFile(path, merged) {
+    const cfg = JSON.parse(await readFile(path, 'utf8'));
+    const valid = (h) => Boolean(h &&
+        typeof h === 'object' &&
+        typeof h.matcher === 'string' &&
+        typeof h.command === 'string');
+    if (Array.isArray(cfg.PreToolUse))
+        merged.PreToolUse.push(...cfg.PreToolUse.filter(valid));
+    if (Array.isArray(cfg.PostToolUse))
+        merged.PostToolUse.push(...cfg.PostToolUse.filter(valid));
+}
+export async function loadHooksConfig(cwd = process.cwd()) {
     const merged = { PreToolUse: [], PostToolUse: [] };
-    for (const p of [join(homedir(), '.sanook', 'hooks.json'), join(process.cwd(), '.sanook', 'hooks.json')]) {
-        try {
-            const cfg = JSON.parse(await readFile(p, 'utf8'));
-            if (Array.isArray(cfg.PreToolUse))
-                merged.PreToolUse.push(...cfg.PreToolUse);
-            if (Array.isArray(cfg.PostToolUse))
-                merged.PostToolUse.push(...cfg.PostToolUse);
-        }
-        catch {
-            /* ไม่มี config = ข้าม */
-        }
+    try {
+        await readHooksFile(appHomePath('hooks.json'), merged);
+    }
+    catch {
+        /* ไม่มี global config = ข้าม */
+    }
+    const root = await projectRoot(cwd);
+    const projectPath = await projectConfigPathIfTrusted('hooks.json', root);
+    if (projectPath) {
+        await readHooksFile(projectPath, merged);
+    }
+    else if (await hasUntrustedProjectConfig('hooks.json', root)) {
+        /* project hook config มีอยู่แต่ยังไม่ trusted = ข้ามแบบ fail-closed */
     }
     return merged;
 }
@@ -31,7 +54,10 @@ export function matches(matcher, tool) {
 /** รัน command — payload เข้า stdin (เป็น DATA ไม่ใช่ shell arg → กัน injection); command = config ของ user (trusted) */
 function runCommand(command, payload, timeoutMs = 10_000) {
     return new Promise((resolve) => {
-        const child = spawn(command, { shell: true });
+        const child = spawn(command, {
+            shell: true,
+            env: envFlag(BRAND_ENV.hooksInheritEnv) ? process.env : safeEnv(),
+        });
         let stdout = '';
         let stderr = '';
         const timer = setTimeout(() => {
@@ -96,8 +122,8 @@ function wrapToolsWithHooks(tools, cfg) {
     return out;
 }
 /** wrap tools ด้วย hooks ถ้ามี config (ไม่มี → คืน tools เดิม zero overhead) */
-export async function maybeWrapHooks(tools) {
-    const cfg = await loadHooksConfig();
+export async function maybeWrapHooks(tools, cwd = process.cwd()) {
+    const cfg = await loadHooksConfig(cwd);
     if (!(cfg.PreToolUse?.length || cfg.PostToolUse?.length))
         return tools;
     return wrapToolsWithHooks(tools, cfg);