micro-models-agent 0.51.1 → 0.52.0

package/dist/tools/grep-tool.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "child_process";
+import { spawn } from "child_process";
 import { resolve } from "path";
 import { t } from "../i18n/index";
 import { logBashCommand } from "../modules/security/audit-log";
@@ -10,8 +10,50 @@ function truncateLines(output) {
     return (lines.slice(0, MAX_PREVIEW_LINES).join("\n") +
         `\n... (${lines.length - MAX_PREVIEW_LINES} more lines)`);
 }
+/**
+ * Run a search command asynchronously with kill-on-timeout.
+ * Exit code 1 (no matches) resolves to an empty string, like execFileSync semantics.
+ */
+export function runSearch(bin, args, cwd, timeoutMs = 30000) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn(bin, args, { cwd, windowsHide: true });
+        let out = "";
+        let err = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        child.stdout?.on("data", (d) => {
+            out += d;
+        });
+        child.stderr?.on("data", (d) => {
+            err += d;
+        });
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`search timed out after ${timeoutMs}ms`));
+            }
+            else if (code === 1) {
+                resolvePromise("");
+            }
+            else if (code === 0) {
+                resolvePromise(out);
+            }
+            else {
+                reject(new Error(err || `exit ${code}`));
+            }
+        });
+    });
+}
 export const grepTool = {
     name: "grep",
+    icon: "🔍",
     description: `Search file contents using a regular expression. Shows up to ${MAX_PREVIEW_LINES} matching lines by default. Uses ripgrep (rg) if available, otherwise falls back to grep -r.`,
     tags: ["file", "code", "research"],
     parameters: {
@@ -41,31 +83,30 @@ export const grepTool = {
         // Log the search (sanitized) for audit purposes
         logBashCommand(ctx.sessionId, `rg ${rgArgs.join(" ")}`, false, "grep-tool");
         try {
-            const output = execFileSync("rg", rgArgs, {
-                encoding: "utf-8",
-                maxBuffer: 1024 * 1024,
-                cwd: ctx.baseDir,
-            });
+            const output = await runSearch("rg", rgArgs, ctx.baseDir);
             return {
                 success: true,
                 output: truncateLines(output || t("file.no_matches")),
             };
         }
         catch (e) {
-            if (e.status === 1)
+            if (e.code === "ENOENT") {
+                // fall through to grep fallback
+            }
+            else if (/timed out/.test(e.message)) {
+                return { success: false, output: t("error.grep_failed", { message: e.message }) };
+            }
+            else if (e.status === 1) {
                 return { success: true, output: t("file.no_matches") };
+            }
             // Fall back to plain grep -r when rg is not available or fails.
-            // Using execFileSync with array args avoids shell injection.
+            // Using array args avoids shell injection.
             try {
                 const grepArgs = ["-rn", pattern, searchPath];
                 if (args.include) {
                     grepArgs.push("--include", String(args.include));
                 }
-                const output = execFileSync("grep", grepArgs, {
-                    encoding: "utf-8",
-                    maxBuffer: 1024 * 1024,
-                    cwd: ctx.baseDir,
-                });
+                const output = await runSearch("grep", grepArgs, ctx.baseDir);
                 return {
                     success: true,
                     output: truncateLines(output || t("file.no_matches")),

package/dist/tools/list-dir.js

@@ -6,6 +6,7 @@ import { safeResolvePath } from "./path-utils";
 import { MAX_PREVIEW_LINES } from "./preview";
 export const listDirTool = {
     name: "list_dir",
+    icon: "📂",
     description: `List files and directories in a given path. Shows up to ${MAX_PREVIEW_LINES} entries by default.`,
     tags: ["file"],
     boundedOutput: true,

package/dist/tools/load-skill.js

@@ -2,6 +2,7 @@ import { t } from "../i18n/index";
 export function createLoadSkillTool(skillsModule) {
     return {
         name: "load_skill",
+        icon: "🎯",
         tags: ["core"],
         description: "Load a skill by name. Skills provide specialized instructions and workflows. When loaded, the skill content is injected into the system prompt (not conversation history) so it persists through context compaction. Only use when the task clearly requires domain-specific knowledge.",
         parameters: {

package/dist/tools/mcp-call.js

@@ -24,6 +24,7 @@ function ensureInitialized(ctx) {
 }
 export const mcpCallTool = {
     name: "mcp_call",
+    icon: "🔗",
     description: "Call a tool on an MCP (Model Context Protocol) server. MCP servers provide external capabilities like databases, APIs, or specialized tools.",
     tags: ["code", "research"],
     parameters: {

package/dist/tools/move-file.js

@@ -8,6 +8,7 @@ import { generateMoveDiff } from "../ui/diff";
 import { safeResolvePath } from "./path-utils";
 export const moveFileTool = {
     name: "move_file",
+    icon: "📦",
     description: "Move or rename a file or directory.",
     tags: ["file"],
     parameters: {

package/dist/tools/path-utils.js

@@ -1,5 +1,33 @@
-import { resolve, normalize, dirname, basename, sep } from "path";
+import { resolve, normalize, dirname, basename, sep, relative, isAbsolute } from "path";
 import { existsSync } from "fs";
+/**
+ * True when targetPath equals dirPath or lies inside it.
+ *
+ * Cross-platform notes:
+ * - Uses path.relative() instead of raw startsWith, so a sibling directory
+ *   sharing the string prefix ("src" vs "src-other") can never pass.
+ * - On Windows the filesystem is case-insensitive: both sides are lowercased
+ *   before comparison so "E:\Proj" and "e:\proj" resolve to the same dir.
+ */
+export function isInsideDir(targetPath, dirPath) {
+    const norm = (p) => (process.platform === "win32" ? p.toLowerCase() : p);
+    const t = norm(resolve(targetPath));
+    const d = norm(resolve(dirPath));
+    if (t === d)
+        return true;
+    const rel = relative(d, t);
+    return rel.length > 0 && !isAbsolute(rel) && !rel.startsWith("..");
+}
+/**
+ * True when targetPath matches a scope entry: either the entry file itself or
+ * anything inside the entry directory. Separator- and case-safe (see
+ * isInsideDir).
+ */
+export function matchesScopeEntry(targetResolved, entryResolved) {
+    if (targetResolved === entryResolved)
+        return true;
+    return isInsideDir(targetResolved, entryResolved);
+}
 /**
  * Resolve a user-provided path against baseDir.
  *
@@ -12,7 +40,29 @@ import { existsSync } from "fs";
  * the full path so write_file still works.
  */
 export function safeResolvePath(baseDir, userPath) {
+    // Absolute path that actually exists — honor it as-is
+    const asIs = resolve(normalize(userPath));
+    if (userPath.startsWith("/") || userPath.startsWith("\\")) {
+        if (existsSync(asIs) || existsSync(dirname(asIs)))
+            return asIs;
+    }
     const norm = normalize(userPath);
+    // Absolute paths are used verbatim — do NOT strip a leading slash and
+    // re-resolve against baseDir (that would turn /var/folders/... into
+    // baseDir/var/folders/... on POSIX). The leading-slash heuristic below
+    // only applies as a fallback when the absolute path does not resolve.
+    if (isAbsolute(norm)) {
+        if (existsSync(norm) || existsSync(dirname(norm)))
+            return norm;
+        // Absolute but not on disk yet (e.g. a new file whose dirs don't exist).
+        // Model mistake recovery: a leading slash may mean "relative to baseDir".
+        const stripped = norm.replace(/^[/\\]/, "");
+        const relativeCandidate = resolve(baseDir, stripped);
+        if (existsSync(relativeCandidate) || existsSync(dirname(relativeCandidate))) {
+            return relativeCandidate;
+        }
+        return norm;
+    }
     const stripped = norm.replace(/^[/\\]/, "");
     const resolved = resolve(baseDir, stripped);
     // Fast path: if it exists (or parent does for new files), return it

package/dist/tools/pipeline-run.js

@@ -53,6 +53,7 @@ async function runStep(ctx, step, params, outputs) {
 }
 export const pipelineRunTool = {
     name: "pipeline_run",
+    icon: "▶️",
     description: "Run a named pipeline with YAML definition. Creates a DAG of sub-agents that execute in dependency order.",
     tags: ["shell", "code"],
     parameters: {

package/dist/tools/process-kill.js

@@ -2,6 +2,7 @@ import { processRegistry } from "../modules/processes";
 import { t } from "../i18n/index";
 export const processKillTool = {
     name: "process_kill",
+    icon: "⛔",
     description: "Stop a background process started via bash (dev server, watcher). Kills the whole process tree (children included). Use the id returned by bash or process_list.",
     tags: ["shell"],
     parameters: {
@@ -12,6 +13,16 @@ export const processKillTool = {
         required: ["id"],
     },
     handler: async (ctx, args) => {
+        if (args.id === undefined || String(args.id).trim() === "") {
+            // ses_mt4fn58c: `process_kill -p=5173` produced "Process not found:
+            // undefined" — no hint about the correct format. Answer with usage.
+            const known = processRegistry.list();
+            const ids = known.map((p) => p.id);
+            const listPart = ids.length
+                ? `\n${t("proc.list_header")}: ${ids.join(", ")}`
+                : `\n${t("proc.missing_id_list")}`;
+            return { success: false, output: `${t("proc.missing_id")}${listPart}` };
+        }
         const id = String(args.id);
         const entry = processRegistry.get(id);
         if (!entry) {

package/dist/tools/process-list.js

@@ -2,6 +2,7 @@ import { processRegistry } from "../modules/processes";
 import { t } from "../i18n/index";
 export const processListTool = {
     name: "process_list",
+    icon: "📊",
     description: "List background processes started via the bash tool (dev servers, watchers, long-running commands). Shows id, pid, command, status, and recent output. Use with process_log and process_kill to inspect or stop them.",
     tags: ["shell"],
     parameters: {

package/dist/tools/process-log.js

@@ -4,6 +4,7 @@ import { MAX_PREVIEW_LINES } from "./preview";
 const DEFAULT_TAIL = MAX_PREVIEW_LINES;
 export const processLogTool = {
     name: "process_log",
+    icon: "📜",
     description: `Show the buffered output of a background process started via bash. Shows the last ${DEFAULT_TAIL} lines by default. Use after starting a dev server to verify it came up without errors, and while it runs to check its state.`,
     tags: ["shell"],
     boundedOutput: true,
@@ -19,6 +20,14 @@ export const processLogTool = {
         required: ["id"],
     },
     handler: async (ctx, args) => {
+        if (args.id === undefined || String(args.id).trim() === "") {
+            const known = processRegistry.list();
+            const ids = known.map((p) => p.id);
+            const listPart = ids.length
+                ? `\n${t("proc.list_header")}: ${ids.join(", ")}`
+                : `\n${t("proc.missing_id_list")}`;
+            return { success: false, output: `${t("proc.missing_id")}${listPart}` };
+        }
         const id = String(args.id);
         const entry = processRegistry.get(id);
         if (!entry) {

package/dist/tools/question.js

@@ -51,6 +51,7 @@ function normalizeQuestions(args) {
 }
 export const questionTool = {
     name: "question",
+    icon: "❓",
     description: DESCRIPTION,
     tags: ["core"],
     interactive: true,

package/dist/tools/read-file.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, existsSync, statSync, openSync, readSync, closeSync } from "fs";
 import { extname } from "path";
 import { t } from "../i18n/index";
 import { isPathInScope } from "../modules/security/path-validator";
@@ -14,8 +14,75 @@ import { safeResolvePath } from "./path-utils";
  * covers typical component files in one call while still capping output.
  */
 const DEFAULT_LIMIT = 300;
+/**
+ * Files larger than this are read through a bounded streaming path instead of
+ * readFileSync (which loads the whole file into memory just to slice a few
+ * hundred lines).
+ */
+const LARGE_FILE_BYTES = 1024 * 1024;
+const STREAM_CHUNK = 256 * 1024;
+/**
+ * Bounded line-slice read for large files: streams the file in chunks,
+ * collects only the requested [offset, offset+limit) window, then counts the
+ * remaining newlines raw (no decode) to produce the total. Memory stays
+ * bounded regardless of file size.
+ */
+function readLineSlice(path, offset, limit) {
+    const fd = openSync(path, "r");
+    try {
+        const buf = Buffer.alloc(STREAM_CHUNK);
+        let pos = 0;
+        let carry = "";
+        let lineNumber = 1;
+        let total = 0;
+        const collected = [];
+        const endLine = offset + limit; // exclusive
+        while (true) {
+            const bytes = readSync(fd, buf, 0, STREAM_CHUNK, pos);
+            if (bytes === 0)
+                break;
+            pos += bytes;
+            const chunk = carry + buf.toString("utf-8", 0, bytes);
+            const parts = chunk.split("\n");
+            carry = parts.pop() ?? "";
+            for (const line of parts) {
+                total++;
+                if (lineNumber >= offset && lineNumber < endLine)
+                    collected.push(line);
+                lineNumber++;
+            }
+            if (lineNumber >= endLine && collected.length >= limit) {
+                // Window complete — count remaining newlines without decoding.
+                const rest = [];
+                while (true) {
+                    const n = readSync(fd, buf, 0, STREAM_CHUNK, pos);
+                    if (n === 0)
+                        break;
+                    pos += n;
+                    rest.push(Buffer.from(buf.subarray(0, n)));
+                }
+                const tail = Buffer.concat([...rest, Buffer.from(carry, "utf-8")]);
+                for (let i = 0; i < tail.length; i++)
+                    if (tail[i] === 0x0a)
+                        total++;
+                total++; // last line has no trailing newline
+                return { selected: collected.join("\n"), total };
+            }
+        }
+        if (carry.length > 0 || total === 0) {
+            total++;
+            if (lineNumber >= offset && lineNumber < endLine)
+                collected.push(carry);
+        }
+        return { selected: collected.join("\n"), total };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 export const readFileTool = {
     name: "read_file",
+    icon: "👀",
     description: `Read a file from the filesystem. Reads up to ${DEFAULT_LIMIT} lines at a time by default; use offset to page through large files.`,
     tags: ["file", "code"],
     boundedOutput: true,
@@ -60,13 +127,24 @@ export const readFileTool = {
                 : t("file.notfound", { path });
             return { success: false, output };
         }
-        const content = readFileSync(resolved, "utf-8");
-        const lines = content.split("\n");
-        const total = lines.length;
         const offset = args.offset || 1;
         const limit = args.limit || DEFAULT_LIMIT;
+        let lines;
+        let total;
+        let selected;
+        if (statSync(resolved).size > LARGE_FILE_BYTES) {
+            const slice = readLineSlice(resolved, offset, limit);
+            total = slice.total;
+            selected = slice.selected;
+        }
+        else {
+            const content = readFileSync(resolved, "utf-8");
+            lines = content.split("\n");
+            total = lines.length;
+            const end = Math.min(offset - 1 + limit, total);
+            selected = lines.slice(offset - 1, end).join("\n");
+        }
         const end = Math.min(offset - 1 + limit, total);
-        const selected = lines.slice(offset - 1, end).join("\n");
         const ext = extname(resolved) || "(no extension)";
         const header = t("file.read_header", {
             path,
@@ -81,7 +159,17 @@ export const readFileTool = {
                 next: String(end + 1),
             })
             : "";
-        const display = truncated ? `${header}${truncated}` : header;
+        // Compact user-facing display: the tool header already shows the path,
+        // so only a partial read needs extra info (the range within the file).
+        // A full read adds nothing — keeps the card to two lines.
+        const fullRead = offset === 1 && end >= total;
+        const display = fullRead
+            ? ""
+            : t("file.read_range", {
+                from: String(offset),
+                to: String(end),
+                total: String(total),
+            });
         return {
             success: true,
             output: `${header}\n${selected}${truncated}`,

package/dist/tools/recall.js

@@ -5,6 +5,7 @@ import { MemoryStore } from "../modules/memory/store";
 const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
 export const recallTool = {
     name: "recall",
+    icon: "💾",
     description: "Recall stored information from memory. Search across preferences, facts, conventions, decisions, errors.",
     tags: ["memory"],
     parameters: {

package/dist/tools/remember.js

@@ -5,6 +5,7 @@ import { MemoryStore } from "../modules/memory/store";
 const CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
 export const rememberTool = {
     name: "remember",
+    icon: "🧠",
     description: "Remember information across sessions. Use for user preferences, facts, conventions, decisions, or errors.",
     tags: ["memory"],
     parameters: {

package/dist/tools/scope-check.js

@@ -1,14 +1,16 @@
 import { resolve, normalize } from "path";
+import { isInsideDir, matchesScopeEntry } from "./path-utils";
 export function isPathInScope(baseDir, targetPath, scope) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
-    if (!targetResolved.startsWith(baseResolved)) {
+    // Separator- and case-safe containment (sibling prefixes cannot pass).
+    if (!isInsideDir(targetResolved, baseResolved)) {
         return { allowed: false, reason: "Path is outside the base working directory" };
     }
     if (!scope)
         return { allowed: true };
-    const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+    const isRead = scope.read_only_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
+    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
     if (isWrite)
         return { allowed: true };
     if (isRead)
@@ -18,12 +20,12 @@ export function isPathInScope(baseDir, targetPath, scope) {
 export function isPathWritable(baseDir, targetPath, scope) {
     const baseResolved = resolve(baseDir);
     const targetResolved = resolve(baseDir, normalize(targetPath));
-    if (!targetResolved.startsWith(baseResolved)) {
+    if (!isInsideDir(targetResolved, baseResolved)) {
         return { allowed: false, reason: "Path is outside the base working directory" };
     }
     if (!scope)
         return { allowed: true };
-    const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve(baseDir, f)));
+    const isWrite = scope.allowed_files.some((f) => matchesScopeEntry(targetResolved, resolve(baseDir, f)));
     if (isWrite)
         return { allowed: true };
     return { allowed: false, reason: "Path is not within the writable scope for this sub-agent" };

package/dist/tools/search-history.js

@@ -22,6 +22,7 @@ function searchFile(filePath, query, maxResults, results) {
 }
 export const searchHistoryTool = {
     name: "search_history",
+    icon: "🕵️",
     description: "Search through session history for past interactions across all sessions.",
     tags: ["research"],
     parameters: {

package/dist/tools/subagent.js

@@ -21,6 +21,7 @@ function buildSubagentSystemPrompt(context, stable) {
 }
 export const subagentTool = {
     name: "subagent",
+    icon: "🤖",
     description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
     tags: ["code"],
     parameters: {
@@ -150,7 +151,6 @@ export const subagentTool = {
             };
             const subAgent = new Agent(subDeps);
             const fullTask = context ? `${task}\n\nContext: ${context}` : task;
-            let scopeRestored = false;
             try {
                 const result = await subAgent.run(fullTask);
                 if (!result.success) {
@@ -184,9 +184,9 @@ export const subagentTool = {
                 };
             }
             finally {
-                if (!scopeRestored) {
-                    ctx.toolExecutor.setScope(parentScope || { allowed_files: [], read_only_files: [] });
-                }
+                // Restore the parent's exact scope: undefined means "no restrictions"
+                // and must not become an empty scope (which denies everything).
+                ctx.toolExecutor.setScope(parentScope);
             }
         }
         catch (e) {

package/dist/tools/web-browse.js

@@ -6,6 +6,7 @@ import { MAX_PREVIEW_LINES } from "./preview";
 const MAX_CHARS = 3000;
 export const webBrowseTool = {
     name: "web_browse",
+    icon: "🌐",
     description: `Fetch and read a web page. Returns the page content as plain text (max ${MAX_PREVIEW_LINES} lines / ${MAX_CHARS} chars). This is a plain HTTP request — it does NOT execute JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content. For such pages use the "browser" tool instead.`,
     tags: ["research"],
     parameters: {

package/dist/tools/web-fetch.js

@@ -16,6 +16,7 @@ function stripHtml(html) {
 }
 export const webFetchTool = {
     name: "web_fetch",
+    icon: "⬇️",
     description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages. This is a plain HTTP request without a browser engine — it does NOT run JavaScript, so JS-rendered single-page apps (weather sites, dashboards, modern SPAs) return empty or near-empty content; use the "browser" tool for those.',
     tags: ["research"],
     parameters: {
@@ -43,20 +44,40 @@ export const webFetchTool = {
         try {
             const response = await fetch(url, {
                 signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+                redirect: "manual",
             });
-            if (!response.ok) {
+            let finalResponse = response;
+            let finalUrl = url;
+            // Follow one redirect level manually, re-validating the target (SSRF).
+            if (response.status >= 300 && response.status < 400) {
+                const loc = response.headers.get("location");
+                if (!loc) {
+                    return { success: false, output: t("error.fetch_failed", { message: "Redirect without location" }) };
+                }
+                finalUrl = new URL(loc, url).toString();
+                const recheck = isUrlAllowed(finalUrl, securityConfig);
+                if (!recheck.allowed) {
+                    logSecurityBlock(ctx.sessionId, "network_request", recheck.reason || "redirect blocked", sanitizeUrl(finalUrl));
+                    return { success: false, output: `[SECURITY BLOCKED] redirect: ${recheck.reason}` };
+                }
+                finalResponse = await fetch(finalUrl, {
+                    signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+                    redirect: "follow",
+                });
+            }
+            if (!finalResponse.ok) {
                 return {
                     success: false,
                     output: t("error.http", {
-                        status: response.status,
-                        statusText: response.statusText,
+                        status: finalResponse.status,
+                        statusText: finalResponse.statusText,
                     }),
                 };
             }
-            const contentType = response.headers.get("content-type") || "";
-            const text = await response.text();
+            const contentType = finalResponse.headers.get("content-type") || "";
+            const text = await finalResponse.text();
             const cleaned = contentType.includes("html") ? stripHtml(text) : text;
-            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(finalUrl), true, `Status: ${finalResponse.status}`);
             const fullChars = cleaned.length;
             const fullLines = cleaned.split("\n").length;
             const maxChars = securityConfig?.maxResponseSize || MAX_CHARS;