micro-models-agent 0.61.0 → 0.62.0

package/dist/modules/providers/presets.js

@@ -0,0 +1,128 @@
+// src/modules/providers/presets.ts
+import { OpenAICompatProvider } from "../../llm/openai-compat";
+/** Build an OpenAI-compatible provider (default for most backends). */
+function openaiCompat(opts) {
+    const retry = (opts.retry ?? {
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+    });
+    const rateLimits = opts.rateLimits;
+    return new OpenAICompatProvider({
+        model: opts.model,
+        baseUrl: opts.baseUrl,
+        apiKey: opts.apiKey,
+        contextWindow: opts.contextWindow,
+        retry,
+        rateLimits,
+        maxCompletionTokens: opts.maxCompletionTokens,
+    });
+}
+const OPENAI_COMPAT = {
+    type: "openai-compat",
+    label: "OpenAI-compatible (LM Studio, Ollama, vLLM, etc.)",
+    baseUrl: "",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        reasoningEffort: false,
+        listModels: true,
+        requiresKey: false,
+        auth: "bearer",
+    },
+    create: openaiCompat,
+};
+const OPENROUTER = {
+    type: "openrouter",
+    label: "OpenRouter (openrouter.ai)",
+    baseUrl: "https://openrouter.ai/api/v1",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: true,
+        reasoningEffort: false,
+        listModels: true,
+        requiresKey: true,
+        auth: "bearer",
+    },
+    create: openaiCompat,
+};
+const OPENAI = {
+    type: "openai",
+    label: "OpenAI API",
+    baseUrl: "https://api.openai.com/v1",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: true,
+        reasoningEffort: true,
+        listModels: true,
+        requiresKey: true,
+        auth: "bearer",
+    },
+    create: openaiCompat,
+};
+const ANTHROPIC = {
+    type: "anthropic",
+    label: "Anthropic Claude",
+    baseUrl: "https://api.anthropic.com",
+    capabilities: {
+        streaming: false,
+        tools: false,
+        vision: true,
+        reasoningEffort: false,
+        listModels: false,
+        requiresKey: true,
+        auth: "header",
+    },
+    // The Anthropic messages API is NOT OpenAI-compatible. This preset is a
+    // placeholder until a real AnthropicProvider lands; the factory still uses
+    // the OpenAI-compatible code path today (broken), flagged via capabilities.
+    create: openaiCompat,
+};
+const OPENCODE_ZEN = {
+    type: "opencode-zen",
+    label: "OpenCode Zen (opencode.ai/zen)",
+    baseUrl: "https://opencode.ai/zen/v1",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        reasoningEffort: false,
+        listModels: true,
+        requiresKey: false,
+        auth: "bearer",
+    },
+    create: openaiCompat,
+};
+const OPENCODE_GO = {
+    type: "opencode-go",
+    label: "OpenCode Go (opencode.ai/go)",
+    baseUrl: "https://opencode.ai/zen/go/v1",
+    capabilities: {
+        streaming: true,
+        tools: true,
+        vision: false,
+        reasoningEffort: false,
+        listModels: true,
+        requiresKey: false,
+        auth: "bearer",
+    },
+    create: openaiCompat,
+};
+/** All builtin provider presets. */
+export const BUILTIN_PROVIDERS = [
+    OPENAI_COMPAT,
+    OPENROUTER,
+    OPENAI,
+    ANTHROPIC,
+    OPENCODE_ZEN,
+    OPENCODE_GO,
+];
+/** Fixed base URLs for hosted providers (no port scan / model autodetect). */
+export const HOSTED_BASE_URLS = {};
+for (const spec of BUILTIN_PROVIDERS) {
+    if (spec.baseUrl)
+        HOSTED_BASE_URLS[spec.type] = spec.baseUrl;
+}

package/dist/modules/providers/registry.js

@@ -0,0 +1,22 @@
+/**
+ * Single source of truth mapping provider `type` → factory + capabilities.
+ * Adding a provider = one `register()` call; no changes to the agent loop.
+ */
+export class ProviderRegistry {
+    specs = new Map();
+    register(spec) {
+        this.specs.set(spec.type, spec);
+    }
+    get(type) {
+        return this.specs.get(type);
+    }
+    has(type) {
+        return this.specs.has(type);
+    }
+    list() {
+        return [...this.specs.values()];
+    }
+    types() {
+        return [...this.specs.keys()];
+    }
+}

package/dist/modules/providers/types.js

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

package/dist/modules/registry.js

