micro-models-agent 0.51.2 → 0.52.0

package/dist/migration/backup.js

@@ -0,0 +1,45 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { t } from "../i18n/index";
+export class BackupManager {
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
+    }
+    backupConfig() {
+        const configPath = join(this.configDir, "config.json");
+        if (!existsSync(configPath))
+            return;
+        const bakPath = join(this.configDir, "config.json.bak");
+        copyFileSync(configPath, bakPath);
+    }
+    backupAll() {
+        const bakDir = this.configDir + ".bak";
+        if (existsSync(bakDir))
+            return;
+        if (existsSync(this.configDir)) {
+            cpSync(this.configDir, bakDir, { recursive: true });
+        }
+    }
+    writeFreshConfig(config) {
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+        writeFileSync(join(this.configDir, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+    }
+    getBackupSummary() {
+        const lines = [];
+        const bakConfig = join(this.configDir, "config.json.bak");
+        const bakDir = this.configDir + ".bak";
+        if (existsSync(bakConfig)) {
+            lines.push(t("migration.config_bak"));
+        }
+        if (existsSync(bakDir)) {
+            const files = readdirSync(bakDir);
+            lines.push(t("migration.dir_bak", { count: files.length }));
+        }
+        return lines.length > 0
+            ? `${t("migration.migrated")}\n${lines.join("\n")}`
+            : t("migration.not_needed");
+    }
+}

package/dist/migration/detect.js

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+const V1_ONLY_FIELDS = ["apiBase", "apiKey", "chatEndpoint", "temperature", "maxTokens"];
+export class MigrationDetector {
+    configDir;
+    constructor(configDir) {
+        this.configDir = configDir;
+    }
+    needsMigration() {
+        const configPath = join(this.configDir, "config.json");
+        if (!existsSync(configPath))
+            return false;
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            const config = JSON.parse(content);
+            if (config.version && config.version.startsWith("2."))
+                return false;
+            for (const field of V1_ONLY_FIELDS) {
+                if (field in config)
+                    return true;
+            }
+            const v2Required = ["provider", "contextWindow", "contextBudget"];
+            const hasAllV2Fields = v2Required.every((f) => f in config);
+            if (!hasAllV2Fields)
+                return true;
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    hasOldSessions() {
+        const sessionsDir = join(this.configDir, "sessions");
+        if (!existsSync(sessionsDir))
+            return false;
+        return readdirSync(sessionsDir).length > 0;
+    }
+    hasOldProfile() {
+        const profilePath = join(this.configDir, "profile.json");
+        if (!existsSync(profilePath))
+            return false;
+        try {
+            const profile = JSON.parse(readFileSync(profilePath, "utf-8"));
+            return !profile.platform && !profile.os;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/migration/index.js

@@ -0,0 +1,2 @@
+export { MigrationDetector } from "./detect";
+export { BackupManager } from "./backup";

package/dist/modules/artifacts/store.js

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve, relative, isAbsolute } from "node:path";
+export class ArtifactStore {
+    root;
+    constructor(opts) {
+        const artifactsDir = opts.artifactsDir || ".mma/artifacts";
+        this.root = resolve(opts.baseDir, artifactsDir, opts.sessionId);
+    }
+    /** Normalize to [a-zA-Z0-9._-]; never empty, never "." or "..". */
+    static sanitizeName(name) {
+        // Strip traversal prefixes so "../../etc/passwd" becomes "etc_passwd",
+        // never ".._.._etc_passwd".
+        const stripped = name.replace(/^(\.\.?[\\/])+/g, "").replace(/^\.{1,2}$/, "");
+        const cleaned = stripped
+            .replace(/[^a-zA-Z0-9._-]/g, "_")
+            .replace(/_{2,}/g, "_")
+            .replace(/^_+|_+$/g, "");
+        if (cleaned === "" || cleaned === "." || cleaned === "..") {
+            return "artifact";
+        }
+        return cleaned;
+    }
+    /** True when `candidate` is strictly inside (or equal to) `root`. */
+    static isInside(root, candidate) {
+        const rel = relative(root, candidate);
+        if (rel === "")
+            return true;
+        return !rel.startsWith("..") && !isAbsolute(rel);
+    }
+    /**
+     * Persist content to <root>/<name>.<ext> and return the absolute path.
+     * Throws if the resolved path escapes root (defense in depth — sanitizeName already removes separators).
+     */
+    save(name, content, ext = "md") {
+        const safe = ArtifactStore.sanitizeName(name);
+        const dir = resolve(this.root);
+        mkdirSync(dir, { recursive: true });
+        const abs = resolve(dir, `${safe}.${ext}`);
+        if (!ArtifactStore.isInside(dir, abs)) {
+            throw new Error(`Artifact path escapes root: ${abs}`);
+        }
+        writeFileSync(abs, content, "utf8");
+        return abs;
+    }
+    /** Read an artifact by its file name (relative to root); null when outside the root or missing. */
+    read(path) {
+        const abs = resolve(this.root, path);
+        if (!ArtifactStore.isInside(this.root, abs))
+            return null;
+        if (!existsSync(abs))
+            return null;
+        return readFileSync(abs, "utf8");
+    }
+    /** First maxChars chars (trimmed) + truncation marker. */
+    summary(content, maxChars) {
+        if (content.length <= maxChars)
+            return content;
+        const head = content.slice(0, maxChars).trimEnd();
+        return `${head}\n…[truncated: ${content.length - maxChars} chars]`;
+    }
+}

package/dist/modules/browser/actions.js

@@ -0,0 +1,76 @@
+export function buildClickScript(elementIndex) {
+    return `
+    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
+    if (!el) throw new Error('Element not found: ${elementIndex}');
+    el.click();
+  `;
+}
+export function buildTypeScript(elementIndex, text) {
+    const escaped = JSON.stringify(text);
+    return `
+    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
+    if (!el) throw new Error('Element not found: ${elementIndex}');
+    const text = JSON.parse(${JSON.stringify(escaped)});
+    el.focus();
+    el.value = text;
+    el.dispatchEvent(new Event('input', { bubbles: true }));
+    el.dispatchEvent(new Event('change', { bubbles: true }));
+  `;
+}
+export function buildScrollScript(direction) {
+    switch (direction) {
+        case "down":
+            return `window.scrollBy({ top: 600, behavior: 'smooth' })`;
+        case "up":
+            return `window.scrollBy({ top: -600, behavior: 'smooth' })`;
+        case "top":
+            return `window.scrollTo({ top: 0, behavior: 'smooth' })`;
+        case "bottom":
+            return `window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' })`;
+    }
+}
+export function buildWaitScript(timeoutMs) {
+    return `await new Promise(r => setTimeout(r, ${timeoutMs}))`;
+}
+export function buildIndexInjectionScript() {
+    return `
+    const selectors = 'a[href], button, input, textarea, select, [role="button"], [role="link"], [role="textbox"], [role="checkbox"], [role="radio"], [contenteditable="true"]';
+    const elements = document.querySelectorAll(selectors);
+    let idx = 1;
+    elements.forEach(el => {
+      const style = window.getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden') return;
+      el.setAttribute('data-browser-index', String(idx++));
+    });
+  `;
+}
+export function buildTextExtractionScript() {
+    return `
+    const contentTags = new Set(['h1','h2','h3','h4','h5','h6','p','li','article','main','section','blockquote','pre','td','th','dt','dd','figcaption']);
+    const out = [];
+    const seen = new Set();
+    const isHidden = (el) => {
+      const st = window.getComputedStyle(el);
+      return st.display === 'none' || st.visibility === 'hidden';
+    };
+    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
+      acceptNode: (node) => {
+        const tag = node.tagName ? node.tagName.toLowerCase() : '';
+        if (!contentTags.has(tag)) return NodeFilter.FILTER_SKIP;
+        if (isHidden(node)) return NodeFilter.FILTER_REJECT;
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    });
+    let node;
+    while ((node = walker.nextNode())) {
+      const tag = node.tagName.toLowerCase();
+      const text = (node.textContent || '').replace(/\\s+/g, ' ').trim();
+      if (!text) continue;
+      if (seen.has(text)) continue;
+      seen.add(text);
+      const line = text.length > 200 ? text.slice(0, 200) + '…' : text;
+      out.push('[' + tag + '] ' + line);
+    }
+    return out.join('\\n');
+  `;
+}

package/dist/modules/browser/bridge-client.js

@@ -0,0 +1,199 @@
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { ConsoleBuffer } from "./session";
+import { pickExistingPath } from "./bridge-path";
+const BRIDGE_REQUEST_TIMEOUT_MS = 30000;
+function bridgeScriptPath() {
+    // Resolve the bridge script for BOTH layouts (rule #12 — read from disk):
+    //   src/modules/browser/bridge-server.mjs          (bun run src/…)
+    //   dist/modules/browser/bridge-server.mjs         (bundle at dist/main.js +
+    //                                                   assets copied by copy-assets.ts)
+    // The single-candidate version looked next to the bundle (dist/bridge-server.mjs),
+    // which copy-assets.ts never produces — so the browser tool died with ENOENT
+    // in the released npm package (observed: v0.37.0).
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(dir, "bridge-server.mjs"),
+        join(dir, "modules", "browser", "bridge-server.mjs"),
+    ];
+    return pickExistingPath(candidates);
+}
+export class BridgeDriver {
+    proc = null;
+    rl = null;
+    pending = new Map();
+    lastStderr = [];
+    nextId = 1;
+    lastUrl = "";
+    console = new ConsoleBuffer(500);
+    network = [];
+    maxConsoleLineChars;
+    constructor(opts = {}) {
+        this.maxConsoleLineChars = opts.maxConsoleLineChars ?? 400;
+    }
+    async send(cmd, params = {}, retried = false) {
+        if (!this.proc || !this.rl) {
+            if (retried || cmd === "close")
+                throw new Error("Bridge is not running");
+            this.spawnBridge();
+            return this.send(cmd, params, true);
+        }
+        const id = this.nextId++;
+        const response = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Bridge timeout waiting for "${cmd}"`));
+            }, BRIDGE_REQUEST_TIMEOUT_MS);
+            this.pending.set(id, (resp) => {
+                clearTimeout(timer);
+                resolve(resp);
+            });
+            this.proc.stdin.write(JSON.stringify({ id, cmd, params }) + "\n");
+        });
+        this.drainEvents(response);
+        if (!response.ok)
+            throw new Error(response.error || `Bridge command failed: ${cmd}`);
+        return response;
+    }
+    drainEvents(resp) {
+        if (Array.isArray(resp.console)) {
+            for (const entry of resp.console) {
+                this.console.add(entry.type, entry.text);
+            }
+        }
+        if (Array.isArray(resp.network)) {
+            for (const err of resp.network)
+                this.network.push(err);
+        }
+        if (resp.data && typeof resp.data.url === "string") {
+            this.lastUrl = resp.data.url;
+        }
+    }
+    async launch(cfg) {
+        this.spawnBridge();
+        await this.send("launch", {
+            headless: cfg.headless,
+            viewport: cfg.viewport,
+            timeoutMs: cfg.timeoutMs,
+            maxConsoleLineChars: this.maxConsoleLineChars,
+        });
+    }
+    spawnBridge() {
+        const script = bridgeScriptPath();
+        const proc = spawn("node", [script], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        this.proc = proc;
+        this.lastStderr = [];
+        proc.stderr.on("data", (chunk) => {
+            this.lastStderr = [...this.lastStderr.slice(-4), chunk.toString()];
+        });
+        const rl = createInterface({ input: proc.stdout });
+        this.rl = rl;
+        rl.on("line", (line) => {
+            let resp;
+            try {
+                resp = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            const resolver = this.pending.get(resp.id);
+            if (resolver) {
+                this.pending.delete(resp.id);
+                resolver(resp);
+            }
+        });
+        proc.on("error", (err) => {
+            if (this.proc !== proc)
+                return; // stale child — a newer bridge is alive
+            this.failPending(`Bridge process failed to start: ${err.message}`);
+            this.proc = null;
+            this.rl = null;
+        });
+        proc.on("exit", (code) => {
+            if (this.proc !== proc)
+                return; // stale child — a newer bridge is alive
+            const stderrTail = this.lastStderr.join("").trim();
+            this.failPending(stderrTail
+                ? `Bridge process exited (code ${code}): ${stderrTail.slice(0, 300)}`
+                : `Bridge process exited (code ${code})`);
+            this.proc = null;
+            this.rl = null;
+        });
+    }
+    failPending(error) {
+        for (const [, resolver] of this.pending) {
+            resolver({ id: -1, ok: false, error });
+        }
+        this.pending.clear();
+    }
+    async goto(url, timeoutMs) {
+        await this.send("goto", { url, timeoutMs });
+    }
+    async evaluate(js) {
+        const resp = await this.send("evaluate", { js });
+        return resp.data?.result;
+    }
+    async content() {
+        const resp = await this.send("content");
+        return String(resp.data?.html ?? "");
+    }
+    async title() {
+        const resp = await this.send("title");
+        return String(resp.data?.title ?? "");
+    }
+    url() {
+        return this.lastUrl;
+    }
+    async waitForLoad(timeoutMs) {
+        await this.send("waitLoad", { timeoutMs });
+    }
+    async screenshot() {
+        const resp = await this.send("screenshot");
+        return Buffer.from(String(resp.data?.base64 ?? ""), "base64");
+    }
+    async cookies() {
+        const resp = await this.send("cookies");
+        return (resp.data?.cookies ?? []);
+    }
+    async addCookies(cookies) {
+        await this.send("setCookies", { cookies });
+    }
+    async goBack(timeoutMs) {
+        await this.send("back", { timeoutMs });
+    }
+    async goForward(timeoutMs) {
+        await this.send("forward", { timeoutMs });
+    }
+    resetEventLog() {
+        this.console.clear();
+        this.network = [];
+    }
+    getConsole() {
+        return this.console.getAll();
+    }
+    getNetworkErrors() {
+        return this.network.slice(-15);
+    }
+    async close() {
+        try {
+            if (this.proc)
+                await this.send("close");
+        }
+        catch {
+            // ignore — we're shutting down
+        }
+        this.dispose();
+    }
+    dispose() {
+        if (this.proc) {
+            this.proc.kill();
+            this.proc = null;
+        }
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+    }
+}

package/dist/modules/browser/bridge-path.js

@@ -0,0 +1,10 @@
+import { existsSync } from "fs";
+/**
+ * Pick the first existing candidate path, falling back to the first candidate.
+ * Split out of bridge-client.ts so the source-vs-dist layout resolution is
+ * unit-testable without spawning a node bridge (rule #12: build-time values
+ * are resolved from disk at runtime, never inlined).
+ */
+export function pickExistingPath(candidates, fallback = candidates[0]) {
+    return candidates.find((p) => existsSync(p)) ?? fallback;
+}