micro-models-agent 0.61.0 → 0.62.0

package/dist/cli/run-result.js

@@ -0,0 +1,33 @@
+import { t } from "../i18n/index";
+import { pc } from "../ui/colors";
+import { formatCost } from "../modules/pricing/prices";
+/**
+ * Render a single-run AgentResult to the terminal (non-JSON mode) and return
+ * the process exit code.
+ *
+ * On failure only the error is printed. The model's `text` (which is the last
+ * *accepted* message, i.e. possibly stale after an audit/hallucination error)
+ * was already streamed live during the run — re-printing it here misleadingly
+ * suggests the task succeeded.
+ */
+export function printRunResult(result, flush) {
+    flush();
+    if (result.success) {
+        if (result.totalCost !== undefined && result.totalCost > 0) {
+            console.log(pc.dim(`${t("repl.cost", { cost: formatCost(result.totalCost) })}`));
+            if (result.costBreakdown && result.costBreakdown.length > 1) {
+                const parts = result.costBreakdown.map((e) => `${e.provider} ${formatCost(e.cost)}`);
+                console.log(pc.dim(`  ${t("repl.cost_breakdown", { breakdown: parts.join(", ") })}`));
+            }
+        }
+        else if (result.totalTokens !== undefined && result.totalTokens > 0) {
+            console.log(pc.dim(`${t("repl.tokens", { tokens: result.totalTokens })}`));
+        }
+        if (!result.text) {
+            console.log(pc.yellow(t("cli.no_output")));
+        }
+        return 0;
+    }
+    console.error(`${t("error.prefix")}${result.error}`);
+    return 1;
+}

package/dist/cli/security-commands.js

