micro-models-agent 2.10.0 → 2.12.0

package/dist/tools/move-file.js

@@ -1,3 +1,4 @@
+/** Тул перемещения/переименования файла или каталога. */
 import { renameSync, existsSync, mkdirSync } from "fs";
 import { resolve, normalize, dirname } from "path";
 import { t } from "../i18n/index";
@@ -6,6 +7,8 @@ import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
 import { generateMoveDiff } from "../ui/diff";
 import { safeResolvePath } from "./path-utils";
+import { protectedPathBlock } from "../modules/security/protected-paths";
+/** Перемещает/переименовывает; обе стороны проверяются по скоупу. */
 export const moveFileTool = {
     name: "move_file",
     icon: "📦",
@@ -25,11 +28,10 @@ export const moveFileTool = {
         const baseDir = resolve(ctx.baseDir);
         const fromResolved = safeResolvePath(baseDir, normalize(fromPath));
         const toResolved = safeResolvePath(baseDir, normalize(toPath));
-        // 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) {
@@ -39,8 +41,8 @@ export const moveFileTool = {
                 output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
             };
         }
-        // Check source path permissions — against the RESOLVED path (the same
-        // one renameSync will act on), never the raw argument.
+        // Права источника — по РЕЗОЛВЛЕННОМУ пути (по нему же работает renameSync),
+        // никогда по сырому аргументу.
         const fromCheck = isPathWritable(ctx.baseDir, fromResolved, ctx.scope, ctx.config.security?.paths);
         if (!fromCheck.allowed) {
             logSecurityBlock(ctx.sessionId, "file_write", fromCheck.reason || "Source path not allowed", fromPath);
@@ -51,7 +53,7 @@ export const moveFileTool = {
                 }),
             };
         }
-        // Check destination path permissions — resolved, same as above.
+        // Права приёмника — тоже по резолвленному.
         const toCheck = isPathWritable(ctx.baseDir, toResolved, ctx.scope, ctx.config.security?.paths);
         if (!toCheck.allowed) {
             logSecurityBlock(ctx.sessionId, "file_write", toCheck.reason || "Destination path not allowed", toPath);
@@ -62,6 +64,13 @@ export const moveFileTool = {
                 }),
             };
         }
