@minko-ai/minko 0.1.0 → 0.1.1

package/dist/plugins/loader.js

@@ -0,0 +1,291 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { minkoHome } from "../config/paths.js";
+import { normalizeHookConfig } from "../config/store.js";
+const MAX_TOOLS = 50;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT = 64 * 1024;
+export function pluginsDir() {
+    return path.join(minkoHome(), 'plugins');
+}
+/**
+ * Loads every `<plugins>/<name>/plugin.json`. A broken plugin is reported and
+ * skipped without affecting the others.
+ */
+export function loadPlugins(dir = pluginsDir(), disabled = []) {
+    const plugins = [];
+    const errors = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return { plugins, errors };
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const pluginDir = path.join(dir, entry.name);
+        try {
+            const manifest = readManifest(pluginDir);
+            const name = manifest.name?.trim() || entry.name;
+            validateName(name);
+            if (disabled.includes(name)) {
+                continue;
+            }
+            plugins.push({
+                name,
+                dir: pluginDir,
+                version: manifest.version,
+                description: manifest.description,
+                tools: normalizeTools(manifest.tools, pluginDir, name),
+                hooks: pluginHooks(manifest.hooks, pluginDir),
+            });
+        }
+        catch (error) {
+            errors.push(entry.name + '：' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    return { plugins, errors };
+}
+export function listPlugins(dir = pluginsDir(), disabled = []) {
+    const plugins = [];
+    const errors = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return { plugins, errors };
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const pluginDir = path.join(dir, entry.name);
+        try {
+            const manifest = readManifest(pluginDir);
+            const name = manifest.name?.trim() || entry.name;
+            validateName(name);
+            plugins.push({
+                name,
+                version: manifest.version,
+                description: manifest.description,
+                toolCount: Array.isArray(manifest.tools) ? manifest.tools.length : 0,
+                dir: pluginDir,
+                enabled: !disabled.includes(name),
+            });
+        }
+        catch (error) {
+            errors.push(entry.name + '：' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    return { plugins, errors };
+}
+export function installPlugin(source, dir = pluginsDir()) {
+    const sourceDir = path.resolve(source);
+    const manifest = readManifest(sourceDir);
+    const name = manifest.name?.trim() || path.basename(sourceDir);
+    validateName(name);
+    const target = path.join(dir, name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.cpSync(sourceDir, target, { recursive: true, force: true });
+    return { name, path: target };
+}
+export function uninstallPlugin(name, dir = pluginsDir()) {
+    validateName(name);
+    const target = path.join(dir, name);
+    if (!fs.existsSync(target)) {
+        return false;
+    }
+    fs.rmSync(target, { recursive: true, force: true });
+    return true;
+}
+export function mergeHooks(...configs) {
+    const merged = { PreToolUse: [], PostToolUse: [], PostToolUseFailure: [] };
+    for (const event of ['PreToolUse', 'PostToolUse', 'PostToolUseFailure']) {
+        merged[event] = configs.flatMap((config) => config?.[event] ?? []);
+    }
+    return merged;
+}
+export function readPluginManifest(pluginDir) {
+    return readManifest(pluginDir);
+}
+function readManifest(pluginDir) {
+    const file = path.join(pluginDir, 'plugin.json');
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        throw new Error('缺少 plugin.json');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error('plugin.json 不是合法 JSON');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('plugin.json 必须是对象');
+    }
+    return parsed;
+}
+function normalizeTools(raw, pluginDir, pluginName) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const tools = [];
+    const seen = new Set();
+    for (const item of raw.slice(0, MAX_TOOLS)) {
+        if (item === null || typeof item !== 'object') {
+            continue;
+        }
+        const record = item;
+        if (typeof record.name !== 'string' || record.name.trim().length === 0) {
+            continue;
+        }
+        if (typeof record.command !== 'string' || record.command.trim().length === 0) {
+            continue;
+        }
+        const toolName = 'plugin__' + sanitize(pluginName) + '__' + sanitize(record.name.trim());
+        if (seen.has(toolName)) {
+            continue;
+        }
+        seen.add(toolName);
+        const readOnly = record.readOnly !== false;
+        const timeoutMs = clampInt(record.timeoutMs, 1_000, 300_000) ?? DEFAULT_TIMEOUT_MS;
+        const parameters = isObjectSchema(record.parameters)
+            ? record.parameters
+            : { type: 'object', properties: {} };
+        const description = typeof record.description === 'string' && record.description.trim().length > 0
+            ? record.description.trim()
+            : record.name.trim();
+        tools.push({
+            readOnly,
+            needsApproval: readOnly ? undefined : () => true,
+            spec: {
+                name: toolName,
+                description: '[' + pluginName + '] ' + description,
+                parameters,
+            },
+            async run(args, ctx) {
+                return await runPluginTool(pluginDir, pluginName, record.command, record.name, args, ctx.signal, timeoutMs);
+            },
+        });
+    }
+    return tools;
+}
+function pluginHooks(raw, pluginDir) {
+    const normalized = normalizeHookConfig(raw);
+    const out = { PreToolUse: [], PostToolUse: [], PostToolUseFailure: [] };
+    for (const event of ['PreToolUse', 'PostToolUse', 'PostToolUseFailure']) {
+        out[event] = normalized[event].map((entry) => {
+            if (typeof entry === 'string') {
+                return {
+                    hooks: [{ type: 'command', command: entry, cwd: pluginDir }],
+                };
+            }
+            return {
+                ...(entry.matcher ? { matcher: entry.matcher } : {}),
+                hooks: entry.hooks.map((hook) => ({
+                    ...hook,
+                    cwd: hook.cwd ?? pluginDir,
+                })),
+            };
+        });
+    }
+    return out;
+}
+function runPluginTool(pluginDir, pluginName, command, toolName, args, signal, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error('插件工具已中断'));
+            return;
+        }
+        const child = spawn(command, {
+            shell: true,
+            cwd: pluginDir,
+            windowsHide: true,
+            env: {
+                ...process.env,
+                MINKO: '1',
+                MINKO_PLUGIN: pluginName,
+                MINKO_PLUGIN_DIR: pluginDir,
+                MINKO_TOOL: toolName,
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (error, output) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(output ?? '');
+            }
+        };
+        const onAbort = () => {
+            child.kill();
+            finish(new Error('插件工具已中断'));
+        };
+        const timer = setTimeout(() => {
+            child.kill();
+            finish(new Error('插件工具超时（' + timeoutMs + 'ms）：' + toolName));
+        }, timeoutMs);
+        timer.unref?.();
+        signal.addEventListener('abort', onAbort, { once: true });
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString('utf8'); });
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString('utf8'); });
+        child.stdin.on('error', () => { });
+        child.on('error', (error) => {
+            finish(new Error('插件工具启动失败：' + error.message));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                finish(undefined, cap(stdout.trim(), MAX_OUTPUT));
+                return;
+            }
+            const detail = stderr.trim() || stdout.trim() || 'exit ' + String(code);
+            finish(new Error('插件工具失败（' + toolName + '）：' + detail));
+        });
+        child.stdin.end(JSON.stringify(args));
+    });
+}
+function isObjectSchema(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    return record.type === 'object' && record.properties !== null && typeof record.properties === 'object';
+}
+function sanitize(value) {
+    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+}
+function validateName(name) {
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+        throw new Error('插件名只能包含字母、数字、点、下划线和短横线');
+    }
+}
+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 cap(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    return text.slice(0, max - 20) + '\n…（插件输出过长，已截断）';
+}