@@ -0,0 +1,164 @@
+import { bootstrap } from "../core/bootstrap";
+import { saveConfig } from "../config/config";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { SECURITY_POLICIES, applySecurityPolicy, getSecurityPolicy, } from "../modules/security/security-policies";
+import { globalAuditNotifier } from "../modules/security/audit-notifier";
+import { t } from "../i18n/index";
+/**
+ * Create security subcommand
+ */
+export function createSecurityCommand(program) {
+    const securityCmd = program.command("security").description(t("cli.security.description"));
+    // security status - show current security configuration
+    securityCmd
+        .command("status")
+        .description(t("cli.security.status"))
+        .action(async () => {
+        const { config } = await bootstrap();
+        const security = config.security || {};
+        const bash = security.bash || {};
+        const paths = security.paths || {};
+        const network = security.network || {};
+        const contentScan = security.contentScan || {};
+        const rateLimits = security.rateLimits || {};
+        const sessionEncryption = security.sessionEncryption || {};
+        const auditNotifier = security.auditNotifier || {};
+        console.log(t("cli.security.current_policy"));
+        console.log(`  ${t("cli.security.bash_enabled")}: ${bash.blacklist?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.path_validation")}: ${paths.denied?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.network_validation")}: ${network.deniedDomains?.length > 0 || network.allowedDomains?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.content_scanning")}: ${contentScan.enabled ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.max_recursion")}: ${security.maxRecursionDepth ?? 3}`);
+        console.log(`  ${t("cli.security.max_file_ops")}: ${security.maxFileOperations ?? 100}`);
+        console.log(`  ${t("cli.security.rate_limit")}: ${rateLimits.maxRequestsPerMinute ?? 60}/min`);
+        console.log(`  ${t("cli.security.session_encryption")}: ${sessionEncryption.enabled ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.audit_notifier")}: ${auditNotifier.enabled ? t("cli.yes") : t("cli.no")}`);
+    });
+    // security policies - manage security policies
+    securityCmd
+        .command("policies")
+        .description(t("cli.security.policies"))
+        .action(async () => {
+        console.log(t("cli.security.available_policies"));
+        console.log("");
+        for (const [preset, policy] of Object.entries(SECURITY_POLICIES)) {
+            if (preset === "custom")
+                continue;
+            const marker = " ";
+            console.log(` ${marker}${preset.padEnd(12)}  ${policy.name}`);
+            console.log(`             ${policy.description}`);
+            console.log(`             ${t("cli.security.recommended_for")}: ${policy.recommendedFor.join(", ")}`);
+            console.log("");
+        }
+    });
+    // security set-policy - apply a security policy
+    securityCmd
+        .command("set-policy")
+        .argument("<preset>", t("cli.security.preset"))
+        .description(t("cli.security.set_policy"))
+        .action(async (preset) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        const validPresets = ["strict", "balanced", "permissive"];
+        if (!validPresets.includes(preset)) {
+            console.log(t("cli.security.invalid_preset", { presets: validPresets.join(", ") }));
+            return;
+        }
+        const policy = getSecurityPolicy(preset);
+        const newSecurityConfig = applySecurityPolicy(preset);
+        // Merge with existing config
+        appConfig.security = newSecurityConfig;
+        saveConfig(appConfig, configPath, dirname(configPath));
+        console.log(t("cli.security.policy_applied", { name: policy.name }));
+        console.log(t("cli.security.policy_description", { description: policy.description }));
+    });
+    // security enable-encryption - enable session file encryption
+    securityCmd
+        .command("enable-encryption")
+        .description(t("cli.security.enable_encryption"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.sessionEncryption = {
+            enabled: true,
+            encryptHistory: true,
+            encryptSessionLog: true,
+        };
+        saveConfig(appConfig, configPath, dirname(configPath));
+        console.log(t("cli.security.encryption_enabled"));
+    });
+    // security disable-encryption - disable session file encryption
+    securityCmd
+        .command("disable-encryption")
+        .description(t("cli.security.disable_encryption"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.sessionEncryption = {
+            enabled: false,
+            encryptHistory: false,
+            encryptSessionLog: false,
+        };
+        saveConfig(appConfig, configPath, dirname(configPath));
+        console.log(t("cli.security.encryption_disabled"));
+    });
+    // security enable-audit - enable audit notifications
+    securityCmd
+        .command("enable-audit")
+        .description(t("cli.security.enable_audit"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.auditNotifier = {
+            enabled: true,
+            minSeverity: "medium",
+            eventTypes: ["security_block", "bash_command", "file_operation", "network_request"],
+            maxRetries: 3,
+            webhookTimeout: 5000,
+        };
+        saveConfig(appConfig, configPath, dirname(configPath));
+        console.log(t("cli.security.audit_enabled"));
+    });
+    // security disable-audit - disable audit notifications
+    securityCmd
+        .command("disable-audit")
+        .description(t("cli.security.disable_audit"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.auditNotifier = {
+            enabled: false,
+            maxRetries: 3,
+            webhookTimeout: 5000,
+        };
+        saveConfig(appConfig, configPath, dirname(configPath));
+        console.log(t("cli.security.audit_disabled"));
+    });
+    // security audit-stats - show audit notification statistics
+    securityCmd
+        .command("audit-stats")
+        .description(t("cli.security.audit_stats"))
+        .action(async () => {
+        const stats = globalAuditNotifier.getStats();
+        console.log(t("cli.security.audit_stats_title"));
+        console.log(`  ${t("cli.security.total_notifications")}: ${stats.total}`);
+        console.log("");
+        console.log(t("cli.security.by_severity"));
+        console.log(`  ${t("cli.security.low")}: ${stats.bySeverity.low}`);
+        console.log(`  ${t("cli.security.medium")}: ${stats.bySeverity.medium}`);
+        console.log(`  ${t("cli.security.high")}: ${stats.bySeverity.high}`);
+        console.log(`  ${t("cli.security.critical")}: ${stats.bySeverity.critical}`);
+        console.log("");
+        console.log(t("cli.security.by_type"));
+        for (const [type, count] of Object.entries(stats.byType)) {
+            if (count > 0) {
+                console.log(`  ${type}: ${count}`);
+            }
+        }
+    });
+}

package/dist/cli/setup.js

