@minko-ai/minko 0.1.0 → 0.1.1

package/dist/mcp/server.js

@@ -0,0 +1,206 @@
+import readline from 'node:readline';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { ALL_TOOLS } from "../tools/registry.js";
+import { listSkills, readSkill } from "../skills/index.js";
+import { readVersion } from "../util/version.js";
+/** Minko as an MCP stdio server; read-only tools are exposed by default. */
+export class McpServer {
+    cwd;
+    config;
+    tools;
+    constructor(options = {}) {
+        this.cwd = options.cwd ?? process.cwd();
+        this.config = options.config;
+        this.tools = options.tools ?? ALL_TOOLS.filter((tool) => tool.readOnly);
+    }
+    async handle(message) {
+        const method = typeof message.method === 'string' ? message.method : '';
+        const id = message.id;
+        if (method === 'initialize') {
+            return result(id, {
+                protocolVersion: '2024-11-05',
+                capabilities: { tools: {}, resources: {}, prompts: {} },
+                serverInfo: { name: 'minko', version: readVersion() },
+            });
+        }
+        if (method === 'notifications/initialized') {
+            return null;
+        }
+        if (method === 'tools/list') {
+            return result(id, {
+                tools: this.tools.map((tool) => ({
+                    name: tool.spec.name,
+                    description: tool.spec.description,
+                    inputSchema: tool.spec.parameters,
+                })),
+            });
+        }
+        if (method === 'tools/call') {
+            const params = message.params !== null && typeof message.params === 'object'
+                ? message.params : {};
+            const name = typeof params.name === 'string' ? params.name : '';
+            const args = params.arguments !== null && typeof params.arguments === 'object'
+                ? params.arguments : {};
+            const tool = this.tools.find((candidate) => candidate.spec.name === name);
+            if (!tool) {
+                return error(id, -32602, 'unknown tool: ' + name);
+            }
+            try {
+                const text = await tool.run(args, {
+                    cwd: this.cwd,
+                    signal: new AbortController().signal,
+                    approve: async () => false,
+                    config: this.config,
+                });
+                return result(id, { content: [{ type: 'text', text }] });
+            }
+            catch (caught) {
+                return result(id, {
+                    content: [{
+                            type: 'text',
+                            text: '错误：' + (caught instanceof Error ? caught.message : String(caught)),
+                        }],
+                    isError: true,
+                });
+            }
+        }
+        if (method === 'resources/list') {
+            return result(id, { resources: this.listResources() });
+        }
+        if (method === 'resources/templates/list') {
+            return result(id, {
+                resourceTemplates: [{
+                        uriTemplate: 'file://{path}',
+                        name: 'workspace file',
+                        description: '工作区内的文件',
+                        mimeType: 'text/plain',
+                    }],
+            });
+        }
+        if (method === 'prompts/list') {
+            return result(id, {
+                prompts: listSkills(this.cwd).map((skill) => ({
+                    name: skill.name,
+                    description: skill.description,
+                    arguments: [{
+                            name: 'args',
+                            description: '传给技能 {{args}} 的参数',
+                            required: false,
+                        }],
+                })),
+            });
+        }
+        if (method === 'prompts/get') {
+            const params = message.params !== null && typeof message.params === 'object'
+                ? message.params : {};
+            const name = typeof params.name === 'string' ? params.name : '';
+            const args = params.arguments !== null && typeof params.arguments === 'object'
+                ? params.arguments : {};
+            const skill = readSkill(this.cwd, name, typeof args.args === 'string' ? args.args : '');
+            if (!skill) {
+                return error(id, -32602, 'prompt not found: ' + name);
+            }
+            return result(id, {
+                description: skill.description,
+                messages: [{
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: '# 技能：' + skill.name + '\n\n' + skill.body,
+                        },
+                    }],
+            });
+        }
+        if (method === 'resources/read') {
+            const params = message.params !== null && typeof message.params === 'object'
+                ? message.params : {};
+            const uri = typeof params.uri === 'string' ? params.uri : '';
+            if (!uri.startsWith('file://')) {
+                return error(id, -32602, '只支持 file:// resource');
+            }
+            let file;
+            try {
+                file = fileURLToPath(uri);
+            }
+            catch {
+                return error(id, -32602, 'resource URI 不合法');
+            }
+            const relative = path.relative(this.cwd, file);
+            if (relative.startsWith('..') || path.isAbsolute(relative)) {
+                return error(id, -32602, 'resource 不在工作目录内');
+            }
+            try {
+                let text = await fs.promises.readFile(file, 'utf8');
+                if (text.length > 64 * 1024) {
+                    text = text.slice(0, 64 * 1024) + '\n…（已截断）';
+                }
+                return result(id, { contents: [{ uri, mimeType: 'text/plain', text }] });
+            }
+            catch (caught) {
+                return error(id, -32603, caught instanceof Error ? caught.message : String(caught));
+            }
+        }
+        if (method === 'shutdown') {
+            return result(id, null);
+        }
+        if (method === 'exit') {
+            return null;
+        }
+        if (id !== undefined && id !== null) {
+            return error(id, -32601, 'method not found: ' + method);
+        }
+        return null;
+    }
+    listResources() {
+        const candidates = new Set();
+        for (const name of ['MINKO.md', 'AGENTS.md', 'CLAUDE.md', 'README.md', 'package.json']) {
+            const file = path.join(this.cwd, name);
+            if (fs.existsSync(file)) {
+                candidates.add(file);
+            }
+        }
+        for (const skill of listSkills(this.cwd)) {
+            if (skill.source === 'project') {
+                candidates.add(skill.path);
+            }
+        }
+        return [...candidates].slice(0, 50).map((file) => ({
+            uri: pathToFileURL(file).href,
+            name: path.relative(this.cwd, file).split(path.sep).join('/'),
+            description: 'Minko workspace file',
+            mimeType: file.endsWith('.json') ? 'application/json' : 'text/markdown',
+        }));
+    }
+}
+export async function runMcpServer(options = {}) {
+    const server = new McpServer(options);
+    const rl = readline.createInterface({ input: process.stdin });
+    for await (const line of rl) {
+        if (line.trim().length === 0) {
+            continue;
+        }
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const response = await server.handle(message);
+        if (response) {
+            process.stdout.write(JSON.stringify(response) + '\n');
+        }
+        if (message.method === 'exit') {
+            break;
+        }
+    }
+    return 0;
+}
+function result(id, value) {
+    return { jsonrpc: '2.0', id, result: value };
+}
+function error(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+}

