sanook-cli 0.5.5 → 0.5.8

package/dist/dashboard/terminal.js

@@ -0,0 +1,214 @@
+import { runAgent } from '../loop.js';
+import { loadConfig } from '../config.js';
+import { redactKey } from '../providers/keys.js';
+import { describeToolCall } from '../ui/tool-activity.js';
+const HISTORY = new Map(); // sessionId → conversation (localhost single-user)
+const MAX_HISTORY_SESSIONS = 20;
+function sseSend(res, event) {
+    if (res.destroyed || res.writableEnded)
+        return; // client gone — don't write to a dead socket
+    try {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+    }
+    catch {
+        /* socket closed mid-write */
+    }
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    const raw = Buffer.concat(chunks).toString('utf8');
+    try {
+        const parsed = JSON.parse(raw || '{}');
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** POST /api/terminal/run — body {prompt, sessionId, autoApprove?} → SSE stream of agent events */
+export async function handleTerminalRun(req, res) {
+    const body = await readJsonBody(req);
+    const prompt = typeof body.prompt === 'string' ? body.prompt.trim() : '';
+    const sessionId = typeof body.sessionId === 'string' && body.sessionId ? body.sessionId : 'web';
+    const autoApprove = body.autoApprove !== false; // default true (localhost = same trust as running CLI)
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+    });
+    if (!prompt) {
+        sseSend(res, { type: 'error', message: 'empty prompt' });
+        sseSend(res, { type: 'done' });
+        res.end();
+        return;
+    }
+    const rememberedFacts = [];
+    // abort the agent run if the browser disconnects mid-stream — otherwise it keeps executing
+    // (and metering cost) and writing to a closed socket. RunAgent honors opts.signal.
+    const ac = new AbortController();
+    const onClose = () => ac.abort();
+    res.on('close', onClose);
+    // headers are already sent above, so everything that can throw stays inside this try and emits an
+    // SSE error here — otherwise the throw propagates to the server's catch, which calls writeHead(500)
+    // on an already-headed response (ERR_HTTP_HEADERS_SENT).
+    try {
+        const config = await loadConfig({});
+        const model = config.model;
+        const history = HISTORY.get(sessionId) ?? [];
+        sseSend(res, { type: 'status', detail: `Agent · ${model}` });
+        const { messages } = await runAgent({
+            model,
+            prompt,
+            history,
+            maxSteps: 20,
+            permissionMode: autoApprove ? 'auto' : 'ask',
+            signal: ac.signal,
+            usageMeta: { sessionId: `web:${sessionId}`, source: 'repl' },
+            onEvent: (e) => {
+                switch (e.type) {
+                    case 'text':
+                        if (e.text)
+                            sseSend(res, { type: 'text', text: e.text });
+                        break;
+                    case 'reasoning':
+                        if (e.text)
+                            sseSend(res, { type: 'reasoning', text: e.text });
+                        break;
+                    case 'tool-call': {
+                        if (e.tool === 'remember') {
+                            const fact = e.detail?.fact;
+                            if (typeof fact === 'string' && fact.trim())
+                                rememberedFacts.push(fact.trim());
+                        }
+                        const activity = describeToolCall(e.tool ?? 'tool', e.detail);
+                        sseSend(res, { type: 'tool-call', tool: e.tool, title: activity.title, diff: activity.diff ?? null });
+                        break;
+                    }
+                    case 'tool-result':
+                        sseSend(res, { type: 'tool-result', tool: e.tool });
+                        break;
+                    case 'status':
+                        if (typeof e.detail === 'string')
+                            sseSend(res, { type: 'status', detail: e.detail });
+                        break;
+                    case 'error':
+                        sseSend(res, { type: 'error', message: redactKey(String(e.detail ?? e.text ?? 'error')) });
+                        break;
+                }
+            },
+        });
+        HISTORY.set(sessionId, messages);
+        if (HISTORY.size > MAX_HISTORY_SESSIONS)
+            HISTORY.delete([...HISTORY.keys()][0]);
+        for (const fact of rememberedFacts)
+            sseSend(res, { type: 'memory', fact });
+        // ✨ self-improvement (same path as REPL/headless)
+        try {
+            const { maybeAutoSkill } = await import('../self-improve.js');
+            const { defaultSkillSynthesizer } = await import('../self-improve-synth.js');
+            const { loadSkills, saveSkill } = await import('../skills.js');
+            const existing = new Set((await loadSkills()).map((s) => s.name));
+            const auto = await maybeAutoSkill(prompt, { synthesize: defaultSkillSynthesizer(model), saveSkill, existingSkillNames: existing });
+            if (auto.created && auto.skillName)
+                sseSend(res, { type: 'skill', name: auto.skillName, count: auto.count });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    catch (err) {
+        sseSend(res, { type: 'error', message: redactKey(err.message) });
+    }
+    finally {
+        res.off('close', onClose);
+    }
+    sseSend(res, { type: 'done' });
+    if (!res.writableEnded)
+        res.end();
+}
+export function resetTerminalSession(sessionId) {
+    HISTORY.delete(sessionId);
+}
+// ---- Raw shell (optional node-pty + ws) ------------------------------------
+let shellAvailability = null;
+// computed specifiers so TS/bundler don't statically resolve these optional, possibly-absent deps
+const PTY_MODULE = 'node-pty';
+const WS_MODULE = 'ws';
+export async function shellStatus() {
+    if (shellAvailability)
+        return shellAvailability;
+    const missing = [];
+    try {
+        await import(PTY_MODULE);
+    }
+    catch {
+        missing.push('node-pty');
+    }
+    try {
+        await import(WS_MODULE);
+    }
+    catch {
+        missing.push('ws');
+    }
+    shellAvailability = missing.length
+        ? { available: false, reason: `ติดตั้ง dependency เสริมก่อน: npm i ${missing.join(' ')}` }
+        : { available: true, reason: 'ready' };
+    return shellAvailability;
+}
+/** Attach a ws upgrade handler for the raw shell at /api/terminal/shell. No-op if deps missing. */
+export async function attachShell(server) {
+    const status = await shellStatus();
+    if (!status.available)
+        return;
+    // dynamic import keeps node-pty/ws optional at build/runtime
+    const pty = (await import(PTY_MODULE));
+    const wsmod = (await import(WS_MODULE));
+    const wss = new wsmod.WebSocketServer({ noServer: true });
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '/', 'http://local');
+        if (url.pathname !== '/api/terminal/shell') {
+            // not ours — destroy the half-open upgraded socket so it doesn't leak (this is the only
+            // 'upgrade' handler on the dashboard server; with noServer ws, Node won't auto-close it).
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            const shell = process.platform === 'win32' ? 'powershell.exe' : process.env.SHELL || 'bash';
+            const term = pty.spawn(shell, [], {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 24,
+                cwd: process.env.HOME || process.cwd(),
+                env: process.env,
+            });
+            const safeKill = () => {
+                try {
+                    term.kill();
+                }
+                catch {
+                    /* pty already exited — kill() can throw for a reaped pid on some platforms */
+                }
+            };
+            term.onData((data) => ws.send(JSON.stringify({ type: 'data', data })));
+            term.onExit(() => ws.close());
+            ws.on('message', (raw) => {
+                try {
+                    const msg = JSON.parse(String(raw));
+                    if (msg.type === 'data' && typeof msg.data === 'string')
+                        term.write(msg.data);
+                    else if (msg.type === 'resize' && msg.cols && msg.rows)
+                        term.resize(msg.cols, msg.rows);
+                }
+                catch {
+                    /* ignore malformed frame */
+                }
+            });
+            ws.on('close', safeKill);
+            // without an 'error' listener, a ws error (abrupt TCP reset / protocol violation) is rethrown
+            // by Node's EventEmitter as an uncaught exception and crashes the whole dashboard server.
+            ws.on('error', safeKill);
+        });
+    });
+}

