micro-models-agent 0.39.0 → 0.40.0

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

@@ -1,27 +1,62 @@
-import { execSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
-import { resolve, extname, join } from 'path';
-let projectTypeCheckPromise = null;
-let projectTypeCheckTimestamp = 0;
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve, extname, join } from "path";
+import { platform } from "os";
 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 = this.checkSyntax(fullPath, ext, ctx.baseDir);
+        const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
         if (syntaxError) {
             result.output += `\n\n[Syntax check failed]: ${syntaxError}`;
             return;
@@ -29,32 +64,50 @@ export class LintOnWritePlugin {
         await this.runProjectLint(ctx, result);
         await this.runProjectTypeCheck(ctx, result);
     }
-    checkSyntax(filePath, ext, baseDir) {
-        if (ext === '.ts' || ext === '.tsx') {
+    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;
+            }
             try {
-                execSync(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 10000 });
+                await runAsync(`bun build --no-bundle --target=bun "${filePath}"`, baseDir, 10000);
+                syntaxCache.set(filePath, { hash, error: null });
                 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 syntax error';
-                    return firstError.trim();
-                }
-                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();
             }
         }
-        if (ext === '.js' || ext === '.jsx') {
+        if (ext === ".js" || ext === ".jsx") {
             try {
-                execSync(`node --check "${filePath}"`, { cwd: baseDir, stdio: 'pipe', timeout: 5000 });
+                await runAsync(`node --check "${filePath}"`, baseDir, 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();
             }
         }
@@ -62,18 +115,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}`);
-            execSync(lintScript, { cwd: ctx.baseDir, stdio: 'pipe' });
-            ctx.logger.debug('Lint passed');
+            await runAsync(lintScript, ctx.baseDir, 30_000);
+            ctx.logger.debug("Lint passed");
         }
         catch (err) {
             ctx.logger.warn(`Lint failed: ${err.message}`);
@@ -81,41 +134,93 @@ 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 (projectTypeCheckPromise && now - projectTypeCheckTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
-            const error = await projectTypeCheckPromise;
+        if (this._checkPromise &&
+            now - this._checkTimestamp < TYPE_CHECK_DEBOUNCE_MS) {
+            const error = await this._checkPromise;
             if (error) {
                 result.output += `\n\n[Project typecheck failed]: ${error}`;
             }
             return;
         }
-        projectTypeCheckTimestamp = now;
-        projectTypeCheckPromise = this.runTscCheck(ctx.baseDir);
-        const error = await projectTypeCheckPromise;
+        this._checkTimestamp = now;
+        this._checkPromise = this.runTscCheck(ctx.baseDir);
+        const error = await this._checkPromise;
         if (error) {
             result.output += `\n\n[Project typecheck failed]: ${error}`;
         }
     }
     async runTscCheck(baseDir) {
         try {
-            execSync(`npx tsc --noEmit --skipLibCheck`, { cwd: baseDir, stdio: 'pipe', timeout: 30000 });
+            await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 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/index.js

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

package/dist/modules/processes/registry.js

@@ -1,6 +1,6 @@
-import { spawn } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { platform } from "os";
-const MAX_LOG_LINES = 300;
+const MAX_LOG_LINES = 2000;
 const MAX_KEPT_PROCESSES = 20;
 let seq = 0;
 function killTree(child) {
@@ -8,10 +8,16 @@ function killTree(child) {
     if (!pid)
         return;
     if (platform() === "win32") {
-        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-            windowsHide: true,
-            stdio: "ignore",
-        });
+        try {
+            spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+                windowsHide: true,
+                stdio: "ignore",
+                timeout: 3000,
+            });
+        }
+        catch {
+            /* already dead */
+        }
         return;
     }
     try {
@@ -29,9 +35,10 @@ function killTree(child) {
 class ProcessRegistry {
     procs = new Map();
     children = new Map();
+    exitWaiters = new Map();
     /**
-     * Start a background process. Returns immediately with the entry; output is
-     * buffered into `entry.log` as it arrives.
+     * 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(command, cwd, sessionId) {
         const id = `proc_${Date.now()}_${++seq}`;
@@ -48,46 +55,98 @@ class ProcessRegistry {
         };
         this.trimOldEntries();
         this.procs.set(id, entry);
-        const child = spawn(command, {
-            cwd,
-            shell: true,
-            windowsHide: true,
-            detached: platform() !== "win32",
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        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;
+        }
         this.children.set(id, child);
         entry.pid = child.pid ?? 0;
-        let partial = "";
+        // 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);
+        };
         const append = (chunk) => {
-            const text = partial + chunk.toString();
-            const lines = text.split(/\r?\n/);
-            partial = lines.pop() ?? "";
+            const decoded = decoder.decode(chunk, { stream: true });
+            buf += decoded;
+            const lines = buf.split(/\r?\n/);
+            buf = lines.pop() ?? "";
             for (const line of lines) {
-                if (entry.log.length >= MAX_LOG_LINES) {
-                    entry.log.shift();
-                }
-                entry.log.push(line);
+                pushLine(line);
             }
         };
+        const flush = () => {
+            buf += decoder.decode();
+            if (buf) {
+                pushLine(buf);
+                buf = "";
+            }
+        };
+        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);
-            if (partial) {
-                entry.log.push(partial);
-                partial = "";
-            }
+            resolveExit();
         });
+        let resolve;
+        const promise = new Promise((r) => {
+            resolve = r;
+        });
+        this.exitWaiters.set(id, { promise, resolve });
         return entry;
     }
     list(sessionId) {
@@ -128,20 +187,51 @@ 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) {
-            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);
+            this.remove(entry.id);
         }
     }
 }

package/dist/modules/processes/runner.js

@@ -1,11 +1,13 @@
-import { spawn } from "child_process";
-import { platform } from "os";
 const activeChildren = new Map();
-/**
- * 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.
- */
+/** 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`. */
 export function killByCallId(callId) {
     const entry = activeChildren.get(callId);
     if (!entry)
@@ -19,106 +21,3 @@ 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 });
-        });
-    });
-}