package/dist/mcp/tools.js

@@ -0,0 +1,173 @@
+import { McpStdioClient } from "./client.js";
+import { McpHttpClient } from "./httpClient.js";
+/** Starts every configured MCP server and exposes its tools as normal Minko tools. */
+export async function connectMcpServers(config) {
+    const entries = Object.entries(config ?? {}).slice(0, 20);
+    const clients = [];
+    const tools = [];
+    const errors = [];
+    await Promise.all(entries.map(async ([name, server]) => {
+        const client = server.url
+            ? new McpHttpClient(name, server)
+            : new McpStdioClient(name, server);
+        try {
+            await client.start();
+            clients.push(client);
+            for (const definition of client.tools()) {
+                tools.push(bridgeTool(name, definition, client));
+            }
+            tools.push(resourceListTool(name, client));
+            tools.push(resourceReadTool(name, client));
+            tools.push(promptListTool(name, client));
+            tools.push(promptGetTool(name, client));
+            tools.push(resourceTemplateListTool(name, client));
+        }
+        catch (error) {
+            errors.push(name + '：' + (error instanceof Error ? error.message : String(error)));
+            await client.close().catch(() => { });
+        }
+    }));
+    tools.sort((a, b) => a.spec.name.localeCompare(b.spec.name));
+    return {
+        tools,
+        errors,
+        close: async () => {
+            await Promise.all(clients.map((client) => client.close().catch(() => { })));
+        },
+    };
+}
+function bridgeTool(serverName, definition, client) {
+    const parameters = isObjectSchema(definition.inputSchema)
+        ? definition.inputSchema
+        : { type: 'object', properties: {} };
+    return {
+        readOnly: false,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__' + sanitize(definition.name),
+            description: '[' + serverName + '] ' + (definition.description ?? definition.name),
+            parameters,
+        },
+        async run(args) {
+            return await client.callTool(definition.name, args);
+        },
+    };
+}
+function sanitize(value) {
+    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+}
+function resourceListTool(serverName, client) {
+    return {
+        readOnly: true,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__list_resources',
+            description: '[' + serverName + '] 列出 MCP server 提供的资源。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const resources = await client.listResources();
+            if (resources.length === 0) {
+                return '没有资源。';
+            }
+            return resources.map((resource) => resource.uri
+                + (resource.name ? ' — ' + resource.name : '')
+                + (resource.description ? ' — ' + resource.description : '')
+                + (resource.mimeType ? '（' + resource.mimeType + '）' : '')).join('\n');
+        },
+    };
+}
+function resourceReadTool(serverName, client) {
+    return {
+        readOnly: true,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__read_resource',
+            description: '[' + serverName + '] 读取一个 MCP resource URI 的内容。',
+            parameters: {
+                type: 'object',
+                properties: { uri: { type: 'string' } },
+                required: ['uri'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const uri = typeof args.uri === 'string' ? args.uri.trim() : '';
+            if (uri.length === 0) {
+                throw new Error('缺少 uri 参数');
+            }
+            return await client.readResource(uri);
+        },
+    };
+}
+function promptListTool(serverName, client) {
+    return {
+        readOnly: true,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__list_prompts',
+            description: '[' + serverName + '] 列出 MCP prompts。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const prompts = await client.listPrompts();
+            if (prompts.length === 0) {
+                return '没有 prompt。';
+            }
+            return prompts.map((prompt) => prompt.name
+                + (prompt.description ? ' — ' + prompt.description : '')
+                + (prompt.arguments && prompt.arguments.length > 0
+                    ? '（参数：' + prompt.arguments.map((arg) => arg.name).join('、') + '）'
+                    : '')).join('\n');
+        },
+    };
+}
+function promptGetTool(serverName, client) {
+    return {
+        readOnly: true,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__get_prompt',
+            description: '[' + serverName + '] 获取一个 MCP prompt 的完整内容。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    arguments: { type: 'object' },
+                },
+                required: ['name'],
+                additionalProperties: false,
+            },
+        },
+        async run(args) {
+            const name = typeof args.name === 'string' ? args.name.trim() : '';
+            if (name.length === 0) {
+                throw new Error('缺少 name 参数');
+            }
+            const promptArgs = args.arguments !== null && typeof args.arguments === 'object'
+                ? args.arguments : {};
+            return await client.getPrompt(name, promptArgs);
+        },
+    };
+}
+function resourceTemplateListTool(serverName, client) {
+    return {
+        readOnly: true,
+        spec: {
+            name: 'mcp__' + sanitize(serverName) + '__list_resource_templates',
+            description: '[' + serverName + '] 列出 MCP resource templates。',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+        },
+        async run() {
+            const templates = await client.listResourceTemplates();
+            if (templates.length === 0) {
+                return '没有 resource template。';
+            }
+            return templates.map((template) => template.uriTemplate
+                + (template.name ? ' — ' + template.name : '')
+                + (template.description ? ' — ' + template.description : '')).join('\n');
+        },
+    };
+}
+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';
+}

