corent-mcp 0.2.1 → 0.3.0

package/README.md

@@ -38,6 +38,31 @@ Get an API key at [corent.tech](https://corent.tech), then add to your MCP clien
 
 For Claude Code: `claude mcp add corent -e CORENT_API_KEY=co_live_... -- npx -y corent-mcp`
 
+### Hosted server (no install)
+
+The hosted server at `https://mcp.corent.tech/mcp` uses the Streamable HTTP
+transport. Pass your API key in the **Authorization header** — this is the way
+to authenticate:
+
+```json
+{
+  "mcpServers": {
+    "corent": {
+      "url": "https://mcp.corent.tech/mcp",
+      "headers": { "Authorization": "Bearer co_live_..." }
+    }
+  }
+}
+```
+
+`X-Corent-Api-Key: co_live_...` is accepted as an equivalent header.
+
+> **Smithery note:** for compatibility with Smithery, the hosted server also
+> accepts the key via query parameters (`?corent_api_key=...` or Smithery's
+> base64 `?config=`). Avoid this form anywhere else — URLs can be logged by
+> proxies, gateways, and access logs, which would expose your key. Prefer the
+> Authorization header.
+
 ## Development
 
 ```sh

package/dist/http.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * Corent MCP server — hosted HTTP entrypoint (Streamable HTTP transport).
+ *
+ * This is the deployed, "remote" form of the server (e.g. mcp.corent.tech/mcp).
+ * Unlike the stdio entrypoint, the API key is NOT read from the environment —
+ * it is resolved PER REQUEST from the caller, so many different users can share
+ * one hosted instance, each billed to their own Corent account.
+ *
+ * Key is accepted from any of (checked in this order):
+ *   - Authorization: Bearer <key>
+ *   - X-Corent-Api-Key: <key>
+ *   - ?corent_api_key= / ?corentApiKey= / ?api_key= / ?apiKey=
+ *   - ?config=<base64 JSON> with { corentApiKey } (Smithery passes config this way)
+ *
+ * Stateless mode: a fresh server + transport is created for each request, so
+ * there is no cross-user session state to leak.
+ */
+import http from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createCorentServer, SERVER_VERSION } from "./server.js";
+const PORT = Number(process.env.PORT ?? 8080);
+const API_URL = process.env.CORENT_API_URL ?? "https://api.corent.tech";
+function extractApiKey(req, url) {
+    const auth = req.headers["authorization"];
+    if (typeof auth === "string" && auth.toLowerCase().startsWith("bearer ")) {
+        const v = auth.slice(7).trim();
+        if (v)
+            return v;
+    }
+    const header = req.headers["x-corent-api-key"];
+    if (typeof header === "string" && header.trim())
+        return header.trim();
+    for (const k of ["corent_api_key", "corentApiKey", "api_key", "apiKey"]) {
+        const v = url.searchParams.get(k);
+        if (v)
+            return v;
+    }
+    // Smithery encodes the configSchema object as base64 JSON in ?config=
+    const cfg = url.searchParams.get("config");
+    if (cfg) {
+        try {
+            const decoded = JSON.parse(Buffer.from(cfg, "base64").toString("utf8"));
+            if (decoded && typeof decoded.corentApiKey === "string")
+                return decoded.corentApiKey;
+            if (decoded && typeof decoded.CORENT_API_KEY === "string")
+                return decoded.CORENT_API_KEY;
+        }
+        catch {
+            /* ignore malformed config */
+        }
+    }
+    return undefined;
+}
+// Query params may carry the caller's API key (Smithery compatibility), so a
+// raw req.url must NEVER be logged. Any request-level logging — now or added
+// later — MUST go through this helper, which strips every param that can
+// carry a key.
+const SENSITIVE_PARAMS = ["corent_api_key", "corentApiKey", "api_key", "apiKey", "config"];
+function redactedPath(url) {
+    const clean = new URL(url.toString());
+    for (const k of SENSITIVE_PARAMS) {
+        if (clean.searchParams.has(k))
+            clean.searchParams.set(k, "[redacted]");
+    }
+    return clean.pathname + clean.search;
+}
+function setCors(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Corent-Api-Key, Mcp-Session-Id, Mcp-Protocol-Version");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (chunk) => {
+            data += chunk;
+            if (data.length > 4_000_000)
+                reject(new Error("body too large"));
+        });
+        req.on("end", () => {
+            if (!data)
+                return resolve(undefined);
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    setCors(res);
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    // Health check — used by Fly and easy to eyeball.
+    if (req.method === "GET" && (url.pathname === "/" || url.pathname === "/health")) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+            status: "ok",
+            service: "corent-mcp",
+            transport: "streamable-http",
+            version: SERVER_VERSION,
+            endpoint: "/mcp",
+        }));
+        return;
+    }
+    if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not found; MCP endpoint is /mcp" }));
+        return;
+    }
+    const apiKey = extractApiKey(req, url);
+    const mcp = createCorentServer({ apiKey, apiUrl: API_URL });
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    res.on("close", () => {
+        transport.close().catch(() => { });
+        mcp.close().catch(() => { });
+    });
+    try {
+        await mcp.connect(transport);
+        const body = req.method === "POST" ? await readBody(req) : undefined;
+        await transport.handleRequest(req, res, body);
+    }
+    catch (err) {
+        // Redacted path only — never req.url, which may carry an API key.
+        console.error(`request failed: ${req.method} ${redactedPath(url)}:`, err instanceof Error ? err.message : err);
+        if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: err instanceof Error ? err.message : "Internal server error" },
+                id: null,
+            }));
+        }
+    }
+});
+server.listen(PORT, () => {
+    console.error(`corent-mcp (streamable-http) v${SERVER_VERSION} listening on :${PORT}${"  ->  /mcp"}`);
+});

package/dist/index.js

@@ -1,89 +1,17 @@
 #!/usr/bin/env node
 /**
- * Corent MCP server — exposes the Corent media generation API
- * (https://corent.tech) as tools any MCP-compatible agent can call.
+ * Corent MCP server — stdio entrypoint (for local `npx corent-mcp` use).
+ * Exposes the Corent media generation API (https://corent.tech) as tools any
+ * MCP-compatible agent can call. The tool definitions live in ./server.ts.
  *
  * Auth: set CORENT_API_KEY in the environment.
  * Optional: CORENT_API_URL to point at a different API host.
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-const API_URL = process.env.CORENT_API_URL ?? "https://corent-api.fly.dev";
-const API_KEY = process.env.CORENT_API_KEY;
-if (!API_KEY) {
-    console.error("CORENT_API_KEY environment variable is required. Get a key at https://corent.tech");
-    process.exit(1);
-}
-async function corent(path, init) {
-    const res = await fetch(`${API_URL}${path}`, {
-        ...init,
-        headers: {
-            Authorization: `Bearer ${API_KEY}`,
-            "Content-Type": "application/json",
-            ...init?.headers,
-        },
-    });
-    const body = await res.json().catch(() => ({}));
-    if (!res.ok) {
-        throw new Error(`Corent API ${res.status}: ${JSON.stringify(body.detail ?? body)}`);
-    }
-    return body;
-}
-function textResult(data) {
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-const server = new McpServer({ name: "corent", version: "0.2.1" });
-server.tool("generate_image", "Generate an image from a text prompt. Returns a permanent public URL. Synchronous: typically completes in 2-20 seconds. Costs a few cents, billed to the Corent account.", {
-    prompt: z.string().describe("What to generate, in plain language"),
-    preference: z
-        .enum(["fast", "cheap", "quality", "balanced"])
-        .default("balanced")
-        .describe("What to optimize for; Corent picks the best model tier automatically"),
-    style: z
-        .enum(["photorealistic", "artistic", "anime", "logo", "text_focused"])
-        .optional()
-        .describe("Optional content style hint"),
-    aspect_ratio: z.enum(["1:1", "16:9", "9:16", "4:3", "3:4"]).default("1:1"),
-}, async ({ prompt, preference, style, aspect_ratio }) => {
-    const data = await corent("/v1/images/generate", {
-        method: "POST",
-        body: JSON.stringify({ prompt, preference, style, aspect_ratio }),
-    });
-    return textResult(data);
+import { createCorentServer } from "./server.js";
+const server = createCorentServer({
+    apiKey: process.env.CORENT_API_KEY,
+    apiUrl: process.env.CORENT_API_URL,
 });
-server.tool("generate_video", "Start generating a video from a text prompt (optionally animating a source image). Asynchronous: returns a job id immediately; poll get_job until status is 'completed'. Video costs more than images (tens of cents to a few dollars depending on tier).", {
-    prompt: z.string().describe("What to generate, in plain language"),
-    preference: z.enum(["fast", "cheap", "quality", "balanced"]).default("balanced"),
-    aspect_ratio: z.enum(["16:9", "9:16", "1:1"]).default("16:9"),
-    duration_s: z.number().int().min(1).max(30).optional().describe("Requested duration in seconds"),
-    image_url: z.string().url().optional().describe("If set, animates this image instead of pure text-to-video"),
-}, async ({ prompt, preference, aspect_ratio, duration_s, image_url }) => {
-    const data = await corent("/v1/videos/generate", {
-        method: "POST",
-        body: JSON.stringify({ prompt, preference, aspect_ratio, duration_s, image_url }),
-    });
-    return textResult(data);
-});
-server.tool("get_job", "Check the status of a generation job (mainly videos). When completed, the response includes the permanent media URL and the cost.", { job_id: z.string().describe("The job id returned by generate_video or generate_image") }, async ({ job_id }) => textResult(await corent(`/v1/jobs/${job_id}`)));
-server.tool("get_balance", "Get the Corent account's remaining balance in cents. Useful before starting expensive video generations.", {}, async () => textResult(await corent("/v1/account/balance")));
-server.tool("get_status", "Get live operational status of Corent's generation tiers (operational/degraded). No auth cost; useful to pick a healthy tier.", {}, async () => textResult(await corent("/v1/status")));
-// --- Intent tools: Corent's differentiator. Describe what you want in plain
-// language; Corent decides image-vs-video, tier, aspect ratio, and cleans the
-// prompt. The agent never picks a model or tier. ---
-server.tool("plan", "Preview how Corent would handle a plain-language request WITHOUT generating anything (costs a fraction of a cent). Corent decides whether it's an image or video, which tier, aspect ratio, and duration, and returns the plan plus an estimated cost. Use this to decide or confirm cost before spending. If the request is something Corent can't generate (audio, text, 3D, editing, real-world actions), can_fulfill is false with a reason.", {
-    intent: z.string().describe("What you want, in natural language, e.g. 'a 10s vertical clip of a sunrise for TikTok'"),
-}, async ({ intent }) => textResult(await corent("/v1/intent", { method: "POST", body: JSON.stringify({ intent }) })));
-server.tool("create", "Describe what you want in plain language and Corent plans AND generates it — choosing image vs video, tier, aspect ratio, and duration for you (the 'zero decisions' path). You MUST pass max_cost_cents as a spend ceiling; if the estimated cost exceeds it, nothing is generated and you're told the estimate so you can raise the ceiling. Image results come back with a URL; video results come back as a job id to poll with get_job.", {
-    intent: z.string().describe("What you want, in natural language"),
-    max_cost_cents: z
-        .number()
-        .int()
-        .min(1)
-        .describe("Spend ceiling in cents for this one generation. Corent refuses if the estimate is higher."),
-}, async ({ intent, max_cost_cents }) => textResult(await corent("/v1/intent/execute", {
-    method: "POST",
-    body: JSON.stringify({ intent, confirm_estimated_cost_cents_up_to: max_cost_cents }),
-})));
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/server.js

@@ -0,0 +1,224 @@
+/**
+ * Shared Corent MCP server definition — the 7 tools, used by both the
+ * stdio entrypoint (index.ts, for local `npx` use) and the hosted HTTP
+ * entrypoint (http.ts). Keeping the tools in one place means the two
+ * transports can never drift apart.
+ *
+ * Agent-native hardening (v0.3.0):
+ * - Tool annotations (readOnlyHint etc), so MCP clients can skip confirmation
+ *   prompts on read-only tools while still confirming the money-spending ones.
+ * - structuredContent + outputSchema on every tool, so agents consume typed
+ *   objects instead of regex-parsing a JSON string out of a text block.
+ * - Machine-readable error codes (insufficient_balance, prompt_not_allowed,
+ *   rate_limited, ...) so agents can branch on failures programmatically.
+ * Tool NAMES are unchanged — existing client configs keep working.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+export const DEFAULT_API_URL = "https://api.corent.tech";
+export const SERVER_VERSION = "0.3.0";
+class CorentApiError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(`Corent API ${status}: ${JSON.stringify(detail)}`);
+        this.status = status;
+        this.detail = detail;
+    }
+}
+/** Map an API failure to a stable, machine-readable error code. */
+function errorCode(err) {
+    const detail = JSON.stringify(err.detail ?? "").toLowerCase();
+    if (err.status === 401)
+        return "invalid_api_key";
+    if (err.status === 402)
+        return "insufficient_balance";
+    if (err.status === 422 && detail.includes("content"))
+        return "prompt_not_allowed";
+    if (err.status === 422)
+        return "invalid_request";
+    if (err.status === 409 || detail.includes("estimate"))
+        return "estimate_exceeds_ceiling";
+    if (err.status === 429)
+        return "rate_limited";
+    if (err.status === 503)
+        return "no_provider_available";
+    if (err.status === 502)
+        return "generation_failed";
+    return "api_error";
+}
+/**
+ * Build a fully-configured Corent MCP server. The API key is resolved per
+ * instance, so the HTTP transport can create one server per request with that
+ * request's key, while stdio creates a single server from the environment.
+ */
+export function createCorentServer(config = {}) {
+    const apiUrl = config.apiUrl ?? DEFAULT_API_URL;
+    const apiKey = config.apiKey;
+    async function corent(path, init) {
+        // Key is enforced here (at call time) rather than at startup, so the server
+        // can advertise its tools to catalogs/agents without a key configured.
+        if (!apiKey) {
+            throw new CorentApiError(401, {
+                message: "CORENT_API_KEY is not set. Get a key at https://corent.tech and add it to your MCP client config.",
+            });
+        }
+        const res = await fetch(`${apiUrl}${path}`, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+                ...init?.headers,
+            },
+        });
+        const body = await res.json().catch(() => ({}));
+        if (!res.ok) {
+            throw new CorentApiError(res.status, body.detail ?? body);
+        }
+        return body;
+    }
+    /** Success: typed structuredContent plus a text fallback for older clients. */
+    function ok(data) {
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            structuredContent: data,
+        };
+    }
+    /** Failure: isError with a stable code an agent can branch on. */
+    function fail(err) {
+        const payload = err instanceof CorentApiError
+            ? { error: errorCode(err), status: err.status, message: err.detail }
+            : { error: "api_error", message: String(err) };
+        return {
+            isError: true,
+            content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+        };
+    }
+    function wrap(fn) {
+        return async (args) => {
+            try {
+                return ok(await fn(args));
+            }
+            catch (err) {
+                return fail(err);
+            }
+        };
+    }
+    const server = new McpServer({ name: "corent", version: SERVER_VERSION });
+    // Loose output shapes: every field optional so an additive API change can
+    // never break a client's schema validation.
+    const mediaMeta = z.object({ model: z.string().optional(), cost_cents: z.number().optional() }).passthrough();
+    const imageOutput = {
+        id: z.string().optional(),
+        status: z.string().optional(),
+        images: z.array(z.object({ url: z.string() }).passthrough()).optional(),
+        meta: mediaMeta.optional(),
+    };
+    const jobOutput = {
+        id: z.string().optional(),
+        status: z.string().optional(),
+        images: z.array(z.object({ url: z.string() }).passthrough()).optional(),
+        videos: z.array(z.object({ url: z.string() }).passthrough()).optional(),
+        meta: mediaMeta.optional(),
+        error: z.string().optional(),
+    };
+    server.registerTool("generate_image", {
+        title: "Generate image",
+        description: "Generate an image from a text prompt. Returns a permanent public URL. Synchronous: typically completes in 2-20 seconds. Costs a few cents, billed to the Corent account. Failed generations are never billed.",
+        inputSchema: {
+            prompt: z.string().describe("What to generate, in plain language"),
+            preference: z
+                .enum(["fast", "cheap", "quality", "balanced"])
+                .default("balanced")
+                .describe("What to optimize for; Corent picks the best model tier automatically"),
+            style: z
+                .enum(["photorealistic", "artistic", "anime", "logo", "text_focused"])
+                .optional()
+                .describe("Optional content style hint"),
+            aspect_ratio: z.enum(["1:1", "16:9", "9:16", "4:3", "3:4"]).default("1:1"),
+        },
+        outputSchema: imageOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ prompt, preference, style, aspect_ratio }) => corent("/v1/images/generate", {
+        method: "POST",
+        body: JSON.stringify({ prompt, preference, style, aspect_ratio }),
+    })));
+    server.registerTool("generate_video", {
+        title: "Generate video",
+        description: "Start generating a video from a text prompt (optionally animating a source image). Asynchronous: returns a job id immediately; poll get_job until status is 'completed'. Video costs more than images (tens of cents to a few dollars depending on tier). Failed generations are never billed.",
+        inputSchema: {
+            prompt: z.string().describe("What to generate, in plain language"),
+            preference: z.enum(["fast", "cheap", "quality", "balanced"]).default("balanced"),
+            aspect_ratio: z.enum(["16:9", "9:16", "1:1"]).default("16:9"),
+            duration_s: z.number().int().min(1).max(30).optional().describe("Requested duration in seconds"),
+            image_url: z.string().url().optional().describe("If set, animates this image instead of pure text-to-video"),
+        },
+        outputSchema: jobOutput,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ prompt, preference, aspect_ratio, duration_s, image_url }) => corent("/v1/videos/generate", {
+        method: "POST",
+        body: JSON.stringify({ prompt, preference, aspect_ratio, duration_s, image_url }),
+    })));
+    server.registerTool("get_job", {
+        title: "Check job status",
+        description: "Check the status of a generation job (mainly videos). When completed, the response includes the permanent media URL and the cost. Read-only and free.",
+        inputSchema: { job_id: z.string().describe("The job id returned by generate_video or generate_image") },
+        outputSchema: jobOutput,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async ({ job_id }) => corent(`/v1/jobs/${job_id}`)));
+    server.registerTool("get_balance", {
+        title: "Check account balance",
+        description: "Get the Corent account's remaining balance in cents. Useful before starting expensive video generations. Read-only and free.",
+        inputSchema: {},
+        outputSchema: { balance_cents: z.number().optional() },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async () => corent("/v1/account/balance")));
+    server.registerTool("get_status", {
+        title: "Check service status",
+        description: "Get live operational status of Corent's generation tiers (operational/degraded). Read-only and free; useful to pick a healthy tier.",
+        inputSchema: {},
+        outputSchema: { status: z.string().optional(), tiers: z.record(z.string(), z.any()).optional() },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async () => corent("/v1/status")));
+    // --- Intent tools: Corent's differentiator. Describe what you want in plain
+    // language; Corent decides image-vs-video, tier, aspect ratio, and cleans the
+    // prompt. The agent never picks a model or tier. ---
+    server.registerTool("plan", {
+        title: "Plan (cost preview, no generation)",
+        description: "Preview how Corent would handle a plain-language request WITHOUT generating anything (costs a fraction of a cent). Corent decides whether it's an image or video, which tier, aspect ratio, and duration, and returns the plan plus an estimated cost. Use this to decide or confirm cost before spending. If the request is something Corent can't generate (audio, text, 3D, editing, real-world actions), can_fulfill is false with a reason.",
+        inputSchema: {
+            intent: z
+                .string()
+                .describe("What you want, in natural language, e.g. 'a 10s vertical clip of a sunrise for TikTok'"),
+        },
+        outputSchema: {
+            plan: z.object({ can_fulfill: z.boolean().optional() }).passthrough().optional(),
+            estimated_cost_cents: z.number().nullable().optional(),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async ({ intent }) => corent("/v1/intent", { method: "POST", body: JSON.stringify({ intent }) })));
+    server.registerTool("create", {
+        title: "Create (plan + generate, budget-capped)",
+        description: "Describe what you want in plain language and Corent plans AND generates it — choosing image vs video, tier, aspect ratio, and duration for you (the 'zero decisions' path). You MUST pass max_cost_cents as a spend ceiling; if the estimated cost exceeds it, nothing is generated and you're told the estimate so you can raise the ceiling. Image results come back with a URL; video results come back as a job id to poll with get_job. Failed generations are never billed.",
+        inputSchema: {
+            intent: z.string().describe("What you want, in natural language"),
+            max_cost_cents: z
+                .number()
+                .int()
+                .min(1)
+                .describe("Spend ceiling in cents for this one generation. Corent refuses if the estimate is higher."),
+        },
+        outputSchema: {
+            executed: z.boolean().optional(),
+            estimated_cost_cents: z.number().nullable().optional(),
+            actual_cost_cents: z.number().nullable().optional(),
+            result: z.object({}).passthrough().nullable().optional(),
+            message: z.string().nullable().optional(),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, wrap(async ({ intent, max_cost_cents }) => corent("/v1/intent/execute", {
+        method: "POST",
+        body: JSON.stringify({ intent, confirm_estimated_cost_cents_up_to: max_cost_cents }),
+    })));
+    return server;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "corent-mcp",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "MCP server for the Corent media generation API — give any AI agent the ability to generate images and videos.",
   "mcpName": "io.github.gg13121/corent-mcp",
   "license": "MIT",