@joelbonito/mcp-server 5.0.1

package/dist/types.d.ts

@@ -0,0 +1,74 @@
+export interface AgentMeta {
+    name: string;
+    description: string;
+    tools: string[];
+    model: string;
+    skills: string[];
+}
+export interface Agent {
+    meta: AgentMeta;
+    body: string;
+    raw: string;
+}
+export interface SkillMeta {
+    name: string;
+    description: string;
+    allowedTools?: string[];
+    version?: string;
+    priority?: string;
+}
+export interface SubFile {
+    filename: string;
+    content: string;
+}
+export interface Skill {
+    meta: SkillMeta;
+    body: string;
+    subFiles: SubFile[];
+    hasScripts: boolean;
+    raw: string;
+}
+export interface WorkflowMeta {
+    description: string;
+}
+export interface Workflow {
+    meta: WorkflowMeta;
+    body: string;
+    raw: string;
+}
+export interface AgentSummary {
+    name: string;
+    description: string;
+    skills: string[];
+}
+export interface SkillSummary {
+    name: string;
+    description: string;
+}
+export interface WorkflowSummary {
+    name: string;
+    description: string;
+}
+export interface RouteResult {
+    agents: AgentSummary[];
+    skills: SkillSummary[];
+    reasoning: string;
+}
+export interface SearchResult {
+    type: "agent" | "skill" | "workflow";
+    name: string;
+    matches: string[];
+}
+export interface ContentCache {
+    agents: Map<string, Agent>;
+    skills: Map<string, Skill>;
+    workflows: Map<string, Workflow>;
+    architecture: string;
+    instructions: string;
+}
+export interface ContentLoader {
+    loadAgents(): Promise<Map<string, Agent>>;
+    loadSkills(): Promise<Map<string, Skill>>;
+    loadWorkflows(): Promise<Map<string, Workflow>>;
+    loadFile(path: string): Promise<string>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/utils/routing.d.ts

@@ -0,0 +1,2 @@
+import type { ContentCache, RouteResult } from "../types.js";
+export declare function routeTask(request: string, cache: ContentCache): RouteResult;

package/dist/utils/routing.js

@@ -0,0 +1,32 @@
+import { ROUTING_KEYWORDS } from "../constants.js";
+export function routeTask(request, cache) {
+    const normalized = request.toLowerCase();
+    const scores = [];
+    for (const [agent, keywords] of Object.entries(ROUTING_KEYWORDS)) {
+        const score = keywords.filter((kw) => normalized.includes(kw)).length;
+        if (score > 0)
+            scores.push({ name: agent, score });
+    }
+    scores.sort((a, b) => b.score - a.score);
+    const top = scores.slice(0, 3);
+    const agents = top.map(({ name }) => {
+        const agent = cache.agents.get(name);
+        return {
+            name,
+            description: agent?.meta.description ?? "",
+            skills: agent?.meta.skills ?? [],
+        };
+    });
+    const skillNames = new Set(agents.flatMap((a) => a.skills));
+    const skills = [...skillNames]
+        .map((name) => {
+        const skill = cache.skills.get(name);
+        return skill ? { name, description: skill.meta.description } : null;
+    })
+        .filter((s) => s !== null);
+    const reasoning = top.length > 0
+        ? `Matched ${top.map((t) => `${t.name} (score: ${t.score})`).join(", ")} based on keyword analysis of: "${request}"`
+        : `No strong keyword match found for: "${request}". Consider using search_content for broader results.`;
+    return { agents, skills, reasoning };
+}
+//# sourceMappingURL=routing.js.map

package/dist/utils/search.d.ts

@@ -0,0 +1,4 @@
+import type { ContentCache, SearchResult } from "../types.js";
+type Scope = "all" | "agents" | "skills" | "workflows";
+export declare function searchContent(query: string, scope: Scope, maxResults: number, cache: ContentCache): SearchResult[];
+export {};

package/dist/utils/search.js

@@ -0,0 +1,42 @@
+export function searchContent(query, scope, maxResults, cache) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    if (scope === "all" || scope === "agents") {
+        for (const [name, agent] of cache.agents) {
+            const matches = findMatches(agent.raw, lowerQuery);
+            if (matches.length > 0) {
+                results.push({ type: "agent", name, matches });
+            }
+        }
+    }
+    if (scope === "all" || scope === "skills") {
+        for (const [name, skill] of cache.skills) {
+            const matches = findMatches(skill.raw, lowerQuery);
+            if (matches.length > 0) {
+                results.push({ type: "skill", name, matches });
+            }
+        }
+    }
+    if (scope === "all" || scope === "workflows") {
+        for (const [name, workflow] of cache.workflows) {
+            const matches = findMatches(workflow.raw, lowerQuery);
+            if (matches.length > 0) {
+                results.push({ type: "workflow", name, matches });
+            }
+        }
+    }
+    return results.slice(0, maxResults);
+}
+function findMatches(content, lowerQuery, maxPerItem = 3) {
+    const lines = content.split("\n");
+    const matches = [];
+    for (const line of lines) {
+        if (line.toLowerCase().includes(lowerQuery)) {
+            matches.push(line.trim());
+            if (matches.length >= maxPerItem)
+                break;
+        }
+    }
+    return matches;
+}
+//# sourceMappingURL=search.js.map

