sanook-cli 0.5.1 → 0.5.5

package/dist/project-scaffold.js

@@ -0,0 +1,124 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const TEMPLATE_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', 'second-brain', 'Templates', 'project-workspace');
+const WORKSPACE_FILES = ['_Index.md', 'overview.md', 'current-state.md', 'context.md', 'repo.md'];
+export function slugifyProject(value) {
+    const slug = value
+        .normalize('NFKD')
+        .toLowerCase()
+        .replace(/[^\p{Letter}\p{Number}]+/gu, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80)
+        .replace(/-+$/g, '');
+    return slug || 'project';
+}
+function renderTemplate(raw, vars) {
+    let out = raw;
+    for (const [key, value] of Object.entries(vars)) {
+        out = out.replaceAll(`{{${key}}}`, value);
+    }
+    return out;
+}
+async function readTemplate(name) {
+    return readFile(join(TEMPLATE_ROOT, name), 'utf8');
+}
+async function fileExists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function maybeAppendProjectsIndex(brainPath, slug, title) {
+    const indexPath = join(brainPath, 'Projects', '_Index.md');
+    let content;
+    try {
+        content = await readFile(indexPath, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const link = `[[Projects/${slug}/_Index]]`;
+    if (content.includes(link))
+        return false;
+    const line = `- ${link} — ${title}`;
+    const marker = 'up:: [[Home]]';
+    const next = content.includes(marker) ? content.replace(marker, `${line}\n\n${marker}`) : `${content.trimEnd()}\n${line}\n`;
+    await writeFile(indexPath, next, 'utf8');
+    return true;
+}
+export async function scaffoldProjectWorkspace(options) {
+    const brainPath = resolve(options.brainPath);
+    const title = options.title.trim() || 'Project';
+    const slug = options.slug?.trim() || slugifyProject(title);
+    const relDir = `Projects/${slug}`;
+    const today = options.today ?? new Date().toISOString().slice(0, 10);
+    const repoPath = options.repoPath?.trim() ?? '';
+    const verify = options.verify?.trim() ?? 'npm test && npm run typecheck';
+    const defaultBranch = options.defaultBranch?.trim() ?? 'main';
+    const created = [];
+    const skipped = [];
+    const warnings = [];
+    const vars = {
+        DATE: today,
+        TITLE: title,
+        SLUG: slug,
+        REPO_PATH: repoPath,
+        VERIFY: verify,
+        DEFAULT_BRANCH: defaultBranch,
+    };
+    for (const name of WORKSPACE_FILES) {
+        const rel = `${relDir}/${name}`;
+        const path = join(brainPath, rel);
+        if ((await fileExists(path)) && !options.force) {
+            skipped.push(rel);
+            continue;
+        }
+        await mkdir(dirname(path), { recursive: true });
+        const raw = await readTemplate(name);
+        await writeFile(path, renderTemplate(raw, vars), 'utf8');
+        created.push(rel);
+    }
+    if (!created.length && skipped.length) {
+        return {
+            ok: false,
+            brainPath,
+            slug,
+            title,
+            relDir,
+            created,
+            skipped,
+            indexed: false,
+            warnings: ['Project workspace already exists. Re-run with --force to overwrite scaffold files.'],
+        };
+    }
+    const indexed = await maybeAppendProjectsIndex(brainPath, slug, title);
+    if (!indexed)
+        warnings.push('Projects/_Index.md was not updated (missing or link already present).');
+    return { ok: true, brainPath, slug, title, relDir, created, skipped, indexed, warnings };
+}
+export function formatScaffoldProjectReport(report) {
+    const lines = ['Sanook brain new project (workspace scaffold)'];
+    lines.push(`vault: ${report.brainPath}`);
+    lines.push(`slug: ${report.slug}`);
+    lines.push(`title: ${report.title}`);
+    lines.push(`dir: ${report.relDir}/`);
+    if (report.created.length) {
+        lines.push(`created (${report.created.length}):`);
+        for (const rel of report.created)
+            lines.push(`  ${rel}`);
+    }
+    if (report.skipped.length) {
+        lines.push(`skipped (${report.skipped.length}):`);
+        for (const rel of report.skipped)
+            lines.push(`  ${rel}`);
+    }
+    if (report.indexed)
+        lines.push('index: Projects/_Index.md updated');
+    for (const warning of report.warnings)
+        lines.push(`warning: ${warning}`);
+    return lines.join('\n');
+}

package/dist/prompt-size.js

@@ -0,0 +1,155 @@
+import { BRAND } from './brand.js';
+import { loadConfig } from './config.js';
+import { gitContext } from './git.js';
+import { SYSTEM } from './loop.js';
+import { loadAutoMemory, loadBrainContext, loadMemory } from './memory.js';
+import { personalityPrompt } from './personality.js';
+import { loadRepoMap } from './repomap.js';
+import { loadSkills, renderAvailableSkills } from './skills.js';
+import { tools as builtInTools } from './tools/index.js';
+const CHARS_PER_TOKEN = 4;
+export function approximateTokens(chars) {
+    return chars <= 0 ? 0 : Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function utf8Bytes(text) {
+    return Buffer.byteLength(text, 'utf8');
+}
+export function measurePromptSection(id, label, text) {
+    return {
+        id,
+        label,
+        chars: text.length,
+        bytes: utf8Bytes(text),
+        approxTokens: approximateTokens(text.length),
+        empty: text.length === 0,
+    };
+}
+function joinPromptBlocks(blocks) {
+    return blocks.filter(Boolean).join('\n\n');
+}
+function toJsonSafe(value, options = {}, depth = 0, seen = new WeakSet()) {
+    const maxDepth = options.maxDepth ?? 6;
+    const maxStringLength = options.maxStringLength ?? 2_000;
+    if (value == null)
+        return value;
+    if (typeof value === 'string')
+        return value.length > maxStringLength ? `${value.slice(0, maxStringLength)}...[truncated]` : value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (typeof value === 'function' || typeof value === 'symbol' || typeof value === 'undefined')
+        return undefined;
+    if (depth >= maxDepth)
+        return '[MaxDepth]';
+    if (Array.isArray(value))
+        return value.map((item) => toJsonSafe(item, options, depth + 1, seen));
+    if (typeof value !== 'object')
+        return String(value);
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    const out = {};
+    for (const [key, child] of Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) {
+        if (key === 'execute' || key === 'experimental_toToolResultContent')
+            continue;
+        const safe = toJsonSafe(child, options, depth + 1, seen);
+        if (safe !== undefined)
+            out[key] = safe;
+    }
+    seen.delete(value);
+    return out;
+}
+export function serializeToolSchemas(tools) {
+    const payload = Object.entries(tools)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, tool]) => {
+        const t = tool;
+        return {
+            name,
+            description: typeof t.description === 'string' ? t.description : '',
+            inputSchema: toJsonSafe(t.inputSchema ?? t.parameters),
+        };
+    });
+    return JSON.stringify(payload, null, 2);
+}
+export async function buildPromptSizeBreakdown(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const planMode = options.planMode ?? false;
+    const [config, memory, autoMemory, skills, git, brain, repoMap,] = await Promise.all([
+        (options.loadConfigImpl ?? loadConfig)({}, cwd),
+        (options.loadMemoryImpl ?? loadMemory)(cwd),
+        (options.loadAutoMemoryImpl ?? loadAutoMemory)(),
+        (options.loadSkillsImpl ?? loadSkills)(cwd),
+        (options.gitContextImpl ?? gitContext)(cwd),
+        (options.loadBrainContextImpl ?? loadBrainContext)(),
+        (options.loadRepoMapImpl ?? loadRepoMap)(cwd),
+    ]);
+    const planSuffix = planMode
+        ? '\n\nPLAN MODE: สำรวจและวางแผนเท่านั้น — ห้ามแก้ไฟล์หรือรันคำสั่งที่เปลี่ยน state. จบด้วยแผนเป็นขั้นตอนให้ user อนุมัติก่อนลงมือ.'
+        : '';
+    const brainNudge = brain
+        ? '\n- second-brain vault โหลดอยู่ (ดู <brain_vault>) — อ่าน current-state + โน้ตที่เกี่ยวก่อนงานไม่ trivial · เจอ preference/decision สำคัญ → remember (เข้า vault) · งานเสร็จควร route/บันทึกตาม Vault Structure Map ของ vault'
+        : '';
+    const baseSystem = SYSTEM + planSuffix + brainNudge;
+    const personality = personalityPrompt(config.personality);
+    const skillsBlock = renderAvailableSkills(skills);
+    const staticSystem = joinPromptBlocks([baseSystem, personality, autoMemory, skillsBlock, brain, memory, repoMap]);
+    const systemPromptText = joinPromptBlocks([staticSystem, git]);
+    const toolSchemaText = serializeToolSchemas(options.tools ?? builtInTools);
+    const sections = [
+        measurePromptSection('base-system', 'Base system', baseSystem),
+        measurePromptSection('personality', 'Personality overlay', personality),
+        measurePromptSection('auto-memory', 'Auto memory', autoMemory),
+        measurePromptSection('skills-index', 'Skills index', skillsBlock),
+        measurePromptSection('brain-context', 'Second-brain context', brain),
+        measurePromptSection('project-memory', 'Project memory', memory),
+        measurePromptSection('repo-map', 'Repo map', repoMap),
+        measurePromptSection('git-context', 'Git context', git),
+    ];
+    const systemPrompt = measurePromptSection('system-prompt', 'System prompt total', systemPromptText);
+    const toolSchemas = measurePromptSection('tool-schemas', 'Built-in tool schemas', toolSchemaText);
+    const totalText = `${systemPromptText}\n\n${toolSchemaText}`;
+    return {
+        cwd,
+        model: config.model,
+        planMode,
+        skillsCount: skills.length,
+        builtInToolsCount: Object.keys(options.tools ?? builtInTools).length,
+        sections,
+        systemPrompt,
+        toolSchemas,
+        total: measurePromptSection('total-fixed-payload', 'Total fixed payload', totalText),
+        notes: [
+            'Counts are approximate; model tokenizers vary.',
+            'MCP tools are intentionally not spawned here. Use `sanook mcp list --tools` for live MCP catalog details.',
+            'The runtime sends git context as a separate system message so the static prompt cache stays useful.',
+        ],
+    };
+}
+function formatNumber(n) {
+    return new Intl.NumberFormat('en-US').format(n);
+}
+function formatSection(section) {
+    const empty = section.empty ? ' (empty)' : '';
+    return `${section.label.padEnd(22)} ${formatNumber(section.chars).padStart(8)} chars  ~${formatNumber(section.approxTokens).padStart(6)} tokens  ${formatNumber(section.bytes).padStart(8)} bytes${empty}`;
+}
+export function renderPromptSizeBreakdown(report) {
+    const lines = [
+        `${BRAND.productName} prompt-size`,
+        `cwd: ${report.cwd}`,
+        `model: ${report.model}${report.planMode ? '  plan-mode: on' : ''}`,
+        `skills: ${report.skillsCount}  built-in tools: ${report.builtInToolsCount}`,
+        '',
+        formatSection(report.systemPrompt),
+        formatSection(report.toolSchemas),
+        formatSection(report.total),
+        '',
+        'Breakdown:',
+        ...report.sections.map((section) => `  ${formatSection(section)}`),
+        '',
+        'Notes:',
+        ...report.notes.map((note) => `  - ${note}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/providers/codex-login.js

@@ -0,0 +1,138 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { codexHome } from './codex.js';
+/** OpenAI Codex OAuth client id (same public client as Codex CLI / Hermes). */
+export const CODEX_OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const CODEX_OAUTH_ISSUER = 'https://auth.openai.com';
+const CODEX_OAUTH_TOKEN_URL = `${CODEX_OAUTH_ISSUER}/oauth/token`;
+export const CODEX_DEVICE_VERIFY_URL = `${CODEX_OAUTH_ISSUER}/codex/device`;
+function parseRetryAfterSeconds(headers) {
+    const raw = headers?.get('retry-after')?.trim();
+    if (!raw)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.floor(seconds);
+    return undefined;
+}
+async function postJson(url, body, fetchImpl) {
+    return fetchImpl(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
+/** Step 1 — request device code (Hermes / Codex CLI compatible). */
+export async function requestCodexDeviceCode(fetchImpl = fetch) {
+    const maxAttempts = 4;
+    let resp;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        resp = await postJson(`${CODEX_OAUTH_ISSUER}/api/accounts/deviceauth/usercode`, { client_id: CODEX_OAUTH_CLIENT_ID }, fetchImpl);
+        if (resp.status !== 429)
+            break;
+        if (attempt < maxAttempts) {
+            const retryAfter = parseRetryAfterSeconds(resp.headers) ?? 2 ** attempt;
+            await new Promise((r) => setTimeout(r, Math.max(1000, Math.min(retryAfter * 1000, 60_000))));
+        }
+    }
+    if (!resp || resp.status === 429) {
+        throw new Error('OpenAI จำกัดการ login ชั่วคราว (429) — รอ 1 นาทีแล้วลองใหม่');
+    }
+    if (!resp.ok) {
+        throw new Error(`ขอ device code ไม่สำเร็จ (HTTP ${resp.status})`);
+    }
+    const data = (await resp.json());
+    const userCode = data.user_code?.trim();
+    const deviceAuthId = data.device_auth_id?.trim();
+    if (!userCode || !deviceAuthId)
+        throw new Error('OpenAI ตอบ device code ไม่ครบ');
+    const pollIntervalMs = Math.max(3000, Number(data.interval ?? 5) * 1000);
+    return { userCode, deviceAuthId, pollIntervalMs };
+}
+/** Step 2 — poll until the user completes browser login. */
+export async function pollCodexDeviceCode(session, opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const deadline = Date.now() + (opts.maxWaitMs ?? 15 * 60_000);
+    while (Date.now() < deadline) {
+        if (opts.signal?.aborted)
+            throw new Error('ยกเลิก login แล้ว');
+        await sleep(session.pollIntervalMs);
+        if (opts.signal?.aborted)
+            throw new Error('ยกเลิก login แล้ว');
+        const pollResp = await postJson(`${CODEX_OAUTH_ISSUER}/api/accounts/deviceauth/token`, { device_auth_id: session.deviceAuthId, user_code: session.userCode }, fetchImpl);
+        if (pollResp.status === 200) {
+            const payload = (await pollResp.json());
+            const authorization_code = payload.authorization_code?.trim();
+            const code_verifier = payload.code_verifier?.trim();
+            if (!authorization_code || !code_verifier)
+                throw new Error('OpenAI ตอบ authorization code ไม่ครบ');
+            return { authorization_code, code_verifier };
+        }
+        if (pollResp.status === 403 || pollResp.status === 404)
+            continue;
+        throw new Error(`รอ login ไม่สำเร็จ (HTTP ${pollResp.status})`);
+    }
+    throw new Error('หมดเวลารอ login (15 นาที) — ลองใหม่');
+}
+/** Step 3 — exchange authorization code for tokens. */
+export async function exchangeCodexDeviceCode(exchange, fetchImpl = fetch) {
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: exchange.authorization_code,
+        redirect_uri: `${CODEX_OAUTH_ISSUER}/deviceauth/callback`,
+        client_id: CODEX_OAUTH_CLIENT_ID,
+        code_verifier: exchange.code_verifier,
+    });
+    const resp = await fetchImpl(CODEX_OAUTH_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    if (resp.status === 429)
+        throw new Error('OpenAI จำกัดการ login ชั่วคราว (429) — รอแล้วลองใหม่');
+    if (!resp.ok)
+        throw new Error(`แลก token ไม่สำเร็จ (HTTP ${resp.status})`);
+    const tokens = (await resp.json());
+    const access_token = tokens.access_token?.trim();
+    const refresh_token = tokens.refresh_token?.trim();
+    if (!access_token || !refresh_token)
+        throw new Error('OpenAI ไม่ส่ง access/refresh token');
+    return {
+        access_token,
+        refresh_token,
+        id_token: tokens.id_token?.trim() || undefined,
+    };
+}
+/** Persist ChatGPT-plan credentials where the official Codex CLI expects them. */
+export async function saveCodexAuthFile(tokens, home = codexHome()) {
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    const authPath = join(home, 'auth.json');
+    const payload = {
+        auth_mode: 'chatgpt',
+        tokens: {
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            ...(tokens.id_token ? { id_token: tokens.id_token } : {}),
+        },
+        last_refresh: new Date().toISOString(),
+    };
+    await writeFile(authPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+    return authPath;
+}
+/** Full Hermes-style device-code login → ~/.codex/auth.json (Codex CLI can reuse). */
+export async function runCodexDeviceCodeLogin(opts = {}) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const onStatus = opts.onStatus ?? (() => { });
+    onStatus('requesting');
+    const session = await requestCodexDeviceCode(fetchImpl);
+    onStatus(`code:${session.userCode}`);
+    onStatus('waiting');
+    const exchange = await pollCodexDeviceCode(session, opts);
+    onStatus('exchanging');
+    const tokens = await exchangeCodexDeviceCode(exchange, fetchImpl);
+    onStatus('saving');
+    const authPath = await saveCodexAuthFile(tokens);
+    onStatus('done');
+    return authPath;
+}

package/dist/providers/codex.js

@@ -2,8 +2,21 @@ import { spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+export function codexHome() {
+    return process.env.CODEX_HOME?.trim() || join(homedir(), '.codex');
+}
+async function readCodexLoggedIn() {
+    try {
+        const auth = JSON.parse(await readFile(join(codexHome(), 'auth.json'), 'utf8'));
+        return auth?.auth_mode === 'chatgpt' || Boolean(auth?.tokens?.access_token);
+    }
+    catch {
+        return false;
+    }
+}
 /** เช็กว่า codex CLI ติดตั้ง + login ChatGPT แล้ว */
 export async function detectCodex() {
+    const loggedIn = await readCodexLoggedIn();
     const hasBinary = await new Promise((resolve) => {
         const p = spawn('codex', ['--version'], { shell: process.platform === 'win32' });
         // timeout: binary ค้าง (shim รอ stdin / Gatekeeper stall ตอนรันครั้งแรกบน macOS) → ไม่ให้ wizard ตัน
@@ -21,24 +34,26 @@ export async function detectCodex() {
         });
     });
     if (!hasBinary) {
-        return { installed: false, loggedIn: false, reason: 'ไม่พบ codex CLI — ติดตั้ง: npm i -g @openai/codex' };
+        return {
+            installed: false,
+            loggedIn,
+            reason: loggedIn
+                ? 'login แล้ว แต่ยังไม่มี codex CLI — ติดตั้ง: npm i -g @openai/codex'
+                : 'ไม่พบ codex CLI — ติดตั้ง: npm i -g @openai/codex',
+        };
     }
-    try {
-        const auth = JSON.parse(await readFile(join(homedir(), '.codex', 'auth.json'), 'utf8'));
-        const loggedIn = auth?.auth_mode === 'chatgpt' || Boolean(auth?.tokens?.access_token);
-        return { installed: true, loggedIn, reason: loggedIn ? undefined : 'ยังไม่ได้ login — รัน: codex login' };
-    }
-    catch {
-        return { installed: true, loggedIn: false, reason: 'ยังไม่ได้ login — รัน: codex login' };
+    if (loggedIn) {
+        return { installed: true, loggedIn: true, reason: undefined };
     }
+    return { installed: true, loggedIn: false, reason: 'ยังไม่ได้ login — รัน: codex login' };
 }
 /**
  * รัน `codex exec` แบบ non-interactive — ส่ง prompt ทาง stdin, parse JSONL events
  * tolerant ต่อ malformed JSONL (codex bug #15451: --json ถูก ignore เมื่อมี tools active)
  */
 export async function runCodex(opts) {
-    // --ask-for-approval never: รัน non-interactive ไม่ค้างรอ approval (ปลอดภัยเพราะ default sandbox = read-only)
-    const args = ['exec', '--skip-git-repo-check', '--sandbox', opts.sandbox ?? 'read-only', '--ask-for-approval', 'never', '--json'];
+    // `codex exec` is already non-interactive; sandbox controls whether generated commands may write.
+    const args = ['exec', '--skip-git-repo-check', '--sandbox', opts.sandbox ?? 'read-only', '--json'];
     if (opts.model)
         args.push('-m', opts.model);
     if (opts.resumeThreadId)
@@ -49,52 +64,83 @@ export async function runCodex(opts) {
         // (codex bug #2733/#3286: ตั้ง OPENAI_API_KEY ค้าง env ทำให้ ChatGPT-plan auth วน loop sign-in)
         const env = { ...process.env };
         delete env.OPENAI_API_KEY;
-        const p = spawn('codex', args, { env, shell: process.platform === 'win32' }); // Windows: codex = JS shim ผ่าน .cmd → ต้อง shell
+        const p = spawn('codex', args, { env, cwd: opts.cwd, shell: process.platform === 'win32' }); // Windows: codex = JS shim ผ่าน .cmd → ต้อง shell
         let finalText = '';
         let threadId;
         let buf = '';
-        opts.signal?.addEventListener('abort', () => p.kill());
-        p.stdin.write(opts.prompt);
-        p.stdin.end();
+        let stderr = '';
+        let aborted = false;
+        const handleStdoutLine = (line) => {
+            const t = line.trim();
+            if (!t)
+                return;
+            if (!t.startsWith('{')) {
+                // plain stdout fallback (JSONL ถูก ignore) — เก็บเป็น final text
+                finalText += (finalText ? '\n' : '') + t;
+                opts.onEvent?.({ type: 'text', text: finalText });
+                return;
+            }
+            try {
+                const ev = JSON.parse(t);
+                if (ev.type === 'thread.started' && ev.thread_id) {
+                    threadId = ev.thread_id;
+                    opts.onEvent?.({ type: 'thread', threadId });
+                }
+                else if (ev.type === 'item.completed' && ev.item?.type === 'agent_message') {
+                    finalText = ev.item.text ?? finalText;
+                    opts.onEvent?.({ type: 'text', text: finalText });
+                }
+                else if (ev.type === 'turn.completed') {
+                    opts.onEvent?.({ type: 'usage', usage: ev.usage });
+                }
+            }
+            catch {
+                // malformed JSON line — ข้าม
+            }
+        };
+        const abortHandler = () => {
+            aborted = true;
+            p.kill();
+        };
+        const cleanupAbortHandler = () => opts.signal?.removeEventListener('abort', abortHandler);
+        // codex อาจตายระหว่างรับ prompt → write ลง stdin ที่ปิดแล้ว = EPIPE; ถ้าไม่ดัก = crash ทั้ง CLI
+        // (close handler ด้านล่าง reject error ที่อ่านรู้เรื่องแทน)
+        p.stdin.on('error', () => { });
+        if (opts.signal?.aborted)
+            abortHandler();
+        else
+            opts.signal?.addEventListener('abort', abortHandler, { once: true });
+        if (!aborted) {
+            p.stdin.write(opts.prompt);
+            p.stdin.end();
+        }
         p.stdout.on('data', (chunk) => {
             buf += chunk.toString();
             const lines = buf.split('\n');
             buf = lines.pop() ?? '';
             for (const line of lines) {
-                const t = line.trim();
-                if (!t)
-                    continue;
-                if (!t.startsWith('{')) {
-                    // plain stdout fallback (JSONL ถูก ignore) — เก็บเป็น final text
-                    finalText += (finalText ? '\n' : '') + t;
-                    opts.onEvent?.({ type: 'text', text: finalText });
-                    continue;
-                }
-                try {
-                    const ev = JSON.parse(t);
-                    if (ev.type === 'thread.started' && ev.thread_id) {
-                        threadId = ev.thread_id;
-                        opts.onEvent?.({ type: 'thread', threadId });
-                    }
-                    else if (ev.type === 'item.completed' && ev.item?.type === 'agent_message') {
-                        finalText = ev.item.text ?? finalText;
-                        opts.onEvent?.({ type: 'text', text: finalText });
-                    }
-                    else if (ev.type === 'turn.completed') {
-                        opts.onEvent?.({ type: 'usage', usage: ev.usage });
-                    }
-                }
-                catch {
-                    // malformed JSON line — ข้าม
-                }
+                handleStdoutLine(line);
             }
         });
-        p.on('error', (err) => reject(new Error(`เรียก codex ไม่ได้: ${err.message}`)));
+        p.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+            if (stderr.length > 4000)
+                stderr = stderr.slice(-4000);
+        });
+        p.on('error', (err) => {
+            cleanupAbortHandler();
+            reject(new Error(`เรียก codex ไม่ได้: ${err.message}`));
+        });
         p.on('close', (code) => {
-            if (code === 0)
+            cleanupAbortHandler();
+            handleStdoutLine(buf);
+            buf = '';
+            if (aborted)
+                reject(new Error(`codex exec ถูกยกเลิก${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
+            else if (code === 0)
                 resolve({ text: finalText.trim(), threadId });
             else
-                reject(new Error(`codex exec จบด้วย exit code ${code}`));
+                reject(new Error(`codex exec จบด้วย exit code ${code}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
         });
     });
 }

package/dist/providers/keys.js

@@ -8,7 +8,7 @@
 /** อ่าน API key จาก env (หลัก + fallbacks) — keychain เป็น enhancement ทีหลัง */
 export function resolveKeyFromEnv(envVar, fallbacks = []) {
     for (const name of [envVar, ...fallbacks]) {
-        const v = process.env[name];
+        const v = process.env[name]?.trim();
         if (v)
             return v;
     }
@@ -36,3 +36,24 @@ export function assertDirectApiKey(policy, key) {
 export function redactKey(s) {
     return s.replace(/\b(AKIA[0-9A-Z]{16}|sk-[A-Za-z0-9_-]{6,}|AIza[A-Za-z0-9_-]{10,}|xai-[A-Za-z0-9]{10,}|gsk_[A-Za-z0-9]{10,}|[A-Za-z0-9_-]{24,})\b/g, (m) => (m.length > 8 ? `${m.slice(0, 4)}…${m.slice(-2)}` : '…'));
 }
+export function redactUnknown(value) {
+    const visiting = new WeakSet();
+    const visit = (current) => {
+        if (typeof current === 'string')
+            return redactKey(current);
+        if (!current || typeof current !== 'object')
+            return current;
+        if (visiting.has(current))
+            return '[Circular]';
+        visiting.add(current);
+        try {
+            if (Array.isArray(current))
+                return current.map(visit);
+            return Object.fromEntries(Object.entries(current).map(([k, v]) => [redactKey(k), visit(v)]));
+        }
+        finally {
+            visiting.delete(current);
+        }
+    };
+    return visit(value);
+}

package/dist/providers/models.js

@@ -22,7 +22,7 @@ export async function listRemoteModels(cfg, key, timeoutMs = 6000) {
                 .map((m) => (m.name ?? '').replace(/^models\//, ''))
                 .filter(Boolean);
         }
-        const base = process.env[`${cfg.id.toUpperCase()}_BASE_URL`] ?? cfg.baseURL;
+        const base = process.env[`${cfg.id.toUpperCase()}_BASE_URL`]?.trim() || cfg.baseURL?.trim();
         if (!base)
             return []; // ไม่มี baseURL = ดึงไม่ได้
         const headers = cfg.id === 'anthropic'
@@ -49,7 +49,7 @@ export async function listRemoteModels(cfg, key, timeoutMs = 6000) {
  */
 export function mergeModelOptions(cfg, remote = []) {
     // group alias ทั้งหมดตาม id (รวม 'default' ด้วย — กัน id ที่มีแต่ alias 'default' เช่น lmstudio:local-model,
-    // ollama:qwen3 หายไปจนเลือกไม่ได้/Select ว่าง). ตอนทำ label ค่อยซ่อนคำ "default" ถ้ามีชื่ออื่นอยู่แล้ว
+    // ollama:llama3.3 หายไปจนเลือกไม่ได้/Select ว่าง). ตอนทำ label ค่อยซ่อนคำ "default" ถ้ามีชื่ออื่นอยู่แล้ว
     const aliasesById = new Map();
     const order = []; // คง first-seen order ของ id
     for (const [alias, id] of Object.entries(cfg.models)) {