sanook-cli 0.5.0 → 0.5.2

package/dist/search/indexer.js

@@ -25,6 +25,7 @@ import { activeFacts, effImportance, loadStore } from '../memory-store.js';
 import { chunkMarkdown } from './chunk.js';
 import { addDoc, removeDoc, removeSource } from './index-core.js';
 import { loadIndex, saveIndex } from './store.js';
+import { buildVectorIndex, embedTexts, getEmbedder, invalidateVectors, saveVectors } from './embed-store.js';
 /** strip a .md path to a human title fallback when a chunk has no heading. */
 function fileTitle(rel) {
     return (rel.split('/').pop() ?? rel).replace(/\.md$/i, '');
@@ -130,6 +131,21 @@ export function foldSkills(index, skills) {
     }
     return skills.length;
 }
+function docEmbeddingText(doc) {
+    return [doc.title?.trim(), doc.text.trim()].filter(Boolean).join('\n').slice(0, 4000);
+}
+export async function vectorizeIndex(index, tag, embed) {
+    const docs = [...index.docs.values()]
+        .filter((d) => d.text.trim())
+        .sort((a, b) => a.id.localeCompare(b.id));
+    if (!docs.length)
+        return buildVectorIndex(tag, []);
+    const vectors = await embed(docs.map(docEmbeddingText));
+    if (vectors.length !== docs.length) {
+        throw new Error(`embedding count mismatch: expected ${docs.length}, got ${vectors.length}`);
+    }
+    return buildVectorIndex(tag, docs.map((d, i) => ({ id: d.id, vec: vectors[i] })));
+}
 // ---- real-filesystem wiring ------------------------------------------------
 const IGNORE_DIRS = new Set([
     'node_modules', 'dist', 'build', 'coverage', '.next', '.cache', '.git',
@@ -176,6 +192,15 @@ export function nodeVaultFS(root) {
     };
 }
 const SESSIONS_DIR = appHomePath('sessions');
+async function configEmbeddingModel() {
+    try {
+        const cfg = JSON.parse(await readFile(appHomePath('config.json'), 'utf8'));
+        return cfg.embeddingModel;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** load first-user-message of the most recent sessions (bounded) for the session corpus. */
 export async function loadRecentSessions(limit = 60) {
     const out = [];
@@ -237,5 +262,23 @@ export async function reindex(now = Date.now()) {
         text: `${s.description} ${s.whenToUse ?? ''}`.trim(),
     })));
     await saveIndex(index, nextManifest);
-    return { ...diff, memory, sessions, skills, vaultPath: brain ?? null };
+    let vectors = 0;
+    const embedder = getEmbedder(process.env.SANOOK_EMBEDDING_MODEL ?? (await configEmbeddingModel()));
+    if (!embedder) {
+        await invalidateVectors().catch(() => { });
+    }
+    else {
+        try {
+            const vi = await vectorizeIndex(index, embedder.tag, (texts) => embedTexts(embedder, texts));
+            await saveVectors(vi);
+            vectors = vi.ids.length;
+        }
+        catch {
+            // Semantic search is optional. A provider/network failure must never break
+            // the BM25 floor. Clear stale vectors so hybrid/semantic cannot rank the
+            // freshly-saved BM25 index with embeddings from an older corpus.
+            await invalidateVectors(embedder.tag).catch(() => { });
+        }
+    }
+    return { ...diff, memory, sessions, skills, vectors, vaultPath: brain ?? null };
 }

package/dist/search/store.js

@@ -34,6 +34,28 @@ export async function indexMtimeMs() {
         return 0;
     }
 }
