@poping/yome 0.0.8 → 0.0.10

package/dist/mesh/rpc-handler.js

@@ -5,7 +5,7 @@
 // which routes by `parsed.domain` to a per-domain bridge. Here on Linux:
 //
 //   domain=bash → spawn /bin/sh and stream output
-//   domain=fs   → file system operations (mkdir / ls / cat / write)
+//   domain=fs   → file system operations (full POSIX paths, no sandbox)
 //
 // Stage A intentionally ships only 'bash' + 'fs' to prove the pipe.
 // Other domains (git / docker / k8s / systemd / pkg / log / svc / net)
@@ -13,16 +13,95 @@
 // "not implemented yet" so the Cloud agent can fall back gracefully.
 //
 // fs actions implemented here (mirrors yome-skill-fs/signature/fs.signature.json):
-//   ls / cat (alias read) / mkdir / write / append
-//   edit  — exact string replace, unique-match by default
-//   grep  — system rg (or fallback grep), line-numbered matches
-//   glob  — fast-glob multi-pattern + exclude
+//   ls / tree / stat / find / read (alias cat) / head / tail
+//   write / append / mkdir / edit / cp / mv / rm
+//   grep — system rg (or fallback grep), line-numbered matches
+//   glob — fast-glob multi-pattern + exclude
+//
+// IMPORTANT path conventions on Linux mesh (different from macOS sandbox!):
+//   - There is NO Desktop/Downloads/Documents sandbox; full POSIX paths allowed.
+//   - `~` and `~/foo` are expanded to the daemon user's $HOME.
+//   - A missing/empty path is treated as $HOME (NOT process.cwd(), because the
+//     daemon's cwd is wherever systemd/the background launcher started it,
+//     which is meaningless to the LLM).
+//   - A relative path is resolved against $HOME (matches `cd ~` then `ls foo`).
 import { spawn } from 'child_process';
 import { promises as fsp } from 'fs';
-import { join, resolve as resolvePath, isAbsolute } from 'path';
+import { homedir } from 'os';
+import { basename, join, resolve as resolvePath, isAbsolute } from 'path';
 import fg from 'fast-glob';
 const BASH_TIMEOUT_MS = 60_000;
 const MAX_STDOUT_CHARS = 64_000;
