micro-models-agent 0.28.17 → 0.29.0

package/dist/modules/plugins/builtin/lint-on-write.js

@@ -1,62 +1,27 @@
-import { spawn, execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { resolve, extname, join } from "path";
-import { platform } from "os";
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, extname, join } from 'path';
+let projectTypeCheckPromise = null;
+let projectTypeCheckTimestamp = 0;
 const TYPE_CHECK_DEBOUNCE_MS = 2000;
-// Per-file syntax checks are cached by (path, content hash): re-writing a file
-// with identical content skips the (expensive) check. Content changes → cache
-// miss → fresh check.
-const syntaxCache = new Map();
-function contentHash(content) {
-    let h = 5381;
-    for (let i = 0; i < content.length; i++) {
-        h = ((h << 5) + h + content.charCodeAt(i)) | 0;
-    }
-    return String(h);
-}
-let _winDecoder;
-function getWinDecoder() {
-    if (_winDecoder === undefined) {
-        if (platform() !== "win32") {
-            _winDecoder = null;
-        }
-        else {
-            try {
-                const cpOut = execSync("chcp.com", {
-                    encoding: "buffer",
-                    timeout: 2000,
-                    windowsHide: true,
-                }).toString("latin1");
-                const m = cpOut.match(/(\d+)/);
-                _winDecoder = m ? new TextDecoder("ibm" + m[1]) : null;
-            }
-            catch {
-                _winDecoder = null;
-            }
-        }
-    }
-    return _winDecoder ?? new TextDecoder("utf-8");
-}
 export class LintOnWritePlugin {
-    name = "lint-on-write";
+    name = 'lint-on-write';
     priority = 10;
-    _checkPromise = null;
-    _checkTimestamp = 0;
     async onAfterTool(ctx, call, result) {
-        if (call.name !== "write_file" && call.name !== "edit_file") {
+        if (call.name !== 'write_file' && call.name !== 'edit_file') {
             return;
         }
         if (!result.success) {
             return;
         }
-        const path = String(call.arguments.path || "");
+        const path = String(call.arguments.path || '');
         if (!path)
             return;
         const fullPath = resolve(ctx.baseDir, path);
         if (!existsSync(fullPath))
             return;
         const ext = extname(fullPath);
-        const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
+        const syntaxError = this.checkSyntax(fullPath, ext, ctx.baseDir);
         if (syntaxError) {
             result.output += `\n\n[Syntax check failed]: ${syntaxError}`;
             return;
@@ -64,50 +29,32 @@ export class LintOnWritePlugin {
         await this.runProjectLint(ctx, result);
         await this.runProjectTypeCheck(ctx, result);
     }
-    async checkSyntax(filePath, ext, baseDir) {
-        if (ext === ".ts" || ext === ".tsx") {
-            // Syntax-only check via bun's parser (~200ms) instead of `npx tsc`
-            // (~3-5s per write). Full type errors are still surfaced by the
-            // debounced project typecheck below when a tsconfig exists.
-            let content = "";
-            try {
-                content = readFileSync(filePath, "utf-8");
-            }
-            catch {
-                return null;
-            }
-            const hash = contentHash(content);
-            const cached = syntaxCache.get(filePath);
-            if (cached && cached.hash === hash) {
-                return cached.error;
-            }
+    checkSyntax(filePath, ext, baseDir) {
+        if (ext === '.ts' || ext === '.tsx') {
             try {
-                await runAsync(`bun build --no-bundle --target=bun "${filePath}"`, baseDir, 10000);
-                syntaxCache.set(filePath, { hash, error: null });
+                execSync(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 10000 });
                 return null;
             }
             catch (err) {
-                if (err.status === 127 ||
-                    err.message.includes("not found") ||
-                    err.message.includes("ENOENT")) {
+                if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
                     return null;
                 }
-                const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
-                const firstError = stderr.split("\n").find((line) => line.trim()) ||
-                    "TypeScript syntax error";
-                syntaxCache.set(filePath, { hash, error: firstError.trim() });
-                return firstError.trim();
+                const stderr = err.stderr?.toString() || err.stdout?.toString() || '';
+                if (stderr.includes('error TS')) {
+                    const firstError = stderr.split('\n').find((line) => line.includes('error TS')) || 'TypeScript syntax error';
+                    return firstError.trim();
+                }
+                return null;
             }
         }
-        if (ext === ".js" || ext === ".jsx") {
+        if (ext === '.js' || ext === '.jsx') {
             try {
-                await runAsync(`node --check "${filePath}"`, baseDir, 5000);
+                execSync(`node --check "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 5000 });
                 return null;
             }
             catch (err) {
-                const stderr = err.stderr?.toString() || "";
-                const firstError = stderr.split("\n").find((line) => line.trim()) ||
-                    "JavaScript syntax error";
+                const stderr = err.stderr?.toString() || '';
+                const firstError = stderr.split('\n').find((line) => line.trim()) || 'JavaScript syntax error';
                 return firstError.trim();
             }
         }
@@ -115,18 +62,18 @@ export class LintOnWritePlugin {
     }
     async runProjectLint(ctx, result) {
         try {
-            const packageJsonPath = join(ctx.baseDir, "package.json");
+            const packageJsonPath = join(ctx.baseDir, 'package.json');
             if (!existsSync(packageJsonPath)) {
                 return;
             }
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
             const lintScript = packageJson.scripts?.lint;
             if (!lintScript) {
                 return;
             }
             ctx.logger.debug(`Running lint: ${lintScript}`);
-            await runAsync(lintScript, ctx.baseDir, 30_000);
-            ctx.logger.debug("Lint passed");
+            execSync(lintScript, { cwd: ctx.baseDir, stdio: 'pipe' });
+            ctx.logger.debug('Lint passed');
         }
         catch (err) {
             ctx.logger.warn(`Lint failed: ${err.message}`);
@@ -134,93 +81,41 @@ export class LintOnWritePlugin {
         }
     }
     async runProjectTypeCheck(ctx, result) {
-        const tsconfigPath = join(ctx.baseDir, "tsconfig.json");
+        const tsconfigPath = join(ctx.baseDir, 'tsconfig.json');
         if (!existsSync(tsconfigPath)) {
             return;
         }
         const now = Date.now();
-        if (this._checkPromise &&
-            now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
-            const error = await this._checkPromise;
+        if (projectTypeCheckPromise && now - projectTypeCheckTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
+            const error = await projectTypeCheckPromise;
             if (error) {
                 result.output += `\n\n[Project typecheck failed]: ${error}`;
             }
             return;
         }
-        this._checkTimestamp = now;
-        this._checkPromise = this.runTscCheck(ctx.baseDir);
-        const error = await this._checkPromise;
+        projectTypeCheckTimestamp = now;
+        projectTypeCheckPromise = this.runTscCheck(ctx.baseDir);
+        const error = await projectTypeCheckPromise;
         if (error) {
             result.output += `\n\n[Project typecheck failed]: ${error}`;
         }
     }
     async runTscCheck(baseDir) {
         try {
-            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000);
+            execSync(`npx tsc --noEmit --skipLibCheck`, { cwd: baseDir, stdio: 'pipe', timeout: 30000 });
             return null;
         }
         catch (err) {
-            if (err.status === 127 ||
-                err.message.includes("not found") ||
-                err.message.includes("ENOENT")) {
+            if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
                 return null;
             }
-            const stderr = err.stderr?.toString() || err.stdout?.toString() || "";
-            if (stderr.includes("error TS")) {
-                const firstError = stderr
-                    .split("\n")
-                    .find((line) => line.includes("error TS")) ||
-                    "TypeScript type error";
+            const stderr = err.stderr?.toString() || err.stdout?.toString() || '';
+            if (stderr.includes('error TS')) {
+                const firstError = stderr.split('\n').find((line) => line.includes('error TS')) || 'TypeScript type error';
                 return firstError.trim();
             }
             return null;
         }
     }
 }
-/**
- * Run a command asynchronously (non-blocking event loop) and resolve when it
- * exits. Rejects with captured stderr/stdout on non-zero exit or timeout.
- */
-function runAsync(command, cwd, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, {
-            cwd,
-            shell: true,
-            windowsHide: true,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        const decoder = getWinDecoder();
-        child.stdout?.on("data", (d) => {
-            stdout += decoder.decode(d, { stream: true });
-        });
-        child.stderr?.on("data", (d) => {
-            stderr += decoder.decode(d, { stream: true });
-        });
-        const timer = setTimeout(() => {
-            child.kill();
-            reject(new Error(`Command timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timer);
-            stdout += decoder.decode();
-            stderr += decoder.decode();
-            if (code === 0) {
-                resolve({ stdout, stderr });
-            }
-            else {
-                const err = new Error(`Command failed with exit code ${code}`);
-                err.stdout = stdout;
-                err.stderr = stderr;
-                err.status = code;
-                reject(err);
-            }
-        });
-    });
-}
 export const plugin = new LintOnWritePlugin();

package/dist/modules/processes/detect.js

@@ -0,0 +1,34 @@
+/**
+ * Heuristic detection of long-running (server/watch) commands.
+ *
+ * The explicit `background: true` bash parameter always wins; this list is a
+ * convenience so dev servers don't block the agent. It only inspects the raw
+ * shell command (a technical process-type decision, not task classification).
+ */
+const LONG_RUNNING_PATTERNS = [
+    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
+    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
+    /(^|\s)--watch\b/i,
+    /(^|\s)-w\b/i,
+    /\bnodemon\b/i,
+    /\btsx watch\b/i,
+    /\b(ts-node|tsc)\s+.*--watch\b/i,
+    /\bvite(?!\s+(build|create))\b/i,
+    /\bwebpack(-dev-server|\s+serve)\b/i,
+    /\bastro dev\b/i,
+    /\bnext (dev|start)\b/i,
+    /\bnuxt (dev|start)\b/i,
+    /\bsvelte-kit (dev|preview)\b/i,
+    /\bgatsby develop\b/i,
+    /\bdocker(-compose)?\s+.*\bup\b/i,
+    /\buvicorn\b|\bgunicorn\b/i,
+    /\bpython\s+-m\s+http\.server\b/i,
+    /\bflask run\b/i,
+    /\bphp artisan serve\b/i,
+    /\brails (server|s)\b/i,
+    /\bvitest watch\b/i,
+    /\bjest --watch\b/i,
+];
+export function isLongRunningCommand(command) {
+    return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
+}

package/dist/modules/processes/index.js

@@ -1,2 +1,3 @@
-export { registerKillable, unregisterKillable, killByCallId, } from "./runner";
+export { runCommand, killByCallId } from "./runner";
 export { processRegistry } from "./registry";
+export { isLongRunningCommand } from "./detect";

package/dist/modules/processes/registry.js

@@ -1,6 +1,6 @@
-import { spawn, spawnSync } from "child_process";
+import { spawn } from "child_process";
 import { platform } from "os";
-const MAX_LOG_LINES = 2000;
+const MAX_LOG_LINES = 300;
 const MAX_KEPT_PROCESSES = 20;
 let seq = 0;
 function killTree(child) {
@@ -8,16 +8,10 @@ function killTree(child) {
     if (!pid)
         return;
     if (platform() === "win32") {
-        try {
-            spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
-                windowsHide: true,
-                stdio: "ignore",
-                timeout: 3000,
-            });
-        }
-        catch {
-            /* already dead */
-        }
+        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+        });
         return;
     }
     try {
@@ -35,10 +29,9 @@ function killTree(child) {
 class ProcessRegistry {
     procs = new Map();
     children = new Map();
-    exitWaiters = new Map();
     /**
-     * Start a command. The returned entry buffers output and reports status; a
-     * call may check `waitForExit(id)` to learn when (if ever) it finishes.
+     * Start a background process. Returns immediately with the entry; output is
+     * buffered into `entry.log` as it arrives.
      */
     start(command, cwd, sessionId) {
         const id = `proc_${Date.now()}_${++seq}`;
@@ -55,98 +48,46 @@ class ProcessRegistry {
         };
         this.trimOldEntries();
         this.procs.set(id, entry);
-        let child;
-        try {
-            child = spawn(command, {
-                cwd,
-                shell: true,
-                windowsHide: true,
-                detached: platform() !== "win32",
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (e) {
-            entry.status = "killed";
-            entry.spawnError = e?.message || String(e);
-            entry.log.push(`[process error] ${entry.spawnError}`);
-            return entry;
-        }
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            windowsHide: true,
+            detached: platform() !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
         this.children.set(id, child);
         entry.pid = child.pid ?? 0;
-        // On Windows, children spawned via cmd.exe output in the OEM code page,
-        // NOT UTF-8. Detect the active code page via chcp.com; fall back to
-        // ibm866 (Russian CP866) when detection fails — still correct for the
-        // majority of users, and always better than the UTF-8 default.
-        const decoder = platform() === "win32"
-            ? (() => {
-                try {
-                    const cpOut = require("child_process")
-                        .execSync("chcp.com", {
-                        encoding: "buffer",
-                        timeout: 2000,
-                        windowsHide: true,
-                    })
-                        .toString("latin1");
-                    const m = cpOut.match(/(\d+)/);
-                    if (m)
-                        return new TextDecoder("ibm" + m[1]);
-                }
-                catch {
-                    /* ignore */
-                }
-                return new TextDecoder("ibm866");
-            })()
-            : new TextDecoder("utf-8");
-        let buf = "";
-        const pushLine = (line) => {
-            if (entry.log.length >= MAX_LOG_LINES) {
-                entry.log.shift();
-            }
-            entry.log.push(line);
-        };
+        let partial = "";
         const append = (chunk) => {
-            const decoded = decoder.decode(chunk, { stream: true });
-            buf += decoded;
-            const lines = buf.split(/\r?\n/);
-            buf = lines.pop() ?? "";
+            const text = partial + chunk.toString();
+            const lines = text.split(/\r?\n/);
+            partial = lines.pop() ?? "";
             for (const line of lines) {
-                pushLine(line);
-            }
-        };
-        const flush = () => {
-            buf += decoder.decode();
-            if (buf) {
-                pushLine(buf);
-                buf = "";
+                if (entry.log.length >= MAX_LOG_LINES) {
+                    entry.log.shift();
+                }
+                entry.log.push(line);
             }
         };
-        const resolveExit = () => {
-            this.exitWaiters.get(id)?.resolve();
-        };
         child.stdout?.on("data", append);
         child.stderr?.on("data", append);
         child.on("error", (err) => {
             if (entry.status === "running") {
                 entry.status = "killed";
             }
-            entry.spawnError = err.message;
             append(Buffer.from(`[process error] ${err.message}`));
-            resolveExit();
         });
         child.on("close", (code) => {
-            flush();
             if (entry.status === "running") {
                 entry.status = "exited";
             }
             entry.exitCode = code;
             this.children.delete(id);
-            resolveExit();
-        });
-        let resolve;
-        const promise = new Promise((r) => {
-            resolve = r;
+            if (partial) {
+                entry.log.push(partial);
+                partial = "";
+            }
         });
-        this.exitWaiters.set(id, { promise, resolve });
         return entry;
     }
     list(sessionId) {
@@ -187,51 +128,20 @@ class ProcessRegistry {
         }
         return targets.length;
     }
-    /**
-     * Resolve `true` when the process exits (or fails to spawn) within
-     * `timeoutMs`, otherwise `false` (still running → a background process).
-     */
-    waitForExit(id, timeoutMs) {
-        const entry = this.procs.get(id);
-        const waiter = this.exitWaiters.get(id);
-        if (!entry || entry.status !== "running" || !waiter) {
-            return Promise.resolve(true);
-        }
-        return new Promise((resolve) => {
-            const timer = setTimeout(() => resolve(false), timeoutMs);
-            waiter.promise.then(() => {
-                clearTimeout(timer);
-                resolve(true);
-            });
-        });
-    }
-    /**
-     * Remove a finished entry (foreground results do not linger). A still-running
-     * entry is killed first so nothing is orphaned.
-     */
-    remove(id) {
-        const entry = this.procs.get(id);
-        if (!entry)
-            return false;
-        if (entry.status === "running") {
-            const child = this.children.get(id);
-            if (child) {
-                killTree(child);
-            }
-            entry.status = "killed";
-        }
-        this.procs.delete(id);
-        this.children.delete(id);
-        this.exitWaiters.delete(id);
-        return true;
-    }
     trimOldEntries() {
         if (this.procs.size < MAX_KEPT_PROCESSES)
             return;
         const sorted = Array.from(this.procs.values()).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
         const toRemove = sorted.slice(0, sorted.length - MAX_KEPT_PROCESSES + 1);
         for (const entry of toRemove) {
-            this.remove(entry.id);
+            if (entry.status === "running") {
+                const child = this.children.get(entry.id);
+                if (child) {
+                    killTree(child);
+                }
+            }
+            this.procs.delete(entry.id);
+            this.children.delete(entry.id);
         }
     }
 }

package/dist/modules/processes/runner.js

@@ -1,13 +1,11 @@
+import { spawn } from "child_process";
+import { platform } from "os";
 const activeChildren = new Map();
-/** Register a kill callback for a tool call id (executor timeout/abort). */
-export function registerKillable(callId, kill) {
-    activeChildren.set(callId, { kill });
-}
-/** Unregister a tool call's kill callback once its handler finished. */
-export function unregisterKillable(callId) {
-    activeChildren.delete(callId);
-}
-/** Invoke (and drop) the kill callback registered for `callId`. */
+/**
+ * Kill a foreground command previously registered by `callId` (used by the
+ * tool executor when the execution timeout fires). Returns true when a child
+ * was found and killed.
+ */
 export function killByCallId(callId) {
     const entry = activeChildren.get(callId);
     if (!entry)
@@ -21,3 +19,106 @@ export function killByCallId(callId) {
     }
     return true;
 }
+function killTree(child) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    if (platform() === "win32") {
+        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+        });
+        return;
+    }
+    try {
+        // `detached: true` makes the child a process-group leader on POSIX,
+        // so killing -pid terminates the whole tree.
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+    }
+}
+/**
+ * Run a shell command asynchronously (non-blocking event loop) and collect
+ * stdout/stderr. The child is killed on timeout and can be killed externally
+ * via `killByCallId` (used by the tool executor timeout).
+ */
+export function runCommand(command, options = {}) {
+    const { cwd, callId, timeoutMs = 120_000, maxBuffer = 10 * 1024 * 1024, } = options;
+    return new Promise((resolve) => {
+        let timedOut = false;
+        let stdout = "";
+        let stderr = "";
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            windowsHide: true,
+            detached: platform() !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutRef = { value: stdout };
+        const stderrRef = { value: stderr };
+        // On Windows, child processes spawned via cmd.exe output in the OEM code
+        // page (typically CP866 for Russian), NOT UTF-8 — even when the parent
+        // console reports code page 65001 via `chcp`.  Always decode with ibm866
+        // so that Cyrillic and other non-ASCII text is not garbled.
+        const decoder = platform() === "win32" ? new TextDecoder("ibm866") : null;
+        const decodeChunk = (chunk) => decoder ? decoder.decode(chunk, { stream: true }) : chunk.toString("utf-8");
+        child.stdout?.on("data", (chunk) => {
+            const text = decodeChunk(chunk);
+            const next = stdoutRef.value.length + text.length;
+            if (next > maxBuffer) {
+                stdoutRef.value =
+                    stdoutRef.value.slice(stdoutRef.value.length + text.length - maxBuffer) + text;
+            }
+            else {
+                stdoutRef.value = stdoutRef.value + text;
+            }
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = decodeChunk(chunk);
+            const next = stderrRef.value.length + text.length;
+            if (next > maxBuffer) {
+                stderrRef.value =
+                    stderrRef.value.slice(stderrRef.value.length + text.length - maxBuffer) + text;
+            }
+            else {
+                stderrRef.value = stderrRef.value + text;
+            }
+        });
+        const entry = {
+            kill: () => killTree(child),
+        };
+        if (callId) {
+            activeChildren.set(callId, entry);
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killTree(child);
+        }, timeoutMs);
+        child.on("error", () => {
+            clearTimeout(timer);
+            if (callId)
+                activeChildren.delete(callId);
+            resolve({
+                stdout: stdoutRef.value,
+                stderr: stderrRef.value,
+                code: null,
+                signal: null,
+                timedOut,
+            });
+        });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            if (callId)
+                activeChildren.delete(callId);
+            resolve({ stdout: stdoutRef.value, stderr: stderrRef.value, code, signal, timedOut });
+        });
+    });
+}