+export function sanitizeManifest(raw) {
+    const out = Object.create(null);
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return out;
+    for (const [path, entry] of Object.entries(raw)) {
+        if (!path || ['__proto__', 'prototype', 'constructor'].includes(path))
+            continue;
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const r = entry;
+        const mtimeMs = Number(r.mtimeMs);
+        const size = Number(r.size);
+        if (!Number.isFinite(mtimeMs) || mtimeMs < 0 || !Number.isFinite(size) || size < 0)
+            continue;
+        if (typeof r.sha !== 'string' || !r.sha || r.sha.length > 256)
+            continue;
+        if (!Array.isArray(r.ids) || !r.ids.every((id) => typeof id === 'string' && id.length > 0 && id.length < 1024))
+            continue;
+        out[path] = { mtimeMs, size, sha: r.sha, ids: [...r.ids] };
+    }
+    return out;
+}
 /**
  * Load the persisted index + manifest. Pure read: a missing or malformed file
  * degrades to an empty index rather than throwing, so a corrupt cache never
@@ -43,7 +65,7 @@ export async function loadIndex() {
     try {
         const raw = JSON.parse(await readFile(INDEX_PATH, 'utf8'));
         if (raw && raw.v === FILE_VERSION) {
-            return { index: indexFromJSON(raw.index), manifest: raw.manifest ?? {} };
+            return { index: indexFromJSON(raw.index), manifest: sanitizeManifest(raw.manifest) };
         }
     }
     catch {

package/dist/session.js

@@ -1,14 +1,50 @@
-import { chmod, readFile, writeFile, mkdir, readdir, realpath } from 'node:fs/promises';
+import { chmod, readFile, writeFile, mkdir, readdir, realpath, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { appHomePath, persistenceEnabled } from './brand.js';
 import { redactKey } from './providers/keys.js';
 // session store — จำ conversation + ความคืบหน้า เพื่อ "ทำงานต่อได้" ไม่ลืมว่าทำถึงไหน
 const SESSION_DIR = appHomePath('sessions');
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isModelMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.role === 'system')
+        return typeof value.content === 'string';
+    if (value.role === 'tool')
+        return Array.isArray(value.content);
+    if (value.role === 'user' || value.role === 'assistant') {
+        return typeof value.content === 'string' || Array.isArray(value.content);
+    }
+    return false;
+}
+function isSession(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        (value.title === undefined || typeof value.title === 'string') &&
+        typeof value.created === 'string' &&
+        typeof value.updated === 'string' &&
+        typeof value.model === 'string' &&
+        typeof value.cwd === 'string' &&
+        Array.isArray(value.messages) &&
+        value.messages.every(isModelMessage));
+}
 export function newSessionId() {
     // CLI runtime — ใช้ Date/random ได้ (ไม่ใช่ workflow context)
     const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
     return `${ts}-${Math.random().toString(36).slice(2, 8)}`;
 }
+export function sessionStorePath() {
+    return SESSION_DIR;
+}
+function sessionFilePath(id) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(id) || id.includes('..')) {
+        throw new Error(`session id ไม่ถูกต้อง: ${id}`);
+    }
+    return join(SESSION_DIR, `${id}.json`);
+}
 function redactUnknown(value) {
     if (typeof value === 'string')
         return redactKey(value);
@@ -22,9 +58,13 @@ function redactUnknown(value) {
 function sanitizeSession(s) {
     return {
         ...s,
+        title: typeof s.title === 'string' ? redactKey(s.title) : s.title,
         messages: redactUnknown(s.messages),
     };
 }
+export function sanitizeSessionForExport(s) {
+    return sanitizeSession(s);
+}
 async function canonicalPath(path) {
     try {
         return await realpath(path);
@@ -37,24 +77,25 @@ export async function saveSession(s) {
     if (!persistenceEnabled())
         return;
     await mkdir(SESSION_DIR, { recursive: true });
-    const path = join(SESSION_DIR, `${s.id}.json`);
+    const path = sessionFilePath(s.id);
     await writeFile(path, `${JSON.stringify(sanitizeSession(s), null, 2)}\n`, { mode: 0o600 });
     await chmod(path, 0o600).catch(() => { });
 }
 export async function loadSession(id) {
     try {
-        return JSON.parse(await readFile(join(SESSION_DIR, `${id}.json`), 'utf8'));
+        const parsed = JSON.parse(await readFile(sessionFilePath(id), 'utf8'));
+        return isSession(parsed) && parsed.id === id ? parsed : null;
     }
     catch {
         return null;
     }
 }
-/** session ล่าสุด (สำหรับ --continue). ค่า default จำกัดเฉพาะ cwd ปัจจุบัน กัน context ข้าม project */
-export async function latestSession(cwd = process.cwd()) {
+export async function listSessions(options = {}) {
     try {
+        const cwd = options.cwd === undefined ? process.cwd() : options.cwd;
         const ids = (await readdir(SESSION_DIR)).filter((f) => f.endsWith('.json')).map((f) => f.slice(0, -5));
         if (!ids.length)
-            return null;
+            return [];
         let sessions = (await Promise.all(ids.map(loadSession))).filter((s) => s !== null);
         if (cwd) {
             const current = await canonicalPath(cwd);
@@ -62,9 +103,54 @@ export async function latestSession(cwd = process.cwd()) {
             sessions = pairs.filter((p) => p.cwd === current).map((p) => p.session);
         }
         sessions.sort((a, b) => b.updated.localeCompare(a.updated));
-        return sessions[0] ?? null;
+        const limit = options.limit;
+        return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? sessions.slice(0, limit) : sessions;
     }
     catch {
+        return [];
+    }
+}
+export async function removeSession(id) {
+    try {
+        await rm(sessionFilePath(id), { force: false });
+        return true;
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 'ENOENT')
+            return false;
+        throw e;
+    }
+}
+export async function renameSession(id, title) {
+    const session = await loadSession(id);
+    if (!session)
         return null;
+    const next = { ...session, title: title.trim(), updated: new Date().toISOString() };
+    await saveSession(next);
+    return next;
+}
+export async function pruneSessions(options = {}) {
+    const sessions = await listSessions({ cwd: options.cwd });
+    const removeIds = new Set();
+    if (Number.isInteger(options.keep) && options.keep >= 0) {
+        for (const s of sessions.slice(options.keep))
+            removeIds.add(s.id);
     }
+    if (options.before) {
+        const beforeMs = options.before.getTime();
+        for (const s of sessions) {
+            const updatedMs = Date.parse(s.updated);
+            if (Number.isFinite(updatedMs) && updatedMs < beforeMs)
+                removeIds.add(s.id);
+        }
+    }
+    const removed = sessions.filter((s) => removeIds.has(s.id));
+    for (const s of removed)
+        await removeSession(s.id);
+    return removed;
+}
+/** session ล่าสุด (สำหรับ --continue). ค่า default จำกัดเฉพาะ cwd ปัจจุบัน กัน context ข้าม project */
+export async function latestSession(cwd = process.cwd()) {
+    return (await listSessions({ cwd, limit: 1 }))[0] ?? null;
 }

package/dist/skill-install.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, readdir, rm, stat, lstat, copyFile, rename } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, basename, resolve, sep, dirname } from 'node:path';
 import { execFile } from 'node:child_process';