package/dist/worker.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    fetch(request: Request): Promise<Response>;
+};
+export default _default;

package/dist/worker.js

@@ -0,0 +1,117 @@
+/**
+ * Cloudflare Workers entrypoint for Inove AI MCP Server.
+ * Serves the same 21 agents, 41 skills, 22 workflows as the stdio server
+ * via Streamable HTTP transport (stateless, public).
+ *
+ * WARNING: This module must NOT import paths.ts or cache.ts — they use node:fs.
+ * Use EmbeddedLoader directly for Worker-compatible content loading.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { SERVER_NAME, SERVER_VERSION } from "./constants.js";
+import { EmbeddedLoader } from "./loaders/embedded.js";
+import { registerResources } from "./core/resources.js";
+import { registerTools } from "./core/tools.js";
+import { registerPrompts } from "./core/prompts.js";
+const MAX_BODY_SIZE = 64 * 1024; // 64 KB — generous for JSON-RPC
+// Module-level cache — Promise-based singleton to prevent race conditions on cold start
+let cachePromise = null;
+function getWorkerCache() {
+    if (!cachePromise) {
+        cachePromise = (async () => {
+            const loader = new EmbeddedLoader();
+            const [agents, skills, workflows, architecture, instructions] = await Promise.all([
+                loader.loadAgents(),
+                loader.loadSkills(),
+                loader.loadWorkflows(),
+                loader.loadFile("ARCHITECTURE"),
+                loader.loadFile("INSTRUCTIONS"),
+            ]);
+            return { agents, skills, workflows, architecture, instructions };
+        })().catch((err) => {
+            cachePromise = null; // Allow retry on next request
+            throw err;
+        });
+    }
+    return cachePromise;
+}
+// CORS: Wildcard is intentional — this is a public, read-only, credential-free API.
+// MCP clients (Claude Desktop, Cursor, VS Code) connect from any origin.
+const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, mcp-session-id",
+};
+const SECURITY_HEADERS = {
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+    "Referrer-Policy": "no-referrer",
+};
+function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json", ...CORS_HEADERS, ...SECURITY_HEADERS },
+    });
+}
+export default {
+    async fetch(request) {
+        try {
+            const url = new URL(request.url);
+            // CORS preflight
+            if (request.method === "OPTIONS") {
+                return new Response(null, { status: 204, headers: { ...CORS_HEADERS, ...SECURITY_HEADERS } });
+            }
+            // Health check
+            if (url.pathname === "/" || url.pathname === "/health") {
+                const c = await getWorkerCache();
+                return jsonResponse({
+                    status: "ok",
+                    name: SERVER_NAME,
+                    version: SERVER_VERSION,
+                    agents: c.agents.size,
+                    skills: c.skills.size,
+                    workflows: c.workflows.size,
+                });
+            }
+            // MCP endpoint
+            if (url.pathname === "/mcp") {
+                // Body size guard — prevent DoS via oversized payloads
+                const contentLength = parseInt(request.headers.get("content-length") ?? "0", 10);
+                if (contentLength > MAX_BODY_SIZE) {
+                    return jsonResponse({ error: "Payload too large" }, 413);
+                }
+                const c = await getWorkerCache();
+                const server = new McpServer({
+                    name: SERVER_NAME,
+                    version: SERVER_VERSION,
+                });
+                registerResources(server, c);
+                registerTools(server, c);
+                registerPrompts(server, c);
+                const transport = new WebStandardStreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined, // Stateless — no session management
+                });
+                await server.connect(transport);
+                const response = await transport.handleRequest(request);
+                if (!response) {
+                    return jsonResponse({ error: "Invalid MCP request" }, 400);
+                }
+                // Inject CORS + security headers into MCP response
+                const headers = new Headers(response.headers);
+                for (const [key, value] of Object.entries({ ...CORS_HEADERS, ...SECURITY_HEADERS })) {
+                    headers.set(key, value);
+                }
+                return new Response(response.body, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers,
+                });
+            }
+            return jsonResponse({ error: "Not found. Use /mcp for MCP protocol or / for health check." }, 404);
+        }
+        catch (error) {
+            return jsonResponse({ error: "Internal server error", message: error instanceof Error ? error.message : "Unknown error" }, 500);
+        }
+    },
+};
+//# sourceMappingURL=worker.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@joelbonito/mcp-server",
+  "version": "5.0.1",
+  "description": "MCP server for Inove AI Framework — agents, skills, and workflows as MCP resources, tools and prompts",
+  "license": "MIT",
+  "author": "Inove AI <hello@inove.ai>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JoelBonito/inove-ai-framework",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://github.com/JoelBonito/inove-ai-framework/tree/main/mcp-server#readme",
+  "keywords": ["mcp", "ai-framework", "agents", "skills", "workflows", "claude", "model-context-protocol"],
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "inove-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "prebuild": "tsx scripts/bundle-content.ts",
+    "build": "tsc",
+    "postbuild": "chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "dev:workers": "wrangler dev",
+    "deploy:workers": "wrangler deploy"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0",
+    "wrangler": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist/",
+    "!dist/**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}