min-agent 0.2.1 → 0.4.0

package/dist/config.js

@@ -1,33 +1,236 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, mkdirSync, existsSync, statSync } from "fs";
 import path from "path";
 import os from "os";
 import readline from "readline";
-const CONFIG_DIR = path.join(os.homedir(), ".min-agent");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-const RULES_FILE = path.join(CONFIG_DIR, "rules.md");
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+import { getEffectiveSandboxPolicy, mergeSandboxConfig, parseSandboxConfig, sandboxLaunchSource, sandboxStatusLabel, } from "./sandbox.js";
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), ".min-agent");
+const CONFIG_FILE_NAME = "config.json";
+const RULES_FILE_NAME = "rules.md";
 export function getConfigDir() {
-    return CONFIG_DIR;
+    return process.env.MIN_AGENT_CONFIG_DIR ?? DEFAULT_CONFIG_DIR;
 }
 export function getRulesFile() {
-    return RULES_FILE;
+    return path.join(getConfigDir(), RULES_FILE_NAME);
 }
-export function loadConfig() {
-    if (!existsSync(CONFIG_FILE))
+let cachedConfig = null;
+const projectCache = new Map();
+export function getProjectConfigDir() {
+    return path.join(process.cwd(), ".min-agent");
+}
+export function getProjectConfigFile() {
+    return path.join(getProjectConfigDir(), CONFIG_FILE_NAME);
+}
+export function loadProjectConfig() {
+    const file = getProjectConfigFile();
+    let st;
+    try {
+        st = statSync(file);
+    }
+    catch {
+        return {};
+    }
+    const cached = projectCache.get(file);
+    if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size)
+        return cached.config;
+    let config;
+    try {
+        config = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        console.warn(`\x1b[33m  ⚠ Project config ${file} is not valid JSON; ignoring\x1b[0m`);
+        return {};
+    }
+    projectCache.set(file, { mtimeMs: st.mtimeMs, size: st.size, config });
+    return config;
+}
+export function saveProjectConfig(config) {
+    const dir = getProjectConfigDir();
+    mkdirSync(dir, { recursive: true });
+    // Keep unknown keys, drop empty skill arrays so the file stays minimal.
+    const { disabledSkills, enabledSkills, ...rest } = config;
+    atomicWriteFileSync(getProjectConfigFile(), JSON.stringify({
+        ...rest,
+        ...(disabledSkills?.length ? { disabledSkills } : {}),
+        ...(enabledSkills?.length ? { enabledSkills } : {}),
+    }, null, 2));
+    projectCache.delete(getProjectConfigFile());
+}
+export function loadConfigFile(configFile) {
+    let st;
+    try {
+        st = statSync(configFile);
+    }
+    catch {
         return {};
+    }
+    if (cachedConfig &&
+        cachedConfig.file === configFile &&
+        cachedConfig.mtimeMs === st.mtimeMs &&
+        cachedConfig.size === st.size) {
+        return cachedConfig.config;
+    }
+    let config;
     try {
-        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+        config = JSON.parse(readFileSync(configFile, "utf-8"));
     }
     catch {
+        console.warn(`\x1b[33m  ⚠ Config file ${configFile} is not valid JSON; using defaults\x1b[0m`);
         return {};
     }
+    cachedConfig = { file: configFile, mtimeMs: st.mtimeMs, size: st.size, config };
+    return config;
+}
+export function loadConfig() {
+    const raw = loadConfigFile(path.join(getConfigDir(), CONFIG_FILE_NAME));
+    const { config, migrated } = migrateLegacyConfig(raw);
+    if (migrated) {
+        try {
+            saveConfig(config);
+        }
+        catch { }
+    }
+    return config;
+}
+export function migrateLegacyConfig(config) {
+    const legacy = config.provider;
+    if (!legacy)
+        return { config, migrated: false };
+    const { provider, ...rest } = config;
+    return {
+        config: { ...rest, providers: [{ name: "default", ...provider }], activeProvider: "default" },
+        migrated: true,
+    };
+}
+export function mergeProjectOverGlobal(global, project) {
+    const activeProvider = project.activeProvider ?? global.activeProvider;
+    const sampling = project.sampling ? { ...global.sampling, ...project.sampling } : global.sampling;
+    const budget = project.budget ? { ...global.budget, ...project.budget } : global.budget;
+    const permission = parsePermissionMode(project.permission) ?? parsePermissionMode(global.permission);
+    const sandbox = mergeSandboxConfig(parseSandboxConfig(global.sandbox), parseSandboxConfig(project.sandbox));
+    const compaction = project.compaction ? { ...global.compaction, ...project.compaction } : global.compaction;
+    const agent = project.agent ? { ...global.agent, ...project.agent } : global.agent;
+    let providers = global.providers;
+    if (project.defaultModel && providers && providers.length > 0) {
+        const idx = activeProvider ? providers.findIndex((p) => p.name === activeProvider) : 0;
+        const target = idx >= 0 ? idx : 0;
+        providers = providers.map((p, i) => (i === target ? { ...p, defaultModel: project.defaultModel } : p));
+    }
+    return {
+        ...global,
+        activeProvider,
+        sampling,
+        budget,
+        permission,
+        ...(sandbox ? { sandbox } : {}),
+        compaction,
+        agent,
+        ...(providers ? { providers } : {}),
+    };
+}
+export function getEffectiveConfig() {
+    return mergeProjectOverGlobal(loadConfig(), loadProjectConfig());
+}
+export function getBudgetSnapshot() {
+    const global = loadConfig();
+    const project = loadProjectConfig();
+    const maxCostUSD = mergeProjectOverGlobal(global, project).budget?.maxCostUSD;
+    const source = project.budget?.maxCostUSD != null ? "project" : global.budget?.maxCostUSD != null ? "global" : null;
+    return { maxCostUSD, source };
+}
+export function parsePermissionMode(value) {
+    if (value === "ask" || value === "accept-edits" || value === "allow-all")
+        return value;
+    return undefined;
+}
+export function permissionModeLabel(mode) {
+    if (mode === "allow-all")
+        return "allow all";
+    if (mode === "accept-edits")
+        return "accept edits";
+    return "ask";
+}
+export function getPermissionSnapshot() {
+    const global = loadConfig();
+    const project = loadProjectConfig();
+    const permission = parsePermissionMode(project.permission) ?? parsePermissionMode(global.permission) ?? "ask";
+    const source = parsePermissionMode(project.permission) != null
+        ? "project"
+        : parsePermissionMode(global.permission) != null
+            ? "global"
+            : null;
+    return { permission, source };
+}
+export function setPermissionMode(permission, scope) {
+    if (scope === "project") {
+        const project = loadProjectConfig();
+        saveProjectConfig({ ...project, permission });
+        return;
+    }
+    saveConfig({ ...loadConfig(), permission });
+}
+export function setSandboxConfig(partial, scope) {
+    if (scope === "project") {
+        const project = loadProjectConfig();
+        const current = parseSandboxConfig(project.sandbox) ?? {};
+        saveProjectConfig({ ...project, sandbox: { ...current, ...partial } });
+        return;
+    }
+    const cfg = loadConfig();
+    const current = parseSandboxConfig(cfg.sandbox) ?? {};
+    saveConfig({ ...cfg, sandbox: { ...current, ...partial } });
+}
+export function getSandboxSnapshot() {
+    const policy = getEffectiveSandboxPolicy();
+    const launch = sandboxLaunchSource();
+    const project = parseSandboxConfig(loadProjectConfig().sandbox);
+    const global = parseSandboxConfig(loadConfig().sandbox);
+    const projectSet = Boolean(project?.mode || project?.network || project?.extraWriteRoots?.length || project?.extraReadRoots?.length);
+    const globalSet = Boolean(global?.mode || global?.network || global?.extraWriteRoots?.length || global?.extraReadRoots?.length);
+    const source = launch ?? (projectSet ? "project" : globalSet ? "global" : null);
+    return {
+        mode: policy.mode,
+        network: policy.network,
+        extraWriteRoots: policy.extraWriteRoots,
+        extraReadRoots: policy.extraReadRoots,
+        source,
+        label: sandboxStatusLabel(policy),
+    };
+}
+export function setBudgetMaxCost(maxCostUSD, scope) {
+    if (scope === "project") {
+        const project = loadProjectConfig();
+        saveProjectConfig({ ...project, budget: { ...project.budget, maxCostUSD } });
+        return;
+    }
+    const cfg = loadConfig();
+    saveConfig({ ...cfg, budget: { ...cfg.budget, maxCostUSD } });
+}
+export function getActiveProvider(config) {
+    if (!config.providers || config.providers.length === 0)
+        return undefined;
+    if (config.activeProvider) {
+        const found = config.providers.find((p) => p.name === config.activeProvider);
+        if (found)
+            return found;
+    }
+    return config.providers[0];
+}
+/** Appends /v1 to an Ollama base URL unless already present */
+export function normalizeOllamaBaseURL(baseURL) {
+    const trimmed = baseURL.replace(/\/$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
 }
 export function saveConfig(config) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+    const dir = getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    atomicWriteFileSync(path.join(dir, CONFIG_FILE_NAME), JSON.stringify(config, null, 2));
+    cachedConfig = null;
 }
 export function isConfigured() {
     const config = loadConfig();
-    return !!(config.provider?.baseURL && config.provider?.apiKey);
+    const provider = getActiveProvider(config);
+    return !!(provider?.baseURL && provider?.apiKey);
 }
 async function fetchModelsFromURL(url, apiKey) {
     const noCacheURL = new URL(url);
@@ -56,20 +259,24 @@ function ask(rl, question, defaultValue) {
         });
     });
 }
