micro-models-agent 0.28.9 → 0.29.0

package/dist/modules/plugins/manager.js

@@ -0,0 +1,161 @@
+export class PluginManager {
+    plugins = [];
+    register(plugin) {
+        this.plugins.push(plugin);
+        this.plugins.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    getAllPlugins() {
+        return [...this.plugins];
+    }
+    runOnBuildPrompt() {
+        return this.plugins.map(p => {
+            try {
+                return p.onBuildPrompt?.() ?? null;
+            }
+            catch {
+                return null;
+            }
+        });
+    }
+    async runOnBeforeTool(ctx, call) {
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeTool) {
+                try {
+                    const result = await plugin.onBeforeTool(ctx, call);
+                    if (result === false)
+                        return false;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return true;
+    }
+    async runOnAfterTool(ctx, call, result) {
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterTool) {
+                try {
+                    await plugin.onAfterTool(ctx, call, result);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    async runOnError(ctx, error) {
+        for (const plugin of this.plugins) {
+            if (plugin.onError) {
+                try {
+                    await plugin.onError(ctx, error);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnSessionStart(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionStart) {
+                try {
+                    plugin.onSessionStart(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnBeforeThink(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onBeforeThink) {
+                try {
+                    plugin.onBeforeThink(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnAfterThink(ctx, response) {
+        for (const plugin of this.plugins) {
+            if (plugin.onAfterThink) {
+                try {
+                    plugin.onAfterThink(ctx, response);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnSessionEnd(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onSessionEnd) {
+                try {
+                    plugin.onSessionEnd(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolCall(ctx) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolCall) {
+                try {
+                    plugin.onToolCall(ctx);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnPhase(ctx, phase) {
+        for (const plugin of this.plugins) {
+            if (plugin.onPhase) {
+                try {
+                    plugin.onPhase(ctx, phase);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolStart(ctx, call) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolStart) {
+                try {
+                    plugin.onToolStart(ctx, call);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    runOnToolEnd(ctx, call, result, durationMs) {
+        for (const plugin of this.plugins) {
+            if (plugin.onToolEnd) {
+                try {
+                    plugin.onToolEnd(ctx, call, result, durationMs);
+                }
+                catch { /* error isolation */ }
+            }
+        }
+    }
+    /** Pipe a text chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnText(ctx, chunk) {
+        for (const plugin of this.plugins) {
+            if (plugin.onText) {
+                try {
+                    const out = plugin.onText(ctx, chunk);
+                    if (typeof out === 'string')
+                        chunk = out;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return chunk;
+    }
+    /** Pipe a meta chunk through plugin transforms; returns the (possibly replaced) chunk. */
+    runOnMeta(ctx, chunk) {
+        for (const plugin of this.plugins) {
+            if (plugin.onMeta) {
+                try {
+                    const out = plugin.onMeta(ctx, chunk);
+                    if (typeof out === 'string')
+                        chunk = out;
+                }
+                catch { /* error isolation */ }
+            }
+        }
+        return chunk;
+    }
+}

package/dist/modules/plugins/types.js

@@ -0,0 +1 @@
+export {};

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

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

package/dist/modules/processes/registry.js

@@ -0,0 +1,148 @@
+import { spawn } from "child_process";
+import { platform } from "os";
+const MAX_LOG_LINES = 300;
+const MAX_KEPT_PROCESSES = 20;
+let seq = 0;
+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 {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            /* already dead */
+        }
+    }
+}
+class ProcessRegistry {
+    procs = new Map();
+    children = new Map();
+    /**
+     * 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}`;
+        const entry = {
+            id,
+            pid: 0,
+            command,
+            cwd,
+            sessionId,
+            status: "running",
+            exitCode: null,
+            startedAt: new Date().toISOString(),
+            log: [],
+        };
+        this.trimOldEntries();
+        this.procs.set(id, 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;
+        let partial = "";
+        const append = (chunk) => {
+            const text = partial + chunk.toString();
+            const lines = text.split(/\r?\n/);
+            partial = lines.pop() ?? "";
+            for (const line of lines) {
+                if (entry.log.length >= MAX_LOG_LINES) {
+                    entry.log.shift();
+                }
+                entry.log.push(line);
+            }
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        child.on("error", (err) => {
+            if (entry.status === "running") {
+                entry.status = "killed";
+            }
+            append(Buffer.from(`[process error] ${err.message}`));
+        });
+        child.on("close", (code) => {
+            if (entry.status === "running") {
+                entry.status = "exited";
+            }
+            entry.exitCode = code;
+            this.children.delete(id);
+            if (partial) {
+                entry.log.push(partial);
+                partial = "";
+            }
+        });
+        return entry;
+    }
+    list(sessionId) {
+        const all = Array.from(this.procs.values());
+        if (!sessionId)
+            return all;
+        return all.filter((p) => p.sessionId === sessionId);
+    }
+    get(id) {
+        return this.procs.get(id);
+    }
+    getLog(id, tail) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return "";
+        const lines = tail && tail > 0 ? entry.log.slice(-tail) : entry.log;
+        return lines.join("\n");
+    }
+    /** Kill a background process tree. Returns false when not found. */
+    kill(id) {
+        const entry = this.procs.get(id);
+        if (!entry)
+            return false;
+        if (entry.status === "running") {
+            entry.status = "killed";
+            const child = this.children.get(id);
+            if (child) {
+                killTree(child);
+            }
+        }
+        return true;
+    }
+    /** Kill every managed background process (used on agent shutdown). */
+    killAll(sessionId) {
+        const targets = this.list(sessionId);
+        for (const entry of targets) {
+            this.kill(entry.id);
+        }
+        return targets.length;
+    }
+    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);
+        }
+    }
+}
+export const processRegistry = new ProcessRegistry();

package/dist/modules/processes/runner.js

@@ -0,0 +1,124 @@
+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.
+ */
+export function killByCallId(callId) {
+    const entry = activeChildren.get(callId);
+    if (!entry)
+        return false;
+    activeChildren.delete(callId);
+    try {
+        entry.kill();
+    }
+    catch {
+        /* already dead */
+    }
+    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/registry.js

@@ -0,0 +1,45 @@
+export class ModuleRegistry {
+    modules = new Map();
+    register(mod) {
+        this.modules.set(mod.name, mod);
+    }
+    get(name) {
+        return this.modules.get(name);
+    }
+    listModules() {
+        return Array.from(this.modules.keys()).sort();
+    }
+    collectPromptBlocks() {
+        const blocks = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getSystemPromptBlock) {
+                const block = mod.getSystemPromptBlock();
+                if (block)
+                    blocks.push(block);
+            }
+        }
+        return blocks;
+    }
+    collectToolDefinitions() {
+        const tools = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getToolDefinitions) {
+                const defs = mod.getToolDefinitions();
+                if (defs)
+                    tools.push(...defs);
+            }
+        }
+        return tools;
+    }
+    collectPlugins() {
+        const plugins = [];
+        for (const mod of this.modules.values()) {
+            if (mod.getPlugin) {
+                const plugin = mod.getPlugin();
+                if (plugin)
+                    plugins.push(plugin);
+            }
+        }
+        return plugins;
+    }
+}

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

@@ -0,0 +1,116 @@
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import { globalAuditNotifier } from "./audit-notifier";
+/**
+ * Directory and file path for audit logs
+ */
+const AUDIT_LOG_DIR = resolve(homedir(), ".mma", "logs");
+const AUDIT_LOG_PATH = resolve(AUDIT_LOG_DIR, "audit.jsonl");
+/**
+ * Ensure audit log directory exists
+ */
+function ensureAuditLogDir() {
+    if (!existsSync(AUDIT_LOG_DIR)) {
+        mkdirSync(AUDIT_LOG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Write an audit log entry
+ */
+export function logAudit(entry) {
+    ensureAuditLogDir();
+    try {
+        const logEntry = JSON.stringify(entry);
+        appendFileSync(AUDIT_LOG_PATH, logEntry + "\n", "utf8");
+    }
+    catch {
+        // Silently fail if we can't write to audit log
+        // This shouldn't break the agent
+    }
+    // Notify audit notifier if enabled
+    try {
+        globalAuditNotifier.notify(entry);
+    }
+    catch {
+        // Silently fail if notification fails
+    }
+}
+/**
+ * Log a tool call
+ */
+export function logToolCall(sessionId, tool, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "tool_call",
+        tool,
+        success,
+        details,
+    });
+}
+/**
+ * Log a file write operation
+ */
+export function logFileWrite(sessionId, path, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "file_write",
+        path,
+        success,
+        details,
+    });
+}
+/**
+ * Log a file delete operation
+ */
+export function logFileDelete(sessionId, path, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "file_delete",
+        path,
+        success,
+        details,
+    });
+}
+/**
+ * Log a bash command execution
+ */
+export function logBashCommand(sessionId, command, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "bash_command",
+        command,
+        success,
+        details,
+    });
+}
+/**
+ * Log a network request
+ */
+export function logNetworkRequest(sessionId, url, success, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "network_request",
+        url,
+        success,
+        details,
+    });
+}
+/**
+ * Log a security block event
+ */
+export function logSecurityBlock(sessionId, action, reason, details) {
+    logAudit({
+        timestamp: new Date().toISOString(),
+        sessionId,
+        action: "security_block",
+        success: false,
+        reason,
+        details,
+    });
+}