micro-models-agent 0.51.1 → 0.52.0

package/dist/modules/browser/session.js

@@ -186,6 +186,10 @@ export class BrowserSession {
     async open(url) {
         if (!url)
             return { success: false, output: t("browser.url_required") };
+        // Security: block dangerous schemes (file:, chrome:, about:, data:).
+        if (/^(file|chrome|about|data|javascript|view-source):/i.test(url)) {
+            return { success: false, output: `[SECURITY BLOCKED] scheme not allowed: ${url}` };
+        }
         if (!url.startsWith("http://") && !url.startsWith("https://") && !url.startsWith("file://")) {
             const isLocalhost = /^(localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?$/i.test(url);
             url = isLocalhost ? "http://" + url : "https://" + url;

package/dist/modules/certification/cli.js

@@ -1,5 +1,4 @@
-import { rmSync } from "fs";
-import { homedir } from "os";
+import { rmSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { existsSync, readFileSync } from "fs";
@@ -7,10 +6,9 @@ import { t } from "../../i18n/index";
 import { pc } from "../../ui/colors";
 import { loadScenarios, filterByTags } from "./loader";
 import { runScenario, findMmaRoot } from "./runner";
-import { readManifest, upsertCertification, removeCertification } from "./manifest";
+import { readManifest, upsertCertification, removeCertification, isFullyPassed } from "./manifest";
 const HERE = dirname(fileURLToPath(import.meta.url));
 const MMA_ROOT = findMmaRoot(HERE);
-const USER_SCENARIO_DIR = join(homedir(), ".mma", "certification", "scenarios");
 function readVersion() {
     const candidates = [join(MMA_ROOT, "package.json")];
     for (const p of candidates) {
@@ -35,12 +33,7 @@ export function parseTags(s) {
 }
 export async function certify(opts) {
     const providerUrl = opts.providerUrl || opts.config.provider.baseUrl;
-    if (opts.tags.includes("security") && !opts.config.security?.enabled) {
-        console.error(pc.red(t("cli.cert_security_required")));
-        process.exitCode = 1;
-        return;
-    }
-    const { scenarios, errors } = loadScenarios(USER_SCENARIO_DIR);
+    const { scenarios, errors } = loadScenarios(join(opts.projectDir, ".mma", "certification", "scenarios"));
     for (const e of errors)
         console.error(pc.yellow(`  ${e}`));
     const selected = filterByTags(scenarios, opts.tags);
@@ -49,7 +42,7 @@ export async function certify(opts) {
         process.exitCode = 1;
         return;
     }
-    const manifest = readManifest();
+    const manifest = readManifest(opts.projectDir);
     const existing = manifest.certifications.find((e) => e.model === opts.name && e.providerUrl === providerUrl);
     if (existing && !opts.force) {
         console.error(pc.yellow(t("cli.cert_exists", { model: opts.name })));
@@ -84,6 +77,7 @@ export async function certify(opts) {
             sandboxBase,
             defaultReps: opts.reps,
             defaultThreshold: 2,
+            baseConfig: opts.config,
             onRep: (id, rep, reps, passed, failures) => {
                 const word = passed ? pc.green(t("cli.cert_rep_pass")) : pc.red(t("cli.cert_rep_fail"));
                 console.log(`[${idx}/${total}] ${id} (${rep}/${reps})... ${word}`);
@@ -110,7 +104,7 @@ export async function certify(opts) {
         suite,
         results,
     };
-    upsertCertification(entry);
+    upsertCertification(entry, opts.projectDir);
     console.log(t("cli.cert_done", {
         passed: String(suite.passed),
         failed: String(suite.failed),
@@ -118,9 +112,17 @@ export async function certify(opts) {
         total: String(suite.total),
     }));
     printResults(results);
+    if (isFullyPassed(entry)) {
+        console.log(pc.green(`\n✔ ${opts.name} is certified`));
+    }
+    else {
+        console.log(pc.yellow(`\n⚠ ${opts.name} is NOT certified — all scenarios must pass`));
+    }
+    // Always write report file
+    writeReport(entry, opts.projectDir);
 }
-export async function certStatus(name, config) {
-    const m = readManifest();
+export async function certStatus(name, config, projectDir) {
+    const m = readManifest(projectDir);
     const providerUrl = config.provider.baseUrl;
     const entry = m.certifications.find((e) => e.model === name && e.providerUrl === providerUrl);
     if (!entry) {
@@ -130,20 +132,25 @@ export async function certStatus(name, config) {
     console.log(`${t("cli.cert_provider_col")}: ${entry.providerUrl}`);
     console.log(`${t("cli.cert_version_col")}: ${entry.mmaVersion}  ${t("cli.cert_date_col")}: ${entry.certifiedAt.slice(0, 10)}`);
     console.log(`${t("cli.cert_suite_col")}: ${entry.suite.passed} pass / ${entry.suite.failed} fail / ${entry.suite.skipped} skipped`);
+    const status = isFullyPassed(entry)
+        ? pc.green("✔ certified")
+        : pc.yellow("⚠ NOT certified");
+    console.log(`Status: ${status}`);
     printResults(entry.results);
 }
-export async function certList() {
-    const m = readManifest();
+export async function certList(projectDir) {
+    const m = readManifest(projectDir);
     if (m.certifications.length === 0) {
         console.log(t("cli.cert_empty"));
         return;
     }
     for (const e of m.certifications) {
-        console.log(`  ${pc.green("✔")} ${e.model}  ${pc.dim(e.providerUrl)}  ${e.mmaVersion}  ${e.certifiedAt.slice(0, 10)}  ${e.suite.passed}/${e.suite.total} pass`);
+        const mark = isFullyPassed(e) ? pc.green("✔") : pc.red("✘");
+        console.log(`  ${mark} ${e.model}  ${pc.dim(e.providerUrl)}  ${e.mmaVersion}  ${e.certifiedAt.slice(0, 10)}  ${e.suite.passed}/${e.suite.total} pass`);
     }
 }
-export async function uncertify(name, config) {
-    const removed = removeCertification(name, config.provider.baseUrl);
+export async function uncertify(name, config, projectDir) {
+    const removed = removeCertification(name, config.provider.baseUrl, projectDir);
     if (removed)
         console.log(t("cli.cert_uncertified", { model: name }));
     else
@@ -170,5 +177,37 @@ function printResults(results) {
         console.log(`  ${icon} ${r.id}  ${detail}`);
         if (r.error)
             console.log(`    ${pc.dim(r.error)}`);
+        if (r.diagnostics)
+            console.log(r.diagnostics);
+    }
+}
+function writeReport(entry, projectDir) {
+    const reportDir = join(projectDir, "certification");
+    const ts = entry.certifiedAt.replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `report-${entry.model.replace(/[/\\:]/g, "_")}-${ts}.json`;
+    const reportPath = join(reportDir, filename);
+    const report = {
+        model: entry.model,
+        providerUrl: entry.providerUrl,
+        mmaVersion: entry.mmaVersion,
+        certifiedAt: entry.certifiedAt,
+        certified: isFullyPassed(entry),
+        suite: entry.suite,
+        results: entry.results.map((r) => ({
+            id: r.id,
+            title: r.title,
+            status: r.status,
+            passed: r.passed,
+            of: r.of,
+            error: r.error,
+            diagnostics: r.diagnostics,
+        })),
+    };
+    try {
+        writeFileSync(reportPath, JSON.stringify(report, null, 2), "utf-8");
+        console.log(pc.dim(`\nReport: ${reportPath}`));
+    }
+    catch (e) {
+        console.error(pc.yellow(`  Failed to write report: ${e.message}`));
     }
 }

package/dist/modules/certification/loader.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, readFileSync } from "fs";
 import { join } from "path";
 import { parse as parseYaml } from "yaml";
 import { BUILTIN_SCENARIOS } from "./scenarios";
-const TAGS = ["core", "security", "image", "network", "browser"];
+const TAGS = ["core", "security", "image", "network", "browser", "moe"];
 const CHECK_TYPES = [
     "fileExists",
     "fileNotExists",
@@ -95,6 +95,7 @@ function normalizeScenario(data, file) {
         fixtures: Array.isArray(d.fixtures) ? d.fixtures : undefined,
         checks: Array.isArray(d.checks) ? d.checks : [],
         skipReason: typeof d.skipReason === "string" ? d.skipReason : undefined,
+        config: typeof d.config === "object" && d.config !== null ? d.config : undefined,
     };
 }
 export function filterByTags(scenarios, tags) {

package/dist/modules/certification/manifest.js

@@ -1,8 +1,10 @@
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { join } from "path";
-export const MANIFEST_PATH = join(homedir(), ".mma", "certifications.json");
-export function readManifest(path = MANIFEST_PATH) {
+export function manifestPath(projectDir) {
+    return join(projectDir, "certification", "certifications.json");
+}
+export function readManifest(projectDir) {
+    const path = manifestPath(projectDir);
     try {
         if (existsSync(path)) {
             const raw = JSON.parse(readFileSync(path, "utf-8"));
@@ -14,26 +16,27 @@ export function readManifest(path = MANIFEST_PATH) {
     }
     return { version: 1, certifications: [] };
 }
-export function saveManifest(m, path = MANIFEST_PATH) {
-    mkdirSync(join(homedir(), ".mma"), { recursive: true });
+export function saveManifest(m, projectDir) {
+    const path = manifestPath(projectDir);
+    mkdirSync(join(projectDir, "certification"), { recursive: true });
     writeFileSync(path, JSON.stringify(m, null, 2), "utf-8");
 }
-export function upsertCertification(entry, path = MANIFEST_PATH) {
-    const m = readManifest(path);
+export function upsertCertification(entry, projectDir) {
+    const m = readManifest(projectDir);
     const idx = m.certifications.findIndex((e) => e.model === entry.model && e.providerUrl === entry.providerUrl);
     if (idx >= 0)
         m.certifications[idx] = entry;
     else
         m.certifications.push(entry);
-    saveManifest(m, path);
+    saveManifest(m, projectDir);
     return m;
 }
-export function removeCertification(model, providerUrl, path = MANIFEST_PATH) {
-    const m = readManifest(path);
+export function removeCertification(model, providerUrl, projectDir) {
+    const m = readManifest(projectDir);
     const before = m.certifications.length;
     m.certifications = m.certifications.filter((e) => !(e.model === model && e.providerUrl === providerUrl));
     if (m.certifications.length !== before) {
-        saveManifest(m, path);
+        saveManifest(m, projectDir);
         return true;
     }
     return false;
@@ -41,10 +44,15 @@ export function removeCertification(model, providerUrl, path = MANIFEST_PATH) {
 export function isStale(entry, currentVersion) {
     return entry.mmaVersion !== currentVersion;
 }
-export function getCertMark(model, providerUrl, currentVersion, path = MANIFEST_PATH) {
-    const m = readManifest(path);
+export function isFullyPassed(entry) {
+    return entry.suite.failed === 0 && entry.suite.passed > 0;
+}
+export function getCertMark(model, providerUrl, currentVersion, projectDir) {
+    const m = readManifest(projectDir);
     const entry = m.certifications.find((e) => e.model === model && e.providerUrl === providerUrl);
     if (!entry)
         return "none";
-    return isStale(entry, currentVersion) ? "stale" : "certified";
+    if (isStale(entry, currentVersion))
+        return "stale";
+    return isFullyPassed(entry) ? "certified" : "none";
 }

package/dist/modules/certification/runner.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
-import { existsSync, mkdirSync, rmSync, cpSync } from "fs";
+import { existsSync, mkdirSync, rmSync, cpSync, writeFileSync, readdirSync, readFileSync } from "fs";
 import { platform } from "os";
-import { join, resolve, dirname } from "path";
+import { join, resolve, dirname, relative } from "path";
 import { checkSandbox } from "./fact-checker";
 export async function runScenario(scenario, opts) {
     if (scenario.mode === "skip") {
@@ -16,10 +16,11 @@ export async function runScenario(scenario, opts) {
     const reps = scenario.reps ?? opts.defaultReps;
     const threshold = Math.min(scenario.passThreshold ?? opts.defaultThreshold, reps);
     const runner = opts.runner ?? defaultRunner;
-    const timeoutMs = opts.timeoutMs ?? 120_000;
+    const timeoutMs = opts.timeoutMs ?? 300_000;
     const entryPoint = resolveMmaEntry(opts.mmaRoot);
     let passed = 0;
     let firstError;
+    let lastFailedSandbox;
     for (let i = 1; i <= reps; i++) {
         const sandbox = join(opts.sandboxBase, `run-${scenario.id}-${i}`);
         let failures = [];
@@ -43,6 +44,14 @@ export async function runScenario(scenario, opts) {
             };
             if (opts.providerKey)
                 env.MMA_PROVIDER_APIKEY = opts.providerKey;
+            // Write cert-specific config if scenario declares overrides
+            if (scenario.config && opts.baseConfig) {
+                const merged = deepMergeAny(opts.baseConfig, scenario.config);
+                const certConfigDir = join(sandbox, ".mma");
+                mkdirSync(certConfigDir, { recursive: true });
+                writeFileSync(join(certConfigDir, "config.json"), JSON.stringify(merged, null, 2), "utf-8");
+                env.MMA_CONFIG_DIR = certConfigDir;
+            }
             const res = await runner(env, opts.mmaRoot, args, timeoutMs);
             output = `${res.stdout}\n${res.stderr}`;
             exitCode = res.code ?? -1;
@@ -64,11 +73,17 @@ export async function runScenario(scenario, opts) {
         const pass = failures.length === 0;
         if (pass)
             passed++;
-        else if (!firstError)
-            firstError = failures.join("; ");
+        else {
+            if (!firstError)
+                firstError = failures.join("; ");
+            lastFailedSandbox = sandbox;
+        }
         opts.onRep?.(scenario.id, i, reps, pass, failures);
     }
     const status = passed >= threshold ? "pass" : "fail";
+    const diagnostics = status === "fail" && lastFailedSandbox
+        ? collectDiagnostics(lastFailedSandbox)
+        : undefined;
     return {
         id: scenario.id,
         title: scenario.title,
@@ -76,6 +91,7 @@ export async function runScenario(scenario, opts) {
         passed,
         of: reps,
         error: status === "pass" ? undefined : firstError,
+        diagnostics,
     };
 }
 function prepareSandbox(sandbox, scenario, mmaRoot) {
@@ -91,6 +107,57 @@ function prepareSandbox(sandbox, scenario, mmaRoot) {
         cpSync(src, dest);
     }
 }
+/** Collect diagnostic info from a failed sandbox for actionable feedback. */
+export function collectDiagnostics(sandbox) {
+    const lines = [];
+    // List user-created files (skip .mma internals)
+    const files = listFiles(sandbox, sandbox);
+    if (files.length > 0) {
+        lines.push(`  Files created: ${files.join(", ")}`);
+    }
+    else {
+        lines.push("  Files created: (none)");
+    }
+    // Read active plan if present
+    const planPath = join(sandbox, ".mma", "plans", "active.json");
+    if (existsSync(planPath)) {
+        try {
+            const plan = JSON.parse(readFileSync(planPath, "utf-8"));
+            const steps = plan.steps ?? [];
+            const done = steps.filter((s) => s.status === "done").length;
+            const pending = steps.filter((s) => s.status === "pending" || s.status === "in_progress");
+            lines.push(`  Plan: ${done}/${steps.length} steps done`);
+            if (pending.length > 0) {
+                lines.push(`  Pending: ${pending.map((s) => `#${s.id} ${s.description}`).join("; ")}`);
+            }
+        }
+        catch {
+            /* corrupt plan — skip */
+        }
+    }
+    return lines.join("\n");
+}
+function listFiles(dir, root) {
+    const result = [];
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name === ".mma")
+                continue;
+            const abs = join(dir, entry.name);
+            const rel = relative(root, abs).replace(/\\/g, "/");
+            if (entry.isDirectory()) {
+                result.push(...listFiles(abs, root));
+            }
+            else {
+                result.push(rel);
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return result;
+}
 export function resolveMmaEntry(mmaRoot) {
     const dev = join(mmaRoot, "src", "cli", "main.ts");
     if (existsSync(dev))
@@ -157,3 +224,22 @@ function killTree(child) {
         }
     }
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deepMergeAny(target, source) {
+    if (!source || typeof source !== "object")
+        return source;
+    if (!target || typeof target !== "object")
+        return source;
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const sv = source[key];
+        const tv = result[key];
+        if (sv && typeof sv === "object" && !Array.isArray(sv) && tv && typeof tv === "object" && !Array.isArray(tv)) {
+            result[key] = deepMergeAny(tv, sv);
+        }
+        else {
+            result[key] = sv;
+        }
+    }
+    return result;
+}