sanook-cli 0.5.1 → 0.5.5

package/dist/tools/polyglot.js

@@ -0,0 +1,126 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { findBinary } from '../lsp/servers.js';
+import { runProcess, formatProcessResult } from '../process-runner.js';
+import { agentCwd } from '../agentContext.js';
+import { checkReadPath } from './permission.js';
+import { maybeSandboxExec } from './sandbox.js';
+import { resolveAgentPath } from './util.js';
+const MAX_TIMEOUT_MS = 300_000;
+// Run a runtime (python/rustc/compiled exe) under the same OS sandbox as run_bash so
+// inline code cannot write outside the workspace (cwd + brain + tmp). No-shell: argv is
+// wrapped directly, so there is no shell interpolation of the code/args.
+async function runConfined(file, args, cwd, opts) {
+    const sb = await maybeSandboxExec(file, args, cwd);
+    return sb ? runProcess(sb.file, sb.args, { cwd, ...opts }) : runProcess(file, args, { cwd, ...opts });
+}
+const RuntimeScriptSchema = z
+    .object({
+    code: z.string().optional().describe('source code to run as a temporary script'),
+    path: z.string().optional().describe('existing script/source file to run instead of code'),
+    args: z.array(z.string()).optional().describe('argv passed to the script/program'),
+    stdin: z.string().optional().describe('stdin content for the process'),
+    timeoutMs: z.number().int().positive().max(MAX_TIMEOUT_MS).optional().describe('timeout in ms (default 120000, max 300000)'),
+})
+    .refine((v) => Boolean(v.code) !== Boolean(v.path), 'provide exactly one of code or path');
+async function existingSourcePath(path) {
+    const full = resolveAgentPath(path);
+    const guard = await checkReadPath(full);
+    if (!guard.ok)
+        return { ok: false, reason: guard.reason };
+    return { ok: true, path: full };
+}
+async function tempSource(suffix, content) {
+    const dir = await mkdtemp(join(tmpdir(), 'sanook-polyglot-'));
+    const path = join(dir, `main${suffix}`);
+    await writeFile(path, content, 'utf8');
+    return { dir, path };
+}
+async function findRuntime(command) {
+    const bin = await findBinary(command, agentCwd());
+    return bin ?? findBinary(command, process.cwd()) ?? null;
+}
+async function runPython(input) {
+    const cwd = agentCwd();
+    const python = (await findRuntime('python3')) ?? (await findRuntime('python'));
+    if (!python)
+        return 'PYTHON: ยังไม่พบ python3/python — ติดตั้ง Python 3.11+ แล้วลองใหม่';
+    let tempDir;
+    let scriptPath;
+    try {
+        if (input.path) {
+            const source = await existingSourcePath(input.path);
+            if (!source.ok)
+                return `BLOCKED: ${source.reason}`;
+            scriptPath = source.path;
+        }
+        else {
+            const temp = await tempSource('.py', input.code ?? '');
+            tempDir = temp.dir;
+            scriptPath = temp.path;
+        }
+        const result = await runConfined(python, [scriptPath, ...(input.args ?? [])], cwd, {
+            input: input.stdin,
+            timeoutMs: input.timeoutMs,
+        });
+        return formatProcessResult(result);
+    }
+    finally {
+        if (tempDir)
+            await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+async function runRust(input) {
+    const cwd = agentCwd();
+    const rustc = await findRuntime('rustc');
+    if (!rustc)
+        return 'RUST: ยังไม่พบ rustc — ติดตั้ง Rust ผ่าน rustup แล้วลองใหม่';
+    let tempDir;
+    try {
+        const temp = await mkdtemp(join(tmpdir(), 'sanook-rust-'));
+        tempDir = temp;
+        const sourcePath = input.path
+            ? await (async () => {
+                const source = await existingSourcePath(input.path);
+                if (!source.ok)
+                    return source;
+                return { ok: true, path: source.path };
+            })()
+            : { ok: true, path: join(temp, 'main.rs') };
+        if (!sourcePath.ok)
+            return `BLOCKED: ${sourcePath.reason}`;
+        if (!input.path)
+            await writeFile(sourcePath.path, input.code ?? '', 'utf8');
+        const exe = join(temp, process.platform === 'win32' ? 'sanook-rust-helper.exe' : 'sanook-rust-helper');
+        const compile = await runConfined(rustc, ['--edition=2021', sourcePath.path, '-o', exe], cwd, {
+            timeoutMs: input.timeoutMs,
+        });
+        if (!compile.ok)
+            return `RUST COMPILE ${formatProcessResult(compile)}`;
+        const run = await runConfined(exe, input.args ?? [], cwd, {
+            input: input.stdin,
+            timeoutMs: input.timeoutMs,
+        });
+        return formatProcessResult(run);
+    }
+    finally {
+        if (tempDir)
+            await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+export const pythonTool = tool({
+    description: 'รัน Python แบบ no-shell สำหรับงานที่ Python ถนัด: data/JSON/CSV transform, document/text parsing, ML/OCR helper, research script. ' +
+        'ใช้ code สำหรับ snippet สั้น หรือ path สำหรับไฟล์ .py ใน workspace. ต้องมี python3/python ใน PATH.',
+    inputSchema: RuntimeScriptSchema,
+    execute: runPython,
+});
+export const rustTool = tool({
+    description: 'compile+run Rust single-file/snippet แบบ no-shell สำหรับงานที่ Rust ถนัด: parser/checker ที่เร็ว, algorithm ที่ต้อง type-safe, native helper prototype. ' +
+        'ใช้ code สำหรับ main.rs ชั่วคราว หรือ path สำหรับไฟล์ .rs เดี่ยวใน workspace. ต้องมี rustc ใน PATH; งาน Cargo project ให้ใช้ run_bash ตามปกติ.',
+    inputSchema: RuntimeScriptSchema,
+    execute: runRust,
+});
+export const runtimeScriptSchema = RuntimeScriptSchema;

package/dist/tools/read.js

@@ -3,6 +3,17 @@ import { z } from 'zod';
 import { readFile } from 'node:fs/promises';
 import { clamp, resolveAgentPath } from './util.js';
 import { checkReadPath } from './permission.js';
+function splitReadableLines(content) {
+    if (!content)
+        return [];
+    const lines = content.split(/\r\n|\n|\r/);
+    if (/(\r\n|\n|\r)$/.test(content))
+        lines.pop();
+    return lines;
+}
+function normalizeReadableLineEndings(content) {
+    return content.replace(/\r\n|\r/g, '\n');
+}
 export const readFileTool = tool({
     description: 'อ่านไฟล์ใน workspace (UTF-8). อ่านก่อนแก้ไฟล์เสมอ. ' +
         'ไฟล์ใหญ่หรือต้องการแค่บางส่วน → ใส่ offset/limit อ่านเฉพาะช่วงบรรทัด (ประหยัด token มาก — คู่กับ grep ที่ให้เลขบรรทัด)',
@@ -20,12 +31,13 @@ export const readFileTool = tool({
             const content = await readFile(full, 'utf8');
             // ไม่ระบุช่วง → คืนทั้งไฟล์ (clamp) เหมือนเดิม
             if (offset == null && limit == null)
-                return clamp(content);
+                return clamp(normalizeReadableLineEndings(content));
             // ระบุช่วง → อ่านเฉพาะบรรทัด start..end (ส่งเฉพาะที่ต้องการเข้า context, ประหยัด token)
-            const lines = content.split('\n');
-            const start = Math.max(0, (offset ?? 1) - 1);
+            const lines = splitReadableLines(content);
+            const requestedOffset = offset ?? 1;
+            const start = Math.max(0, requestedOffset - 1);
             if (start >= lines.length)
-                return `(ไฟล์มี ${lines.length} บรรทัด — offset ${offset} เกินช่วง)`;
+                return `(ไฟล์มี ${lines.length} บรรทัด — offset ${requestedOffset} เกินช่วง)`;
             const end = limit == null ? lines.length : Math.min(lines.length, start + limit);
             const slice = lines.slice(start, end).join('\n');
             return clamp(`[บรรทัด ${start + 1}-${end} จาก ${lines.length}]\n${slice}`);

package/dist/tools/sandbox.js

@@ -27,15 +27,12 @@ function seatbeltProfile(writable) {
         '  (literal "/dev/null") (literal "/dev/stdout") (literal "/dev/stderr"))',
     ].join('\n');
 }
-function bwrapArgs(writable, cmd) {
+function bwrapArgs(writable, tail) {
     const binds = writable.flatMap((w) => ['--bind', w, w]);
-    return ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc', ...binds, '/bin/sh', '-c', cmd];
+    return ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc', ...binds, ...tail];
 }
-/**
- * คืน {file,args} สำหรับรัน cmd แบบ sandbox (ผ่าน execFile) — หรือ null ถ้าไม่มี sandbox/ปิดไว้
- * (caller รัน cmd ตรงๆ ตามเดิม). path ที่มี '"' → ข้าม sandbox (กัน profile พัง)
- */
-export async function maybeSandbox(cmd, cwd = process.cwd()) {
+// writable dirs (cwd + tmp + brain) — or null when sandbox is disabled / unusable
+async function sandboxWritable(cwd) {
     if (envFlag(BRAND_ENV.allowOutsideWorkspace) || envFlag('SANOOK_NO_SANDBOX'))
         return null;
     const writable = [canon(cwd), canon(tmpdir())];
@@ -44,18 +41,46 @@ export async function maybeSandbox(cmd, cwd = process.cwd()) {
         writable.push(canon(brain));
     if (writable.some((w) => w.includes('"')))
         return null;
+    return writable;
+}
+function sandboxBin() {
     const os = platform();
     if (os === 'darwin') {
         const bin = ['/usr/bin/sandbox-exec', '/usr/sbin/sandbox-exec'].find((p) => existsSync(p));
-        if (!bin)
-            return null;
-        return { file: bin, args: ['-p', seatbeltProfile(writable), '/bin/sh', '-c', cmd] };
+        return bin ? { os, bin } : null;
     }
     if (os === 'linux') {
         const bin = ['/usr/bin/bwrap', '/bin/bwrap'].find((p) => existsSync(p));
-        if (!bin)
-            return null;
-        return { file: bin, args: bwrapArgs(writable, cmd) };
+        return bin ? { os, bin } : null;
     }
     return null;
 }
+// wrap an execFile-style argv (already split — no shell) under the sandbox tail
+function wrap(writable, tail) {
+    const sb = sandboxBin();
+    if (!sb)
+        return null;
+    if (sb.os === 'darwin')
+        return { file: sb.bin, args: ['-p', seatbeltProfile(writable), ...tail] };
+    return { file: sb.bin, args: bwrapArgs(writable, tail) };
+}
+/**
+ * คืน {file,args} สำหรับรัน cmd แบบ sandbox (ผ่าน execFile) — หรือ null ถ้าไม่มี sandbox/ปิดไว้
+ * (caller รัน cmd ตรงๆ ตามเดิม). path ที่มี '"' → ข้าม sandbox (กัน profile พัง)
+ */
+export async function maybeSandbox(cmd, cwd = process.cwd()) {
+    const writable = await sandboxWritable(cwd);
+    if (!writable)
+        return null;
+    return wrap(writable, ['/bin/sh', '-c', cmd]);
+}
+/**
+ * เหมือน maybeSandbox แต่สำหรับ "no-shell" exec (run_python/run_rust): ห่อ argv โดยตรง
+ * ผ่าน execFile (ไม่มี shell interpolation) — confine write ให้อยู่ใน cwd+brain+tmp เท่ากับ run_bash.
+ */
+export async function maybeSandboxExec(file, argv, cwd = process.cwd()) {
+    const writable = await sandboxWritable(cwd);
+    if (!writable)
+        return null;
+    return wrap(writable, [file, ...argv]);
+}

package/dist/tools/schedule.js

@@ -2,6 +2,7 @@ import { tool } from 'ai';
 import { z } from 'zod';
 import { parseSchedule } from '../gateway/schedule.js';
 import { enqueueTask, listTasks, removeTask } from '../gateway/ledger.js';
+import { formatTarget, parseSendTarget } from '../gateway/targets.js';
 /** ตั้งงานตามเวลา — agent เรียกเองเมื่อ user พูดเรื่องเวลา/รอบ ("ทุกๆ X โมง/นาที") */
 export const scheduleTaskTool = tool({
     description: 'ตั้งงานให้ทำตามเวลา/เป็นรอบ — เรียกเมื่อ user ขอให้ทำอะไร "ทุกๆ X" หรือ "ตอน X โมง" หรือเวลาในอนาคต. ' +
@@ -13,21 +14,36 @@ export const scheduleTaskTool = tool({
         when: z.string().describe('เวลา: every 30m / 09:00 / ISO / "ทุก 2 ชั่วโมง"'),
         task: z.string().describe('สิ่งที่จะให้ทำตอนถึงเวลา — เขียนเป็น prompt เต็มในตัวเอง (รันเป็น fresh agent ไม่มี context นี้)'),
         model: z.string().optional().describe('model spec (ไม่ใส่ = default ของ gateway)'),
+        deliver: z
+            .string()
+            .optional()
+            .describe('ปลายทางส่งผลลัพธ์ เช่น telegram, telegram:123, discord:channel, slack:C01, mattermost:channel, homeassistant:notification_id, email:owner@example.com, line:U123, sms:+15551234567, ntfy:topic, signal:+15551234567, whatsapp:15551234567, matrix:!room:server, googlechat:spaces/AAA, bluebubbles:user@example.com, teams'),
     }),
-    execute: async ({ when, task, model }) => {
+    execute: async ({ when, task, model, deliver }) => {
         const sched = parseSchedule(when, Date.now());
         if (!sched) {
             return `ตั้งเวลาไม่ได้: "${when}" ไม่ใช่รูปแบบที่รองรับ — ลอง "every 30m", "09:00", ISO, หรือ "ทุก 2 ชั่วโมง"`;
         }
+        let normalizedDeliver;
+        if (deliver?.trim()) {
+            try {
+                normalizedDeliver = formatTarget(parseSendTarget(deliver));
+            }
+            catch (e) {
+                return `ตั้งปลายทางส่งผลลัพธ์ไม่ได้: ${e.message}`;
+            }
+        }
         const t = await enqueueTask({
             kind: sched.recurring ? 'cron' : 'once',
             spec: task,
             schedule: sched.recurring ? sched.normalized : undefined,
             model,
+            deliver: normalizedDeliver,
             runAt: sched.runAt,
         });
         const at = new Date(t.runAt).toLocaleString();
-        return (`ตั้งงาน ${t.id} แล้ว — รัน ${at}${sched.recurring ? ` แล้วทุก ${sched.normalized}` : ' (ครั้งเดียว)'}. ` +
+        return (`ตั้งงาน ${t.id} แล้ว — รัน ${at}${sched.recurring ? ` แล้วทุก ${sched.normalized}` : ' (ครั้งเดียว)'}` +
+            `${normalizedDeliver ? ` และส่งผลลัพธ์ไป ${normalizedDeliver}` : ''}. ` +
             `งานจะทำงานเมื่อ gateway เปิดอยู่ (sanook serve)`);
     },
 });
@@ -44,7 +60,7 @@ export const listScheduledTool = tool({
         if (!tasks.length)
             return filter ? `ไม่มีงานสถานะ ${filter}` : 'ยังไม่มีงานที่ตั้งเวลาไว้';
         return tasks
-            .map((t) => `${t.id} [${t.status}] ${t.schedule ?? 'once'} → ${t.spec.slice(0, 60)} (next ${new Date(t.runAt).toLocaleString()})`)
+            .map((t) => `${t.id} [${t.status}] ${t.schedule ?? 'once'}${t.deliver ? ` to:${t.deliver}` : ''} → ${t.spec.slice(0, 60)} (next ${new Date(t.runAt).toLocaleString()})`)
             .join('\n');
     },
 });

package/dist/tools/search.js

@@ -9,19 +9,203 @@ import { checkReadPath } from './permission.js';
 import { agentCwd } from '../agentContext.js';
 // pure-JS grep fallback — ใช้เมื่อ ripgrep (rg) ไม่ได้ติดตั้ง (เช่น Windows สะอาด) → grep ใช้ได้ทุกแพลตฟอร์ม
 const FALLBACK_IGNORE = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.cache', '.turbo', '.vercel', 'vendor']);
+const FALLBACK_IGNORE_FILES = new Set(['.ds_store', '.localized', 'desktop.ini', 'thumbs.db']);
 const FALLBACK_MAX_FILE = 2 * 1024 * 1024; // ข้ามไฟล์ใหญ่ (กันช้า/binary)
 const PER_FILE_CAP = 50; // เหมือน rg --max-count 50
+function isFallbackIgnoredFile(name) {
+    return FALLBACK_IGNORE_FILES.has(name.toLowerCase()) || name.startsWith('._');
+}
+function isFallbackIgnoredDir(name) {
+    return FALLBACK_IGNORE.has(name.toLowerCase()) || name.startsWith('.');
+}
+function otherAsciiCase(ch) {
+    const code = ch.charCodeAt(0);
+    if (code >= 65 && code <= 90)
+        return ch.toLowerCase();
+    if (code >= 97 && code <= 122)
+        return ch.toUpperCase();
+    return undefined;
+}
+function isAsciiLower(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= 97 && code <= 122;
+}
+function isAsciiUpper(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= 65 && code <= 90;
+}
+function findCharClassEnd(source, start) {
+    let escaping = false;
+    const literalRightBracket = source[start] === '^' ? start + 1 : start;
+    for (let i = start; i < source.length; i += 1) {
+        const ch = source[i];
+        if (escaping) {
+            escaping = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (ch === ']' && i !== literalRightBracket)
+            return i;
+    }
+    return -1;
+}
+function findScopedGroupEnd(source, start) {
+    let depth = 1;
+    let escaping = false;
+    for (let i = start; i < source.length; i += 1) {
+        const ch = source[i];
+        if (escaping) {
+            escaping = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (ch === '[') {
+            const end = findCharClassEnd(source, i + 1);
+            if (end < 0)
+                return -1;
+            i = end;
+            continue;
+        }
+        if (ch === '(')
+            depth += 1;
+        if (ch === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function foldAsciiRegexCharClass(source) {
+    let out = '';
+    const literalRightBracket = source[0] === '^' ? 1 : 0;
+    for (let i = 0; i < source.length; i += 1) {
+        const ch = source[i];
+        if (ch === ']' && i === literalRightBracket) {
+            out += '\\]';
+            continue;
+        }
+        if (ch === '\\' && i + 1 < source.length) {
+            out += `${ch}${source[i + 1]}`;
+            i += 1;
+            continue;
+        }
+        if (i + 2 < source.length &&
+            source[i + 1] === '-' &&
+            source[i + 2] !== ']' &&
+            ((isAsciiLower(ch) && isAsciiLower(source[i + 2])) || (isAsciiUpper(ch) && isAsciiUpper(source[i + 2]))) &&
+            ch.charCodeAt(0) <= source[i + 2].charCodeAt(0)) {
+            out += `${ch}-${source[i + 2]}${otherAsciiCase(ch)}-${otherAsciiCase(source[i + 2])}`;
+            i += 2;
+            continue;
+        }
+        const other = i === 0 && ch === '^' ? undefined : otherAsciiCase(ch);
+        out += other ? `${ch}${other}` : ch;
+    }
+    return out;
+}
+function foldAsciiRegexLetters(source) {
+    let out = '';
+    let escaping = false;
+    for (let i = 0; i < source.length; i += 1) {
+        const ch = source[i];
+        if (escaping) {
+            out += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaping = true;
+            continue;
+        }
+        if (ch === '[') {
+            const end = findCharClassEnd(source, i + 1);
+            if (end < 0) {
+                out += ch;
+                continue;
+            }
+            out += `[${foldAsciiRegexCharClass(source.slice(i + 1, end))}]`;
+            i = end;
+            continue;
+        }
+        const other = otherAsciiCase(ch);
+        out += other ? `[${ch}${other}]` : ch;
+    }
+    return out;
+}
+function expandScopedCaseInsensitiveGroups(pattern) {
+    let out = '';
+    let changed = false;
+    let escaping = false;
+    for (let i = 0; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (escaping) {
+            out += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaping = true;
+            continue;
+        }
+        if (ch === '[') {
+            const end = findCharClassEnd(pattern, i + 1);
+            if (end < 0)
+                return undefined;
+            out += pattern.slice(i, end + 1);
+            i = end;
+            continue;
+        }
+        if (!pattern.startsWith('(?i:', i)) {
+            out += ch;
+            continue;
+        }
+        const end = findScopedGroupEnd(pattern, i + 4);
+        if (end < 0)
+            return undefined;
+        out += `(?:${foldAsciiRegexLetters(pattern.slice(i + 4, end))})`;
+        i = end;
+        changed = true;
+    }
+    return changed ? out : undefined;
+}
+function compileFallbackRegex(pattern) {
+    const caseInsensitive = pattern.match(/^\(\?i\)([\s\S]*)$/);
+    if (caseInsensitive) {
+        const source = expandScopedCaseInsensitiveGroups(caseInsensitive[1]) ?? caseInsensitive[1];
+        return new RegExp(source, 'i');
+    }
+    const scopedCaseInsensitive = expandScopedCaseInsensitiveGroups(pattern);
+    if (scopedCaseInsensitive)
+        return new RegExp(scopedCaseInsensitive);
+    return new RegExp(pattern); // rg ใช้ Rust regex; JS regex ใกล้เคียงพอสำหรับ pattern ทั่วไป
+}
 export async function jsGrep(pattern, base, target) {
     let re;
     try {
-        re = new RegExp(pattern); // rg ใช้ Rust regex; JS regex ใกล้เคียงพอสำหรับ pattern ทั่วไป
+        re = compileFallbackRegex(pattern);
     }
     catch {
         return `ERROR: grep regex ไม่ถูกต้อง: "${pattern}"`;
     }
     const root = isAbsolute(target) ? target : join(base, target);
+    const rootGuard = await checkReadPath(root);
+    if (!rootGuard.ok)
+        return `BLOCKED: ${rootGuard.reason}`;
     const out = [];
+    let truncated = false;
     const scanFile = async (full) => {
+        const guard = await checkReadPath(full);
+        if (!guard.ok)
+            return;
         let s;
         try {
             s = await stat(full);
@@ -41,10 +225,14 @@ export async function jsGrep(pattern, base, target) {
         if (content.includes('\u0000'))
             return; // binary
         const rel = relative(base, full) || full;
-        const lines = content.split(/\r?\n/);
+        const lines = content.split(/\r\n|\n|\r/);
         let perFile = 0;
-        for (let i = 0; i < lines.length && out.length < MAX_RESULTS; i++) {
+        for (let i = 0; i < lines.length && !truncated; i++) {
             if (re.test(lines[i])) {
+                if (out.length >= MAX_RESULTS) {
+                    truncated = true;
+                    break;
+                }
                 out.push(`${rel}:${i + 1}:${lines[i].slice(0, 300)}`);
                 if (++perFile >= PER_FILE_CAP)
                     break;
@@ -52,7 +240,7 @@ export async function jsGrep(pattern, base, target) {
         }
     };
     const walk = async (dir) => {
-        if (out.length >= MAX_RESULTS)
+        if (truncated)
             return;
         let entries;
         try {
@@ -61,15 +249,19 @@ export async function jsGrep(pattern, base, target) {
         catch {
             return;
         }
-        for (const e of entries) {
-            if (out.length >= MAX_RESULTS)
+        for (const e of entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+            if (truncated)
                 return;
+            const full = join(dir, e.name);
+            const guard = await checkReadPath(full);
+            if (!guard.ok)
+                continue;
             if (e.isDirectory()) {
-                if (!FALLBACK_IGNORE.has(e.name) && !e.name.startsWith('.'))
-                    await walk(join(dir, e.name));
+                if (!isFallbackIgnoredDir(e.name))
+                    await walk(full);
             }
-            else if (e.isFile()) {
-                await scanFile(join(dir, e.name));
+            else if (e.isFile() && !isFallbackIgnoredFile(e.name)) {
+                await scanFile(full);
             }
         }
     };
@@ -86,10 +278,22 @@ export async function jsGrep(pattern, base, target) {
         await walk(root);
     if (!out.length)
         return '(no matches)';
+    if (truncated)
+        out.push(`... [>${MAX_RESULTS} matches, truncated]`);
     return `${clamp(out.join('\n'))}\n[JS fallback — ติดตั้ง ripgrep (rg) เพื่อความเร็ว + เคารพ .gitignore: brew/apt/choco/scoop install ripgrep]`;
 }
 const execFileAsync = promisify(execFile);
 const MAX_RESULTS = 200;
+export function formatRipgrepOutput(stdout) {
+    const text = stdout.replace(/(?:\r\n|\n|\r)$/, '');
+    if (!text)
+        return '(no matches)';
+    const allLines = text.split(/\r\n|\n|\r/);
+    const lines = allLines.slice(0, MAX_RESULTS);
+    if (allLines.length > MAX_RESULTS)
+        lines.push(`... [>${MAX_RESULTS} matches, truncated]`);
+    return clamp(lines.join('\n')) || '(no matches)';
+}
 function unsafeGlobPattern(pattern) {
     return isAbsolute(pattern) || pattern.split(/[\\/]+/).includes('..');
 }
@@ -109,14 +313,22 @@ export const globTool = tool({
             return `BLOCKED: ${guard.reason}`;
         try {
             const out = [];
+            let truncated = false;
             for await (const f of glob(pattern, { cwd: base })) {
-                out.push(f);
+                const match = String(f);
+                const itemGuard = await checkReadPath(join(base, match));
+                if (!itemGuard.ok)
+                    continue;
                 if (out.length >= MAX_RESULTS) {
-                    out.push(`... [>${MAX_RESULTS} matches, truncated]`);
+                    truncated = true;
                     break;
                 }
+                out.push(match);
             }
-            return out.length ? out.sort().join('\n') : '(no matches)';
+            out.sort();
+            if (truncated)
+                out.push(`... [>${MAX_RESULTS} matches, truncated]`);
+            return out.length ? out.join('\n') : '(no matches)';
         }
         catch (err) {
             return `ERROR: glob "${pattern}" ล้มเหลว — ${err.message}`;
@@ -138,8 +350,7 @@ export const grepTool = tool({
             // execFile (args array, ไม่ผ่าน shell) → $(...)/backtick/$VAR ใน pattern/path เป็น inert
             // กัน command injection (JSON.stringify ไม่ใช่ shell quoting — เคยรั่ว); -e กัน pattern ขึ้นต้นด้วย -
             const { stdout } = await execFileAsync('rg', ['--line-number', '--no-heading', '--max-count', '50', '-e', pattern, '--', path], { cwd: base, maxBuffer: 10 * 1024 * 1024 });
-            const lines = stdout.trim().split('\n').slice(0, MAX_RESULTS);
-            return clamp(lines.join('\n')) || '(no matches)';
+            return formatRipgrepOutput(stdout);
         }
         catch (err) {
             // ripgrep exit code 1 = ไม่เจอ match (ไม่ใช่ error จริง)