@minko-ai/minko 0.1.0 → 0.1.1

package/dist/config/store.js

@@ -0,0 +1,605 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configPath } from "./paths.js";
+export const POWER_LABELS = {
+    full: '完全开放权限',
+    workspace: '工作区权限',
+    restricted: '受限制访问（默认）',
+    readonly: '禁止访问文件',
+};
+export const PRESETS = [
+    {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        kind: 'openai',
+        baseUrl: 'https://api.deepseek.com',
+        model: 'deepseek-flash',
+        hint: 'DeepSeek 开放平台，OpenAI 兼容',
+    },
+    {
+        id: 'anthropic',
+        label: 'Claude',
+        kind: 'anthropic',
+        baseUrl: 'https://api.anthropic.com',
+        model: 'claude-sonnet-5-5',
+        hint: 'Anthropic 官方 API',
+    },
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        kind: 'openai',
+        baseUrl: 'https://api.openai.com/v1',
+        model: 'gpt-4.1',
+        hint: 'OpenAI 官方 API',
+    },
+    {
+        id: 'xai',
+        label: 'xAI',
+        kind: 'openai',
+        baseUrl: 'https://api.x.ai/v1',
+        model: 'grok-3',
+        hint: 'xAI Grok，OpenAI 兼容',
+    },
+    {
+        id: 'dashscope',
+        label: 'DashScope / Qwen',
+        kind: 'openai',
+        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+        model: 'qwen-plus',
+        hint: '阿里云百炼，OpenAI 兼容',
+    },
+    {
+        id: 'kimi',
+        label: 'Kimi / Moonshot',
+        kind: 'openai',
+        baseUrl: 'https://api.moonshot.cn/v1',
+        model: 'kimi-k2.5',
+        hint: 'Moonshot，OpenAI 兼容',
+    },
+    {
+        id: 'openrouter',
+        label: 'OpenRouter',
+        kind: 'openai',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        model: 'openrouter/auto',
+        hint: 'OpenRouter 聚合网关',
+    },
+    {
+        id: 'ollama',
+        label: 'Ollama（本地）',
+        kind: 'openai',
+        baseUrl: 'http://127.0.0.1:11434/v1',
+        model: 'qwen3:latest',
+        hint: '本地 Ollama，不需要 API Key',
+        noKey: true,
+    },
+];
+export function emptyConfig() {
+    return {
+        active: '',
+        providers: {},
+        approval: 'ask',
+        maxTokens: 8192,
+        power: 'restricted',
+        permissions: emptyPermissionRules(),
+        hooks: emptyHookConfig(),
+        mcpServers: {},
+        rag: {},
+        lsp: {},
+        plugins: { disabled: [] },
+        oauth: {},
+        web: {},
+        fallbackProviders: [],
+        modelAliases: {},
+        sandbox: { mode: 'off' },
+    };
+}
+export function loadConfig(file = configPath()) {
+    if (!fs.existsSync(file)) {
+        return emptyConfig();
+    }
+    const raw = fs.readFileSync(file, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('配置文件不是合法的 JSON：' + file);
+    }
+    return normalizeConfig(parsed);
+}
+export function normalizeConfig(input) {
+    const base = emptyConfig();
+    if (input === null || typeof input !== 'object') {
+        return base;
+    }
+    const record = input;
+    const providers = {};
+    const rawProviders = record.providers;
+    if (rawProviders && typeof rawProviders === 'object') {
+        for (const [name, value] of Object.entries(rawProviders)) {
+            const entry = normalizeProvider(value);
+            if (entry) {
+                providers[name] = entry;
+            }
+        }
+    }
+    const active = typeof record.active === 'string' ? record.active : '';
+    const approval = record.approval === 'auto' ? 'auto' : 'ask';
+    const maxTokens = typeof record.maxTokens === 'number' && record.maxTokens > 0
+        ? Math.floor(record.maxTokens)
+        : base.maxTokens;
+    const power = record.power === 'full' || record.power === 'workspace'
+        || record.power === 'readonly'
+        ? record.power
+        : 'restricted';
+    return {
+        active,
+        providers,
+        approval,
+        maxTokens,
+        power,
+        permissions: normalizePermissionRules(record.permissions),
+        hooks: normalizeHookConfig(record.hooks),
+        mcpServers: normalizeMcpServers(record.mcpServers),
+        rag: normalizeRagConfig(record.rag),
+        lsp: normalizeLspConfig(record.lsp),
+        plugins: normalizePluginsConfig(record.plugins),
+        oauth: normalizeOAuthConfig(record.oauth),
+        web: normalizeWebConfig(record.web),
+        fallbackProviders: normalizeStringArray(record.fallbackProviders, 10),
+        modelAliases: normalizeStringMap(record.modelAliases, 100),
+        sandbox: normalizeSandboxConfig(record.sandbox),
+    };
+}
+function emptyPermissionRules() {
+    return { deny: [], ask: [], allow: [] };
+}
+function emptyHookConfig() {
+    return { PreToolUse: [], PostToolUse: [], PostToolUseFailure: [] };
+}
+function normalizePermissionRules(value) {
+    const out = emptyPermissionRules();
+    if (value === null || typeof value !== 'object') {
+        return out;
+    }
+    const record = value;
+    for (const action of ['deny', 'ask', 'allow']) {
+        const list = record[action];
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        out[action] = list
+            .filter((item) => typeof item === 'string' && item.trim().length > 0)
+            .map((item) => item.trim())
+            .slice(0, 200);
+    }
+    return out;
+}
+export function normalizeHookConfig(value) {
+    const out = emptyHookConfig();
+    if (value === null || typeof value !== 'object') {
+        return out;
+    }
+    const record = value;
+    for (const event of ['PreToolUse', 'PostToolUse', 'PostToolUseFailure']) {
+        const list = record[event];
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        const entries = [];
+        for (const item of list.slice(0, 100)) {
+            if (typeof item === 'string') {
+                const command = item.trim();
+                if (command.length > 0) {
+                    entries.push(command);
+                }
+                continue;
+            }
+            if (item === null || typeof item !== 'object') {
+                continue;
+            }
+            const raw = item;
+            if (!Array.isArray(raw.hooks)) {
+                continue;
+            }
+            const commands = [];
+            for (const candidate of raw.hooks) {
+                if (candidate === null || typeof candidate !== 'object') {
+                    continue;
+                }
+                const hook = candidate;
+                if (hook.type !== undefined && hook.type !== 'command') {
+                    continue;
+                }
+                if (typeof hook.command !== 'string' || hook.command.trim().length === 0) {
+                    continue;
+                }
+                const command = { type: 'command', command: hook.command.trim() };
+                if (typeof hook.cwd === 'string' && hook.cwd.trim().length > 0) {
+                    command.cwd = hook.cwd.trim();
+                }
+                commands.push(command);
+            }
+            if (commands.length === 0) {
+                continue;
+            }
+            const matcher = typeof raw.matcher === 'string' && raw.matcher.trim().length > 0
+                ? raw.matcher.trim()
+                : undefined;
+            entries.push(matcher ? { matcher, hooks: commands } : { hooks: commands });
+        }
+        out[event] = entries;
+    }
+    return out;
+}
+function normalizeMcpServers(value) {
+    const out = {};
+    if (value === null || typeof value !== 'object') {
+        return out;
+    }
+    const record = value;
+    let count = 0;
+    for (const [name, raw] of Object.entries(record)) {
+        if (count >= 20) {
+            break;
+        }
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const entry = raw;
+        const command = typeof entry.command === 'string' ? entry.command.trim() : '';
+        const url = typeof entry.url === 'string' ? entry.url.trim() : '';
+        if (command.length === 0 && url.length === 0) {
+            continue;
+        }
+        const server = command.length > 0 ? { command } : { url };
+        if (Array.isArray(entry.args)) {
+            const args = entry.args.filter((item) => typeof item === 'string');
+            if (args.length > 0) {
+                server.args = args;
+            }
+        }
+        if (entry.env !== null && typeof entry.env === 'object') {
+            const env = {};
+            for (const [key, item] of Object.entries(entry.env)) {
+                if (typeof item === 'string') {
+                    env[key] = item;
+                }
+            }
+            if (Object.keys(env).length > 0) {
+                server.env = env;
+            }
+        }
+        if (typeof entry.cwd === 'string' && entry.cwd.trim().length > 0) {
+            server.cwd = entry.cwd.trim();
+        }
+        if (typeof entry.token === 'string' && entry.token.trim().length > 0) {
+            server.token = entry.token.trim();
+        }
+        if (entry.oauth !== null && typeof entry.oauth === 'object') {
+            const oauth = entry.oauth;
+            const deviceAuthorizationUrl = typeof oauth.deviceAuthorizationUrl === 'string'
+                ? oauth.deviceAuthorizationUrl.trim() : '';
+            const tokenUrl = typeof oauth.tokenUrl === 'string' ? oauth.tokenUrl.trim() : '';
+            const clientId = typeof oauth.clientId === 'string' ? oauth.clientId.trim() : '';
+            if (deviceAuthorizationUrl && tokenUrl && clientId) {
+                const parsed = { deviceAuthorizationUrl, tokenUrl, clientId };
+                if (Array.isArray(oauth.scopes)) {
+                    const scopes = oauth.scopes.filter((item) => typeof item === 'string' && item.trim().length > 0).map((item) => item.trim()).slice(0, 20);
+                    if (scopes.length > 0) {
+                        parsed.scopes = scopes;
+                    }
+                }
+                server.oauth = parsed;
+            }
+        }
+        out[name] = server;
+        count += 1;
+    }
+    return out;
+}
+function normalizeRagConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return {};
+    }
+    const rag = value;
+    const out = {};
+    const embeddings = normalizeRagEmbeddings(rag.embeddings);
+    if (embeddings) {
+        out.embeddings = embeddings;
+    }
+    const remote = normalizeRagRemote(rag.remote);
+    if (remote) {
+        out.remote = remote;
+    }
+    return out;
+}
+function normalizeRagEmbeddings(value) {
+    if (value === null || typeof value !== 'object') {
+        return undefined;
+    }
+    const entry = value;
+    const embeddings = { enabled: entry.enabled !== false };
+    const baseUrl = typeof entry.baseUrl === 'string' ? entry.baseUrl.trim() : '';
+    if (baseUrl.length > 0) {
+        embeddings.baseUrl = baseUrl;
+    }
+    const model = typeof entry.model === 'string' ? entry.model.trim() : '';
+    if (model.length > 0) {
+        embeddings.model = model;
+    }
+    const apiKey = typeof entry.apiKey === 'string' ? entry.apiKey.trim() : '';
+    if (apiKey.length > 0) {
+        embeddings.apiKey = apiKey;
+    }
+    const batchSize = clampInt(entry.batchSize, 1, 128);
+    if (batchSize !== undefined) {
+        embeddings.batchSize = batchSize;
+    }
+    const maxChunks = clampInt(entry.maxChunks, 100, 10_000);
+    if (maxChunks !== undefined) {
+        embeddings.maxChunks = maxChunks;
+    }
+    const dimensions = clampInt(entry.dimensions, 64, 4_096);
+    if (dimensions !== undefined) {
+        embeddings.dimensions = dimensions;
+    }
+    return embeddings;
+}
+function normalizeRagRemote(value) {
+    if (value === null || typeof value !== 'object') {
+        return undefined;
+    }
+    const entry = value;
+    const baseUrl = typeof entry.baseUrl === 'string' ? entry.baseUrl.trim() : '';
+    if (baseUrl.length === 0) {
+        return undefined;
+    }
+    const remote = { baseUrl };
+    const apiKey = typeof entry.apiKey === 'string' ? entry.apiKey.trim() : '';
+    if (apiKey.length > 0) {
+        remote.apiKey = apiKey;
+    }
+    const timeoutMs = clampInt(entry.timeoutMs, 500, 60_000);
+    if (timeoutMs !== undefined) {
+        remote.timeoutMs = timeoutMs;
+    }
+    const topK = clampInt(entry.topK, 1, 20);
+    if (topK !== undefined) {
+        remote.topK = topK;
+    }
+    return remote;
+}
+function clampInt(value, min, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function normalizeLspConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return {};
+    }
+    const raw = value.servers;
+    if (raw === null || typeof raw !== 'object') {
+        return {};
+    }
+    const servers = {};
+    let count = 0;
+    for (const [language, entry] of Object.entries(raw)) {
+        if (count >= 20) {
+            break;
+        }
+        if (entry === null || typeof entry !== 'object') {
+            continue;
+        }
+        const record = entry;
+        if (typeof record.command !== 'string' || record.command.trim().length === 0) {
+            continue;
+        }
+        const server = { command: record.command.trim() };
+        if (Array.isArray(record.args)) {
+            const args = record.args.filter((item) => typeof item === 'string');
+            if (args.length > 0) {
+                server.args = args;
+            }
+        }
+        servers[language] = server;
+        count += 1;
+    }
+    return Object.keys(servers).length > 0 ? { servers } : {};
+}
+function normalizePluginsConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return { disabled: [] };
+    }
+    const record = value;
+    const raw = record.disabled;
+    const disabled = Array.isArray(raw)
+        ? raw
+            .filter((item) => typeof item === 'string' && item.trim().length > 0)
+            .map((item) => item.trim())
+            .slice(0, 100)
+        : [];
+    const registryUrl = typeof record.registryUrl === 'string' ? record.registryUrl.trim() : '';
+    return {
+        disabled,
+        ...(registryUrl.length > 0 ? { registryUrl } : {}),
+    };
+}
+function normalizeOAuthConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return {};
+    }
+    const record = value;
+    const oauth = {};
+    const deviceAuthorizationUrl = typeof record.deviceAuthorizationUrl === 'string'
+        ? record.deviceAuthorizationUrl.trim() : '';
+    if (deviceAuthorizationUrl.length > 0) {
+        oauth.deviceAuthorizationUrl = deviceAuthorizationUrl;
+    }
+    const tokenUrl = typeof record.tokenUrl === 'string' ? record.tokenUrl.trim() : '';
+    if (tokenUrl.length > 0) {
+        oauth.tokenUrl = tokenUrl;
+    }
+    const clientId = typeof record.clientId === 'string' ? record.clientId.trim() : '';
+    if (clientId.length > 0) {
+        oauth.clientId = clientId;
+    }
+    if (Array.isArray(record.scopes)) {
+        const scopes = record.scopes
+            .filter((item) => typeof item === 'string' && item.trim().length > 0)
+            .map((item) => item.trim())
+            .slice(0, 20);
+        if (scopes.length > 0) {
+            oauth.scopes = scopes;
+        }
+    }
+    const provider = typeof record.provider === 'string' ? record.provider.trim() : '';
+    if (provider.length > 0) {
+        oauth.provider = provider;
+    }
+    const name = typeof record.name === 'string' ? record.name.trim() : '';
+    if (name.length > 0) {
+        oauth.name = name;
+    }
+    return oauth;
+}
+function normalizeWebConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return {};
+    }
+    const record = value;
+    const searchUrl = typeof record.searchUrl === 'string' ? record.searchUrl.trim() : '';
+    return searchUrl.length > 0 ? { searchUrl } : {};
+}
+function normalizeSandboxConfig(value) {
+    if (value === null || typeof value !== 'object') {
+        return { mode: 'off' };
+    }
+    const record = value;
+    if (record.mode !== 'docker') {
+        return { mode: 'off' };
+    }
+    const sandbox = { mode: 'docker' };
+    const image = typeof record.image === 'string' ? record.image.trim() : '';
+    if (image.length > 0) {
+        sandbox.image = image;
+    }
+    if (record.network === true) {
+        sandbox.network = true;
+    }
+    if (record.allowFallback === true) {
+        sandbox.allowFallback = true;
+    }
+    if (Array.isArray(record.extraArgs)) {
+        const extraArgs = record.extraArgs
+            .filter((item) => typeof item === 'string' && item.trim().length > 0)
+            .map((item) => item.trim())
+            .slice(0, 20);
+        if (extraArgs.length > 0) {
+            sandbox.extraArgs = extraArgs;
+        }
+    }
+    return sandbox;
+}
+function normalizeStringArray(value, cap) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((item) => typeof item === 'string' && item.trim().length > 0)
+        .map((item) => item.trim())
+        .slice(0, cap);
+}
+function normalizeStringMap(value, cap) {
+    if (value === null || typeof value !== 'object') {
+        return {};
+    }
+    const out = {};
+    let count = 0;
+    for (const [key, item] of Object.entries(value)) {
+        if (count >= cap) {
+            break;
+        }
+        if (typeof item !== 'string' || item.trim().length === 0) {
+            continue;
+        }
+        out[key.trim()] = item.trim();
+        count += 1;
+    }
+    return out;
+}
+function normalizeProvider(value) {
+    if (value === null || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    const kind = record.kind === 'anthropic' ? 'anthropic' : 'openai';
+    const baseUrl = typeof record.baseUrl === 'string' ? record.baseUrl.trim() : '';
+    const model = typeof record.model === 'string' ? record.model.trim() : '';
+    const apiKey = typeof record.apiKey === 'string' ? record.apiKey.trim() : '';
+    if (baseUrl.length === 0 || model.length === 0) {
+        return null;
+    }
+    const maxTokens = typeof record.maxTokens === 'number' && record.maxTokens > 0
+        ? Math.floor(record.maxTokens)
+        : undefined;
+    const auth = record.auth === 'bearer' ? 'bearer' : undefined;
+    return { kind, baseUrl: normalizeBaseUrl(baseUrl), model, apiKey, maxTokens, auth };
+}
+export function normalizeBaseUrl(url) {
+    return url.trim().replace(/\/+$/, '');
+}
+export function saveConfig(config, file = configPath()) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    try {
+        fs.chmodSync(file, 0o600);
+    }
+    catch {
+        // Windows ignores POSIX modes; the file still lives under the user profile.
+    }
+}
+export function activeProvider(config) {
+    const name = config.active;
+    if (!name) {
+        return null;
+    }
+    const provider = config.providers[name];
+    if (!provider) {
+        return null;
+    }
+    return { name, provider };
+}
+export function presetById(id) {
+    return PRESETS.find((preset) => preset.id === id);
+}
+export function upsertProvider(config, name, provider) {
+    return {
+        ...config,
+        active: name,
+        providers: { ...config.providers, [name]: provider },
+    };
+}
+/** Local gateways (Ollama, LM Studio, etc.) do not need an API key. */
+export function needsApiKey(baseUrl) {
+    return !/^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(?::|\/|$)/i.test(baseUrl);
+}
+/** Problems that must be fixed before the first request is sent. */
+export function configProblems(config) {
+    const problems = [];
+    const active = activeProvider(config);
+    if (!active) {
+        problems.push('还没有配置模型：运行 minko config 选择服务商并填入 API Key');
+        return problems;
+    }
+    if (active.provider.apiKey.length === 0 && needsApiKey(active.provider.baseUrl)) {
+        problems.push('模型 ' + active.name + ' 还没有 API Key：运行 minko config --api-key <key>');
+    }
+    if (!/^https?:\/\//i.test(active.provider.baseUrl)) {
+        problems.push('服务地址必须以 http:// 或 https:// 开头');
+    }
+    return problems;
+}