+        // Защищённые пути с любой стороны (.git/, .env, ключи) — спросить юзера.
+        const fromProtected = protectedPathBlock(ctx, fromResolved, fromPath);
+        if (fromProtected)
+            return fromProtected;
+        const toProtected = protectedPathBlock(ctx, toResolved, toPath);
+        if (toProtected)
+            return toProtected;
         if (!existsSync(fromResolved)) {
             return {
                 success: false,
@@ -74,9 +83,7 @@ export const moveFileTool = {
         }
         renameSync(fromResolved, toResolved);
         const diff = generateMoveDiff(fromPath, toPath);
-        // Increment file operations counter
         ctx.fileOperationsCount = currentCount + 1;
-        // Log file move
         logFileWrite(ctx.sessionId, `${fromPath} -> ${toPath}`, true, "File moved");
         return {
             success: true,

package/dist/tools/path-utils.js

@@ -1,20 +1,20 @@
+/** Утилиты путей: нормализация, jail-проверки, резолв от baseDir. */
 import { resolve, normalize, dirname, basename, sep, relative, isAbsolute } from "path";
 import { existsSync } from "fs";
 /**
- * Normalize backslashes to forward slashes for display and comparison.
- * On POSIX this is a no-op; on Windows it converts `src\foo\bar.ts` → `src/foo/bar.ts`.
+ * Бэкслэши → прямые слэши для показа и сравнения.
+ * На POSIX no-op; на Windows `src\foo\bar.ts` → `src/foo/bar.ts`.
  */
 export function toForwardSlash(p) {
     return p.replace(/\\/g, "/");
 }
 /**
- * True when targetPath equals dirPath or lies inside it.
+ * True, если targetPath равен dirPath или внутри него.
  *
- * 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.
+ * Кроссплатформенно:
+ * - через path.relative(), а не raw startsWith: сосед с общим префиксом
+ *   ("src" vs "src-other") не пройдёт;
+ * - на Windows ФС регистронезависима: обе стороны lowercased до сравнения.
  */
 export function isInsideDir(targetPath, dirPath) {
     const norm = (p) => (process.platform === "win32" ? p.toLowerCase() : p);
@@ -23,12 +23,13 @@ export function isInsideDir(targetPath, dirPath) {
     if (t === d)
         return true;
     const rel = relative(d, t);
-    return rel.length > 0 && !isAbsolute(rel) && !rel.startsWith("..");
+    // Побег наверх — только реальный `..`/`../…`. Файл буквально `..foo`
+    // даёт rel === "..foo" и легально внутри.
+    return rel.length > 0 && !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
 }
 /**
- * True when targetPath matches a scope entry: either the entry file itself or
- * anything inside the entry directory. Separator- and case-safe (see
- * isInsideDir).
+ * True, если targetPath — сам scope-entry или внутри него. Проверка
+ * сепараторов и регистра — как в isInsideDir.
  */
 export function matchesScopeEntry(targetResolved, entryResolved) {
     if (targetResolved === entryResolved)
@@ -36,33 +37,32 @@ export function matchesScopeEntry(targetResolved, entryResolved) {
     return isInsideDir(targetResolved, entryResolved);
 }
 /**
- * Resolve a user-provided path against baseDir.
+ * Резолв пользовательского пути от baseDir.
  *
- * Handles common model mistakes:
- * 1. Leading slash: "/testing/cat3" → resolve relative to baseDir
- * 2. Missing separator: "E:\agent_test" when baseDir is "E:\agent\_test"
- *    → inserts the missing backslash
+ * Чинит типовые ошибки модели:
+ * 1. Ведущий слэш: "/testing/cat3" → относительно baseDir.
+ * 2. Пропущенный сепаратор: "E:\agent_test" при baseDir "E:\agent\_test"
+ *    → вставка недостающего бэкслэша.
  *
- * For new files the parent directory must exist; we check that instead of
- * the full path so write_file still works.
+ * Для новых файлов обязан существовать родитель — проверяется он, а не
+ * полный путь, иначе write_file не сработает.
  */
 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.
+    // Абсолютные пути — дословно, БЕЗ сдирания ведущего слэша и перерезолва
+    // от baseDir (иначе /var/folders/... станет baseDir/var/folders/... на POSIX).
+    // Эвристика ведущего слэша ниже — только fallback, когда путь не на диске.
     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".
+        // Абсолютный, но ещё не на диске (новый файл без существующих dirs).
+        // Восстановление ошибки модели: ведущий слэш мог значить "от baseDir".
         const stripped = norm.replace(/^[/\\]/, "");
         const relativeCandidate = resolve(baseDir, stripped);
         if (existsSync(relativeCandidate) || existsSync(dirname(relativeCandidate))) {
@@ -72,11 +72,11 @@ export function safeResolvePath(baseDir, userPath) {
     }
     const stripped = norm.replace(/^[/\\]/, "");
     const resolved = resolve(baseDir, stripped);
-    // Fast path: if it exists (or parent does for new files), return it
+    // Быстрый путь: существует сам (или родитель для новых файлов).
     if (existsSync(resolved) || existsSync(dirname(resolved)))
         return resolved;
     const baseNorm = normalize(baseDir);
-    // Walk ancestors and look for missing separators
+    // Подъём по предкам в поиске пропущенных сепараторов.
     let cur = baseNorm;
     while (cur && cur !== dirname(cur)) {
         const name = basename(cur);
@@ -94,7 +94,7 @@ export function safeResolvePath(baseDir, userPath) {
                 if (existsSync(fixedResolved) || existsSync(dirname(fixedResolved))) {
                     return fixedResolved;
                 }
-                // Try from ancestor's parent
+                // Проба от родителя предка.
                 const fromParent = resolve(dirname(cur), normalize(fixed));
                 if (existsSync(fromParent) || existsSync(dirname(fromParent))) {
                     return fromParent;

package/dist/tools/pipeline-run.js

@@ -1,3 +1,4 @@
+/** Тул прогона именованного YAML-пайплайна (DAG субагентов). */
 import { t } from "../i18n/index";
 import { PipelineEngine } from "../modules/pipelines/engine";
 import { PipelineParser } from "../modules/pipelines/parser";
@@ -8,9 +9,10 @@ import { PluginManager } from "../modules/plugins/manager";
 import { HallucinationDetector } from "../modules/hallucination/detector";
 import { logSecurityBlock } from "../modules/security/audit-log";
 import { getSessionSecurityConfig } from "../modules/security/session-isolation";
-const engine = new PipelineEngine();
+/** Максимум параллельных шагов / попыток шага. */
 const MAX_CONCURRENT = 3;
 const MAX_ATTEMPTS = 3;
+/** Прогоняет шаг пайплайна субагентом с ретраями (параметры/выходы — в промпт). */
 async function runStep(ctx, step, params, outputs) {
     const prompt = TemplateEngine.render(step.prompt, params, outputs);
     let lastError = "";
@@ -51,6 +53,7 @@ async function runStep(ctx, step, params, outputs) {
     }
     return { ok: false, output: "", error: lastError };
 }
+/** Запускает DAG субагентов в порядке зависимостей. Параметры: name, yaml, params. */
 export const pipelineRunTool = {
     name: "pipeline_run",
     icon: "▶️",
@@ -75,14 +78,18 @@ export const pipelineRunTool = {
         if (!ctx.llmProvider || !ctx.toolExecutor) {
             return {
                 success: false,
-                output: "Pipeline cannot run: missing llmProvider or toolExecutor in context",
+                output: t("tool.pipeline_cannot_run"),
             };
         }
         const securityConfig = ctx.sessionContext
             ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
             : ctx.config.security;
         const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
-        const currentDepth = ctx.recursionDepth ?? 0;
+        // Глубина — на SHARED-контексте исполнителя (вложенные субагенты/пайплайны
+        // читают её там); `ctx.recursionDepth` снапшотится раз и не инкрементится,
+        // поэтому старый гард не срабатывал. Зеркало subagent.ts.
+        const executor = ctx.toolExecutor;
+        const currentDepth = executor?.getRecursionDepth?.() ?? ctx.recursionDepth ?? 0;
         if (currentDepth >= maxDepth) {
             logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, name);
             return {
@@ -90,9 +97,12 @@ export const pipelineRunTool = {
                 output: `[SECURITY BLOCKED] Maximum pipeline recursion depth (${maxDepth}) exceeded`,
             };
         }
+        // Свежий движок на вызов: module-level синглтон сбрасывался конкурентными
+        // вызовами (MoE-волны делят исполнитель) и портил состояние шагов.
+        const engine = new PipelineEngine();
+        executor?.setRecursionDepth?.(currentDepth + 1);
         try {
             const pipeline = PipelineParser.parse(yaml);
-            engine.reset();
             const order = engine.resolveDependencies(pipeline.steps);
             const completed = new Set();
             const outputs = {};
@@ -130,16 +140,28 @@ export const pipelineRunTool = {
             if (failed.size > 0) {
                 return {
                     success: false,
-                    output: `Pipeline "${pipeline.name}" failed. Executed ${completed.size}/${pipeline.steps.length} steps.\n${logs.join("\n")}`,
+                    output: t("tool.pipeline_failed", {
+                        name: pipeline.name,
+                        done: String(completed.size),
+                        total: String(pipeline.steps.length),
+                        logs: logs.join("\n"),
+                    }),
                 };
             }
             return {
                 success: true,
-                output: `Pipeline "${pipeline.name}" completed successfully (${completed.size} steps).\n${logs.join("\n")}`,
+                output: t("tool.pipeline_completed", {
+                    name: pipeline.name,
+                    steps: String(completed.size),
+                    logs: logs.join("\n"),
+                }),
             };
         }
         catch (e) {
-            return { success: false, output: `Pipeline error: ${e.message}` };
+            return { success: false, output: t("tool.pipeline_error", { error: e.message }) };
+        }
+        finally {
+            executor?.setRecursionDepth?.(currentDepth);
         }
     },
 };

package/dist/tools/preview.js

@@ -1,2 +1,2 @@
-/** Maximum number of lines shown in tool output previews. */
+/** Максимум строк в превью вывода тулов. */
 export const MAX_PREVIEW_LINES = 15;

package/dist/tools/process-ids.js

@@ -0,0 +1,31 @@
+/** Общие хелперы process_*-тулов: хинт без id, валидация + lookup. */
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+/**
+ * Общий ответ "id не дан" для process_*-тулов: хинт использования плюс
+ * известные сейчас id (или пометка пустого реестра). Одна копия, чтобы
+ * process-kill/log/wait не расходились.
+ */
+export function missingProcessIdHint() {
+    const ids = processRegistry.list().map((p) => p.id);
+    const listPart = ids.length
+        ? `\n${t("proc.list_header")}: ${ids.join(", ")}`
+        : `\n${t("proc.missing_id_list")}`;
+    return `${t("proc.missing_id")}${listPart}`;
+}
+/**
+ * Общая валидация id + lookup в реестре для process_*-тулов. Возвращает запись
+ * либо `{ ok: false, output }` для прямого возврата (нет id — хинт,
+ * неизвестный id — not-found).
+ */
+export function lookupProcess(args) {
+    if (args.id === undefined || String(args.id).trim() === "") {
+        return { ok: false, output: missingProcessIdHint() };
+    }
+    const id = String(args.id);
+    const entry = processRegistry.get(id);
+    if (!entry) {
+        return { ok: false, output: t("proc.not_found", { id }) };
+    }
+    return { ok: true, id, entry };
+}

package/dist/tools/process-kill.js

@@ -1,5 +1,7 @@
 import { processRegistry } from "../modules/processes";
 import { t } from "../i18n/index";
+import { lookupProcess } from "./process-ids";
+/** Останавливает фоновый процесс по id из bash/process_list. */
 export const processKillTool = {
     name: "process_kill",
     icon: "⛔",
@@ -12,22 +14,13 @@ 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) {
-            return { success: false, output: t("proc.not_found", { id }) };
-        }
+    handler: async (_ctx, args) => {
+        // Без id отвечаем использованием: голое "not found: undefined" не
+        // подсказывает верный формат.
+        const found = lookupProcess(args);
+        if (!found.ok)
+            return { success: false, output: found.output };
+        const { id, entry } = found;
         const killed = processRegistry.kill(id);
         if (!killed) {
             return { success: false, output: t("proc.kill_failed", { id }) };

package/dist/tools/process-list.js

@@ -1,5 +1,6 @@
 import { processRegistry } from "../modules/processes";
 import { t } from "../i18n/index";
+/** Показывает фоновые процессы сессии с хинтом управления. */
 export const processListTool = {
     name: "process_list",
     icon: "📊",

package/dist/tools/process-log.js

@@ -1,11 +1,15 @@
 import { processRegistry } from "../modules/processes";
 import { t } from "../i18n/index";
 import { MAX_PREVIEW_LINES } from "./preview";
+import { lookupProcess } from "./process-ids";
 const DEFAULT_TAIL = MAX_PREVIEW_LINES;
+/** Потолок из описания тула; тул вне усечения по бюджету. */
+const MAX_TAIL = 300;
+/** Показывает буферизированный вывод фонового процесса (последние N строк). */
 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.`,
+    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. For a finite task that should complete, prefer process_wait over polling this tool.`,
     tags: ["shell"],
     boundedOutput: true,
     parameters: {
@@ -19,26 +23,17 @@ 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) {
-            return { success: false, output: t("proc.not_found", { id }) };
-        }
+    handler: async (_ctx, args) => {
+        const found = lookupProcess(args);
+        if (!found.ok)
+            return { success: false, output: found.output };
+        const { id, entry } = found;
         const status = entry.status === "running"
             ? t("proc.status_running")
             : entry.status === "exited"
                 ? t("proc.status_exited")
                 : t("proc.status_killed");
-        const tail = typeof args.tail === "number" ? args.tail : DEFAULT_TAIL;
+        const tail = Math.min(MAX_TAIL, Math.max(1, typeof args.tail === "number" ? Math.floor(args.tail) : DEFAULT_TAIL));
         const log = processRegistry.getLog(id, tail);
         if (!log) {
             return {

package/dist/tools/process-wait.js

@@ -0,0 +1,63 @@
+import { processRegistry } from "../modules/processes";
+import { t } from "../i18n/index";
+import { lookupProcess } from "./process-ids";
+import { PROCESS_WAIT_DEFAULT_MS as DEFAULT_WAIT_MS, PROCESS_WAIT_MAX_MS as MAX_WAIT_MS, } from "../config/timeouts";
+/**
+ * Дефолтное ожидание: хватает на типичный тест/билд, но в пределах таймаута
+ * исполнителя. `timeoutMs` тула даёт запас под явное долгое ожидание
+ * (кламп MAX_WAIT_MS).
+  */
+const DEFAULT_TAIL = 20;
+const MAX_TAIL = 100;
+/** Ждёт выхода процесса до timeoutMs; отчитывается кодом и хвостом вывода. */
+export const processWaitTool = {
+    name: "process_wait",
+    icon: "⏳",
+    description: "Wait for a background process started via bash to finish, instead of polling process_log or sleeping (ping/timeout/sleep commands). Blocks up to timeoutMs, then reports whether the process exited (with its exit code and recent output) or is still running. For dev servers/watchers that never exit, use process_log to inspect and process_kill to stop them.",
+    tags: ["shell"],
+    boundedOutput: true,
+    timeoutMs: 120000,
+    parameters: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Process id from bash output or process_list" },
+            timeoutMs: {
+                type: "number",
+                description: `How long to wait in milliseconds (default: ${DEFAULT_WAIT_MS}, max ${MAX_WAIT_MS})`,
+            },
+            tail: {
+                type: "number",
+                description: `Number of trailing output lines to include (default: ${DEFAULT_TAIL}, max ${MAX_TAIL})`,
+            },
+        },
+        required: ["id"],
+    },
+    handler: async (_ctx, args) => {
+        const found = lookupProcess(args);
+        if (!found.ok)
+            return { success: false, output: found.output };
+        const { id } = found;
+        const waitMs = Math.min(MAX_WAIT_MS, Math.max(1000, typeof args.timeoutMs === "number" ? Math.floor(args.timeoutMs) : DEFAULT_WAIT_MS));
+        const started = Date.now();
+        await processRegistry.waitForExit(id, waitMs);
+        const elapsed = Date.now() - started;
+        const entry = processRegistry.get(id);
+        if (!entry) {
+            return { success: false, output: t("proc.not_found", { id }) };
+        }
+        const tail = Math.min(MAX_TAIL, Math.max(1, typeof args.tail === "number" ? Math.floor(args.tail) : DEFAULT_TAIL));
+        const log = processRegistry.getLog(id, tail);
+        const logPart = log ? `\n${log}` : `\n${t("proc.log_empty")}`;
+        if (entry.status !== "running") {
+            const status = entry.status === "exited" ? t("proc.status_exited") : t("proc.status_killed");
+            return {
+                success: true,
+                output: `${t("proc.wait_exited", { id, ms: elapsed, status, code: entry.exitCode ?? "?" })}${logPart}`,
+            };
+        }
+        return {
+            success: true,
+            output: `${t("proc.wait_running", { id, ms: elapsed })}\n${t("proc.wait_hint", { id })}${logPart}`,
+        };
+    },
+};

package/dist/tools/prompt-io.js

@@ -1,6 +1,7 @@
+/** Терминал-независимая поверхность промпта для интерактивных тулов. */
 import { formatMenu, choicePrompt, parseSelection, CUSTOM_INDEX, } from "./user-input";
 import { t } from "../i18n/index";
-/** Build a PromptIO from injectable ask/print primitives (testable, terminal-agnostic). */
+/** Собирает PromptIO из инжектируемых ask/print (тестируемо, без терминала). */
 export function createPromptIO(deps) {
     return {
         async askText(question) {
@@ -9,8 +10,8 @@ export function createPromptIO(deps) {
         async askChoice(question, options, opts = {}) {
             const multiple = opts.multiple ?? false;
             const entryCount = options.length + (opts.allowCustom ? 1 : 0);
-            // No selectable entries (and no custom entry) — parseSelection can never
-            // succeed, so return without printing a dead menu or looping forever.
+            // Выбирать нечего (и кастома нет) — parseSelection не сойдётся никогда,
+            // поэтому выходим без печати мёртвого меню и вечного цикла.
             if (entryCount === 0)
                 return [];
             const customEntry = options.length;