+// ──────────────────────────────────────────────────────────────────────
+// Path helpers — shared by every fs action so behaviour is identical
+// across read/write/grep/glob.
+// ──────────────────────────────────────────────────────────────────────
+/** Expand a leading `~` to $HOME. `~user` is intentionally NOT supported. */
+function expandTilde(p) {
+    if (!p)
+        return p;
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/**
+ * Resolve a user-supplied path with consistent semantics on Linux mesh:
+ *   - empty / undefined → $HOME (NOT cwd — the daemon's cwd is opaque)
+ *   - leading `~` → $HOME-relative
+ *   - absolute → kept as-is
+ *   - relative → resolved against $HOME
+ */
+function resolveUserPath(raw, fallbackToHome = true) {
+    const s = (raw ?? '').trim();
+    if (!s) {
+        if (fallbackToHome)
+            return homedir();
+        return '';
+    }
+    const expanded = expandTilde(s);
+    if (isAbsolute(expanded))
+        return expanded;
+    return resolvePath(homedir(), expanded);
+}
+/**
+ * Extract the path argument from a parsed fs command.
+ * Server-side commandParser stores the bare positional under `args.positional`
+ * (see Server/agent/commandParser.ts:558). Older code paths and the
+ * yome-skill-fs signature use `--path=`, so we accept both.
+ */
+function pathArg(args, fallbackToHome = true) {
+    const fromPath = typeof args.path === 'string' ? args.path : '';
+    const fromPos = typeof args.positional === 'string' ? args.positional : '';
+    return resolveUserPath(fromPath || fromPos, fallbackToHome);
+}
+function intArg(args, key, dflt) {
+    const v = args[key];
+    if (typeof v !== 'string')
+        return dflt;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : dflt;
+}
+function strArg(args, key, dflt = '') {
+    const v = args[key];
+    return typeof v === 'string' ? v : dflt;
+}
+function boolArg(args, key) {
+    return args[key] === 'true' || args[key] === true;
+}
+function humanSize(n) {
+    if (n < 1024)
+        return `${n}B`;
+    if (n < 1024 ** 2)
+        return `${(n / 1024).toFixed(1)}KB`;
+    if (n < 1024 ** 3)
+        return `${(n / 1024 ** 2).toFixed(1)}MB`;
+    return `${(n / 1024 ** 3).toFixed(2)}GB`;
+}
+// ──────────────────────────────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────────────────────────────
 export class RpcHandler {
     client;
     opts;
@@ -86,6 +165,7 @@ export class RpcHandler {
         const domain = req.parsed?.domain;
         switch (domain) {
             case 'bash':
+            case 'sh':
                 return this.handleBash(req);
             case 'fs':
                 return this.handleFs(req);
@@ -100,30 +180,40 @@ export class RpcHandler {
             case 'svc':
                 return {
                     stdout: '',
-                    stderr: `[mesh] domain '${domain}' not implemented on linux cli yet — falling back to bash via Cloud agent`,
+                    stderr: `[mesh] domain '${domain}' not implemented on linux cli yet — use \`bash exec --cmd="..."\` instead`,
                     exitCode: 127,
                 };
             default:
                 return {
                     stdout: '',
-                    stderr: `[mesh] unknown domain: ${domain}`,
+                    stderr: `[mesh] unknown domain: ${domain} (linux cli implements: sh, fs). For shell access use \`sh <command>\`.`,
                     exitCode: 127,
                 };
         }
     }
     /**
-     * `bash exec --cmd="..."` or any other action where args.cmd is the
-     * shell line. We deliberately only honour --cmd (not raw `command`)
-     * to match the existing domain-RPC parser shape that other domains
-     * use; if cmd is absent we fall back to req.command.
+     * Handles both `bash` (legacy: --cmd=…) and `sh` (new top-level shell
+     * domain: everything after the leading `sh ` token is the shell
+     * line). Resolution order:
+     *   1. parsed.args.cmd — legacy `bash exec --cmd="..."`
+     *   2. req.command with leading `sh ` / `bash ` stripped — `sh find / | xargs grep ...`
+     *   3. raw req.command as last resort.
      */
     handleBash(req) {
-        const shellLine = req.parsed?.args?.cmd ?? req.command ?? '';
+        let shellLine = req.parsed?.args?.cmd ?? '';
+        if (!shellLine) {
+            const raw = (req.command ?? '').trim();
+            const stripped = raw.replace(/^(?:sh|bash)\s+/i, '');
+            shellLine = stripped || raw;
+        }
         if (!shellLine.trim()) {
             return Promise.resolve({ stdout: '', stderr: '[bash] empty command', exitCode: 2 });
         }
         return new Promise((resolveP) => {
-            const proc = spawn('sh', ['-c', shellLine], { stdio: ['ignore', 'pipe', 'pipe'] });
+            const proc = spawn('sh', ['-c', shellLine], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: homedir(),
+            });
             let stdout = '';
             let stderr = '';
             let killed = false;
@@ -152,70 +242,186 @@ export class RpcHandler {
         });
     }
     /**
-     * `fs <action> --path=... --content=...` minimal port of the same
-     * actions the macOS FileBridge exposes (Server/agent/commands/fsCommands.ts
-     * lists the canonical action set). Stage A: cat / ls / mkdir / write.
+     * `fs <action> [<path>] [--key=value ...]`
+     * Path resolution: see `resolveUserPath` — empty → $HOME, ~ expanded,
+     * relative → resolved against $HOME, full POSIX paths allowed.
      */
     async handleFs(req) {
         const action = req.parsed?.action ?? '';
-        const args = req.parsed?.args ?? {};
-        const path = typeof args.path === 'string' ? args.path : '';
-        const safeJoinedPath = path && isAbsolute(path) ? path : resolvePath(process.cwd(), path);
+        const args = (req.parsed?.args ?? {});
         try {
             switch (action) {
+                case 'ls': {
+                    const target = pathArg(args);
+                    const entries = await fsp.readdir(target, { withFileTypes: true });
+                    // Output TSV: `name\ttype\tsize` so the Server-side fsDomain.ls
+                    // compress() (which filters on `\t`) actually sees rows. Header
+                    // line lets compress() detect it. Sort: dirs first, then by name.
+                    entries.sort((a, b) => {
+                        if (a.isDirectory() !== b.isDirectory())
+                            return a.isDirectory() ? -1 : 1;
+                        return a.name.localeCompare(b.name);
+                    });
+                    const rows = ['name\ttype\tsize'];
+                    for (const e of entries) {
+                        const full = join(target, e.name);
+                        let sizeStr = '-';
+                        if (e.isFile()) {
+                            try {
+                                const st = await fsp.stat(full);
+                                sizeStr = humanSize(st.size);
+                            }
+                            catch { /* keep '-' */ }
+                        }
+                        const kind = e.isDirectory() ? 'dir' : e.isSymbolicLink() ? 'link' : 'file';
+                        rows.push(`${e.name}\t${kind}\t${sizeStr}`);
+                    }
+                    return { stdout: `${target}:\n${rows.join('\n')}`, stderr: '', exitCode: 0 };
+                }
+                case 'tree': {
+                    const target = pathArg(args);
+                    const depth = Math.max(1, intArg(args, 'depth', 2));
+                    const out = [target];
+                    await walkTree(target, depth, '', out);
+                    return { stdout: out.join('\n'), stderr: '', exitCode: 0 };
+                }
+                case 'stat': {
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs stat] path is required', exitCode: 2 };
+                    const st = await fsp.stat(target);
+                    const info = {
+                        name: basename(target) || target,
+                        path: target,
+                        type: st.isDirectory() ? 'dir' : st.isSymbolicLink() ? 'link' : 'file',
+                        size: st.size,
+                        sizeFormatted: humanSize(st.size),
+                        modifiedAt: st.mtime.toISOString(),
+                        createdAt: st.birthtime.toISOString(),
+                        mode: '0' + (st.mode & 0o777).toString(8),
+                    };
+                    return { stdout: JSON.stringify(info), stderr: '', exitCode: 0 };
+                }
+                case 'find': {
+                    // fs find <path> --name=GLOB [--type=file|dir] [--limit=20]
+                    const target = pathArg(args);
+                    const namePat = strArg(args, 'name');
+                    if (!namePat)
+                        return { stdout: '', stderr: '[fs find] --name is required', exitCode: 2 };
+                    const typeFilter = strArg(args, 'type');
+                    const limit = Math.max(1, intArg(args, 'limit', 20));
+                    const matches = await fg([`**/${namePat}`], {
+                        cwd: target,
+                        dot: true,
+                        onlyFiles: typeFilter === 'file' ? true : typeFilter === 'dir' ? false : false,
+                        onlyDirectories: typeFilter === 'dir',
+                        absolute: true,
+                        suppressErrors: true,
+                        ignore: ['**/node_modules/**', '**/.git/**'],
+                    });
+                    if (matches.length === 0) {
+                        return { stdout: 'path\tname\nNo matches found\t-', stderr: '', exitCode: 0 };
+                    }
+                    const shown = matches.slice(0, limit);
+                    // TSV so Server-side compress() picks rows correctly.
+                    const rows = ['path\tname', ...shown.map((p) => `${p}\t${basename(p)}`)];
+                    const tail = matches.length > limit
+                        ? `\n[showing ${limit} of ${matches.length}; raise --limit or narrow --name]`
+                        : '';
+                    return { stdout: rows.join('\n') + tail, stderr: '', exitCode: 0 };
+                }
                 case 'cat':
                 case 'read': {
-                    const content = await fsp.readFile(safeJoinedPath, 'utf-8');
-                    return { stdout: content, stderr: '', exitCode: 0 };
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs read] path is required', exitCode: 2 };
+                    const st = await fsp.stat(target);
+                    if (st.isDirectory()) {
+                        return {
+                            stdout: '',
+                            stderr: `[fs read] ${target} is a directory — use \`fs ls ${shellQuote(target)}\` instead`,
+                            exitCode: 1,
+                        };
+                    }
+                    const content = await fsp.readFile(target, 'utf-8');
+                    const lines = intArg(args, 'lines', 50);
+                    const offset = Math.max(0, intArg(args, 'offset', 0));
+                    if (offset === 0 && lines >= content.split('\n').length) {
+                        return { stdout: content, stderr: '', exitCode: 0 };
+                    }
+                    const all = content.split('\n');
+                    const slice = all.slice(offset, offset + lines).join('\n');
+                    return { stdout: slice, stderr: '', exitCode: 0 };
                 }
-                case 'ls': {
-                    const entries = await fsp.readdir(safeJoinedPath, { withFileTypes: true });
-                    const lines = entries.map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`);
-                    return { stdout: lines.join('\n'), stderr: '', exitCode: 0 };
+                case 'head': {
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs head] path is required', exitCode: 2 };
+                    const lines = Math.max(1, intArg(args, 'lines', 10));
+                    const content = await fsp.readFile(target, 'utf-8');
+                    return { stdout: content.split('\n').slice(0, lines).join('\n'), stderr: '', exitCode: 0 };
+                }
+                case 'tail': {
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs tail] path is required', exitCode: 2 };
+                    const lines = Math.max(1, intArg(args, 'lines', 10));
+                    const content = await fsp.readFile(target, 'utf-8');
+                    return { stdout: content.split('\n').slice(-lines).join('\n'), stderr: '', exitCode: 0 };
                 }
                 case 'mkdir': {
-                    await fsp.mkdir(safeJoinedPath, { recursive: true });
-                    return { stdout: `created ${safeJoinedPath}`, stderr: '', exitCode: 0 };
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs mkdir] path is required', exitCode: 2 };
+                    await fsp.mkdir(target, { recursive: true });
+                    return { stdout: `created ${target}`, stderr: '', exitCode: 0 };
                 }
                 case 'write': {
-                    const content = typeof args.content === 'string' ? args.content : '';
-                    const force = args.force === 'true';
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs write] path is required', exitCode: 2 };
+                    const content = strArg(args, 'content');
+                    const force = boolArg(args, 'force');
                     if (!force) {
                         try {
-                            await fsp.access(safeJoinedPath);
-                            return { stdout: '', stderr: `[fs] ${safeJoinedPath} already exists; pass --force=true to overwrite`, exitCode: 1 };
+                            await fsp.access(target);
+                            return { stdout: '', stderr: `[fs write] ${target} already exists; pass --force=true to overwrite`, exitCode: 1 };
                         }
                         catch { /* file doesn't exist — fine */ }
                     }
-                    await fsp.mkdir(join(safeJoinedPath, '..'), { recursive: true });
-                    await fsp.writeFile(safeJoinedPath, content, 'utf-8');
-                    return { stdout: `wrote ${content.length} bytes to ${safeJoinedPath}`, stderr: '', exitCode: 0 };
+                    await fsp.mkdir(join(target, '..'), { recursive: true });
+                    await fsp.writeFile(target, content, 'utf-8');
+                    return { stdout: `wrote ${content.length} bytes to ${target}`, stderr: '', exitCode: 0 };
                 }
                 case 'append': {
-                    const content = typeof args.content === 'string' ? args.content : '';
-                    await fsp.mkdir(join(safeJoinedPath, '..'), { recursive: true });
-                    await fsp.appendFile(safeJoinedPath, content, 'utf-8');
-                    return { stdout: `appended ${content.length} bytes to ${safeJoinedPath}`, stderr: '', exitCode: 0 };
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs append] path is required', exitCode: 2 };
+                    const content = strArg(args, 'content');
+                    await fsp.mkdir(join(target, '..'), { recursive: true });
+                    await fsp.appendFile(target, content, 'utf-8');
+                    return { stdout: `appended ${content.length} bytes to ${target}`, stderr: '', exitCode: 0 };
                 }
                 case 'edit': {
-                    const oldStr = typeof args.old === 'string' ? args.old : '';
-                    const newStr = typeof args.new === 'string' ? args.new : '';
-                    const all = args.all === 'true';
-                    if (!oldStr) {
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs edit] path is required', exitCode: 2 };
+                    const oldStr = strArg(args, 'old');
+                    const newStr = strArg(args, 'new');
+                    const all = boolArg(args, 'all');
+                    if (!oldStr)
                         return { stdout: '', stderr: '[fs edit] --old is required', exitCode: 2 };
-                    }
                     let original;
                     try {
-                        original = await fsp.readFile(safeJoinedPath, 'utf-8');
+                        original = await fsp.readFile(target, 'utf-8');
                     }
                     catch (err) {
-                        return { stdout: '', stderr: `[fs edit] cannot read ${safeJoinedPath}: ${err.message}`, exitCode: 1 };
+                        return { stdout: '', stderr: `[fs edit] cannot read ${target}: ${err.message}`, exitCode: 1 };
                     }
                     if (!all) {
                         const first = original.indexOf(oldStr);
-                        if (first === -1) {
+                        if (first === -1)
                             return { stdout: '', stderr: '[fs edit] --old not found in file', exitCode: 1 };
-                        }
                         const second = original.indexOf(oldStr, first + oldStr.length);
                         if (second !== -1) {
                             return {
@@ -225,62 +431,91 @@ export class RpcHandler {
                             };
                         }
                         const next = original.slice(0, first) + newStr + original.slice(first + oldStr.length);
-                        await fsp.writeFile(safeJoinedPath, next, 'utf-8');
-                        return { stdout: `replaced 1 occurrence in ${safeJoinedPath}`, stderr: '', exitCode: 0 };
+                        await fsp.writeFile(target, next, 'utf-8');
+                        return { stdout: `replaced 1 occurrence in ${target}`, stderr: '', exitCode: 0 };
                     }
-                    // --all=true → split/join replaces every literal occurrence (no regex).
                     const parts = original.split(oldStr);
                     const count = parts.length - 1;
-                    if (count === 0) {
+                    if (count === 0)
                         return { stdout: '', stderr: '[fs edit] --old not found in file', exitCode: 1 };
+                    await fsp.writeFile(target, parts.join(newStr), 'utf-8');
+                    return { stdout: `replaced ${count} occurrence(s) in ${target}`, stderr: '', exitCode: 0 };
+                }
+                case 'cp':
+                case 'mv': {
+                    const src = pathArg(args, false);
+                    const dst = resolveUserPath(strArg(args, 'to'), false);
+                    if (!src || !dst) {
+                        return { stdout: '', stderr: `[fs ${action}] both <path> and --to=<dest> are required`, exitCode: 2 };
+                    }
+                    const force = boolArg(args, 'force');
+                    try {
+                        await fsp.access(dst);
+                        if (!force) {
+                            return { stdout: '', stderr: `[fs ${action}] ${dst} already exists; pass --force=true to overwrite`, exitCode: 1 };
+                        }
+                    }
+                    catch { /* target doesn't exist — fine */ }
+                    await fsp.mkdir(join(dst, '..'), { recursive: true });
+                    if (action === 'mv') {
+                        await fsp.rename(src, dst);
+                    }
+                    else {
+                        // Node 16.7+ has fsp.cp; use recursive for dirs.
+                        await fsp.cp(src, dst, { recursive: true, force: true });
                     }
-                    const next = parts.join(newStr);
-                    await fsp.writeFile(safeJoinedPath, next, 'utf-8');
-                    return { stdout: `replaced ${count} occurrence(s) in ${safeJoinedPath}`, stderr: '', exitCode: 0 };
+                    return { stdout: `${action} ${src} → ${dst}`, stderr: '', exitCode: 0 };
+                }
+                case 'rm': {
+                    const target = pathArg(args, false);
+                    if (!target)
+                        return { stdout: '', stderr: '[fs rm] path is required', exitCode: 2 };
+                    const recursive = boolArg(args, 'recursive');
+                    await fsp.rm(target, { recursive, force: false });
+                    return { stdout: `removed ${target}`, stderr: '', exitCode: 0 };
                 }
                 case 'grep':
                     return this.handleFsGrep(req);
                 case 'glob':
                     return this.handleFsGlob(req);
                 default:
-                    return { stdout: '', stderr: `[fs] unknown action: ${action}`, exitCode: 127 };
+                    return {
+                        stdout: '',
+                        stderr: `[fs] unknown action: ${action} (linux supports: ls, tree, stat, find, read/cat, head, tail, write, append, mkdir, edit, cp, mv, rm, grep, glob)`,
+                        exitCode: 127,
+                    };
             }
         }
         catch (err) {
-            return { stdout: '', stderr: `[fs] ${err.message}`, exitCode: 1 };
+            const msg = err.code === 'EISDIR'
+                ? `${err.message} — use \`fs ls\` for directories`
+                : err.message;
+            return { stdout: '', stderr: `[fs] ${msg}`, exitCode: 1 };
         }
     }
     /**
      * `fs grep <pattern> [path] [--type=ts] [--glob=*.md] [--context=2] [-i]
-     *  [--fixed=true] [--limit=200]` — shells out to ripgrep when present,
-     * otherwise falls back to /usr/bin/grep so the action stays useful on
-     * minimal Linux images. Returns line-anchored matches identical to
-     * the local Grep tool's output shape so the Cloud LLM can reason
-     * about the result without mode-switching.
+     *  [--fixed=true] [--limit=200]` — ripgrep when present, fallback to grep.
+     * Both pattern and path support positional/--flag entry, with ~ expansion
+     * via resolveUserPath.
      */
     handleFsGrep(req) {
-        const args = req.parsed?.args ?? {};
-        // commandParser stores the bare positional under args.positional;
-        // accept --pattern=... too for symmetry.
-        const pattern = typeof args.pattern === 'string' && args.pattern
-            ? args.pattern
-            : (typeof args.positional === 'string' ? args.positional : '');
+        const args = (req.parsed?.args ?? {});
+        // pattern: bare positional, OR --pattern=. The path (if any) is parsed
+        // server-side as positional2.
+        const pattern = strArg(args, 'pattern') || strArg(args, 'positional');
         if (!pattern) {
             return Promise.resolve({ stdout: '', stderr: '[fs grep] pattern is required', exitCode: 2 });
         }
-        const pathArg = typeof args.path === 'string' && args.path ? args.path : process.cwd();
-        const searchPath = isAbsolute(pathArg) ? pathArg : resolvePath(process.cwd(), pathArg);
-        const caseInsensitive = args.i === 'true';
-        const fixed = args.fixed === 'true';
-        const globFilter = typeof args.glob === 'string' ? args.glob : '';
-        const typeFilter = typeof args.type === 'string' ? args.type : '';
-        const contextRaw = typeof args.context === 'string' ? Number.parseInt(args.context, 10) : NaN;
-        const ctx = Number.isFinite(contextRaw) && contextRaw >= 0 ? contextRaw : 0;
-        const limitRaw = typeof args.limit === 'string' ? Number.parseInt(args.limit, 10) : NaN;
-        const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : 200;
+        const pathRaw = strArg(args, 'path') || strArg(args, 'positional2');
+        const searchPath = resolveUserPath(pathRaw, true);
+        const caseInsensitive = boolArg(args, 'i');
+        const fixed = boolArg(args, 'fixed');
+        const globFilter = strArg(args, 'glob');
+        const typeFilter = strArg(args, 'type');
+        const ctx = Math.max(0, intArg(args, 'context', 0));
+        const limit = Math.max(1, intArg(args, 'limit', 200));
         return new Promise((resolveP) => {
-            // Probe rg synchronously via spawn callback chain so we don't fork
-            // twice when rg isn't present.
             const probe = spawn('which', ['rg'], { stdio: ['ignore', 'pipe', 'ignore'] });
             let probeOut = '';
             probe.stdout.on('data', (b) => { probeOut += b.toString('utf-8'); });
@@ -310,105 +545,60 @@ export class RpcHandler {
                         argv.push('-C', String(ctx));
                     if (globFilter)
                         argv.push(`--include=${globFilter}`);
+                    argv.push('--exclude-dir=.git', '--exclude-dir=node_modules');
                 }
                 argv.push(pattern, searchPath);
-                const proc = spawn(argv[0], argv.slice(1), { stdio: ['ignore', 'pipe', 'pipe'] });
-                let stdout = '';
-                let stderr = '';
-                proc.stdout.on('data', (b) => { stdout += b.toString('utf-8'); });
-                proc.stderr.on('data', (b) => { stderr += b.toString('utf-8'); });
-                proc.on('close', (exitCode) => {
-                    // grep / rg both exit 1 when there are no matches — treat as success.
-                    const noMatches = (exitCode === 1) && !stdout.trim();
-                    if (noMatches) {
-                        resolveP({ stdout: 'No matches found', stderr: '', exitCode: 0 });
-                        return;
-                    }
-                    if (exitCode !== 0 && exitCode !== 1) {
-                        resolveP({ stdout: '', stderr: stderr || `[fs grep] exit ${exitCode}`, exitCode: exitCode ?? 1 });
-                        return;
-                    }
-                    const lines = stdout.split('\n');
-                    if (lines.length > limit) {
-                        const head = lines.slice(0, limit).join('\n');
-                        resolveP({
-                            stdout: `${head}\n\n[showing ${limit} of ${lines.length} lines; raise --limit or narrow the search]`,
-                            stderr: '',
-                            exitCode: 0,
-                        });
-                        return;
-                    }
-                    resolveP({ stdout: stdout.trim() || 'No matches found', stderr: '', exitCode: 0 });
-                });
-                proc.on('error', (err) => {
-                    resolveP({ stdout: '', stderr: `[fs grep] spawn ${argv[0]}: ${err.message}`, exitCode: 1 });
-                });
+                runGrepLike(argv, limit, resolveP);
             });
             probe.on('error', () => {
-                // `which` not available; just try grep.
                 const argv = ['grep', '-rn'];
                 if (caseInsensitive)
                     argv.push('-i');
                 if (fixed)
                     argv.push('-F');
+                if (ctx > 0)
+                    argv.push('-C', String(ctx));
+                if (globFilter)
+                    argv.push(`--include=${globFilter}`);
+                argv.push('--exclude-dir=.git', '--exclude-dir=node_modules');
                 argv.push(pattern, searchPath);
-                const proc = spawn(argv[0], argv.slice(1), { stdio: ['ignore', 'pipe', 'pipe'] });
-                let stdout = '';
-                let stderr = '';
-                proc.stdout.on('data', (b) => { stdout += b.toString('utf-8'); });
-                proc.stderr.on('data', (b) => { stderr += b.toString('utf-8'); });
-                proc.on('close', (exitCode) => {
-                    const noMatches = (exitCode === 1) && !stdout.trim();
-                    if (noMatches) {
-                        resolveP({ stdout: 'No matches found', stderr: '', exitCode: 0 });
-                        return;
-                    }
-                    resolveP({ stdout: stdout.trim() || 'No matches found', stderr, exitCode: exitCode ?? 0 });
-                });
-                proc.on('error', (err) => {
-                    resolveP({ stdout: '', stderr: `[fs grep] grep unavailable: ${err.message}`, exitCode: 1 });
-                });
+                runGrepLike(argv, limit, resolveP);
             });
         });
     }
     /**
      * `fs glob <pattern...> [--folder=DIR] [--exclude=PAT...]`
-     * Multi-pattern OR via fast-glob. Returns sorted relative file paths
-     * under --folder (default cwd), capped at 100 entries.
+     * Multi-pattern OR via fast-glob.
      */
     async handleFsGlob(req) {
-        const args = req.parsed?.args ?? {};
-        // Wire-level args are Record<string,string>. Accept patterns as either
-        // a comma-separated string under --patterns, a JSON array string under
-        // --patterns, or the bare positional (`fs glob "**/*.ts"`).
+        const args = (req.parsed?.args ?? {});
         const rawPatterns = (() => {
             const p = args.patterns;
             if (typeof p === 'string' && p.trim()) {
                 const s = p.trim();
                 if (s.startsWith('[')) {
                     try {
-                        const parsedArr = JSON.parse(s);
-                        if (Array.isArray(parsedArr))
-                            return parsedArr.map(String);
+                        const arr = JSON.parse(s);
+                        if (Array.isArray(arr))
+                            return arr.map(String);
                     }
-                    catch { /* fall through to comma split */ }
+                    catch { /* fall through */ }
                 }
                 return s.split(',').map((q) => q.trim()).filter(Boolean);
             }
-            if (typeof args.positional === 'string' && args.positional.trim()) {
-                const list = [args.positional.trim()];
-                if (typeof args.positional2 === 'string' && args.positional2.trim()) {
-                    list.push(args.positional2.trim());
-                }
-                return list;
-            }
-            return [];
+            const pos1 = strArg(args, 'positional');
+            const pos2 = strArg(args, 'positional2');
+            const list = [];
+            if (pos1)
+                list.push(pos1);
+            if (pos2)
+                list.push(pos2);
+            return list;
         })();
         if (rawPatterns.length === 0) {
             return { stdout: '', stderr: '[fs glob] at least one pattern is required', exitCode: 2 };
         }
-        const folderArg = typeof args.folder === 'string' && args.folder ? args.folder : process.cwd();
-        const folder = isAbsolute(folderArg) ? folderArg : resolvePath(process.cwd(), folderArg);
+        const folder = resolveUserPath(strArg(args, 'folder'), true);
         const ignore = (() => {
             const base = ['**/node_modules/**', '**/.git/**'];
             const ex = args.exclude;
@@ -416,9 +606,9 @@ export class RpcHandler {
                 const s = ex.trim();
                 if (s.startsWith('[')) {
                     try {
-                        const parsedArr = JSON.parse(s);
-                        if (Array.isArray(parsedArr))
-                            return [...base, ...parsedArr.map(String)];
+                        const arr = JSON.parse(s);
+                        if (Array.isArray(arr))
+                            return [...base, ...arr.map(String)];
                     }
                     catch { /* fall through */ }
                 }
@@ -433,12 +623,12 @@ export class RpcHandler {
                 dot: true,
                 onlyFiles: true,
                 absolute: false,
+                suppressErrors: true,
             });
             files.sort();
             const limit = 100;
-            if (files.length === 0) {
+            if (files.length === 0)
                 return { stdout: 'No files found', stderr: '', exitCode: 0 };
-            }
             const truncated = files.length > limit;
             const shown = truncated ? files.slice(0, limit) : files;
             const header = `Found ${files.length} file(s) under ${folder}`;
@@ -463,4 +653,70 @@ export class RpcHandler {
             console.log(`[rpc] ${line}`);
     }
 }
+// ──────────────────────────────────────────────────────────────────────
+// Local helpers (module-private)
+// ──────────────────────────────────────────────────────────────────────
+function shellQuote(s) {
+    return /[\s'"`$\\]/.test(s) ? `'${s.replace(/'/g, "'\\''")}'` : s;
+}
+async function walkTree(dir, depth, prefix, out) {
+    if (depth <= 0)
+        return;
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        out.push(`${prefix}[error: ${err.message}]`);
+        return;
+    }
+    entries.sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory())
+            return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        const last = i === entries.length - 1;
+        const branch = last ? '└── ' : '├── ';
+        const next = last ? '    ' : '│   ';
+        out.push(`${prefix}${branch}${e.name}${e.isDirectory() ? '/' : ''}`);
+        if (e.isDirectory()) {
+            await walkTree(join(dir, e.name), depth - 1, prefix + next, out);
+        }
+    }
+}
+function runGrepLike(argv, limit, resolveP) {
+    const proc = spawn(argv[0], argv.slice(1), { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (b) => { stdout += b.toString('utf-8'); });
+    proc.stderr.on('data', (b) => { stderr += b.toString('utf-8'); });
+    proc.on('close', (exitCode) => {
+        // grep / rg exit 1 when there are no matches — that's success for us.
+        const noMatches = exitCode === 1 && !stdout.trim();
+        if (noMatches) {
+            resolveP({ stdout: 'No matches found', stderr: '', exitCode: 0 });
+            return;
+        }
+        if (exitCode !== 0 && exitCode !== 1) {
+            resolveP({ stdout: '', stderr: stderr || `[fs grep] exit ${exitCode}`, exitCode: exitCode ?? 1 });
+            return;
+        }
+        const lines = stdout.split('\n');
+        if (lines.length > limit) {
+            const head = lines.slice(0, limit).join('\n');
+            resolveP({
+                stdout: `${head}\n\n[showing ${limit} of ${lines.length} lines; raise --limit or narrow the search]`,
+                stderr: '',
+                exitCode: 0,
+            });
+            return;
+        }
+        resolveP({ stdout: stdout.trim() || 'No matches found', stderr: '', exitCode: 0 });
+    });
+    proc.on('error', (err) => {
+        resolveP({ stdout: '', stderr: `[fs grep] spawn ${argv[0]}: ${err.message}`, exitCode: 1 });
+    });
+}
 //# sourceMappingURL=rpc-handler.js.map