@@ -0,0 +1,48 @@
+export class ModuleRegistry {
+    modules = new Map();
+    register(mod) {
+        this.modules.set(mod.name, mod);
+        return this;
+    }
+    get(name) {
+        return this.modules.get(name);
+    }
+    listModules() {
+        return Array.from(this.modules.keys()).sort();
+    }
+    collectPromptBlocks(exclude = []) {
+        const blocks = [];
+        for (const [name, mod] of this.modules) {
+            if (exclude.includes(name))
+                continue;
+            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,136 @@
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { resolve, join } from "path";
+import { homedir } from "os";
+import { globalAuditNotifier } from "./audit-notifier";
+let _globalAuditDir = resolve(homedir(), ".mma", "logs");
+let _sessionAuditDir = null;
+function getAuditDir() {
+    return _sessionAuditDir ?? _globalAuditDir;
+}
+/**
+ * Set the session directory for audit logs. When set, all audit entries
+ * are written to the session-specific directory instead of the global one.
+ */
+export function setAuditSessionDir(dir) {
+    _sessionAuditDir = dir;
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Clear the session directory — fall back to global audit dir.
+ */
+export function clearAuditSessionDir() {
+    _sessionAuditDir = null;
+}
+/**
+ * Set the global audit log directory (used when no session dir is active).
+ */
+export function setGlobalAuditDir(dir) {
+    _globalAuditDir = dir;
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Write an audit log entry
+ */
+export function logAudit(entry) {
+    const dir = getAuditDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    try {
+        const logEntry = JSON.stringify(entry);
+        appendFileSync(join(dir, "audit.jsonl"), 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,
+    });
+}

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

@@ -0,0 +1,292 @@
+import { writeFileSync, appendFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+/**
+ * Severity weights for comparison
+ */
+const SEVERITY_WEIGHTS = {
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+};
+/**
+ * Default audit notifier configuration
+ */
+export const DEFAULT_AUDIT_NOTIFIER_CONFIG = {
+    enabled: false,
+    filePath: join(homedir(), ".mma", "logs", "audit-notifications.jsonl"),
+    webhookTimeout: 5000,
+    minSeverity: "medium",
+    eventTypes: [
+        "security_block",
+        "bash_command",
+        "file_operation",
+        "network_request",
+        "authentication",
+        "configuration_change",
+    ],
+    maxRetries: 3,
+};
+/**
+ * Audit notifier for sending notifications about security events
+ */
+export class AuditNotifier {
+    config;
+    retryQueue = [];
+    isProcessing = false;
+    constructor(config) {
+        this.config = { ...DEFAULT_AUDIT_NOTIFIER_CONFIG, ...config };
+        this.ensureLogDirectory();
+    }
+    /**
+     * Check if notifier is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Enable the notifier
+     */
+    enable() {
+        this.config.enabled = true;
+    }
+    /**
+     * Disable the notifier
+     */
+    disable() {
+        this.config.enabled = false;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+        this.ensureLogDirectory();
+    }
+    /**
+     * Ensure the log directory exists
+     */
+    ensureLogDirectory() {
+        if (this.config.filePath) {
+            const dir = dirname(this.config.filePath);
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    /**
+     * Check if an event type should be notified
+     */
+    shouldNotify(eventType) {
+        if (!this.config.enabled)
+            return false;
+        return this.config.eventTypes?.includes(eventType) ?? false;
+    }
+    /**
+     * Check if a severity level should be notified
+     */
+    shouldNotifySeverity(severity) {
+        const minSeverity = this.config.minSeverity ?? "medium";
+        const minWeight = SEVERITY_WEIGHTS[minSeverity];
+        const eventWeight = SEVERITY_WEIGHTS[severity];
+        return eventWeight >= minWeight;
+    }
+    /**
+     * Send a notification for an audit event
+     */
+    async notify(entry) {
+        if (!this.config.enabled)
+            return null;
+        const eventType = this.mapEventType(entry.action);
+        if (!eventType || !this.shouldNotify(eventType))
+            return null;
+        const severity = this.determineSeverity(entry);
+        if (!this.shouldNotifySeverity(severity))
+            return null;
+        const notification = {
+            timestamp: new Date().toISOString(),
+            eventType,
+            severity,
+            message: entry.details || entry.reason || entry.action,
+            details: entry.details ? { details: entry.details } : undefined,
+            sessionId: entry.sessionId,
+        };
+        // Write to file
+        this.writeToFile(notification);
+        // Send to webhook if configured
+        if (this.config.webhookUrl) {
+            await this.sendToWebhook(notification);
+        }
+        return notification;
+    }
+    /**
+     * Map audit log entry action to notification event type
+     */
+    mapEventType(action) {
+        const typeMap = {
+            tool_call: "tool_call",
+            bash_command: "bash_command",
+            file_write: "file_operation",
+            file_delete: "file_operation",
+            network_request: "network_request",
+            security_block: "security_block",
+        };
+        return typeMap[action] || null;
+    }
+    /**
+     * Determine severity from audit log entry
+     */
+    determineSeverity(entry) {
+        // Default severity based on action type
+        const typeSeverity = {
+            security_block: "high",
+            bash_command: "high",
+            file_delete: "medium",
+            file_write: "medium",
+            network_request: "medium",
+            tool_call: "low",
+            session_start: "low",
+            session_end: "low",
+        };
+        return typeSeverity[entry.action] || "low";
+    }
+    /**
+     * Write notification to file
+     */
+    writeToFile(notification) {
+        if (!this.config.filePath)
+            return;
+        try {
+            const line = JSON.stringify(notification);
+            appendFileSync(this.config.filePath, line + "\n", "utf8");
+        }
+        catch (error) {
+            console.error("[AuditNotifier] Failed to write to file:", error);
+        }
+    }
+    /**
+     * Send notification to webhook
+     */
+    async sendToWebhook(notification) {
+        if (!this.config.webhookUrl)
+            return;
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.config.webhookTimeout);
+            const response = await fetch(this.config.webhookUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(notification),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`Webhook returned ${response.status}`);
+            }
+        }
+        catch (error) {
+            console.error("[AuditNotifier] Webhook failed, adding to retry queue:", error);
+            this.addToRetryQueue(notification);
+        }
+    }
+    /**
+     * Add notification to retry queue
+     */
+    addToRetryQueue(notification) {
+        this.retryQueue.push({ entry: notification, retries: 0 });
+        if (!this.isProcessing) {
+            this.processRetryQueue();
+        }
+    }
+    /**
+     * Process the retry queue
+     */
+    async processRetryQueue() {
+        if (this.retryQueue.length === 0 || this.isProcessing)
+            return;
+        this.isProcessing = true;
+        while (this.retryQueue.length > 0) {
+            const item = this.retryQueue[0];
+            if (item.retries >= (this.config.maxRetries ?? 3)) {
+                console.error("[AuditNotifier] Max retries exceeded for notification:", item.entry);
+                this.retryQueue.shift();
+                continue;
+            }
+            try {
+                await this.sendToWebhook(item.entry);
+                this.retryQueue.shift();
+            }
+            catch (error) {
+                item.retries++;
+                // Exponential backoff
+                const delay = Math.pow(2, item.retries) * 1000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        this.isProcessing = false;
+    }
+    /**
+     * Read notifications from file
+     */
+    readNotifications(limit = 100) {
+        if (!this.config.filePath || !existsSync(this.config.filePath)) {
+            return [];
+        }
+        try {
+            const content = readFileSync(this.config.filePath, "utf8");
+            const lines = content.split("\n").filter(Boolean);
+            return lines.slice(-limit).map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Clear all notifications
+     */
+    clearNotifications() {
+        if (this.config.filePath) {
+            writeFileSync(this.config.filePath, "", "utf8");
+        }
+        this.retryQueue = [];
+    }
+    /**
+     * Get notification statistics
+     */
+    getStats() {
+        const notifications = this.readNotifications();
+        const bySeverity = { low: 0, medium: 0, high: 0, critical: 0 };
+        const byType = {
+            tool_call: 0,
+            tool_result: 0,
+            bash_command: 0,
+            file_operation: 0,
+            network_request: 0,
+            security_block: 0,
+            authentication: 0,
+            configuration_change: 0,
+            session_start: 0,
+            session_end: 0,
+        };
+        for (const n of notifications) {
+            bySeverity[n.severity] = (bySeverity[n.severity] || 0) + 1;
+            byType[n.eventType] = (byType[n.eventType] || 0) + 1;
+        }
+        return {
+            total: notifications.length,
+            bySeverity,
+            byType,
+        };
+    }
+}
+/**
+ * Global audit notifier instance
+ */
+export const globalAuditNotifier = new AuditNotifier();
+/**
+ * Create an audit notifier with custom configuration
+ */
+export function createAuditNotifier(config) {
+    return new AuditNotifier(config);
+}
+// Import readFileSync for readNotifications
+import { readFileSync } from "fs";