sanook-cli 0.5.1 → 0.5.5

package/dist/support-dump.js

@@ -0,0 +1,206 @@
+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');
+    const polyglot = await import('./polyglot.js')
+        .then((m) => m.inspectPolyglotRuntimes({ cwd }))
+        .catch((e) => e);
+    const webSurface = await import('./web-surface.js')
+        .then((m) => m.inspectWebSurface({ cwd, loadConfig: async () => mcp }))
+        .catch((e) => e);
+    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(`  contextCompression: ${loadedConfig.contextCompression}`);
+        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('web search:');
+    if (webSurface instanceof Error) {
+        lines.push(`  load error: ${redactKey(webSurface.message)}`);
+    }
+    else {
+        lines.push(`  local search internet: ${yesNo(webSurface.localSearch.internet)}`);
+        lines.push(`  web candidates: ${webSurface.webCandidates.length}`);
+        for (const candidate of webSurface.webCandidates.slice(0, 10)) {
+            lines.push(`  ${candidate.name}: ${candidate.transport} ${candidate.reasons.join(' · ')}`);
+        }
+        if (webSurface.webCandidates.length > 10)
+            lines.push(`  ... ${webSurface.webCandidates.length - 10} more`);
+    }
+    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('runtimes:');
+    if (polyglot instanceof Error) {
+        lines.push(`  load error: ${redactKey(polyglot.message)}`);
+    }
+    else {
+        for (const runtime of polyglot.runtimes) {
+            lines.push(`  ${runtime.id}: ${runtime.status}${runtime.version ? ` (${runtime.version})` : ''}`);
+        }
+    }
+    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/tool-catalog.js

@@ -0,0 +1,59 @@
+export const TOOL_CATALOG = [
+    {
+        detail: 'Read, write, patch, list, glob, grep, and run bounded shell commands in the current workspace.',
+        group: 'Files',
+        name: 'workspace tools',
+        summary: 'read/write/edit/list/glob/grep/bash',
+    },
+    {
+        detail: 'Inspect diffs, status, logs, and create commits when the user explicitly wants a commit.',
+        group: 'Git',
+        name: 'git tools',
+        summary: 'status/diff/log/commit',
+    },
+    {
+        detail: 'Remember facts, recall local memory, discover skills, and create reusable skill workflows.',
+        group: 'Memory',
+        name: 'memory + skills',
+        summary: 'remember/recall/find_skills/create_skill',
+    },
+    {
+        detail: 'Fetch public pages via the ethical web ladder (robots.txt, SSRF guard, reader/Tavily/Wayback fallbacks).',
+        group: 'Research',
+        name: 'web fetch',
+        summary: 'web_fetch (ethical ladder)',
+    },
+    {
+        detail: 'Use local brain search for vault/session/skill retrieval, and configured MCP web/search/fetch servers for current external facts with citations.',
+        group: 'Research',
+        name: 'local + web grounding',
+        summary: 'sanook search + web MCP readiness',
+    },
+    {
+        detail: 'Schedule recurring or future tasks for the Sanook gateway service to run later.',
+        group: 'Gateway',
+        name: 'scheduled tasks',
+        summary: 'schedule/list/cancel',
+    },
+    {
+        detail: 'Fan work out to sub-agents, collect results, cancel background jobs, and inspect task status.',
+        group: 'Agents',
+        name: 'agent orchestration',
+        summary: 'task/task_parallel/task_spawn/task_collect',
+    },
+    {
+        detail: 'Ask the language server for type errors and lint-like diagnostics after code edits.',
+        group: 'Quality',
+        name: 'diagnostics',
+        summary: 'LSP diagnostics',
+    },
+    {
+        detail: 'Run optional Python or Rust snippets/files without shell strings for data analysis and native-helper prototypes.',
+        group: 'Polyglot',
+        name: 'python + rust runtime tools',
+        summary: 'run_python/run_rust',
+    },
+];
+export function formatToolCatalog(tools = TOOL_CATALOG) {
+    return tools.map((tool) => `${tool.group}: ${tool.summary}`).join('\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');
         }