@@ -13,6 +13,7 @@ const USER_SKILLS = appHomePath('skills');
 const MAX_FILES = 300;
 const MAX_BYTES = 20 * 1024 * 1024; // 20MB ต่อ skill
 const MAX_MD = 2 * 1024 * 1024; // 2MB ต่อ SKILL.md จาก URL
+const SUPPORT_DIRS = new Set(['references', 'scripts', 'assets', 'templates']);
 const exists = async (p) => {
     try {
         await stat(p);
@@ -22,7 +23,7 @@ const exists = async (p) => {
         return false;
     }
 };
-async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
+async function copyTreeSafe(srcDir, destDir, budget, depth = 2, atRoot = true) {
     if (depth < 0)
         return;
     let entries;
@@ -35,12 +36,14 @@ async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
     for (const e of entries) {
         if (e.name.startsWith('.'))
             continue; // skip .git/dotfiles
+        if (atRoot && e.name !== 'SKILL.md' && !SUPPORT_DIRS.has(e.name))
+            continue;
         const s = join(srcDir, e.name);
         const st = await lstat(s);
         if (st.isSymbolicLink())
             continue; // ห้าม copy symlink (กัน planted symlink หลุด ~/.sanook)
         if (st.isDirectory()) {
-            await copyTreeSafe(s, join(destDir, e.name), budget, depth - 1);
+            await copyTreeSafe(s, join(destDir, e.name), budget, depth - 1, false);
         }
         else if (st.isFile()) {
             if (--budget.files < 0)
@@ -53,7 +56,22 @@ async function copyTreeSafe(srcDir, destDir, budget, depth = 2) {
         }
     }
 }
-/** copy skill dir (SKILL.md + references/scripts ที่เป็น regular file) → ~/.sanook/skills/<name> */
+async function replaceSkillDir(name, populate) {
+    const dest = join(USER_SKILLS, name);
+    const tmp = join(USER_SKILLS, `.${name}.${randomUUID()}.tmp`);
+    await mkdir(USER_SKILLS, { recursive: true });
+    try {
+        await populate(tmp);
+        await rm(dest, { recursive: true, force: true });
+        await rename(tmp, dest);
+        return dest;
+    }
+    catch (e) {
+        await rm(tmp, { recursive: true, force: true }).catch(() => { });
+        throw e;
+    }
+}
+/** copy skill dir (SKILL.md + allowed support dirs as regular files) → ~/.sanook/skills/<name> */
 async function installFromDir(srcDir) {
     const md = join(srcDir, 'SKILL.md');
     const stMd = await lstat(md);
@@ -63,10 +81,7 @@ async function installFromDir(srcDir) {
     const name = meta.name || basename(srcDir);
     if (!isValidSkillName(name))
         throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
-    const dest = join(USER_SKILLS, name);
-    await rm(dest, { recursive: true, force: true });
-    await mkdir(dest, { recursive: true });
-    await copyTreeSafe(srcDir, dest, { files: MAX_FILES, bytes: MAX_BYTES });
+    const dest = await replaceSkillDir(name, (tmp) => copyTreeSafe(srcDir, tmp, { files: MAX_FILES, bytes: MAX_BYTES }));
     return { name, path: dest };
 }
 /** เขียน SKILL.md เดียว (จาก URL) → ~/.sanook/skills/<name> */
@@ -75,10 +90,10 @@ async function installFromContent(content, fallbackName) {
     const name = meta.name || fallbackName;
     if (!isValidSkillName(name))
         throw new Error(`ชื่อ skill ไม่ถูกต้อง: "${name}"`);
-    const dest = join(USER_SKILLS, name);
-    await rm(dest, { recursive: true, force: true });
-    await mkdir(dest, { recursive: true });
-    await writeFile(join(dest, 'SKILL.md'), content);
+    const dest = await replaceSkillDir(name, async (tmp) => {
+        await mkdir(tmp, { recursive: true });
+        await writeFile(join(tmp, 'SKILL.md'), content);
+    });
     return { name, path: dest };
 }
 /** หา SKILL.md ใน dir (ตรงๆ, ทุก subdir, หรือ skills/ subdir) → ติดตั้งทั้งหมด */
@@ -95,6 +110,8 @@ async function installFromLocal(path, onLog) {
             continue;
         }
         for (const e of entries) {
+            if (e.name.startsWith('.'))
+                continue;
             if (e.isDirectory() && (await exists(join(root, e.name, 'SKILL.md')))) {
                 try {
                     out.push(await installFromDir(join(root, e.name)));

package/dist/support-dump.js

@@ -0,0 +1,175 @@
+import { arch, platform, release } from 'node:os';
+import { appHomePath, appProjectPath, BRAND } from './brand.js';
+import { authConfigPath, loadConfig, readGlobalConfigRaw, readStoredAuthRaw } from './config.js';
+import { loadMcpConfig } from './mcp.js';
+import { parseSpec, PROVIDERS } from './providers/registry.js';
+import { redactKey } from './providers/keys.js';
+import { listSessions, sessionStorePath } from './session.js';
+import { loadSkills } from './skills.js';
+import { projectRoot, projectTrustStatus } from './trust.js';
+function yesNo(value) {
+    return value ? 'yes' : 'no';
+}
+function valueOrUnset(value) {
+    if (value === undefined || value === null || value === '')
+        return '(not set)';
+    return String(value);
+}
+function keySource(envVar, fallbacks, env) {
+    for (const name of [envVar, ...fallbacks]) {
+        const key = env[name]?.trim();
+        if (key)
+            return { name, key };
+    }
+    return null;
+}
+function providerStatusLines(stored, env, showKeys) {
+    const lines = ['provider auth:'];
+    for (const [id, cfg] of Object.entries(PROVIDERS)) {
+        if (!cfg.requiresKey) {
+            lines.push(`  ${id.padEnd(10)} ${cfg.label}: no API key required`);
+            continue;
+        }
+        const runtime = keySource(cfg.envVar, cfg.envFallbacks ?? [], env);
+        const saved = stored[cfg.envVar];
+        const state = runtime ? `ready via ${runtime.name}` : saved ? `stored in auth.json` : `missing ${cfg.envVar}`;
+        const key = runtime?.key ?? saved;
+        const keySuffix = showKeys && key ? ` (${runtime?.name ?? cfg.envVar}=${redactKey(key)})` : '';
+        lines.push(`  ${id.padEnd(10)} ${cfg.label}: ${state}${keySuffix}`);
+    }
+    return lines;
+}
+function mcpEndpointLabel(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+    }
+    catch {
+        return '(http endpoint)';
+    }
+}
+export async function buildSupportDump(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const lines = [];
+    const mcpLogs = [];
+    const rawConfig = await readGlobalConfigRaw();
+    const storedAuth = await readStoredAuthRaw();
+    const loadedConfig = await loadConfig({}, cwd).catch((e) => e);
+    const parsed = loadedConfig instanceof Error ? null : parseSpec(loadedConfig.model);
+    const provider = parsed ? PROVIDERS[parsed.provider] : undefined;
+    const root = await projectRoot(cwd);
+    const trust = await projectTrustStatus(root);
+    const { readGatewayConfig, resolveBlueBubblesConfig, resolveDiscordConfig, resolveEmailConfig, resolveGoogleChatConfig, resolveHomeAssistantConfig, resolveLineConfig, resolveMattermostConfig, resolveMatrixConfig, resolveNtfyConfig, resolveSignalConfig, resolveSlackConfig, resolveSmsConfig, resolveTelegramConfig, resolveTeamsConfig, resolveWhatsAppConfig, resolveWebhookConfig, gatewayConfigPath, } = await import('./gateway/config.js');
+    const { gatewayServiceStatus } = await import('./gateway/service.js');
+    const { listConfiguredTargets } = await import('./gateway/targets.js');
+    const { redactSignalId } = await import('./gateway/signal.js');
+    const { redactWhatsAppId } = await import('./gateway/whatsapp.js');
+    const gatewayConfig = await readGatewayConfig();
+    const telegram = resolveTelegramConfig(gatewayConfig, env);
+    const discord = resolveDiscordConfig(gatewayConfig, env);
+    const slack = resolveSlackConfig(gatewayConfig, env);
+    const email = resolveEmailConfig(gatewayConfig, env);
+    const homeassistant = resolveHomeAssistantConfig(gatewayConfig, env);
+    const line = resolveLineConfig(gatewayConfig, env);
+    const mattermost = resolveMattermostConfig(gatewayConfig, env);
+    const sms = resolveSmsConfig(gatewayConfig, env);
+    const ntfy = resolveNtfyConfig(gatewayConfig, env);
+    const signal = resolveSignalConfig(gatewayConfig, env);
+    const whatsapp = resolveWhatsAppConfig(gatewayConfig, env);
+    const matrix = resolveMatrixConfig(gatewayConfig, env);
+    const googleChat = resolveGoogleChatConfig(gatewayConfig, env);
+    const bluebubbles = resolveBlueBubblesConfig(gatewayConfig, env);
+    const teams = resolveTeamsConfig(gatewayConfig, env);
+    const webhooks = resolveWebhookConfig(gatewayConfig, env);
+    const service = await gatewayServiceStatus();
+    const targets = listConfiguredTargets(gatewayConfig, env);
+    const mcp = await loadMcpConfig((m) => mcpLogs.push(m), cwd);
+    const skills = await loadSkills(cwd);
+    const currentSessions = await listSessions({ cwd });
+    const allSessions = await listSessions({ cwd: null });
+    const { tools } = await import('./tools/index.js');
+    lines.push(`${BRAND.productName} support dump`);
+    lines.push(`version: ${options.version ?? '(dev)'}`);
+    if (options.packageName)
+        lines.push(`package: ${options.packageName}`);
+    lines.push(`node: ${process.version}`);
+    lines.push(`platform: ${platform()} ${release()} ${arch()}`);
+    lines.push(`cwd: ${cwd}`);
+    lines.push(`project root: ${root}`);
+    lines.push(`project trust: ${trust.trusted ? 'trusted' : `untrusted (${trust.reason})`}`);
+    lines.push('');
+    lines.push('paths:');
+    lines.push(`  config: ${appHomePath('config.json')}`);
+    lines.push(`  auth: ${authConfigPath()}`);
+    lines.push(`  gateway config: ${gatewayConfigPath()}`);
+    lines.push(`  gateway service log: ${service.logPath}`);
+    lines.push(`  sessions: ${sessionStorePath()}`);
+    lines.push(`  mcp global: ${appHomePath('mcp.json')}`);
+    lines.push(`  mcp project: ${appProjectPath(root, 'mcp.json')}`);
+    lines.push('');
+    lines.push('agent config:');
+    if (loadedConfig instanceof Error) {
+        lines.push(`  load error: ${redactKey(loadedConfig.message)}`);
+        lines.push(`  raw keys: ${Object.keys(rawConfig).sort().join(', ') || '(none)'}`);
+    }
+    else {
+        lines.push(`  model: ${loadedConfig.model}`);
+        lines.push(`  provider: ${provider?.label ?? parsed?.provider ?? '(unknown)'}`);
+        lines.push(`  fallbackModel: ${valueOrUnset(loadedConfig.fallbackModel)}`);
+        lines.push(`  permissionMode: ${loadedConfig.permissionMode}`);
+        lines.push(`  maxSteps: ${loadedConfig.maxSteps}`);
+        lines.push(`  budgetUsd: ${valueOrUnset(loadedConfig.budgetUsd)}`);
+        lines.push(`  brainPath: ${valueOrUnset(loadedConfig.brainPath)}`);
+        lines.push(`  cacheTtl: ${loadedConfig.cacheTtl}`);
+        lines.push(`  compaction: ${loadedConfig.compaction}`);
+        lines.push(`  thinking: ${valueOrUnset(loadedConfig.thinking)}`);
+        lines.push(`  summaryModel: ${valueOrUnset(loadedConfig.summaryModel)}`);
+        lines.push(`  embeddingModel: ${valueOrUnset(loadedConfig.embeddingModel)}`);
+    }
+    lines.push('');
+    lines.push(...providerStatusLines(storedAuth, env, options.showKeys === true));
+    lines.push('');
+    lines.push('gateway:');
+    lines.push(`  service: ${service.running ? `running pid ${service.state?.pid}` : service.state ? `stopped last pid ${service.state.pid}` : 'not started'}`);
+    lines.push(`  telegram: ${telegram.token ? `configured via ${telegram.source}` : 'not configured'}; enabled=${yesNo(telegram.enabled)}; allowed=${telegram.allowedChatIds.length}; write=${yesNo(telegram.allowWrite)}`);
+    lines.push(`  discord: ${discord.token ? `configured via ${discord.source}` : 'not configured'}; enabled=${yesNo(discord.enabled)}; allowed=${discord.allowedChannelIds.length}; default=${valueOrUnset(discord.defaultChannelId)}; write=${yesNo(discord.allowWrite)}`);
+    lines.push(`  slack: ${slack.botToken ? `configured via ${slack.source}` : 'not configured'}; enabled=${yesNo(slack.enabled)}; appToken=${yesNo(Boolean(slack.appToken))}; allowed=${slack.allowedChannelIds.length}; default=${valueOrUnset(slack.defaultChannelId)}; write=${yesNo(slack.allowWrite)}`);
+    lines.push(`  mattermost: ${mattermost.serverUrl || mattermost.token ? `configured via ${mattermost.source}` : 'not configured'}; enabled=${yesNo(mattermost.enabled)}; url=${valueOrUnset(mattermost.serverUrl)}; token=${yesNo(Boolean(mattermost.token))}; allowedUsers=${mattermost.allowedUsers.length}; allowedChannels=${mattermost.allowedChannels.length}; home=${valueOrUnset(mattermost.homeChannel)}; requireMention=${yesNo(mattermost.requireMention)}; replyMode=${mattermost.replyMode}`);
+    lines.push(`  homeassistant: ${homeassistant.token ? `configured via ${homeassistant.source}` : 'not configured'}; enabled=${yesNo(homeassistant.enabled)}; url=${valueOrUnset(homeassistant.url)}; token=${yesNo(Boolean(homeassistant.token))}; watchDomains=${homeassistant.watchDomains.length}; watchEntities=${homeassistant.watchEntities.length}; ignore=${homeassistant.ignoreEntities.length}; watchAll=${yesNo(homeassistant.watchAll)}; cooldown=${homeassistant.cooldownSeconds}s`);
+    lines.push(`  email: ${email.address ? `configured via ${email.source}` : 'not configured'}; enabled=${yesNo(email.enabled)}; smtp=${valueOrUnset(email.smtpHost)}:${email.smtpPort}; imap=${valueOrUnset(email.imapHost)}:${email.imapPort}; allowed=${email.allowedUsers.length}; home=${valueOrUnset(email.homeAddress)}`);
+    lines.push(`  line: ${line.channelAccessToken ? `configured via ${line.source}` : 'not configured'}; enabled=${yesNo(line.enabled)}; allowed=${line.allowedUsers.length + line.allowedGroups.length + line.allowedRooms.length}; home=${valueOrUnset(line.homeChannel)}; secret=${yesNo(Boolean(line.channelSecret))}`);
+    lines.push(`  sms: ${sms.accountSid && sms.authToken && sms.phoneNumber ? `configured via ${sms.source}` : 'not configured'}; enabled=${yesNo(sms.enabled)}; allowed=${sms.allowedUsers.length}; home=${valueOrUnset(sms.homeChannel)}; webhook=${valueOrUnset(sms.webhookUrl)}; signature=${sms.insecureNoSignature ? 'disabled' : 'required'}`);
+    lines.push(`  ntfy: ${ntfy.topic || ntfy.token ? `configured via ${ntfy.source}` : 'not configured'}; enabled=${yesNo(ntfy.enabled)}; server=${valueOrUnset(ntfy.serverUrl)}; topic=${valueOrUnset(ntfy.topic)}; publish=${valueOrUnset(ntfy.publishTopic)}; allowed=${ntfy.allowedUsers.length}; home=${valueOrUnset(ntfy.homeChannel)}; token=${yesNo(Boolean(ntfy.token))}; markdown=${yesNo(ntfy.markdown)}`);
+    lines.push(`  signal: ${signal.account ? `configured via ${signal.source}` : 'not configured'}; enabled=${yesNo(signal.enabled)}; url=${valueOrUnset(signal.httpUrl)}; account=${redactSignalId(signal.account)}; allowed=${signal.allowedUsers.length}; groups=${signal.groupAllowedUsers.length}; home=${redactSignalId(signal.homeChannel)}; requireMention=${yesNo(signal.requireMention)}`);
+    lines.push(`  whatsapp: ${whatsapp.phoneNumberId || whatsapp.accessToken ? `configured via ${whatsapp.source}` : 'not configured'}; enabled=${yesNo(whatsapp.enabled)}; phoneNumberId=${yesNo(Boolean(whatsapp.phoneNumberId))}; token=${yesNo(Boolean(whatsapp.accessToken))}; secret=${yesNo(Boolean(whatsapp.appSecret))}; verifyToken=${yesNo(Boolean(whatsapp.verifyToken))}; allowed=${whatsapp.allowedUsers.length}; home=${redactWhatsAppId(whatsapp.homeChannel)}; public=${valueOrUnset(whatsapp.publicUrl)}; api=${whatsapp.apiVersion}`);
+    lines.push(`  matrix: ${matrix.homeserver || matrix.accessToken || matrix.userId ? `configured via ${matrix.source}` : 'not configured'}; enabled=${yesNo(matrix.enabled)}; homeserver=${valueOrUnset(matrix.homeserver)}; token=${yesNo(Boolean(matrix.accessToken))}; user=${valueOrUnset(matrix.userId)}; password=${yesNo(Boolean(matrix.password))}; allowedUsers=${matrix.allowedUsers.length}; allowedRooms=${matrix.allowedRooms.length}; home=${valueOrUnset(matrix.homeRoom)}; requireMention=${yesNo(matrix.requireMention)}; autoJoin=${yesNo(matrix.autoJoin)}`);
+    lines.push(`  googlechat: ${googleChat.serviceAccountJson || googleChat.incomingWebhookUrl ? `configured via ${googleChat.source}` : 'not configured'}; enabled=${yesNo(googleChat.enabled)}; project=${valueOrUnset(googleChat.projectId)}; subscription=${yesNo(Boolean(googleChat.subscriptionName))}; serviceAccount=${yesNo(Boolean(googleChat.serviceAccountJson))}; webhook=${yesNo(Boolean(googleChat.incomingWebhookUrl))}; allowedUsers=${googleChat.allowedUsers.length}; allowedSpaces=${googleChat.allowedSpaces.length}; freeSpaces=${googleChat.freeResponseSpaces.length}; home=${valueOrUnset(googleChat.homeChannel)}; flow=${googleChat.maxMessages}/${googleChat.maxBytes}`);
+    lines.push(`  bluebubbles: ${bluebubbles.serverUrl || bluebubbles.password ? `configured via ${bluebubbles.source}` : 'not configured'}; enabled=${yesNo(bluebubbles.enabled)}; server=${valueOrUnset(bluebubbles.serverUrl)}; password=${yesNo(Boolean(bluebubbles.password))}; webhook=${bluebubbles.webhookHost}:${bluebubbles.webhookPort}${bluebubbles.webhookPath}; allowed=${bluebubbles.allowedUsers.length}; home=${valueOrUnset(bluebubbles.homeChannel)}; requireMention=${yesNo(bluebubbles.requireMention)}`);
+    lines.push(`  teams: ${teams.incomingWebhookUrl || teams.graphAccessToken || teams.clientId ? `configured via ${teams.source}` : 'not configured'}; enabled=${yesNo(teams.enabled)}; mode=${teams.deliveryMode}; webhook=${yesNo(Boolean(teams.incomingWebhookUrl))}; graphToken=${yesNo(Boolean(teams.graphAccessToken))}; chat=${valueOrUnset(teams.chatId)}; teamChannel=${teams.teamId && teams.channelId ? 'set' : '(not set)'}; home=${valueOrUnset(teams.homeChannel)}; botApp=${teams.clientId && teams.tenantId ? 'set' : '(not set)'}; allowed=${teams.allowedUsers.length}; port=${teams.port}`);
+    lines.push(`  webhooks: ${webhooks.enabled ? `enabled via ${webhooks.source}` : 'not enabled'}; routes=${Object.keys(webhooks.routes).length}; secret=${yesNo(Boolean(webhooks.secret))}; public=${valueOrUnset(webhooks.publicUrl)}`);
+    lines.push(`  send targets: ${targets.length}`);
+    lines.push('');
+    lines.push('mcp:');
+    const mcpEntries = Object.entries(mcp);
+    lines.push(`  servers: ${mcpEntries.length}`);
+    for (const [name, cfg] of mcpEntries.slice(0, 20)) {
+        lines.push(`  ${name}: ${cfg.url ? `http ${mcpEndpointLabel(cfg.url)}` : `stdio ${valueOrUnset(cfg.command)}`}`);
+    }
+    if (mcpEntries.length > 20)
+        lines.push(`  ... ${mcpEntries.length - 20} more`);
+    for (const log of mcpLogs)
+        lines.push(`  note: ${redactKey(log)}`);
+    lines.push('');
+    lines.push('inventory:');
+    lines.push(`  built-in tools: ${Object.keys(tools).length}`);
+    lines.push(`  skills: ${skills.length}`);
+    lines.push(`  sessions current project: ${currentSessions.length}`);
+    lines.push(`  sessions all projects: ${allSessions.length}`);
+    const latest = currentSessions[0] ?? allSessions[0];
+    if (latest)
+        lines.push(`  latest session: ${latest.id} updated ${latest.updated}`);
+    lines.push('');
+    lines.push(options.showKeys ? 'secrets: redacted prefixes/suffixes shown; raw keys are never printed' : 'secrets: hidden; use --show-keys to show redacted key fingerprints');
+    return `${lines.join('\n')}\n`;
+}

package/dist/tools/edit.js

@@ -4,6 +4,19 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { checkWritePath } from './permission.js';
 import { resolveAgentPath } from './util.js';
 import { renderEditDiff } from '../diff.js';
+function detectLineEnding(content) {
+    if (content.includes('\r\n'))
+        return '\r\n';
+    if (content.includes('\r'))
+        return '\r';
+    return '\n';
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n|\r/g, '\n');
+}
+function restoreLineEndings(content, lineEnding) {
+    return lineEnding === '\n' ? content : content.replace(/\n/g, lineEnding);
+}
 /** tier 1: exact substring match + นับจำนวนครั้ง */
 export function exactMatch(content, needle) {
     if (needle.length === 0)
@@ -25,6 +38,8 @@ export function exactMatch(content, needle) {
  * คืน offset ของบล็อกที่ match ในไฟล์จริง (รวม indentation เดิม)
  */
 export function whitespaceFlexMatch(content, needle) {
+    if (needle.length === 0)
+        return null;
     const needleLines = needle.split('\n').map((l) => l.trim());
     const contentLines = content.split('\n');
     // offset อักขระของจุดเริ่มแต่ละบรรทัด
@@ -85,39 +100,54 @@ export const editFileTool = tool({
         catch (err) {
             return `ERROR: อ่านไฟล์ "${path}" ไม่ได้ — ${err.message}`;
         }
-        // normalize CRLF→LF เพื่อให้ match/offset consistent แล้ว restore EOL เดิมตอนเขียน
-        // (กัน flex match กิน \r แล้วทำ line ending พังบนไฟล์ Windows)
-        const usesCRLF = raw.includes('\r\n');
-        const content = usesCRLF ? raw.replace(/\r\n/g, '\n') : raw;
-        const oldNorm = old_string.replace(/\r\n/g, '\n');
-        const newNorm = new_string.replace(/\r\n/g, '\n');
+        // normalize CRLF/CR→LF เพื่อให้ match/offset consistent แล้ว restore EOL เดิมตอนเขียน
+        // (กัน flex match กิน \r แล้วทำ line ending พังบนไฟล์ Windows/legacy Mac)
+        const lineEnding = detectLineEnding(raw);
+        const content = normalizeLineEndings(raw);
+        const oldNorm = normalizeLineEndings(old_string);
+        const newNorm = normalizeLineEndings(new_string);
         // replace_all: แทนที่ทุกที่ที่ตรง "เป๊ะ" (exact เท่านั้น — flex หลายช่วงกำกวม) → old_string สั้นได้ ไม่ต้อง unique
         if (replace_all) {
             const exact = exactMatch(content, oldNorm);
             if (!exact) {
                 return `ERROR: ไม่พบ old_string ในไฟล์ "${path}" — replace_all ใช้ match แบบตรงเป๊ะเท่านั้น (อ่านไฟล์ใหม่แล้วคัดข้อความที่ตรง)`;
             }
-            let updated = content.split(oldNorm).join(newNorm); // split/join = แทนที่ทุกที่ (string literal, ไม่ใช่ regex)
-            if (usesCRLF)
-                updated = updated.replace(/\n/g, '\r\n');
+            const parts = content.split(oldNorm); // split/join = แทนที่ทุกที่ (string literal, ไม่ใช่ regex)
+            const updated = restoreLineEndings(parts.join(newNorm), lineEnding);
             try {
                 await writeFile(full, updated, 'utf8');
             }
             catch (err) {
                 return `ERROR: เขียนไฟล์ "${path}" ไม่ได้ — ${err.message}`;
             }
-            return `OK: แก้ "${path}" (${exact.count} ที่)\n${renderEditDiff(oldNorm, newNorm)}`;
+            // นับจาก split (non-overlapping จริง) ไม่ใช่ exact.count ที่นับ overlapping → เลขตรงกับที่แทนจริง
+            return `OK: แก้ "${path}" (${parts.length - 1} ที่)\n${renderEditDiff(oldNorm, newNorm)}`;
         }
-        const m = findMatch(content, oldNorm);
+        const exact = exactMatch(content, oldNorm);
+        const m = exact ?? whitespaceFlexMatch(content, oldNorm);
+        const isFlex = !exact && !!m; // match มาจาก tier whitespace-flex (old_string indentation ไม่ตรงไฟล์)
         if (!m) {
             return `ERROR: ไม่พบ old_string ในไฟล์ "${path}" — อ่านไฟล์ใหม่ด้วย read_file แล้วคัดข้อความที่ตรงเป๊ะมาใช้`;
         }
         if (m.count > 1) {
-            return `ERROR: old_string พบ ${m.count} ที่ในไฟล์ "${path}" — ตั้ง replace_all:true เพื่อแก้ทุกที่ หรือใส่ context รอบๆ ให้พอ unique (ใช้เท่าที่จำเป็น ประหยัด token)`;
+            // flex tier: replace_all ใช้ไม่ได้ (exact-only) → แนะให้ใส่ context อย่างเดียว กัน dead-end loop
+            return isFlex
+                ? `ERROR: old_string ตรง ${m.count} ที่ในไฟล์ "${path}" (แบบ flex) — ใส่ context รอบๆ ให้ unique แล้วลองใหม่`
+                : `ERROR: old_string พบ ${m.count} ที่ในไฟล์ "${path}" — ตั้ง replace_all:true เพื่อแก้ทุกที่ หรือใส่ context รอบๆ ให้พอ unique (ใช้เท่าที่จำเป็น ประหยัด token)`;
+        }
+        // flex match กิน indentation เดิมของไฟล์ (เทียบแบบ trim) — ต้อง re-apply indent ให้ replacement
+        // ไม่งั้น code โดน de-indent (พัง Python/YAML + เยื้องเพี้ยนทุกภาษา) แบบเงียบๆ
+        let replacement = newNorm;
+        if (isFlex) {
+            const baseIndent = content.slice(m.start).match(/^[ \t]*/)?.[0] ?? '';
+            if (baseIndent) {
+                const newLines = newNorm.split('\n');
+                const nonBlank = newLines.filter((l) => l.trim() !== '');
+                const commonNew = nonBlank.length ? Math.min(...nonBlank.map((l) => (l.match(/^[ \t]*/)?.[0].length ?? 0))) : 0;
+                replacement = newLines.map((l) => (l.trim() === '' ? l : baseIndent + l.slice(commonNew))).join('\n');
+            }
         }
-        let updated = content.slice(0, m.start) + newNorm + content.slice(m.end);
-        if (usesCRLF)
-            updated = updated.replace(/\n/g, '\r\n');
+        const updated = restoreLineEndings(content.slice(0, m.start) + replacement + content.slice(m.end), lineEnding);
         try {
             await writeFile(full, updated, 'utf8');
         }