package/dist/oauth/device.js

@@ -0,0 +1,111 @@
+/**
+ * Generic OAuth 2.0 Device Authorization Grant (RFC 8628). Provider-agnostic:
+ * the endpoints and client id come from config.oauth.
+ */
+export async function deviceLogin(config, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const now = options.now ?? Date.now;
+    const deviceForm = new URLSearchParams({ client_id: config.clientId });
+    if (config.scopes && config.scopes.length > 0) {
+        deviceForm.set('scope', config.scopes.join(' '));
+    }
+    const device = await postForm(fetchImpl, config.deviceAuthorizationUrl, deviceForm);
+    const deviceCode = typeof device.device_code === 'string' ? device.device_code : '';
+    const userCode = typeof device.user_code === 'string' ? device.user_code : '';
+    const verificationUri = typeof device.verification_uri === 'string' ? device.verification_uri : '';
+    if (deviceCode.length === 0 || userCode.length === 0 || verificationUri.length === 0) {
+        throw new Error('OAuth 设备授权响应缺少 device_code / user_code / verification_uri');
+    }
+    const expiresIn = numberOr(device.expires_in, 600);
+    const verificationUriComplete = typeof device.verification_uri_complete === 'string'
+        ? device.verification_uri_complete
+        : undefined;
+    options.onUserCode?.({
+        userCode,
+        verificationUri,
+        ...(verificationUriComplete ? { verificationUriComplete } : {}),
+        expiresIn,
+    });
+    let intervalMs = Math.max(1_000, numberOr(device.interval, 5) * 1_000);
+    const deadline = now() + expiresIn * 1_000;
+    while (now() < deadline) {
+        await sleep(intervalMs);
+        const tokenForm = new URLSearchParams({
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode,
+            client_id: config.clientId,
+        });
+        const response = await fetchImpl(config.tokenUrl, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/x-www-form-urlencoded',
+                accept: 'application/json',
+            },
+            body: tokenForm,
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (response.ok && typeof payload.access_token === 'string' && payload.access_token.length > 0) {
+            const token = {
+                accessToken: payload.access_token,
+                tokenType: typeof payload.token_type === 'string' ? payload.token_type : 'Bearer',
+            };
+            if (typeof payload.refresh_token === 'string') {
+                token.refreshToken = payload.refresh_token;
+            }
+            if (typeof payload.scope === 'string') {
+                token.scope = payload.scope;
+            }
+            const tokenExpiresIn = numberOr(payload.expires_in, 0);
+            if (tokenExpiresIn > 0) {
+                token.expiresAt = now() + tokenExpiresIn * 1_000;
+            }
+            return token;
+        }
+        const error = typeof payload.error === 'string' ? payload.error : '';
+        const description = typeof payload.error_description === 'string'
+            ? payload.error_description
+            : '';
+        if (error === 'authorization_pending') {
+            continue;
+        }
+        if (error === 'slow_down') {
+            intervalMs += 5_000;
+            continue;
+        }
+        if (error === 'access_denied') {
+            throw new Error('OAuth 授权被拒绝' + (description ? '：' + description : ''));
+        }
+        if (error === 'expired_token') {
+            throw new Error('OAuth 设备码已过期，请重新登录');
+        }
+        if (error.length > 0) {
+            throw new Error('OAuth 登录失败：' + error + (description ? '（' + description + '）' : ''));
+        }
+        throw new Error('OAuth 令牌请求失败（HTTP ' + response.status + '）');
+    }
+    throw new Error('OAuth 登录超时');
+}
+async function postForm(fetchImpl, url, form) {
+    const response = await fetchImpl(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded',
+            accept: 'application/json',
+        },
+        body: form,
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        const error = typeof payload.error === 'string' ? payload.error : '';
+        const description = typeof payload.error_description === 'string'
+            ? payload.error_description
+            : '';
+        throw new Error('OAuth 设备授权失败（HTTP ' + response.status + '）'
+            + (error ? '：' + error : '') + (description ? '（' + description + '）' : ''));
+    }
+    return payload;
+}
+function numberOr(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}

