micro-models-agent 0.51.1 → 0.52.0

package/dist/core/environment.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { arch, homedir, hostname, platform, release } from "os";
+import { env } from "process";
+import { readMmaVersion } from "./version";
+import { sanitizeUrl } from "../modules/security/network-validator";
+import { t } from "../i18n/index";
+/** Tools probed for availability on PATH (real executables only — no .cmd shims). */
+const TOOL_CHECKS = ["bun", "node", "git", "python"];
+function readEngineRequirement() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(p, "utf8"));
+            if (raw.engines?.node)
+                return String(raw.engines.node);
+        }
+        catch {
+            // Broken package.json — fall through
+        }
+    }
+    return ">=20";
+}
+/** Numeric tuple comparison: does `version` meet the minimum in `requirement` (e.g. `>=20`)? */
+export function satisfiesMinimum(version, requirement) {
+    const minMatch = requirement.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!minMatch)
+        return true;
+    const min = [
+        parseInt(minMatch[1], 10),
+        minMatch[2] ? parseInt(minMatch[2], 10) : 0,
+        minMatch[3] ? parseInt(minMatch[3], 10) : 0,
+    ];
+    const parts = version.replace(/^v/i, "").split(".");
+    const got = [
+        parts[0] ? parseInt(parts[0], 10) : 0,
+        parts[1] ? parseInt(parts[1], 10) : 0,
+        parts[2] ? parseInt(parts[2], 10) : 0,
+    ];
+    for (let i = 0; i < 3; i++) {
+        if (got[i] > min[i])
+            return true;
+        if (got[i] < min[i])
+            return false;
+    }
+    return true;
+}
+export function detectRuntime() {
+    const bun = globalThis.Bun;
+    const isBun = typeof bun !== "undefined" && typeof bun?.version !== "undefined";
+    const engine = readEngineRequirement();
+    const runtime = isBun ? "bun" : "node";
+    const runtimeVersion = isBun ? String(bun.version) : process.version;
+    return {
+        runtime,
+        runtimeVersion,
+        nodeVersion: process.version,
+        engine,
+        // engines.node applies to the Node runtime. Bun satisfies it through its
+        // embedded Node (process.version) — never compare the Bun version itself
+        // against a Node requirement (Bun 1.x would always look "too old").
+        engineOk: satisfiesMinimum(process.version, engine),
+    };
+}
+function toolVersion(cmd) {
+    try {
+        const res = spawnSync(cmd, ["--version"], {
+            encoding: "utf8",
+            timeout: 3000,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (res.error || res.status !== 0)
+            return "missing";
+        const out = ((res.stdout || "") + (res.stderr || "")).trim();
+        return out.split(/\r?\n/)[0].slice(0, 40) || "ok";
+    }
+    catch {
+        return "missing";
+    }
+}
+/** Where Playwright keeps downloaded browser binaries (env override wins). */
+export function playwrightBrowsersDir() {
+    if (process.env.PLAYWRIGHT_BROWSERS_PATH)
+        return process.env.PLAYWRIGHT_BROWSERS_PATH;
+    return process.platform === "win32"
+        ? join(homedir(), "AppData", "Local", "ms-playwright")
+        : join(homedir(), ".cache", "ms-playwright");
+}
+/** Playwright package presence/version + whether browser binaries are downloaded. */
+export function playwrightInfo() {
+    let installed = false;
+    let version = "";
+    const browsersDir = playwrightBrowsersDir();
+    try {
+        // Rule #12: resolve from disk at runtime — works in both src/ and dist/
+        // layouts, and under both Bun and Node (the bridge uses createRequire too).
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("playwright/package.json");
+        installed = existsSync(pkgPath);
+        version = JSON.parse(readFileSync(pkgPath, "utf8")).version || "";
+    }
+    catch {
+        installed = false;
+    }
+    let browsersInstalled = false;
+    try {
+        if (existsSync(browsersDir)) {
+            browsersInstalled = readdirSync(browsersDir).some((d) => /chrom/i.test(d));
+        }
+    }
+    catch {
+        browsersInstalled = false;
+    }
+    return { installed, version, browsersDir, browsersInstalled };
+}
+/** Pure requirements check — produces warnings from a report (no side effects). */
+export function checkEnvironmentRequirements(report) {
+    const warnings = [];
+    if (report.runtime.runtime === "node") {
+        warnings.push(t("env.runtime_node", { version: report.runtime.nodeVersion }));
+    }
+    if (!report.runtime.engineOk) {
+        warnings.push(t("env.runtime_old", {
+            version: report.runtime.nodeVersion,
+            engine: report.runtime.engine,
+        }));
+    }
+    if (report.tools.bun === "missing") {
+        warnings.push(t("env.tool_missing", { tool: "bun" }));
+    }
+    if (report.tools.git === "missing") {
+        warnings.push(t("env.tool_missing", { tool: "git" }));
+    }
+    if (report.features.browser && report.playwright) {
+        if (!report.playwright.installed) {
+            warnings.push(t("env.playwright_missing"));
+        }
+        else if (!report.playwright.browsersInstalled) {
+            warnings.push(t("env.playwright_browsers_missing", { dir: report.playwright.browsersDir }));
+        }
+    }
+    return warnings;
+}
+export function collectEnvironment(opts) {
+    const runtime = detectRuntime();
+    const tools = {};
+    if (opts.scanTools) {
+        for (const tool of TOOL_CHECKS)
+            tools[tool] = toolVersion(tool);
+    }
+    const provider = opts.config
+        ? {
+            model: opts.config.model,
+            baseUrl: sanitizeUrl(opts.config.provider?.baseUrl || ""),
+            contextWindow: opts.config.contextWindow,
+            retry: {
+                maxRetries: opts.config.retry?.maxRetries ?? 0,
+                baseDelay: opts.config.retry?.baseDelay ?? 0,
+                maxDelay: opts.config.retry?.maxDelay ?? 0,
+                maxStreamRetries: opts.config.retry?.maxStreamRetries ?? 0,
+                noDataTimeoutMs: opts.config.retry?.noDataTimeoutMs ?? 0,
+            },
+        }
+        : null;
+    const report = {
+        ts: new Date().toISOString(),
+        mmaVersion: readMmaVersion(),
+        runtime,
+        os: {
+            platform: platform(),
+            arch: arch(),
+            release: release(),
+            hostname: hostname(),
+            shell: env.SHELL || env.ComSpec || "unknown",
+            home: homedir(),
+            cwd: process.cwd(),
+        },
+        paths: { configDir: opts.configDir, baseDir: opts.baseDir || process.cwd() },
+        tools,
+        provider,
+        features: { browser: Boolean(opts.config?.browser?.enabled) },
+        playwright: playwrightInfo(),
+        warnings: [],
+    };
+    report.warnings = checkEnvironmentRequirements(report);
+    return report;
+}
+/** Compact human line + full structured report into the JSONL log. */
+export function logEnvironment(report, logger) {
+    logger.info(`Environment: ${report.os.platform} ${report.os.arch} | ${report.runtime.runtime} ${report.runtime.runtimeVersion} (node ${report.runtime.nodeVersion}) | mma ${report.mmaVersion} | ${report.provider?.model ?? "no provider"}`);
+    logger.logStructured("environment", report);
+}

package/dist/core/session-logger.js

@@ -1,4 +1,7 @@
 import { setAuditSessionDir } from "../modules/security/audit-log";
+import { sanitizeLogMessage } from "../modules/security/data-sanitizer";
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
 /**
  * Thin wrapper around SessionManager that eliminates repetitive
  * `if (sessionManager)` + `new Date().toISOString()` boilerplate
@@ -9,9 +12,11 @@ import { setAuditSessionDir } from "../modules/security/audit-log";
  */
 export class SessionLogger {
     session;
+    getCaller;
     logger;
-    constructor(session, logger) {
+    constructor(session, logger, getCaller) {
         this.session = session;
+        this.getCaller = getCaller;
         this.logger = logger;
         this.bindSessionDir();
     }
@@ -37,24 +42,28 @@ export class SessionLogger {
         });
     }
     logUser(content) {
+        const sanitized = sanitizeLogMessage(content);
         this.session?.appendMessage({
             role: "user",
-            content,
+            content: sanitized,
             timestamp: new Date().toISOString(),
         });
         this.session?.appendLog({
             ts: new Date().toISOString(),
             type: "user",
-            content,
+            content: sanitized,
         });
     }
     logAssistant(content, reasoning, toolCalls, iteration) {
+        const caller = this.getCaller?.();
         if (reasoning) {
             this.session?.appendLog({
                 ts: new Date().toISOString(),
                 type: "reasoning",
                 content: reasoning,
                 iteration,
+                provider: caller?.provider,
+                model: caller?.model,
             });
         }
         this.session?.appendLog({
@@ -71,13 +80,18 @@ export class SessionLogger {
                 }
                 : {}),
             iteration,
+            provider: caller?.provider,
+            model: caller?.model,
         });
     }
     saveAssistantMessage(content) {
+        const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "assistant",
             content: content.slice(0, 500),
             timestamp: new Date().toISOString(),
+            provider: caller?.provider,
+            model: caller?.model,
         });
     }
     logToolDefs(toolCount, toolNames, iteration) {
@@ -95,16 +109,19 @@ export class SessionLogger {
             type: "tool_call",
             tool: call.name,
             tool_call_id: call.id,
-            args: call.arguments,
+            args: JSON.parse(sanitizeLogMessage(JSON.stringify(call.arguments))),
             iteration,
         });
     }
     logToolResult(call, result, duration, iteration) {
+        const caller = this.getCaller?.();
         this.session?.appendMessage({
             role: "tool",
-            content: result.output.slice(0, 500),
+            content: sanitizeLogMessage(result.output.slice(0, 500)),
             name: call.name,
             timestamp: new Date().toISOString(),
+            provider: caller?.provider,
+            model: caller?.model,
         });
         this.session?.appendLog({
             ts: new Date().toISOString(),
@@ -112,10 +129,12 @@ export class SessionLogger {
             tool: call.name,
             tool_call_id: call.id,
             success: result.success,
-            content: result.output.slice(0, 1000),
+            content: sanitizeLogMessage(result.output.slice(0, 1000)),
             diff: result.diff,
             duration,
             iteration,
+            provider: caller?.provider,
+            model: caller?.model,
         });
     }
     logCompaction(info) {
@@ -144,6 +163,8 @@ export class SessionLogger {
                 ? "context snapshot at session start"
                 : `context at iteration ${info.iteration}`,
             iteration: info.iteration,
+            provider: info.provider,
+            model: info.model,
             window: info.window,
             systemBudget: info.systemBudget,
             reserveBudget: info.reserveBudget,
@@ -163,6 +184,8 @@ export class SessionLogger {
             ts: new Date().toISOString(),
             type: "llm_usage",
             iteration,
+            provider: usage.provider,
+            model: usage.model,
             promptTokens: usage.promptTokens,
             completionTokens: usage.completionTokens,
             totalTokens: usage.totalTokens,
@@ -194,4 +217,35 @@ export class SessionLogger {
             ...(iteration !== undefined ? { iteration } : {}),
         });
     }
+    /**
+     * Log session startup diagnostics: environment, LSP probe, plugins, skills.
+     * Should be the FIRST entry in session.jsonl so the file is self-describing.
+     * Skips if a session_start entry already exists (e.g. logged by REPL).
+     */
+    logSessionStart(data) {
+        // Skip if session_start already logged (REPL may have logged it with LSP probe)
+        const meta = this.session?.getActiveMeta();
+        if (meta) {
+            const logPath = join(this.session.getSessionDirectory(meta.id), "session.jsonl");
+            try {
+                if (existsSync(logPath)) {
+                    const content = readFileSync(logPath, "utf-8");
+                    if (content.includes('"type":"session_start"'))
+                        return;
+                }
+            }
+            catch {
+                // File read error — proceed to write
+            }
+        }
+        this.session?.appendLog({
+            ts: new Date().toISOString(),
+            type: "session_start",
+            content: "session started",
+            environment: data.environment,
+            lspProbe: data.lspProbe,
+            plugins: data.plugins,
+            skills: data.skills,
+        });
+    }
 }

package/dist/core/version.js

@@ -22,3 +22,5 @@ export function readMmaVersion() {
     }
     return "0.0.0";
 }
+/** Legacy alias — use readMmaVersion(). */
+export const readVersion = readMmaVersion;