package/dist/diff.js

@@ -1,7 +1,11 @@
 // minimal unified-ish diff (zero dep) — โชว์ให้เห็นว่าแก้อะไรก่อน/หลัง โปร่งใส
 const MAX_LINES = 14;
-/** diff ของ edit (old block → new block) — render เป็น -old / +new */
-export function renderEditDiff(oldStr, newStr) {
+/**
+ * core prefix/suffix-trim diff — shared by renderEditDiff (string) and the REPL's colored
+ * diffLines (src/ui/tool-activity.ts) so the algorithm lives in one place. Callers pick their
+ * own line cap; only the formatting differs.
+ */
+export function editDiffSegments(oldStr, newStr, max = MAX_LINES) {
     const oldL = oldStr.split('\n');
     const newL = newStr.split('\n');
     // ตัด common prefix/suffix lines ที่เหมือนกัน เพื่อโชว์เฉพาะส่วนที่เปลี่ยน
@@ -15,15 +19,25 @@ export function renderEditDiff(oldStr, newStr) {
         suf++;
     const oldMid = oldL.slice(pre, oldL.length - suf);
     const newMid = newL.slice(pre, newL.length - suf);
+    return {
+        removed: oldMid.slice(0, max),
+        added: newMid.slice(0, max),
+        moreRemoved: Math.max(0, oldMid.length - max),
+        moreAdded: Math.max(0, newMid.length - max),
+    };
+}
+/** diff ของ edit (old block → new block) — render เป็น -old / +new */
+export function renderEditDiff(oldStr, newStr) {
+    const seg = editDiffSegments(oldStr, newStr, MAX_LINES);
     const lines = [];
-    for (const l of oldMid.slice(0, MAX_LINES))
+    for (const l of seg.removed)
         lines.push(`- ${l}`);
-    if (oldMid.length > MAX_LINES)
-        lines.push(`  …(-${oldMid.length - MAX_LINES} บรรทัด)`);
-    for (const l of newMid.slice(0, MAX_LINES))
+    if (seg.moreRemoved)
+        lines.push(`  …(-${seg.moreRemoved} บรรทัด)`);
+    for (const l of seg.added)
         lines.push(`+ ${l}`);
-    if (newMid.length > MAX_LINES)
-        lines.push(`  …(+${newMid.length - MAX_LINES} บรรทัด)`);
+    if (seg.moreAdded)
+        lines.push(`  …(+${seg.moreAdded} บรรทัด)`);
     return lines.join('\n');
 }
 /** สรุปการ write — จำนวนบรรทัด/ตัวอักษร + ถ้าเขียนทับ บอก before→after */

package/dist/gateway/session.js

@@ -172,6 +172,10 @@ async function runAndSaveGatewayTurn(opts, existing, prompt, history, model) {
         maxSteps: opts.maxSteps ?? 20,
         budgetUsd: opts.budgetUsd,
         permissionMode: opts.permissionMode ?? 'ask',
+        usageMeta: {
+            sessionId: `${opts.platform}:${opts.target}`,
+            source: 'gateway',
+        },
     });
     await saveGatewayState(opts, existing, model, messages);
     return { text, messages, suppressDelivery: shouldSuppressDelivery(text) };

package/dist/install-info.js

@@ -0,0 +1,91 @@
+// Multi-platform install metadata — single source for Dashboard, README sync, and docs.
+import { readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const INSTALL_PKG = 'sanook-cli';
+export const INSTALL_REPO = 'Sir-chawakorn/sanook-cli';
+export const INSTALL_REPO_URL = `https://github.com/${INSTALL_REPO}`;
+export const INSTALL_BRANCH = 'main';
+/** Custom domain when DNS + Pages are configured */
+export const INSTALL_DOMAIN = 'sanook.ai';
+/** GitHub Pages project URL (works when gh-pages branch is deployed) */
+export const INSTALL_PAGES_URL = `https://${INSTALL_REPO.split('/')[0]}.github.io/${INSTALL_REPO.split('/')[1]}`;
+/** jsDelivr CDN — stable short URL without custom domain */
+export const INSTALL_CDN_URL = `https://cdn.jsdelivr.net/gh/${INSTALL_REPO}@${INSTALL_BRANCH}/scripts`;
+const __dir = dirname(fileURLToPath(import.meta.url));
+/** package.json version at build time (repo root when running from src/) */
+export function installPkgVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dir, '..', 'package.json'), 'utf8'));
+        return pkg.version ?? 'latest';
+    }
+    catch {
+        return 'latest';
+    }
+}
+export function installScriptUrl(name, preferDomain = false) {
+    if (preferDomain)
+        return `https://${INSTALL_DOMAIN}/${name}`;
+    return `https://raw.githubusercontent.com/${INSTALL_REPO}/${INSTALL_BRANCH}/scripts/${name}`;
+}
+export function installScriptPagesUrl(name) {
+    return `${INSTALL_PAGES_URL}/${name}`;
+}
+export function installScriptCdnUrl(name) {
+    return `${INSTALL_CDN_URL}/${name}`;
+}
+/** Install channels shown on Dashboard + docs. `ready` = users can run today without extra infra. */
+export function installMethods() {
+    const sh = installScriptUrl('install.sh');
+    const ps1 = installScriptUrl('install.ps1');
+    const shPages = installScriptPagesUrl('install.sh');
+    const shDomain = installScriptUrl('install.sh', true);
+    const shCdn = installScriptCdnUrl('install.sh');
+    return [
+        {
+            id: 'npm',
+            label: 'npm / npx',
+            recommended: true,
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux / Windows', cmd: `npm install -g ${INSTALL_PKG}` },
+                { os: 'Run without installing', cmd: `npx ${INSTALL_PKG}` },
+            ],
+            note: 'ต้องมี Node.js ≥ 22',
+        },
+        {
+            id: 'curl',
+            label: 'Install script',
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux / WSL (GitHub raw)', cmd: `curl -fsSL ${sh} | bash` },
+                { os: 'Windows PowerShell (GitHub raw)', cmd: `irm ${ps1} | iex` },
+                { os: 'CDN (jsDelivr)', cmd: `curl -fsSL ${shCdn} | bash` },
+                { os: 'GitHub Pages', cmd: `curl -fsSL ${shPages} | bash` },
+                { os: `Short URL (${INSTALL_DOMAIN})`, cmd: `curl -fsSL ${shDomain} | bash` },
+            ],
+            note: `${INSTALL_DOMAIN} ต้องตั้ง DNS ที่ GoDaddy ก่อน — ดู scripts/configure-sanook-ai-dns.sh`,
+        },
+        {
+            id: 'homebrew',
+            label: 'Homebrew',
+            ready: true,
+            commands: [
+                { os: 'macOS / Linux (trust tap ครั้งแรก)', cmd: `brew trust ${INSTALL_REPO.split('/')[0]}/tap` },
+                { os: 'macOS / Linux', cmd: `brew tap ${INSTALL_REPO.split('/')[0]}/tap` },
+                { os: 'macOS / Linux', cmd: `brew install ${INSTALL_PKG}` },
+            ],
+            note: `Live ที่ homebrew-tap — brew tap ${INSTALL_REPO.split('/')[0]}/tap && brew install ${INSTALL_PKG}`,
+        },
+        {
+            id: 'winget',
+            label: 'WinGet',
+            ready: false,
+            commands: [{ os: 'Windows', cmd: 'winget install Sanook.SanookCLI' }],
+            note: 'CLA ลงนามแล้ว — PR #391114 รอ validation + merge (release zip v0.5.7 พร้อม)',
+        },
+    ];
+}
+export function dashboardInstallPayload() {
+    return { pkg: INSTALL_PKG, version: installPkgVersion(), methods: installMethods() };
+}