-const MODELS_CACHE_FILE = path.join(CONFIG_DIR, "models-cache.json");
+const MODELS_CACHE_FILE = "models-cache.json";
+function modelsCachePath() {
+    return path.join(getConfigDir(), MODELS_CACHE_FILE);
+}
 function loadModelsCache() {
-    if (!existsSync(MODELS_CACHE_FILE))
+    const file = modelsCachePath();
+    if (!existsSync(file))
         return [];
     try {
-        return JSON.parse(readFileSync(MODELS_CACHE_FILE, "utf-8"));
+        return JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
         return [];
     }
 }
 function saveModelsCache(models) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(MODELS_CACHE_FILE, JSON.stringify(models), "utf-8");
+    mkdirSync(getConfigDir(), { recursive: true });
+    atomicWriteFileSync(modelsCachePath(), JSON.stringify(models));
 }
 export async function fetchModels(baseURL, apiKey) {
     try {
@@ -101,26 +308,88 @@ export async function fetchModels(baseURL, apiKey) {
 }
 export async function runSetup() {
     const config = loadConfig();
-    const existing = config.provider;
+    const providers = config.providers ?? [];
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     console.log("\n🔧 min-agent 配置\n");
+    if (providers.length > 0) {
+        console.log("已配置的 Provider:");
+        providers.forEach((p, i) => {
+            const marker = p.name === config.activeProvider ? " ← 当前" : "";
+            console.log(`  ${i + 1}. ${p.name ?? "(未命名)"}  ${p.baseURL}  (${p.defaultModel ?? "未设置模型"})${marker}`);
+        });
+        console.log();
+        console.log("选项:");
+        console.log("  1. 添加新 Provider");
+        console.log("  2. 切换当前 Provider");
+        console.log("  3. 修改当前 Provider");
+        console.log("  4. 完成");
+        const choice = await ask(rl, "选择 (1/2/3/4)", "4");
+        if (choice === "1") {
+            const provider = await collectProvider(rl, undefined);
+            provider.name =
+                (await ask(rl, "Provider 名称", `provider-${providers.length + 1}`)).trim() ||
+                    `provider-${providers.length + 1}`;
+            providers.push(provider);
+            config.activeProvider = provider.name;
+            config.providers = providers;
+            saveConfig(config);
+            console.log(`\n✓ Provider "${provider.name}" 已添加并设为当前`);
+        }
+        else if (choice === "2") {
+            const sel = await ask(rl, "输入序号选择当前 Provider");
+            const idx = parseInt(sel, 10) - 1;
+            const target = providers[idx];
+            if (!target?.name) {
+                console.error("无效序号");
+            }
+            else {
+                config.activeProvider = target.name;
+                saveConfig(config);
+                console.log(`\n✓ 当前 Provider 已切换为: ${target.name}`);
+            }
+        }
+        else if (choice === "3") {
+            const name = getActiveProvider(config)?.name ?? providers[0]?.name;
+            if (!name) {
+                console.error("无可用 Provider");
+                rl.close();
+                return;
+            }
+            const idx = providers.findIndex((p) => p.name === name);
+            providers[idx] = { ...(await collectProvider(rl, providers[idx])), name };
+            config.providers = providers;
+            saveConfig(config);
+            console.log(`\n✓ Provider "${name}" 已更新`);
+        }
+        else {
+            console.log("\n配置未变更");
+        }
+        rl.close();
+        return;
+    }
+    // 首次配置
+    const provider = await collectProvider(rl, undefined);
+    provider.name = "default";
+    config.providers = [provider];
+    config.activeProvider = "default";
+    saveConfig(config);
+    rl.close();
+    console.log(`\n✓ 配置已保存到 ${path.join(getConfigDir(), CONFIG_FILE_NAME)}`);
+}
+async function collectProvider(rl, existing) {
     console.log("Provider 类型:");
     console.log("  1. openai-compatible (默认，兼容 OpenAI API 的任意服务)");
     console.log("  2. openai (OpenAI 官方)");
     console.log("  3. ollama (本地 Ollama)");
     console.log();
     const typeChoice = await ask(rl, "选择 Provider (1/2/3)", existing?.type === "ollama" ? "3" : existing?.type === "openai" ? "2" : "1");
-    const providerType = typeChoice === "3" ? "ollama"
-        : typeChoice === "2" ? "openai"
-            : "openai-compatible";
+    const providerType = typeChoice === "3" ? "ollama" : typeChoice === "2" ? "openai" : "openai-compatible";
     let baseURL;
     let apiKey;
     if (providerType === "ollama") {
         baseURL = await ask(rl, "Ollama API URL", existing?.baseURL || "http://localhost:11434/v1");
-        if (!baseURL.replace(/\/$/, "").endsWith("/v1")) {
-            baseURL = `${baseURL.replace(/\/$/, "")}/v1`;
-        }
-        apiKey = "ollama"; // Ollama doesn't need a real key
+        baseURL = normalizeOllamaBaseURL(baseURL);
+        apiKey = "ollama";
     }
     else if (providerType === "openai") {
         baseURL = "https://api.openai.com/v1";
@@ -132,7 +401,6 @@ export async function runSetup() {
     }
     if (!baseURL || (!apiKey && providerType !== "ollama")) {
         console.error("URL 和 Key 不能为空");
-        rl.close();
         process.exit(1);
     }
     console.log("\n正在获取模型列表...");
@@ -146,24 +414,16 @@ export async function runSetup() {
         });
         console.log();
         const choice = await ask(rl, "选择默认模型 (输入序号或模型名)", defaultModel);
-        const idx = parseInt(choice) - 1;
-        if (idx >= 0 && idx < models.length) {
+        const idx = parseInt(choice, 10) - 1;
+        if (idx >= 0 && idx < models.length)
             defaultModel = models[idx];
-        }
-        else if (choice) {
+        else if (choice)
             defaultModel = choice;
-        }
     }
     else {
         console.log("  ⚠ 无法获取模型列表，请手动输入模型名");
         const hint = providerType === "ollama" ? "llama3" : providerType === "openai" ? "gpt-4o" : "";
         defaultModel = await ask(rl, "默认模型", defaultModel || hint);
     }
-    rl.close();
-    config.provider = { type: providerType, baseURL, apiKey, defaultModel };
-    saveConfig(config);
-    console.log(`\n✓ 配置已保存到 ${CONFIG_FILE}`);
-    console.log(`  Type:  ${providerType}`);
-    console.log(`  URL:   ${baseURL}`);
-    console.log(`  Model: ${defaultModel}\n`);
+    return { type: providerType, baseURL, apiKey, defaultModel };
 }

package/dist/confirm.js

@@ -1,13 +1,42 @@
-import { loadConfig } from "./config.js";
+import { AsyncLocalStorage } from "async_hooks";
+import { getEffectiveConfig } from "./config.js";
+import { normalizeQuestionOptions, normalizeQuestionPrompt } from "./question-format.js";
+import readline from "readline";
 let autoApprove = false;
 export function setAutoApprove(value) {
     autoApprove = value;
 }
 export function isAutoApprove() {
+    const ctx = confirmAls.getStore();
+    if (ctx)
+        return ctx.autoApprove;
     if (autoApprove)
         return true;
-    const config = loadConfig();
-    return config.permission === "allow-all";
+    return getPermissionMode() === "allow-all";
+}
+let permissionOverride;
+export function setPermissionOverride(mode) {
+    permissionOverride = mode;
+}
+export function getPermissionOverride() {
+    return permissionOverride;
+}
+export function getPermissionMode() {
+    if (permissionOverride)
+        return permissionOverride;
+    const config = getEffectiveConfig();
+    return config.permission === "allow-all" || config.permission === "accept-edits" || config.permission === "ask"
+        ? config.permission
+        : "ask";
+}
+export function isEditAutoApprove() {
+    if (isAutoApprove())
+        return true;
+    return getPermissionMode() === "accept-edits";
+}
+const confirmAls = new AsyncLocalStorage();
+export function runWithConfirmContext(ctx, fn) {
+    return confirmAls.run(ctx, fn);
 }
 /** Optional readline interface to pause/resume during confirmation prompts. */
 let _rl = null;
@@ -19,16 +48,71 @@ let _tuiConfirm = null;
 export function setTuiConfirm(handler) {
     _tuiConfirm = handler;
 }
+/** Optional TUI question handler — when set, askQuestion() delegates to the TUI. Returns null on cancel. */
+let _tuiQuestion = null;
+export function setTuiQuestion(handler) {
+    _tuiQuestion = handler;
+}
+/** Ask the user a free-form question. Returns the answer, or null if cancelled. */
+export async function askQuestion(prompt, options) {
+    const safePrompt = normalizeQuestionPrompt(prompt);
+    const choices = normalizeQuestionOptions(options);
+    const safeOptions = choices.length > 0 ? choices : undefined;
+    const ctx = confirmAls.getStore();
+    if (ctx) {
+        if (ctx.autoApprove)
+            return null;
+        if (ctx.onQuestion)
+            return ctx.onQuestion(safePrompt, safeOptions);
+        return null;
+    }
+    if (_tuiQuestion)
+        return _tuiQuestion(safePrompt, safeOptions);
+    if (!process.stdin.isTTY) {
+        console.log(`\n\x1b[33m❓ ${safePrompt} (no interactive terminal — skipped)\x1b[0m`);
+        return null;
+    }
+    console.log();
+    console.log(`\x1b[33m❓ ${safePrompt}\x1b[0m`);
+    if (safeOptions) {
+        for (let i = 0; i < safeOptions.length; i++) {
+            console.log(`\x1b[90m   ${i + 1}. ${safeOptions[i]}\x1b[0m`);
+        }
+    }
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question("\x1b[36m   → \x1b[0m", (answer) => {
+            rl.close();
+            resolve(answer.trim() || "(no answer)");
+        });
+    });
+}
 /**
  * Ask user for confirmation. Returns true if approved.
  * Display order: detail first, then [y/N] prompt at the bottom.
  */
 export async function confirm(message) {
+    const ctx = confirmAls.getStore();
+    if (ctx) {
+        if (ctx.autoApprove)
+            return true;
+        if (ctx.onConfirm)
+            return ctx.onConfirm(message);
+        return false;
+    }
     if (isAutoApprove())
         return true;
     // If TUI mode is active, delegate to the TUI overlay
     if (_tuiConfirm)
         return _tuiConfirm(message);
+    // Non-interactive stdin can never answer — reject instead of hanging
+    if (!process.stdin.isTTY) {
+        console.log(`\n\x1b[33m⚠ Rejected (no interactive terminal): ${message}\x1b[0m`);
+        return false;
+    }
     // Pause readline so it doesn't consume/echo the keystroke
     _rl?.pause();
     // Detail on top, prompt at the bottom
@@ -60,17 +144,29 @@ export async function confirm(message) {
 /** Check if a shell command is potentially dangerous */
 export function isDangerousCommand(command) {
     const dangerous = [
-        /\brm\s+(-rf?|--recursive)\s/,
-        /\brm\s+-[a-z]*f/,
+        /\brm\s+(-[a-z]*[rf][a-z]*|--recursive)\s/,
         /\bsudo\b/,
         /\bmkfs\b/,
         /\bdd\s+/,
         /\b(shutdown|reboot|halt|poweroff)\b/,
-        /\bgit\s+(push|reset\s+--hard|clean\s+-[a-z]*f)/,
-        /\bnpm\s+publish\b/,
-        /\bdrop\s+(table|database)\b/i,
-        /\btruncate\s+table\b/i,
+        /\bgit\s+(push|reset\s+--hard|clean\s+-[a-z]*f|rebase)/,
+        /\bnpm\s+(publish|unpublish)\b/,
+        /\b(drop|truncate)\s+(table|database)\b/i,
         /\bformat\b.*\b[a-z]:\b/i,
+        /\bfind\b[^|;&]*\s+-delete\b/,
+        /\|\s*(ba|z|fi)?sh\b/,
+        /\bchmod\s+(-[a-zA-Z]+\s+)?[0-7]{3,4}\b/,
+        /\bchown\s+-R\b/,
+        /\bkill(all)?\s+(-9|-[a-z]*9)/,
+        /\b(pkill|killall)\b/,
+        /\bgit\s+checkout\s+\./,
+        /\bgit\s+stash\b/,
+        /\b(docker|podman)\s+(rm|prune|system)\b/,
+        /\b(shred|wipefs)\b/,
+        /\b(cp|mv)\s+-[a-z]*f\b/,
+        /[^<>=!&]\s*>>?\s*[^<>=&]|^\s*>>?\s*[^<>=&]/,
+        /:\(\)\s*\{/,
+        />+\s*\/dev\/(sd[a-z]+|nvme\d|disk\d)/,
     ];
     return dangerous.some((re) => re.test(command));
 }