package/dist/modules/security/audit-log.js

@@ -1,28 +1,48 @@
 import { existsSync, mkdirSync, appendFileSync } from "fs";
-import { resolve } from "path";
+import { resolve, join } from "path";
 import { homedir } from "os";
 import { globalAuditNotifier } from "./audit-notifier";
+let _globalAuditDir = resolve(homedir(), ".mma", "logs");
+let _sessionAuditDir = null;
+function getAuditDir() {
+    return _sessionAuditDir ?? _globalAuditDir;
+}
 /**
- * Directory and file path for audit logs
+ * Set the session directory for audit logs. When set, all audit entries
+ * are written to the session-specific directory instead of the global one.
  */
-const AUDIT_LOG_DIR = resolve(homedir(), ".mma", "logs");
-const AUDIT_LOG_PATH = resolve(AUDIT_LOG_DIR, "audit.jsonl");
+export function setAuditSessionDir(dir) {
+    _sessionAuditDir = dir;
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
 /**
- * Ensure audit log directory exists
+ * Clear the session directory — fall back to global audit dir.
  */
-function ensureAuditLogDir() {
-    if (!existsSync(AUDIT_LOG_DIR)) {
-        mkdirSync(AUDIT_LOG_DIR, { recursive: true, mode: 0o700 });
+export function clearAuditSessionDir() {
+    _sessionAuditDir = null;
+}
+/**
+ * Set the global audit log directory (used when no session dir is active).
+ */
+export function setGlobalAuditDir(dir) {
+    _globalAuditDir = dir;
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 }
 /**
  * Write an audit log entry
  */
 export function logAudit(entry) {
-    ensureAuditLogDir();
+    const dir = getAuditDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
     try {
         const logEntry = JSON.stringify(entry);
-        appendFileSync(AUDIT_LOG_PATH, logEntry + "\n", "utf8");
+        appendFileSync(join(dir, "audit.jsonl"), logEntry + "\n", "utf8");
     }
     catch {
         // Silently fail if we can't write to audit log