package/dist/loop.js

@@ -19,6 +19,7 @@ import { agentTuning, loadConfig } from './config.js';
 import { BRAND, envFlag } from './brand.js';
 import { semanticRecallHits } from './knowledge.js';
 import { personalityPrompt } from './personality.js';
+import { recordAgentUsage, usageFromCodexPayload } from './usage-ledger.js';
 // auto-compact เมื่อ context ใกล้เต็ม — conservative (safe สำหรับ model 200K, เผื่อ output)
 const AUTO_COMPACT_TOKENS = 120_000;
 const OS_LABEL = process.platform === 'win32'
@@ -148,7 +149,6 @@ async function maybeWrapWithHeadroom(model) {
  * แกน harness — agent loop: LLM -> tool -> result -> loop จนเสร็จ
  * multi-provider (BYOK) ผ่าน registry + cost meter + budget cap
  */
-/** delegate path — spawn official codex CLI (ChatGPT plan quota) แทน SDK loop */
 async function runDelegate(opts) {
     const { runCodex } = await import('./providers/codex.js');
     const meter = new CostMeter(specKey(opts.model), opts.budgetUsd, agentContext.getStore()?.sharedBudget);
@@ -173,10 +173,11 @@ async function runDelegate(opts) {
     // sandbox: plan/ask-mode → read-only (สกัด approval รายไฟล์ของ codex ไม่ได้ จึงไม่ให้แก้);
     // auto (--yes / config auto) → workspace-write เพื่อให้ codex แก้ไฟล์ได้จริง (ไม่งั้นเป็น coding agent ที่แก้อะไรไม่ได้)
     const sandbox = opts.planMode || (opts.permissionMode ?? 'ask') === 'ask' ? 'read-only' : 'workspace-write';
+    opts.onEvent?.({ type: 'status', detail: `Codex · ${model} · ${sandbox}` });
     let text = '';
     const out = await runCodex({
         prompt,
-        model: model === 'gpt-5-codex' ? undefined : model,
+        model: model === PROVIDERS.codex.models.default ? undefined : model,
         sandbox,
         cwd: opts.cwd, // worktree isolation ของ sub-agent
         signal: opts.signal,
@@ -190,6 +191,9 @@ async function runDelegate(opts) {
                     opts.onEvent?.({ type: 'text', text: delta });
             }
             else if (e.type === 'usage') {
+                const parsed = usageFromCodexPayload(e.usage);
+                if (parsed)
+                    meter.add(parsed);
                 opts.onEvent?.({ type: 'finish', detail: 'codex · ChatGPT quota' });
             }
         },
@@ -200,7 +204,26 @@ async function runDelegate(opts) {
         { role: 'user', content: opts.prompt },
         { role: 'assistant', content: text },
     ];
-    return { messages, text, cost: meter };
+    return finishAgentRun(opts, { messages, text, cost: meter });
+}
+function inferUsageSource(opts) {
+    if (opts.usageMeta?.source)
+        return opts.usageMeta.source;
+    if ((opts.subagentDepth ?? 0) > 0)
+        return 'subagent';
+    if (opts.planMode)
+        return 'plan';
+    return 'headless';
+}
+function finishAgentRun(opts, result) {
+    recordAgentUsage({
+        model: opts.model,
+        cost: result.cost,
+        cwd: opts.cwd ?? agentCwd(),
+        sessionId: opts.usageMeta?.sessionId,
+        source: inferUsageSource(opts),
+    });
+    return result;
 }
 export async function runAgent(opts) {
     // context ผ่าน AsyncLocalStorage (ไม่ใช่ process.env global) → parallel sub-agent ไม่ชนกัน
@@ -213,6 +236,7 @@ export async function runAgent(opts) {
     if (PROVIDERS[parseSpec(opts.model).provider]?.kind === 'delegate') {
         return runDelegate(opts);
     }
+    opts.onEvent?.({ type: 'status', detail: `Agent · ${opts.model}` });
     const rawModel = resolveModel(opts.model); // throws ถ้าไม่มี key / provider ผิด
     let meter = new CostMeter(specKey(opts.model), opts.budgetUsd, sharedBudget);
     // โหลด context: auto-memory + skills + git state + repo map + project SANOOK.md → system prompt
@@ -355,14 +379,17 @@ export async function runAgent(opts) {
                     opts.onEvent?.({ type: 'text', text: part.text });
                     break;
                 case 'reasoning-delta':
+                    opts.onEvent?.({ type: 'status', detail: 'Thinking…' });
                     opts.onEvent?.({ type: 'reasoning', text: part.text });
                     break;
                 case 'tool-call':
                     if (isMutatingTool(part.toolName))
                         sideEffectToolSeen = true;
+                    opts.onEvent?.({ type: 'status', detail: `Tool · ${part.toolName}` });
                     opts.onEvent?.({ type: 'tool-call', tool: part.toolName, detail: part.input });
                     break;
                 case 'tool-result':
+                    opts.onEvent?.({ type: 'status', detail: `Done · ${part.toolName}` });
                     opts.onEvent?.({ type: 'tool-result', tool: part.toolName, detail: part.output });
                     break;
                 case 'error':
@@ -409,5 +436,5 @@ export async function runAgent(opts) {
         throw new Error(cleanProviderError(streamError));
     const response = await result.response;
     // คืน history เต็ม (conversation + response messages) — ไม่รวม system (กัน user turn เก่าหาย + ไม่ save system ซ้ำ)
-    return { messages: [...conversation, ...response.messages], text, cost: meter };
+    return finishAgentRun(opts, { messages: [...conversation, ...response.messages], text, cost: meter });
 }