sanook-cli 0.5.7 → 0.5.9

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/i18n/en.js

@@ -36,6 +36,7 @@ export const en = {
         codexOptionRecheck: 'Re-check (after install/login)',
         codexOptionBack: '← Choose another provider',
         codexInstallCmd: 'npm i -g @openai/codex',
+        codexModelHint: 'ChatGPT plan supports gpt-5.5 · gpt-5.4 · gpt-5.4-mini only (legacy *-codex ids are not available)',
         keyEscHint: '(Esc = back)',
         keyOpenAiCodexHint: 'Have ChatGPT Plus/Pro? Press Esc and pick OpenAI Codex (ChatGPT plan) — no API key needed.',
         keyFormatHint: 'Key format',

package/dist/i18n/th.js

@@ -36,6 +36,7 @@ export const th = {
         codexOptionRecheck: 'เช็กใหม่ (หลังติดตั้ง/login)',
         codexOptionBack: '← กลับไปเลือก provider อื่น',
         codexInstallCmd: 'npm i -g @openai/codex',
+        codexModelHint: 'ChatGPT plan ใช้ได้ gpt-5.5 · gpt-5.4 · gpt-5.4-mini เท่านั้น (โมเดล *-codex เก่าใช้ไม่ได้)',
         keyEscHint: '(Esc = กลับ)',
         keyOpenAiCodexHint: 'มี ChatGPT Plus/Pro? กด Esc แล้วเลือก OpenAI Codex (ChatGPT plan) — ไม่ต้อง API key',
         keyFormatHint: 'รูปแบบ key',

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

@@ -174,10 +174,19 @@ async function runDelegate(opts) {
     // 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}` });
+    const { normalizeCodexChatGptModel } = await import('./providers/codex.js');
+    const normalized = normalizeCodexChatGptModel(model);
+    if (normalized.migratedFrom) {
+        opts.onEvent?.({
+            type: 'status',
+            detail: `Codex model ${normalized.migratedFrom} ไม่รองรับ ChatGPT plan → ใช้ ${normalized.model} แทน (sanook model เพื่ออัปเดต: /model codex)`,
+        });
+    }
     let text = '';
+    const execModel = normalized.model === PROVIDERS.codex.models.default ? undefined : normalized.model;
     const out = await runCodex({
         prompt,
-        model: model === PROVIDERS.codex.models.default ? undefined : model,
+        model: execModel,
         sandbox,
         cwd: opts.cwd, // worktree isolation ของ sub-agent
         signal: opts.signal,