package/dist/plugins/market.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { pluginsDir, readPluginManifest } from "./loader.js";
+/** Fetches and validates a plugin marketplace JSON index. */
+export async function fetchMarket(registryUrl) {
+    const response = await fetch(registryUrl, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error('插件市场请求失败（HTTP ' + response.status + '）');
+    }
+    const payload = await response.json();
+    const raw = Array.isArray(payload)
+        ? payload
+        : payload !== null && typeof payload === 'object'
+            ? payload.plugins
+            : null;
+    if (!Array.isArray(raw)) {
+        throw new Error('插件市场索引格式不对');
+    }
+    const entries = [];
+    const seen = new Set();
+    for (const item of raw.slice(0, 200)) {
+        if (item === null || typeof item !== 'object') {
+            continue;
+        }
+        const record = item;
+        if (typeof record.name !== 'string' || record.name.trim().length === 0) {
+            continue;
+        }
+        if (typeof record.git !== 'string' || record.git.trim().length === 0) {
+            continue;
+        }
+        const name = record.name.trim();
+        if (seen.has(name)) {
+            continue;
+        }
+        seen.add(name);
+        entries.push({
+            name,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            version: typeof record.version === 'string' ? record.version : undefined,
+            git: record.git.trim(),
+        });
+    }
+    return entries;
+}
+export function searchMarket(entries, query) {
+    const wanted = query.trim().toLowerCase();
+    if (wanted.length === 0) {
+        return entries;
+    }
+    return entries.filter((entry) => entry.name.toLowerCase().includes(wanted)
+        || (entry.description ?? '').toLowerCase().includes(wanted));
+}
+/** Clones a git repository into the plugin directory. */
+export function installFromGit(url, dir = pluginsDir()) {
+    if (url.trim().length === 0) {
+        throw new Error('缺少 git 地址');
+    }
+    const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'minko-plugin-'));
+    try {
+        try {
+            execFileSync('git', ['clone', '--depth', '1', url, temporary], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                timeout: 60_000,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            const stderr = error.stderr;
+            const detail = stderr ? stderr.toString().trim() : error instanceof Error ? error.message : '';
+            throw new Error('git clone 失败：' + (detail || url));
+        }
+        const manifest = readPluginManifest(temporary);
+        const name = manifest.name?.trim()
+            || path.basename(url).replace(/\.git$/i, '').replace(/[^A-Za-z0-9._-]/g, '-');
+        if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+            throw new Error('插件名不合法：' + name);
+        }
+        const target = path.join(dir, name);
+        if (fs.existsSync(target)) {
+            throw new Error('插件已安装：' + name + '（先 minko plugin uninstall ' + name + '）');
+        }
+        fs.mkdirSync(dir, { recursive: true });
+        fs.cpSync(temporary, target, { recursive: true, force: true });
+        return { name, path: target };
+    }
+    finally {
+        try {
+            fs.rmSync(temporary, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,279 @@
+import { HttpError } from "../util/errors.js";
+import { retryAfterFromHeaders, withRetry } from "./retry.js";
+import { sseEvents } from "./sse.js";
+export function toAnthropicMessages(messages) {
+    const systemParts = [];
+    const out = [];
+    const push = (role, blocks) => {
+        if (blocks.length === 0) {
+            return;
+        }
+        const last = out.length > 0 ? out[out.length - 1] : undefined;
+        if (last && last.role === role) {
+            last.content.push(...blocks);
+            return;
+        }
+        out.push({ role, content: blocks });
+    };
+    for (const message of messages) {
+        if (message.role === 'system') {
+            systemParts.push(message.content);
+            continue;
+        }
+        if (message.role === 'tool') {
+            push('user', [{ type: 'tool_result', tool_use_id: message.toolCallId, content: message.content }]);
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const blocks = [];
+            if (message.content.length > 0) {
+                blocks.push({ type: 'text', text: message.content });
+            }
+            for (const call of message.toolCalls) {
+                blocks.push({ type: 'tool_use', id: call.id, name: call.name, input: safeParse(call.arguments) });
+            }
+            push('assistant', blocks);
+            continue;
+        }
+        push('user', [{ type: 'text', text: message.content }]);
+    }
+    return { system: systemParts.join('\n\n'), messages: out };
+}
+function safeParse(raw) {
+    if (raw.trim().length === 0) {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export class AnthropicProvider {
+    config;
+    retry;
+    cacheEnabled = true;
+    constructor(config, retry = {}) {
+        this.config = config;
+        this.retry = retry;
+    }
+    async stream(messages, tools, handlers, signal) {
+        const converted = toAnthropicMessages(messages);
+        let response;
+        try {
+            response = await this.send(converted, tools, handlers, signal, this.cacheEnabled);
+        }
+        catch (error) {
+            // Some Anthropic-compatible gateways reject cache_control. Retry once
+            // without markers so caching is an optimization, never a hard failure.
+            if (this.cacheEnabled
+                && error instanceof HttpError
+                && error.status === 400
+                && /cache_control|prompt cach/i.test(error.body)) {
+                this.cacheEnabled = false;
+                response = await this.send(converted, tools, handlers, signal, false);
+            }
+            else {
+                throw error;
+            }
+        }
+        if (!response.body) {
+            throw new Error('服务端没有返回可读的流');
+        }
+        const textParts = [];
+        const reasoningParts = [];
+        const toolCalls = [];
+        let usage = { input: 0, output: 0 };
+        let current = null;
+        for await (const event of sseEvents(response.body)) {
+            let payload;
+            try {
+                payload = JSON.parse(event.data);
+            }
+            catch {
+                continue;
+            }
+            switch (event.event) {
+                case 'message_start': {
+                    const message = payload.message;
+                    const rawUsage = message?.usage;
+                    if (rawUsage) {
+                        const next = {
+                            input: numberOrZero(rawUsage.input_tokens),
+                            output: numberOrZero(rawUsage.output_tokens),
+                        };
+                        const cached = numberOrZero(rawUsage.cache_read_input_tokens);
+                        if (cached > 0) {
+                            next.cached = cached;
+                        }
+                        usage = next;
+                        handlers.onUsage?.(usage);
+                    }
+                    break;
+                }
+                case 'content_block_start': {
+                    const block = payload.content_block;
+                    const index = typeof payload.index === 'number' ? payload.index : -1;
+                    if (!block) {
+                        break;
+                    }
+                    if (block.type === 'tool_use') {
+                        current = {
+                            kind: 'tool',
+                            id: typeof block.id === 'string' ? block.id : 'tool_' + index,
+                            name: typeof block.name === 'string' ? block.name : '',
+                            json: '',
+                        };
+                    }
+                    else if (block.type === 'thinking') {
+                        current = { kind: 'thinking', id: '', name: '', json: '' };
+                    }
+                    else {
+                        current = { kind: 'text', id: '', name: '', json: '' };
+                        const initial = block.text;
+                        if (typeof initial === 'string' && initial.length > 0) {
+                            textParts.push(initial);
+                            handlers.onText?.(initial);
+                        }
+                    }
+                    break;
+                }
+                case 'content_block_delta': {
+                    const delta = payload.delta;
+                    if (!delta) {
+                        break;
+                    }
+                    if (delta.type === 'text_delta' && typeof delta.text === 'string') {
+                        textParts.push(delta.text);
+                        handlers.onText?.(delta.text);
+                    }
+                    else if (delta.type === 'thinking_delta' && typeof delta.thinking === 'string') {
+                        reasoningParts.push(delta.thinking);
+                        handlers.onReasoning?.(delta.thinking);
+                    }
+                    else if (delta.type === 'input_json_delta' && typeof delta.partial_json === 'string' && current) {
+                        current.json += delta.partial_json;
+                    }
+                    break;
+                }
+                case 'content_block_stop': {
+                    if (current && current.kind === 'tool') {
+                        const call = {
+                            id: current.id,
+                            name: current.name,
+                            arguments: current.json.trim().length > 0 ? current.json : '{}',
+                        };
+                        toolCalls.push(call);
+                        handlers.onToolCall?.(call);
+                    }
+                    current = null;
+                    break;
+                }
+                case 'message_delta': {
+                    const rawUsage = payload.usage;
+                    if (rawUsage && typeof rawUsage.output_tokens === 'number') {
+                        const next = { input: usage.input, output: rawUsage.output_tokens };
+                        if (usage.cached !== undefined) {
+                            next.cached = usage.cached;
+                        }
+                        usage = next;
+                        handlers.onUsage?.(usage);
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        return {
+            text: textParts.join(''),
+            reasoning: reasoningParts.join(''),
+            toolCalls,
+            usage,
+        };
+    }
+    async send(converted, tools, handlers, signal, cacheEnabled) {
+        const body = buildAnthropicBody(this.config, converted, tools, cacheEnabled);
+        const headers = {
+            'content-type': 'application/json',
+            'anthropic-version': '2023-06-01',
+        };
+        if (this.config.auth === 'bearer') {
+            headers.authorization = 'Bearer ' + this.config.apiKey;
+        }
+        else {
+            headers['x-api-key'] = this.config.apiKey;
+        }
+        return await withRetry(async () => {
+            const result = await fetch(messagesUrl(this.config.baseUrl), {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!result.ok) {
+                throw new HttpError(result.status, await result.text(), retryAfterFromHeaders(result.headers));
+            }
+            return result;
+        }, { ...this.retry, signal, onRetry: handlers.onRetry });
+    }
+}
+function buildAnthropicBody(config, converted, tools, cacheEnabled) {
+    const toolDefs = tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+    }));
+    if (cacheEnabled && toolDefs.length > 0) {
+        toolDefs[toolDefs.length - 1].cache_control = { type: 'ephemeral' };
+    }
+    // A stable order matters: system → tools → conversation. The last block is
+    // the moving breakpoint, so the whole prefix before it can be reused.
+    const messages = cacheEnabled ? addMessageCache(converted.messages) : converted.messages;
+    const system = cacheEnabled && converted.system.length > 0
+        ? [{ type: 'text', text: converted.system, cache_control: { type: 'ephemeral' } }]
+        : converted.system;
+    const body = {
+        model: config.model,
+        max_tokens: config.maxTokens && config.maxTokens > 0 ? config.maxTokens : 8192,
+        system,
+        messages,
+        stream: true,
+    };
+    if (toolDefs.length > 0) {
+        body.tools = toolDefs;
+    }
+    return body;
+}
+function addMessageCache(messages) {
+    if (messages.length === 0) {
+        return messages;
+    }
+    const out = messages.map((message) => ({
+        role: message.role,
+        content: message.content.slice(),
+    }));
+    const last = out[out.length - 1];
+    if (last.content.length > 0) {
+        const index = last.content.length - 1;
+        last.content[index] = {
+            ...last.content[index],
+            cache_control: { type: 'ephemeral' },
+        };
+    }
+    return out;
+}
+function messagesUrl(baseUrl) {
+    const base = baseUrl.replace(/\/+$/, '');
+    if (/\/v1$/i.test(base)) {
+        return base + '/messages';
+    }
+    return base + '/v1/messages';
+}
+function numberOrZero(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+export function createAnthropicProvider(config) {
+    return new AnthropicProvider(config);
+}