micro-models-agent 0.47.0 → 0.48.1

package/dist/tools/web-fetch.js

@@ -0,0 +1,98 @@
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
+import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { DEFAULT_SECURITY_CONFIG } from "../config/security";
+import { MAX_PREVIEW_LINES } from "./preview";
+const MAX_CHARS = 5000;
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&[^;]+;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export const webFetchTool = {
+    name: "web_fetch",
+    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: {
+        type: "object",
+        properties: {
+            url: { type: "string", description: "URL to fetch" },
+        },
+        required: ["url"],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url);
+        // Get session-specific security config
+        const config = ctx.config || {};
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(config, ctx.sessionContext).network
+            : config.security?.network || DEFAULT_SECURITY_CONFIG.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000),
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    output: t("error.http", {
+                        status: response.status,
+                        statusText: response.statusText,
+                    }),
+                };
+            }
+            const contentType = response.headers.get("content-type") || "";
+            const text = await response.text();
+            const cleaned = contentType.includes("html") ? stripHtml(text) : text;
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            const fullChars = cleaned.length;
+            const fullLines = cleaned.split("\n").length;
+            const maxChars = securityConfig?.maxResponseSize || MAX_CHARS;
+            let content;
+            if (cleaned.length > maxChars) {
+                content = cleaned.slice(0, maxChars) + t("file.truncated");
+            }
+            else {
+                content = cleaned;
+            }
+            const contentLines = content.split("\n");
+            if (contentLines.length > MAX_PREVIEW_LINES) {
+                content =
+                    contentLines.slice(0, MAX_PREVIEW_LINES).join("\n") +
+                        `\n... (${contentLines.length - MAX_PREVIEW_LINES} more lines)`;
+            }
+            const truncated = cleaned.length > maxChars || fullLines > MAX_PREVIEW_LINES
+                ? t("file.truncated").trim()
+                : "";
+            return {
+                success: true,
+                output: content || t("file.empty_page"),
+                display: t("tool.web_fetch_result", {
+                    url: sanitizeUrl(url),
+                    chars: String(fullChars),
+                    lines: String(fullLines),
+                    truncated,
+                }),
+            };
+        }
+        catch (e) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
+            return {
+                success: false,
+                output: t("error.fetch_failed", { message: e.message }),
+            };
+        }
+    },
+};

package/dist/tools/web-search.js

@@ -0,0 +1,78 @@
+import { t } from "../i18n/index";
+import { isUrlAllowed, sanitizeUrl } from "../modules/security/network-validator";
+import { logNetworkRequest, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+export const webSearchTool = {
+    name: "web_search",
+    description: "Search the web for information. Returns search results with titles and snippets. Use this for search queries instead of opening search engines (Google/Yandex/Bing) in the browser — they block headless browsers.",
+    tags: ["research"],
+    parameters: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query" },
+            numResults: {
+                type: "number",
+                description: "Number of results (default 5)",
+            },
+        },
+        required: ["query"],
+    },
+    handler: async (ctx, args) => {
+        const query = String(args.query || "");
+        const numResults = Number(args.numResults) || 5;
+        // Build search URL
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Search URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000),
+            });
+            const html = await response.text();
+            const results = [];
+            const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+            let match;
+            let count = 0;
+            while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
+                const href = match[1].trim();
+                const title = match[2].replace(/<[^>]+>/g, "").trim();
+                const snippet = match[3].replace(/<[^>]+>/g, "").trim();
+                results.push(`${count + 1}. ${title}\n   URL: ${href}\n   ${snippet}`);
+                count++;
+            }
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
+            if (results.length === 0) {
+                return { success: true, output: t("tool.no_results", { query }) };
+            }
+            return {
+                success: true,
+                output: t("tool.search_results", {
+                    query,
+                    results: results.join("\n"),
+                }),
+                display: t("tool.web_search_result", {
+                    query,
+                    count: String(results.length),
+                }),
+            };
+        }
+        catch (err) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+            return {
+                success: false,
+                output: t("error.search_failed", { message: err.message }),
+            };
+        }
+    },
+};

package/dist/tools/write-file.js

