mcp-file-adapter 0.1.0

package/README.md

@@ -0,0 +1,37 @@
+# mcp-file-adapter
+
+本地 MCP stdio 适配器：将 4 个工具调用转为远程 HTTP 请求，并直接上传/下载文件。
+
+## 环境变量
+
+- REMOTE_BASE_URL: 远程服务地址，默认 http://localhost:8080
+- TIMEOUT_MS: 请求超时，默认 30000
+
+## 启动参数
+
+- --remote-base-url=...  最高优先级
+
+## 鉴权
+
+- 固定 token: mcp-file-service-token
+
+## 工具
+
+- list_files { path }
+- dir_mkdir { path, recursive? }
+- upload_file { local_path, remote_path, overwrite?, mkdirs? }
+- download_file { remote_path, local_path, overwrite?, mkdirs? }
+
+## 运行
+
+```bash
+npm install
+npm run dev
+```
+
+## 发布
+
+```bash
+npm run build
+npm publish
+```

package/dist/index.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { createReadStream, createWriteStream, promises as fs } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+function readArg(name) {
+    const prefix = `--${name}=`;
+    for (const arg of process.argv.slice(2)) {
+        if (arg === `--${name}`)
+            return "true";
+        if (arg.startsWith(prefix))
+            return arg.slice(prefix.length);
+    }
+    return undefined;
+}
+const REMOTE_BASE_URL = readArg("remote-base-url") || process.env.REMOTE_BASE_URL || "http://localhost:8080";
+const AUTH_TOKEN = "mcp-file-service-token";
+const TIMEOUT_MS = Number(process.env.TIMEOUT_MS || 30000);
+function ok(result, message) {
+    return {
+        content: [{ type: "text", text: message ?? JSON.stringify(result) }],
+        structuredContent: result,
+    };
+}
+function fail(error, code) {
+    const result = { ok: false, error, code };
+    return {
+        content: [{ type: "text", text: `error: ${error}` }],
+        structuredContent: result,
+    };
+}
+function resolveLocalPath(localPath) {
+    return path.resolve(process.cwd(), localPath);
+}
+function buildUrl(pathname, params) {
+    const url = new URL(pathname, REMOTE_BASE_URL);
+    Object.entries(params).forEach(([key, value]) => url.searchParams.set(key, value));
+    return url.toString();
+}
+async function fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function parseJsonResponse(res) {
+    const text = await res.text();
+    if (!text)
+        return {};
+    return JSON.parse(text);
+}
+async function failFromResponse(res) {
+    try {
+        const data = await parseJsonResponse(res);
+        if (data && data.ok === false && typeof data.error === "string") {
+            return fail(String(data.error), typeof data.code === "string" ? data.code : undefined);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return fail(`remote error: ${res.status} ${res.statusText}`);
+}
+async function postJson(pathname, body) {
+    const url = new URL(pathname, REMOTE_BASE_URL);
+    const res = await fetchWithTimeout(url.toString(), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${AUTH_TOKEN}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        return failFromResponse(res);
+    const data = await parseJsonResponse(res);
+    if (data.ok === false && typeof data.error === "string") {
+        return fail(String(data.error), typeof data.code === "string" ? data.code : undefined);
+    }
+    return ok(data);
+}
+function createServer() {
+    const server = new McpServer({
+        name: "mcp-file-adapter",
+        version: "0.1.0",
+    });
+    const errorSchema = z.object({
+        ok: z.literal(false),
+        error: z.string(),
+        code: z.string().optional(),
+    });
+    server.registerTool("list_files", {
+        description: "列出远程目录下的条目；返回 name/type/size/mtimeMs。",
+        inputSchema: z.object({
+            path: z.string(),
+        }),
+        outputSchema: z.union([
+            z.object({
+                ok: z.literal(true),
+                entries: z.array(z.object({
+                    name: z.string(),
+                    type: z.enum(["file", "dir"]),
+                    size: z.number().optional(),
+                    mtimeMs: z.number(),
+                })),
+            }),
+            errorSchema,
+        ]),
+    }, async ({ path: relPath }) => {
+        const url = buildUrl("/list", { path: relPath });
+        const res = await fetchWithTimeout(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${AUTH_TOKEN}` },
+        });
+        if (!res.ok)
+            return failFromResponse(res);
+        const data = await parseJsonResponse(res);
+        if (data.ok === false && typeof data.error === "string") {
+            return fail(String(data.error), typeof data.code === "string" ? data.code : undefined);
+        }
+        return ok(data);
+    });
+    server.registerTool("dir_mkdir", {
+        description: "在远程创建目录；path 为相对路径，recursive 默认为 true。",
+        inputSchema: z.object({
+            path: z.string(),
+            recursive: z.boolean().optional(),
+        }),
+        outputSchema: z.union([
+            z.object({
+                ok: z.literal(true),
+            }),
+            errorSchema,
+        ]),
+    }, async ({ path: relPath, recursive }) => {
+        return postJson("/mkdir", { path: relPath, recursive: recursive ?? true });
+    });
+    server.registerTool("upload_file", {
+        description: "上传本地文件到远程；local_path 为本地路径，remote_path 为远程相对路径。",
+        inputSchema: z.object({
+            local_path: z.string(),
+            remote_path: z.string(),
+            overwrite: z.boolean().optional(),
+            mkdirs: z.boolean().optional(),
+        }),
+        outputSchema: z.union([
+            z.object({
+                ok: z.literal(true),
+                remote_path: z.string(),
+                local_path: z.string(),
+                size: z.number(),
+            }),
+            errorSchema,
+        ]),
+    }, async ({ local_path: localPath, remote_path: remotePath, overwrite, mkdirs, }) => {
+        try {
+            const localFull = resolveLocalPath(localPath);
+            const stat = await fs.stat(localFull);
+            if (!stat.isFile())
+                return fail("invalid local path", "EISDIR");
+            const url = buildUrl("/upload", {
+                path: remotePath,
+                overwrite: overwrite ? "1" : "0",
+                mkdirs: mkdirs ? "1" : "0",
+            });
+            const body = Readable.toWeb(createReadStream(localFull));
+            const res = await fetchWithTimeout(url, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${AUTH_TOKEN}`,
+                    "Content-Type": "application/octet-stream",
+                },
+                body,
+                duplex: "half",
+            });
+            if (!res.ok)
+                return failFromResponse(res);
+            const data = await parseJsonResponse(res);
+            if (data.ok === false && typeof data.error === "string") {
+                return fail(String(data.error), typeof data.code === "string" ? data.code : undefined);
+            }
+            return ok({
+                ok: true,
+                local_path: localPath,
+                remote_path: remotePath,
+                size: stat.size,
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : "unknown error";
+            return fail(error);
+        }
+    });
+    server.registerTool("download_file", {
+        description: "下载远程文件到本地；remote_path 为远程相对路径，local_path 为本地路径。",
+        inputSchema: z.object({
+            remote_path: z.string(),
+            local_path: z.string(),
+            overwrite: z.boolean().optional(),
+            mkdirs: z.boolean().optional(),
+        }),
+        outputSchema: z.union([
+            z.object({
+                ok: z.literal(true),
+                remote_path: z.string(),
+                local_path: z.string(),
+                size: z.number(),
+            }),
+            errorSchema,
+        ]),
+    }, async ({ remote_path: remotePath, local_path: localPath, overwrite, mkdirs, }) => {
+        try {
+            const localFull = resolveLocalPath(localPath);
+            if (mkdirs) {
+                await fs.mkdir(path.dirname(localFull), { recursive: true });
+            }
+            if (!overwrite) {
+                try {
+                    await fs.stat(localFull);
+                    return fail("file exists", "EEXIST");
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        throw err;
+                }
+            }
+            const url = buildUrl("/download", { path: remotePath });
+            const res = await fetchWithTimeout(url, {
+                method: "GET",
+                headers: { Authorization: `Bearer ${AUTH_TOKEN}` },
+            });
+            if (!res.ok)
+                return failFromResponse(res);
+            if (!res.body)
+                return fail("empty response body");
+            const stream = Readable.fromWeb(res.body);
+            await pipeline(stream, createWriteStream(localFull));
+            const stat = await fs.stat(localFull);
+            return ok({
+                ok: true,
+                local_path: localPath,
+                remote_path: remotePath,
+                size: stat.size,
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : "unknown error";
+            return fail(error);
+        }
+    });
+    return server;
+}
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "mcp-file-adapter",
+    "version": "0.1.0",
+    "description": "Local MCP stdio adapter for remote file service.",
+    "license": "MIT",
+    "type": "module",
+    "main": "dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "bin": {
+        "mcp-file-adapter": "dist/index.js"
+    },
+    "scripts": {
+        "dev": "tsx src/index.ts",
+        "build": "tsc -p tsconfig.json",
+        "prepublishOnly": "npm run build",
+        "start": "node dist/index.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.25.3",
+        "zod": "^3.25.0"
+    },
+    "devDependencies": {
+        "@types/node": "^20.11.30",
+        "tsx": "^4.19.0",
+        "typescript": "^5.5.0"
+    }
+}