package/dist/tools/git.js

@@ -1,7 +1,11 @@
 import { tool } from 'ai';
 import { z } from 'zod';
 import { runGit } from '../git.js';
+import { agentCwd } from '../agentContext.js';
 const gitErr = (e) => `git error: ${e.message}`;
+// รัน git ใน cwd ของ agent (worktree ของ sub-agent ถ้ามี) — ไม่งั้น git_commit/status/diff ไปโดน MAIN repo
+// แทนที่ของ sub-agent ที่ isolate ไว้ (worktree isolation พัง / commit ผิด tree)
+const gitCwd = () => agentCwd();
 export const gitStatusTool = tool({
     description: 'ดู git status — ไฟล์ที่เปลี่ยน/staged/untracked + branch',
     inputSchema: z.object({
@@ -10,7 +14,7 @@ export const gitStatusTool = tool({
     execute: async ({ path }) => {
         try {
             const args = ['status', '--short', '--branch', ...(path ? ['--', path] : [])];
-            return (await runGit(args)).trim() || '(clean)';
+            return (await runGit(args, gitCwd())).trim() || '(clean)';
         }
         catch (e) {
             return gitErr(e);
@@ -26,7 +30,7 @@ export const gitDiffTool = tool({
     execute: async ({ staged, path }) => {
         try {
             const args = ['diff', ...(staged ? ['--staged'] : []), ...(path ? ['--', path] : [])];
-            const out = await runGit(args);
+            const out = await runGit(args, gitCwd());
             return out.length > 20000 ? `${out.slice(0, 20000)}\n... [diff ยาว, ตัด]` : out || '(no changes)';
         }
         catch (e) {
@@ -41,7 +45,7 @@ export const gitLogTool = tool({
     }),
     execute: async ({ count = 10 }) => {
         try {
-            return (await runGit(['log', '--oneline', '-n', String(Math.min(Math.max(count, 1), 50))])) || '(no commits)';
+            return (await runGit(['log', '--oneline', '-n', String(Math.min(Math.max(count, 1), 50))], gitCwd())) || '(no commits)';
         }
         catch (e) {
             return gitErr(e);
@@ -57,9 +61,10 @@ export const gitCommitTool = tool({
     }),
     execute: async ({ message, addAll }) => {
         try {
+            const cwd = gitCwd();
             if (addAll)
-                await runGit(['add', '-A']);
-            return (await runGit(['commit', '-m', message])).trim();
+                await runGit(['add', '-A'], cwd);
+            return (await runGit(['commit', '-m', message], cwd)).trim();
         }
         catch (e) {
             return gitErr(e);

package/dist/tools/homeassistant.js

@@ -0,0 +1,106 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { readGatewayConfig, resolveHomeAssistantConfig } from '../gateway/config.js';
+import { homeAssistantApiUrl, homeAssistantAuthHeaders, readHomeAssistantJsonResponse } from '../gateway/homeassistant.js';
+const BLOCKED_DOMAINS = new Set(['shell_command', 'command_line', 'python_script', 'pyscript', 'hassio', 'rest_command']);
+const ENTITY_ID_RE = /^[a-z_][a-z0-9_]*\.[a-z0-9_]+$/;
+async function loadHaConfig() {
+    const config = resolveHomeAssistantConfig(await readGatewayConfig());
+    if (!config.token)
+        throw new Error('ยังไม่ได้ตั้ง Home Assistant — รัน: sanook gateway setup homeassistant หรือ set HASS_TOKEN');
+    return config;
+}
+async function haFetch(config, path, init = {}) {
+    const r = await fetch(homeAssistantApiUrl(config, path), {
+        ...init,
+        headers: {
+            ...homeAssistantAuthHeaders(config.token, init.method ? { 'content-type': 'application/json' } : {}),
+            ...(init.headers ?? {}),
+        },
+    });
+    return readHomeAssistantJsonResponse(r, 'Home Assistant API');
+}
+function validateEntityId(entityId) {
+    const clean = entityId.trim();
+    if (!ENTITY_ID_RE.test(clean))
+        throw new Error(`entity_id ไม่ปลอดภัย/ไม่ถูกต้อง: ${entityId}`);
+    return clean;
+}
+function stateSummary(state) {
+    const name = typeof state.attributes?.friendly_name === 'string' ? state.attributes.friendly_name : state.entity_id;
+    return `${state.entity_id}: ${state.state ?? '(unknown)'}${name && name !== state.entity_id ? ` (${name})` : ''}`;
+}
+export const haListEntitiesTool = tool({
+    description: 'Home Assistant: list entities/states. Requires HASS_TOKEN or gateway setup homeassistant.',
+    inputSchema: z.object({
+        domain: z.string().optional().describe('Filter by entity domain เช่น light, switch, climate, sensor'),
+        area: z.string().optional().describe('Simple friendly-name substring filter เช่น living room, kitchen'),
+        limit: z.number().int().positive().max(200).optional().describe('Maximum rows to return (default 80)'),
+    }),
+    execute: async ({ domain, area, limit }) => {
+        const config = await loadHaConfig();
+        const states = await haFetch(config, '/states');
+        const cleanDomain = domain?.trim();
+        const areaNeedle = area?.trim().toLowerCase();
+        const rows = states
+            .filter((s) => !cleanDomain || s.entity_id?.startsWith(`${cleanDomain}.`))
+            .filter((s) => !areaNeedle || String(s.attributes?.friendly_name ?? s.entity_id ?? '').toLowerCase().includes(areaNeedle))
+            .slice(0, limit ?? 80)
+            .map(stateSummary);
+        return rows.length ? rows.join('\n') : 'ไม่พบ Home Assistant entity ที่ตรงเงื่อนไข';
+    },
+});
+export const haGetStateTool = tool({
+    description: 'Home Assistant: get detailed state and attributes for one entity.',
+    inputSchema: z.object({
+        entity_id: z.string().describe('Entity id เช่น light.living_room'),
+    }),
+    execute: async ({ entity_id }) => {
+        const config = await loadHaConfig();
+        const entityId = validateEntityId(entity_id);
+        const state = await haFetch(config, `/states/${encodeURIComponent(entityId)}`);
+        return JSON.stringify(state, null, 2);
+    },
+});
+export const haListServicesTool = tool({
+    description: 'Home Assistant: list available service domains/actions, optionally filtered by domain.',
+    inputSchema: z.object({
+        domain: z.string().optional().describe('Filter by service domain เช่น light, climate, switch'),
+    }),
+    execute: async ({ domain }) => {
+        const config = await loadHaConfig();
+        const services = await haFetch(config, '/services');
+        const cleanDomain = domain?.trim();
+        const rows = services
+            .filter((entry) => !cleanDomain || entry.domain === cleanDomain)
+            .map((entry) => `${entry.domain}: ${Object.keys(entry.services ?? {}).sort().join(', ') || '(none)'}`);
+        return rows.length ? rows.join('\n') : 'ไม่พบ Home Assistant service ที่ตรงเงื่อนไข';
+    },
+});
+export const haCallServiceTool = tool({
+    description: 'Home Assistant: call a service to control a device. Blocks unsafe domains such as shell_command, command_line, python_script, pyscript, hassio, and rest_command.',
+    inputSchema: z.object({
+        domain: z.string().describe('Service domain เช่น light, switch, climate, cover, media_player, scene, script'),
+        service: z.string().describe('Service name เช่น turn_on, turn_off, toggle, set_temperature'),
+        entity_id: z.string().optional().describe('Optional target entity id เช่น light.living_room'),
+        data: z.record(z.unknown()).optional().describe('Additional JSON service data'),
+    }),
+    execute: async ({ domain, service, entity_id, data }) => {
+        const config = await loadHaConfig();
+        const cleanDomain = domain.trim();
+        const cleanService = service.trim();
+        if (!/^[a-z_][a-z0-9_]*$/.test(cleanDomain))
+            throw new Error(`domain ไม่ถูกต้อง: ${domain}`);
+        if (!/^[a-z_][a-z0-9_]*$/.test(cleanService))
+            throw new Error(`service ไม่ถูกต้อง: ${service}`);
+        if (BLOCKED_DOMAINS.has(cleanDomain))
+            return `⛔ blocked Home Assistant domain: ${cleanDomain}`;
+        const entityId = entity_id ? validateEntityId(entity_id) : undefined;
+        const body = { ...(data ?? {}), ...(entityId ? { entity_id: entityId } : {}) };
+        const result = await haFetch(config, `/services/${encodeURIComponent(cleanDomain)}/${encodeURIComponent(cleanService)}`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        return `OK Home Assistant ${cleanDomain}.${cleanService}${entityId ? ` ${entityId}` : ''} (${Array.isArray(result) ? result.length : 0} state update(s))`;
+    },
+});

package/dist/tools/index.js

@@ -11,6 +11,9 @@ import { scheduleTaskTool, listScheduledTool, cancelScheduledTool } from './sche
 import { taskTool, taskParallelTool, taskSpawnTool, taskCollectTool, taskCancelTool, taskStatusTool } from './task.js';
 import { diagnosticsTool } from './diagnostics.js';
 import { gitStatusTool, gitDiffTool, gitLogTool, gitCommitTool } from './git.js';
+import { haCallServiceTool, haGetStateTool, haListEntitiesTool, haListServicesTool } from './homeassistant.js';
+import { pythonTool, rustTool } from './polyglot.js';
+import { webFetchTool } from './web-fetch-tool.js';
 /** tool registry ที่ส่งให้ agent loop */
 export const tools = {
     read_file: readFileTool,
@@ -20,6 +23,8 @@ export const tools = {
     glob: globTool,
     grep: grepTool,
     run_bash: bashTool,
+    run_python: pythonTool,
+    run_rust: rustTool,
     remember: rememberTool,
     recall: recallTool,
     skill: skillTool,
@@ -39,5 +44,10 @@ export const tools = {
     git_diff: gitDiffTool,
     git_log: gitLogTool,
     git_commit: gitCommitTool,
+    ha_list_entities: haListEntitiesTool,
+    ha_get_state: haGetStateTool,
+    ha_list_services: haListServicesTool,
+    ha_call_service: haCallServiceTool,
+    web_fetch: webFetchTool,
 };
 export { readFileTool, writeFileTool, editFileTool, listDirTool, globTool, grepTool, bashTool };

package/dist/tools/list.js

@@ -1,6 +1,7 @@
 import { tool } from 'ai';
 import { z } from 'zod';
-import { readdir } from 'node:fs/promises';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
 import { clamp, resolveAgentPath } from './util.js';
 import { checkReadPath } from './permission.js';
 export const listDirTool = tool({
@@ -15,11 +16,23 @@ export const listDirTool = tool({
             return `BLOCKED: ${guard.reason}`;
         try {
             const entries = await readdir(full, { withFileTypes: true });
-            const out = entries
-                .filter((e) => !e.name.startsWith('.') || e.name === '.env.example' || e.name === '.gitignore')
-                .map((e) => (e.isDirectory() ? `${e.name}/` : e.name))
-                .sort()
-                .join('\n');
+            const visible = [];
+            for (const e of entries) {
+                if (e.name.startsWith('.') && e.name !== '.env.example' && e.name !== '.gitignore')
+                    continue;
+                const entryPath = join(full, e.name);
+                const entryGuard = await checkReadPath(entryPath);
+                if (!entryGuard.ok)
+                    continue;
+                let isDirectory = e.isDirectory();
+                if (!isDirectory && e.isSymbolicLink()) {
+                    isDirectory = await stat(entryPath)
+                        .then((s) => s.isDirectory())
+                        .catch(() => false);
+                }
+                visible.push(isDirectory ? `${e.name}/` : e.name);
+            }
+            const out = visible.sort().join('\n');
             return clamp(out) || '(empty)';
         }
         catch (err) {