@@ -0,0 +1,81 @@
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { dirname } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { scanContent } from "../modules/security/content-scanner";
+import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { generateDiff, generateNewFileDiff } from "../ui/diff";
+import { safeResolvePath } from "./path-utils";
+export const writeFileTool = {
+    name: "write_file",
+    description: "Create or overwrite a file with given content. Creates intermediate directories if needed.",
+    tags: ["file", "code"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path" },
+            content: { type: "string", description: "File content" },
+        },
+        required: ["path", "content"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const resolved = safeResolvePath(ctx.baseDir, path);
+        // Check path permissions using the resolved path
+        const scopeCheck = isPathWritable(ctx.baseDir, resolved, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check content for dangerous patterns — only when security is enabled.
+        // contentScan has its own `enabled` flag, but it must NOT fire while the
+        // global security switch is off (false positives on ordinary CLI code).
+        const content = String(args.content);
+        if (securityConfig?.enabled && securityConfig?.contentScan?.enabled) {
+            const scanResult = scanContent(content, path, securityConfig.contentScan);
+            if (!scanResult.allowed) {
+                logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
+                return {
+                    success: false,
+                    output: `[SECURITY BLOCKED] ${scanResult.reason}`,
+                };
+            }
+        }
+        const dir = dirname(resolved);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const fileExists = existsSync(resolved);
+        let oldContent = "";
+        if (fileExists) {
+            oldContent = readFileSync(resolved, "utf-8");
+        }
+        writeFileSync(resolved, content, "utf-8");
+        const diff = fileExists ? generateDiff(oldContent, content) : generateNewFileDiff(content);
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log successful file write
+        logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? "updated" : "created"}`);
+        return { success: true, output: t("file.written", { path }), diff };
+    },
+};

package/dist/ui/box.js

@@ -0,0 +1,77 @@
+import stringWidth from "string-width";
+import { pc } from "./colors";
+import { getTerminalWidth } from "./table";
+/** Wrap a string to `width` columns, keeping ANSI codes intact. */
+export function wrapText(text, width) {
+    if (width < 1)
+        return text ? [text] : [];
+    const lines = [];
+    let current = "";
+    const push = (token) => {
+        const candidate = current ? `${current} ${token}` : token;
+        if (stringWidth(candidate) <= width) {
+            current = candidate;
+            return;
+        }
+        if (current) {
+            lines.push(current);
+            current = "";
+        }
+        if (stringWidth(token) <= width) {
+            current = token;
+            return;
+        }
+        let acc = "";
+        for (const ch of token) {
+            if (stringWidth(acc + ch) <= width) {
+                acc += ch;
+            }
+            else {
+                lines.push(acc);
+                acc = ch;
+            }
+        }
+        current = acc;
+    };
+    for (const token of text.split(/\s+/)) {
+        if (token)
+            push(token);
+    }
+    if (current)
+        lines.push(current);
+    return lines.length ? lines : [""];
+}
+function padTo(text, width) {
+    const gap = Math.max(0, width - stringWidth(text));
+    return text + " ".repeat(gap);
+}
+/** Render a box with an optional title embedded in the top border. */
+export function box(lines, opts = {}) {
+    const pad = opts.padding ?? 1;
+    const width = Math.max(20, Math.min(opts.width ?? getTerminalWidth(), 120));
+    const inner = Math.max(1, width - 2 - pad * 2);
+    const wrapped = [];
+    for (const line of lines) {
+        for (const part of wrapText(line, inner))
+            wrapped.push(part);
+    }
+    const out = [];
+    const title = opts.title ?? "";
+    if (title) {
+        const head = `─ ${title} `;
+        out.push(pc.dim(`┌${head}${"─".repeat(Math.max(0, width - 2 - stringWidth(head)))}┐`));
+    }
+    else {
+        out.push(pc.dim(`┌${"─".repeat(width - 2)}┐`));
+    }
+    for (const line of wrapped) {
+        out.push(pc.dim("│") + " ".repeat(pad) + padTo(line, inner) + " ".repeat(pad) + pc.dim("│"));
+    }
+    out.push(pc.dim(`└${"─".repeat(width - 2)}┘`));
+    return out;
+}
+/** A horizontal rule that respects the terminal width (max 60 cols). */
+export function divider(width) {
+    const w = Math.min(width ?? getTerminalWidth(), 60);
+    return pc.dim("─".repeat(w));
+}

package/dist/ui/colors.js

@@ -0,0 +1,4 @@
+import { createColors } from "picocolors";
+const isTty = () => process.stdout.isTTY === true;
+const enabled = isTty() && !process.env.CI && !process.env.NO_COLOR;
+export const pc = createColors(enabled);

package/dist/ui/diff.js

@@ -0,0 +1,178 @@
+import { pc } from "./colors";
+const CONTEXT_LINES = 3;
+const MAX_DIFF_LINES = 100;
+function computeLCS(oldLines, newLines) {
+    const m = oldLines.length;
+    const n = newLines.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (oldLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            }
+            else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+    return dp;
+}
+function buildDiff(oldLines, newLines) {
+    const dp = computeLCS(oldLines, newLines);
+    const result = [];
+    let i = oldLines.length;
+    let j = newLines.length;
+    const raw = [];
+    while (i > 0 && j > 0) {
+        if (oldLines[i - 1] === newLines[j - 1]) {
+            raw.unshift({
+                type: "context",
+                oldNum: i,
+                newNum: j,
+                content: oldLines[i - 1],
+            });
+            i--;
+            j--;
+        }
+        else if (dp[i - 1][j] > dp[i][j - 1]) {
+            raw.unshift({
+                type: "remove",
+                oldNum: i,
+                newNum: 0,
+                content: oldLines[i - 1],
+            });
+            i--;
+        }
+        else {
+            raw.unshift({
+                type: "add",
+                oldNum: 0,
+                newNum: j,
+                content: newLines[j - 1],
+            });
+            j--;
+        }
+    }
+    while (i > 0) {
+        raw.unshift({
+            type: "remove",
+            oldNum: i,
+            newNum: 0,
+            content: oldLines[i - 1],
+        });
+        i--;
+    }
+    while (j > 0) {
+        raw.unshift({
+            type: "add",
+            oldNum: 0,
+            newNum: j,
+            content: newLines[j - 1],
+        });
+        j--;
+    }
+    const changed = new Set();
+    for (let k = 0; k < raw.length; k++) {
+        if (raw[k].type !== "context") {
+            changed.add(k);
+        }
+    }
+    const included = new Set();
+    for (const idx of changed) {
+        for (let k = Math.max(0, idx - CONTEXT_LINES); k <= Math.min(raw.length - 1, idx + CONTEXT_LINES); k++) {
+            included.add(k);
+        }
+    }
+    let lastIncluded = -1;
+    for (let k = 0; k < raw.length; k++) {
+        if (included.has(k)) {
+            if (lastIncluded >= 0 && k > lastIncluded + 1) {
+                result.push({
+                    type: "context",
+                    oldNum: null,
+                    newNum: null,
+                    content: "...",
+                });
+            }
+            const line = raw[k];
+            result.push({
+                type: line.type,
+                oldNum: line.type === "add" ? null : line.oldNum,
+                newNum: line.type === "remove" ? null : line.newNum,
+                content: line.content,
+            });
+            lastIncluded = k;
+        }
+    }
+    return result;
+}
+function formatLine(line, maxNumWidth) {
+    const num = line.type === "remove" ? line.oldNum : line.newNum;
+    const numStr = num !== null ? String(num).padStart(maxNumWidth) : " ".repeat(maxNumWidth);
+    if (line.type === "remove") {
+        return `${numStr} ${pc.red("-")} ${line.content}`;
+    }
+    else if (line.type === "add") {
+        return `${numStr} ${pc.green("+")} ${line.content}`;
+    }
+    else if (line.content === "...") {
+        return pc.dim(`  ${" ".repeat(maxNumWidth)}...`);
+    }
+    else {
+        return `  ${numStr}   ${line.content}`;
+    }
+}
+export function generateDiff(oldContent, newContent) {
+    if (oldContent === newContent)
+        return "";
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    const diff = buildDiff(oldLines, newLines);
+    if (diff.length === 0)
+        return "";
+    const oldNums = diff.filter((l) => l.oldNum !== null).map((l) => l.oldNum);
+    const newNums = diff.filter((l) => l.newNum !== null).map((l) => l.newNum);
+    const maxOldNum = oldNums.length > 0 ? Math.max(...oldNums) : 0;
+    const maxNewNum = newNums.length > 0 ? Math.max(...newNums) : 0;
+    const maxNumWidth = Math.max(String(maxOldNum).length, String(maxNewNum).length, 3);
+    let lines = diff.map((l) => formatLine(l, maxNumWidth));
+    if (lines.length > MAX_DIFF_LINES) {
+        const truncated = lines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${lines.length - MAX_DIFF_LINES} more lines)`));
+        lines = truncated;
+    }
+    return lines.join("\n");
+}
+export function generateNewFileDiff(content) {
+    const lines = content.split("\n");
+    const maxNumWidth = Math.max(String(lines.length).length, 3);
+    const diffLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const numStr = String(i + 1).padStart(maxNumWidth);
+        diffLines.push(`${numStr} ${pc.green("+")} ${lines[i]}`);
+    }
+    if (diffLines.length > MAX_DIFF_LINES) {
+        const truncated = diffLines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${diffLines.length - MAX_DIFF_LINES} more lines)`));
+        return truncated.join("\n");
+    }
+    return diffLines.join("\n");
+}
+export function generateDeleteDiff(content) {
+    const lines = content.split("\n");
+    const maxNumWidth = Math.max(String(lines.length).length, 3);
+    const diffLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const numStr = String(i + 1).padStart(maxNumWidth);
+        diffLines.push(`${numStr} ${pc.red("-")} ${lines[i]}`);
+    }
+    if (diffLines.length > MAX_DIFF_LINES) {
+        const truncated = diffLines.slice(0, MAX_DIFF_LINES);
+        truncated.push(pc.dim(`  ... (${diffLines.length - MAX_DIFF_LINES} more lines)`));
+        return truncated.join("\n");
+    }
+    return diffLines.join("\n");
+}
+export function generateMoveDiff(fromPath, toPath) {
+    return [pc.red(`  - ${fromPath}`), pc.green(`  + ${toPath}`)].join("\n");
+}

package/dist/ui/index.js

@@ -0,0 +1,6 @@
+export { formatMarkdown, formatError, formatSuccess, formatWarning, FormattingStream, } from "./md-formatter";
+export { writeOutput, writeError, writeSuccess, writeWarning } from "./output";
+export { formatTable, splitRow, isSeparatorRow, getTerminalWidth } from "./table";
+export { box, divider, wrapText } from "./box";
+export { Spinner, isSpinnerSupported } from "./spinner";
+export { Renderer, isRichTerminal, summarizeArgs } from "./renderer";