@ekoindia/eps-context-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/load-bundle.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var here = path.dirname(fileURLToPath(import.meta.url));
+var BAKED_PATH = path.resolve(here, "../data/eps.json");
+var loadBundle = async () => {
+  const url = process.env.EPS_BUNDLE_URL;
+  if (url) {
+    try {
+      const res = await fetch(url);
+      if (res.ok)
+        return { bundle: await res.json(), source: "remote" };
+    } catch {
+    }
+  }
+  const raw = await fs.readFile(BAKED_PATH, "utf8");
+  return { bundle: JSON.parse(raw), source: "baked" };
+};
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/bundle-access.ts
+var toIndexEntry = (a) => ({
+  slug: a.slug,
+  productId: a.productId,
+  productName: a.productName,
+  name: a.name,
+  method: a.method,
+  path: a.path,
+  summary: a.summary,
+  category: a.category,
+  relevance: a.relevance
+});
+var listApis = (bundle, category) => bundle.apis.filter((a) => !category || a.category === category).map(toIndexEntry);
+var listTopics = (bundle) => Object.keys(bundle.topics);
+var listRecipes = (bundle) => bundle.recipes.map((r) => ({ id: r.id, name: r.name, summary: r.summary }));
+var searchApis = (bundle, query) => {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (!terms.length) return listApis(bundle);
+  const scored = bundle.apis.map((a) => {
+    const hay = `${a.name} ${a.summary} ${a.path} ${a.category} ${a.productName}`.toLowerCase();
+    let score = 0;
+    for (const t of terms) if (hay.includes(t)) score += 1;
+    return { a, score };
+  });
+  return scored.filter((s) => s.score > 0).sort((x, y) => y.score - x.score).map((s) => toIndexEntry(s.a));
+};
+var getApi = (bundle, slug) => bundle.apis.find((a) => a.slug === slug);
+var getTopic = (bundle, topic) => bundle.topics[topic];
+var getRecipe = (bundle, id) => bundle.recipes.find((r) => r.id === id);
+
+// src/signing-snippets.ts
+var SIGNING_LANGUAGES = [
+  "php",
+  "java",
+  "csharp",
+  "javascript",
+  "python",
+  "go"
+];
+var SNIPPETS = {
+  php: `<?php
+// Backend only. Never expose access_key in a browser.
+$accessKey = getenv('EKO_ACCESS_KEY');
+$timestamp = (string) round(microtime(true) * 1000);
+$encodedKey = base64_encode($accessKey);
+$secretKey = base64_encode(hash_hmac('sha256', $timestamp, $encodedKey, true));
+// Send headers: developer_key, secret-key: $secretKey, secret-key-timestamp: $timestamp
+`,
+  java: `// Backend only. Never expose access_key in a browser.
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+import java.util.Base64;
+
+String accessKey = System.getenv("EKO_ACCESS_KEY");
+String timestamp = String.valueOf(System.currentTimeMillis());
+String encodedKey = Base64.getEncoder().encodeToString(accessKey.getBytes("UTF-8"));
+Mac mac = Mac.getInstance("HmacSHA256");
+mac.init(new SecretKeySpec(encodedKey.getBytes("UTF-8"), "HmacSHA256"));
+String secretKey = Base64.getEncoder().encodeToString(mac.doFinal(timestamp.getBytes("UTF-8")));
+`,
+  csharp: `// Backend only. Never expose access_key in a browser.
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+string accessKey = Environment.GetEnvironmentVariable("EKO_ACCESS_KEY");
+string timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds().ToString();
+string encodedKey = Convert.ToBase64String(Encoding.UTF8.GetBytes(accessKey));
+using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(encodedKey));
+string secretKey = Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(timestamp)));
+`,
+  javascript: `// Backend only (Node.js). Never expose access_key in a browser.
+import crypto from "node:crypto";
+
+const accessKey = process.env.EKO_ACCESS_KEY;
+const timestamp = Date.now().toString();
+const encodedKey = Buffer.from(accessKey).toString("base64");
+const secretKey = crypto
+	.createHmac("sha256", encodedKey)
+	.update(timestamp)
+	.digest("base64");
+// headers: { developer_key, "secret-key": secretKey, "secret-key-timestamp": timestamp }
+`,
+  python: `# Backend only. Never expose access_key in a browser.
+import base64, hashlib, hmac, os, time
+
+access_key = os.environ["EKO_ACCESS_KEY"]
+timestamp = str(int(time.time() * 1000))
+encoded_key = base64.b64encode(access_key.encode())
+secret_key = base64.b64encode(
+	hmac.new(encoded_key, timestamp.encode(), hashlib.sha256).digest()
+).decode()
+`,
+  go: `// Backend only. Never expose access_key in a browser.
+package main
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"os"
+	"time"
+)
+
+func secretKey() (string, string) {
+	accessKey := os.Getenv("EKO_ACCESS_KEY")
+	timestamp := fmt.Sprintf("%d", time.Now().UnixMilli())
+	encodedKey := base64.StdEncoding.EncodeToString([]byte(accessKey))
+	mac := hmac.New(sha256.New, []byte(encodedKey))
+	mac.Write([]byte(timestamp))
+	return base64.StdEncoding.EncodeToString(mac.Sum(nil)), timestamp
+}
+`
+};
+var getSigningSnippet = (language) => SNIPPETS[language] ?? `Unsupported language "${language}". Supported: ${SIGNING_LANGUAGES.join(", ")}.`;
+
+// src/server.ts
+var json = (value) => ({
+  content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+});
+var createEpsServer = (bundle, source) => {
+  const server = new McpServer({
+    name: "eps-context-mcp",
+    version: bundle.meta.bundleVersion
+  });
+  server.registerTool(
+    "list_apis",
+    {
+      title: "List EPS APIs",
+      description: "Compact index of EPS API endpoints (no request/response bodies). Optionally filter by category.",
+      inputSchema: { category: z.string().optional() }
+    },
+    async ({ category }) => json(listApis(bundle, category))
+  );
+  server.registerTool(
+    "list_topics",
+    {
+      title: "List topics",
+      description: "List documentation topic ids.",
+      inputSchema: {}
+    },
+    async () => json(listTopics(bundle))
+  );
+  server.registerTool(
+    "list_recipes",
+    {
+      title: "List recipes",
+      description: "List multi-step recipe ids + names.",
+      inputSchema: {}
+    },
+    async () => json(listRecipes(bundle))
+  );
+  server.registerTool(
+    "search",
+    {
+      title: "Search APIs",
+      description: "Ranked endpoint matches for a query (ids only, no bodies).",
+      inputSchema: { query: z.string() }
+    },
+    async ({ query }) => json(searchApis(bundle, query))
+  );
+  server.registerTool(
+    "get_api",
+    {
+      title: "Get API detail",
+      description: "Full detail for one endpoint by slug.",
+      inputSchema: { slug: z.string() }
+    },
+    async ({ slug }) => {
+      const api = getApi(bundle, slug);
+      return api ? json(api) : json({ error: `Unknown slug "${slug}"` });
+    }
+  );
+  server.registerTool(
+    "get_topic",
+    {
+      title: "Get topic",
+      description: "One topic: auth | errors | pricing | environments.",
+      inputSchema: {
+        topic: z.enum(["auth", "errors", "pricing", "environments"])
+      }
+    },
+    async ({ topic }) => json(getTopic(bundle, topic))
+  );
+  server.registerTool(
+    "get_recipe",
+    {
+      title: "Get recipe",
+      description: "One multi-step recipe (steps + branches) by id.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => {
+      const recipe = getRecipe(bundle, id);
+      return recipe ? json(recipe) : json({ error: `Unknown recipe "${id}"` });
+    }
+  );
+  server.registerTool(
+    "get_signing_snippet",
+    {
+      title: "Get signing snippet",
+      description: "Paste-ready BACKEND code to compute the secret-key. Secret-free: access_key comes from your secret store.",
+      inputSchema: { language: z.enum(SIGNING_LANGUAGES) }
+    },
+    async ({ language }) => ({
+      content: [{ type: "text", text: getSigningSnippet(language) }]
+    })
+  );
+  server.registerTool(
+    "get_meta",
+    {
+      title: "Get meta",
+      description: "Bundle org/version + data source.",
+      inputSchema: {}
+    },
+    async () => json({ ...bundle.meta, source })
+  );
+  return server;
+};
+
+// src/index.ts
+async function main() {
+  const { bundle, source } = await loadBundle();
+  const server = createEpsServer(bundle, source);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `eps-context-mcp running (bundle ${bundle.meta.bundleVersion}, ${source})`
+  );
+}
+main().catch((err) => {
+  console.error("eps-context-mcp fatal:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@ekoindia/eps-context-mcp",
+	"version": "0.1.0",
+	"description": "Local MCP server giving AI coding agents context for Eko Platform Services (EPS) APIs.",
+	"license": "MIT",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ekoindia/eko-eps-website.git",
+		"directory": "packages/eps-context-mcp"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"bin": {
+		"eps-context-mcp": "dist/index.js"
+	},
+	"files": [
+		"dist",
+		"data"
+	],
+	"scripts": {
+		"bake": "node scripts/bake-bundle.mjs",
+		"build": "tsup",
+		"test": "vitest run",
+		"prepublishOnly": "npm run bake && npm run build"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.0.0",
+		"zod": "^3.25.76"
+	},
+	"devDependencies": {
+		"tsup": "^8.0.0",
+		"typescript": "^5.8.3",
+		"vitest": "^3.2.4"
+	},
+	"engines": {
+		"node": ">=18"
+	}
+}