package/dist/oauth/store.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { minkoHome } from "../config/paths.js";
+export function oauthStorePath() {
+    return path.join(minkoHome(), 'oauth.json');
+}
+export function saveOAuthToken(profile, tokens, file = oauthStorePath()) {
+    if (profile.trim().length === 0) {
+        throw new Error('OAuth profile 不能为空');
+    }
+    const store = readStore(file);
+    store.profiles[profile] = { ...tokens, savedAt: new Date().toISOString() };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(store, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    try {
+        fs.chmodSync(file, 0o600);
+    }
+    catch { /* Windows ignores POSIX modes */ }
+}
+export function loadOAuthToken(profile, file = oauthStorePath()) {
+    const token = readStore(file).profiles[profile];
+    if (!token || typeof token.accessToken !== 'string' || token.accessToken.length === 0) {
+        return null;
+    }
+    return {
+        accessToken: token.accessToken,
+        ...(typeof token.refreshToken === 'string' ? { refreshToken: token.refreshToken } : {}),
+        tokenType: typeof token.tokenType === 'string' ? token.tokenType : 'Bearer',
+        ...(typeof token.scope === 'string' ? { scope: token.scope } : {}),
+        ...(typeof token.expiresAt === 'number' ? { expiresAt: token.expiresAt } : {}),
+    };
+}
+export function listOAuthProfiles(file = oauthStorePath()) {
+    return Object.keys(readStore(file).profiles).sort();
+}
+function readStore(file) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (raw.profiles === null || typeof raw.profiles !== 'object') {
+            return { version: 1, profiles: {} };
+        }
+        const profiles = {};
+        for (const [name, value] of Object.entries(raw.profiles)) {
+            if (value !== null && typeof value === 'object') {
+                profiles[name] = value;
+            }
+        }
+        return { version: 1, profiles };
+    }
+    catch {
+        return { version: 1, profiles: {} };
+    }
+}