@@ -0,0 +1,237 @@
+import * as readline from "readline";
+import { pc } from "../ui/colors";
+import { t, setLocale } from "../i18n/index";
+import { Spinner } from "../ui/spinner";
+import { BUILTIN_PROVIDERS, HOSTED_BASE_URLS } from "../modules/providers/presets";
+import { box } from "../ui/box";
+import { renderTable } from "../ui/table";
+async function withSpinner(message, fn) {
+    const spinner = new Spinner();
+    spinner.start(message);
+    try {
+        return await fn();
+    }
+    finally {
+        spinner.stop();
+    }
+}
+/** Render a numbered list inside a box. */
+function menuList(items) {
+    const lines = items.map((it, i) => ` ${pc.cyan(`[${i + 1}]`)} ${it.label}${it.url ? `  ${pc.dim(it.url)}` : ""}`);
+    for (const l of box(lines, { width: 72 }))
+        console.log(l);
+}
+function ask(rl, question, defaultValue) {
+    return new Promise((resolve) => {
+        const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+        rl.question(prompt, (answer) => {
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+const PROVIDER_TYPES = BUILTIN_PROVIDERS.map((spec) => ({
+    value: spec.type,
+    label: spec.label,
+}));
+const KNOWN_PORTS = [
+    { port: 1234, label: "LM Studio" },
+    { port: 11434, label: "Ollama" },
+    { port: 8080, label: "vLLM / custom" },
+    { port: 4891, label: "GPT4All" },
+];
+async function scanPorts() {
+    const found = [];
+    for (const { port, label } of KNOWN_PORTS) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            const resp = await fetch(`http://localhost:${port}/v1/models`, {
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (resp.ok) {
+                found.push({ label, url: `http://localhost:${port}/v1` });
+            }
+        }
+        catch {
+            /* port not available */
+        }
+    }
+    return found;
+}
+async function fetchModels(apiBase, apiKey) {
+    try {
+        const url = `${apiBase.replace(/\/+$/, "")}/models`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const resp = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!resp.ok)
+            return [];
+        const data = (await resp.json());
+        const models = (data.data || data || [])
+            .map((m) => m.id || m.name || m.model || "")
+            .filter(Boolean);
+        return models;
+    }
+    catch {
+        return [];
+    }
+}
+async function testChat(apiBase, apiKey, model) {
+    try {
+        const url = `${apiBase.replace(/\/+$/, "")}/chat/completions`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 10000);
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model,
+                messages: [{ role: "user", content: 'Say "ok"' }],
+                max_tokens: 20,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!resp.ok)
+            return false;
+        const data = (await resp.json());
+        const msg = data.choices?.[0]?.message;
+        const text = msg?.content || msg?.reasoning_content || "";
+        return text.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runSetup(externalRl) {
+    console.log(t("setup.title"));
+    const rl = externalRl ||
+        readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    const ownRl = !externalRl;
+    console.log(t("setup.language"));
+    const locale = await ask(rl, t("setup.ui_lang"), "en");
+    setLocale(locale);
+    console.log(t("setup.select_provider"));
+    menuList(PROVIDER_TYPES);
+    const providerChoice = await ask(rl, t("setup.select_provider_num", { max: PROVIDER_TYPES.length }), "1");
+    const providerIdx = Math.max(0, Math.min(PROVIDER_TYPES.length - 1, (parseInt(providerChoice) || 1) - 1));
+    const provider = PROVIDER_TYPES[providerIdx].value;
+    let apiBase = "";
+    if (provider === "openai-compat") {
+        const found = await withSpinner(t("setup.scanning_spinner"), async () => scanPorts());
+        if (found.length > 0) {
+            console.log(t("setup.found_servers", { count: found.length }));
+            menuList([
+                ...found.map((f) => ({ label: f.label, url: f.url })),
+                { label: t("setup.custom_url") },
+            ]);
+            const choice = await ask(rl, t("setup.select_server", { max: found.length + 1 }), "1");
+            const idx = (parseInt(choice) || 1) - 1;
+            if (idx >= found.length) {
+                apiBase = await ask(rl, t("setup.api_base"), "http://localhost:1234/v1");
+            }
+            else {
+                apiBase = found[Math.max(0, Math.min(found.length - 1, idx))].url;
+            }
+        }
+        else {
+            console.log(t("setup.no_servers"));
+            apiBase = await ask(rl, t("setup.api_base"), "http://localhost:1234/v1");
+        }
+    }
+    else {
+        apiBase = HOSTED_BASE_URLS[provider] ?? "";
+    }
+    const defaultKey = provider === "openai-compat" ? "not-needed" : "";
+    const apiKey = await ask(rl, t("setup.api_key"), defaultKey);
+    const models = await withSpinner(t("setup.fetching_spinner"), () => fetchModels(apiBase, apiKey));
+    let model = "";
+    if (models.length > 0) {
+        console.log(t("setup.available_models"));
+        menuList(models.slice(0, 10).map((m) => ({ label: m })));
+        const choice = await ask(rl, t("setup.select_model", { max: Math.min(models.length, 10) }), "1");
+        const idx = Math.max(0, Math.min(models.length - 1, (parseInt(choice) || 1) - 1));
+        model = models[idx];
+    }
+    else {
+        model = await ask(rl, t("setup.model_name"), "qwen/qwen3.5-9b");
+    }
+    const connected = await withSpinner(t("setup.testing_spinner", { model }), () => testChat(apiBase, apiKey, model));
+    if (connected) {
+        console.log(pc.green(t("setup.ok")));
+    }
+    else {
+        console.log(pc.yellow(t("setup.warning")));
+    }
+    console.log(t("setup.agent_settings"));
+    const contextWindow = parseInt(await ask(rl, t("setup.context_window"), "32768"));
+    const maxIterations = parseInt(await ask(rl, t("setup.max_iters"), "1000"));
+    // Security settings
+    console.log(t("setup.security_header"));
+    console.log(pc.dim(t("setup.security_status_on")));
+    const configureSecurity = await ask(rl, t("setup.security_configure"), "n");
+    let securityBashBlock = false;
+    let securityFlagsBlock = false;
+    let securityPathsDeny = true;
+    if (configureSecurity.toLowerCase() === "y" || configureSecurity.toLowerCase() === "yes") {
+        securityBashBlock = (await ask(rl, t("setup.security_bash_block"), "n")).toLowerCase() === "y";
+        securityFlagsBlock =
+            (await ask(rl, t("setup.security_flags_block"), "n")).toLowerCase() === "y";
+        securityPathsDeny = (await ask(rl, t("setup.security_paths_deny"), "Y")).toLowerCase() !== "n";
+    }
+    if (ownRl) {
+        rl.close();
+        // Bun: closed readline can leave stdin in a state where a later
+        // raw-mode LineEditor never receives keypress events. Force-reset:
+        process.stdin.removeAllListeners("data");
+        process.stdin.removeAllListeners("keypress");
+        if (typeof process.stdin.setRawMode === "function") {
+            process.stdin.setRawMode(false);
+        }
+        // Pause + resume forces Bun to flush its internal buffer and
+        // release the stream so LineEditor can attach cleanly.
+        process.stdin.pause();
+        process.stdin.resume();
+    }
+    const answers = {
+        provider,
+        apiBase,
+        apiKey: apiKey || "not-needed",
+        model,
+        contextWindow,
+        maxToolIterations: maxIterations,
+        locale,
+        securityBashBlock,
+        securityFlagsBlock,
+        securityPathsDeny,
+    };
+    console.log(pc.green(pc.bold(t("setup.complete"))));
+    const summary = renderTable([
+        t("setup.summary_setting"),
+        t("setup.summary_value"),
+        t("setup.summary_setting"),
+        t("setup.summary_value"),
+    ], [
+        [t("setup.provider_type"), provider, t("setup.model_name"), model],
+        ["API Base URL", apiBase, t("setup.context_window"), String(contextWindow)],
+        [t("setup.api_key"), apiKey || "not-needed", t("setup.max_iters"), String(maxIterations)],
+        [t("setup.ui_lang"), locale, "", ""],
+    ], { maxColumns: 4 });
+    for (const l of summary)
+        console.log(l);
+    return answers;
+}