@arii/boomtick-mcp 0.4.2 → 0.6.0

package/dist/mcp/http.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { createMcpHttpServer } from "./http.js";
+describe("createMcpHttpServer", () => {
+    let mcpServer;
+    let httpServerObj;
+    let port;
+    beforeEach(async () => {
+        mcpServer = new Server({ name: "test-server", version: "1.0.0" }, { capabilities: {} });
+    });
+    afterEach(() => {
+        if (httpServerObj?.server) {
+            httpServerObj.server.close();
+        }
+    });
+    it("should respond with OAuth protected resource metadata on /.well-known/oauth-protected-resource", async () => {
+        httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
+        port = await httpServerObj.listen(0);
+        const res = await fetch(`http://localhost:${port}/.well-known/oauth-protected-resource`);
+        expect(res.status).toBe(200);
+        const body = await res.json();
+        expect(body.resource).toBe("mcp://boomtick-mcp");
+        expect(body.authorization_servers).toBeDefined();
+        expect(body.scopes_supported).toEqual(["mcp:read", "mcp:write"]);
+    });
+    it("should reject requests when Bearer token is missing or invalid", async () => {
+        httpServerObj = createMcpHttpServer({ port: 0, bearerToken: "secret123", mcpServer });
+        port = await httpServerObj.listen(0);
+        // Request without token
+        const res1 = await fetch(`http://localhost:${port}/sse`);
+        expect(res1.status).toBe(401);
+        expect(res1.headers.get("www-authenticate")).toContain('Bearer realm="boomtick-mcp"');
+        // Request with wrong token
+        const res2 = await fetch(`http://localhost:${port}/sse`, {
+            headers: { Authorization: "Bearer wrong" },
+        });
+        expect(res2.status).toBe(401);
+        // Request with valid token
+        const res3 = await fetch(`http://localhost:${port}/.well-known/oauth-protected-resource`, {
+            headers: { Authorization: "Bearer secret123" },
+        });
+        expect(res3.status).toBe(200);
+    });
+    it("should handle 404 for unknown endpoints", async () => {
+        httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
+        port = await httpServerObj.listen(0);
+        const res = await fetch(`http://localhost:${port}/unknown-path`);
+        expect(res.status).toBe(404);
+    });
+    it("should return 500 if bearer token is not configured on server for protected endpoints", async () => {
+        httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
+        port = await httpServerObj.listen(0);
+        const res = await fetch(`http://localhost:${port}/sse`);
+        expect(res.status).toBe(500);
+        const body = await res.json();
+        expect(body.error).toContain("Server misconfiguration");
+    });
+});

package/dist/mcp/server.js

@@ -1,9 +1,9 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { config } from "../config.js";
 import { createSuccessResult, createErrorResult } from "../lib/result.js";
-import { MCP_TOOLS, MCP_PROMPTS, MCP_RESOURCES } from "./definitions.js";
+import { MCP_TOOLS, MCP_PROMPTS, MCP_RESOURCES, MCP_RESOURCE_TEMPLATES } from "./definitions.js";
 import { normalizeArguments } from "../lib/param_utils.js";
 import { healthHandler, HealthCheckInputSchema } from "./tools.js";
 import { searchOpenPrsHandler, SearchOpenPrsInputSchema } from "../tools/github.search_open_prs.js";
@@ -14,14 +14,11 @@ import { getChangedFilesHandler, GetChangedFilesInputSchema } from "../tools/rep
 import { readAgentContextHandler, ReadAgentContextInputSchema } from "../tools/repo.read_agent_context.js";
 import { getCommandSchemaHandler, GetCommandSchemaInputSchema } from "../tools/repo.get_command_schema.js";
 import { getPackageScriptsHandler, GetPackageScriptsInputSchema } from "../tools/repo.get_package_scripts.js";
-import { getRouteMapHandler, GetRouteMapInputSchema } from "../tools/repo.get_route_map.js";
 import { readCiLogsHandler, ReadCiLogsInputSchema } from "../tools/repo.read_ci_logs.js";
 import { repoLogsHandler, RepoLogsInputSchema } from "../tools/repo.logs.js";
 import { createRepairBranchHandler, CreateRepairBranchInputSchema } from "../tools/repo.create_repair_branch.js";
 import { createBranchHandler, CreateBranchInputSchema } from "../tools/repo.create_branch.js";
 import { runTestsHandler, RunTestsInputSchema } from "../tools/repo.run_tests.js";
-import { runLighthouseHandler, RunLighthouseInputSchema } from "../tools/repo.run_lighthouse.js";
-import { runPlaywrightHandler, RunPlaywrightInputSchema } from "../tools/repo.run_playwright.js";
 import { commitPatchHandler, CommitPatchInputSchema } from "../tools/repo.commit_patch.js";
 import { openReplacementPrHandler, OpenReplacementPrInputSchema } from "../tools/github.open_replacement_pr.js";
 import { commentTriageSummaryHandler, CommentTriageSummaryInputSchema } from "../tools/github.comment_triage_summary.js";
@@ -39,12 +36,11 @@ import { listJulesSessionsHandler, ListJulesSessionsInputSchema } from "../tools
 import { cancelJulesSessionHandler, CancelJulesSessionInputSchema } from "../tools/jules/cancel-session.js";
 import { getJulesPullRequestHandler, GetJulesPullRequestInputSchema } from "../tools/jules/get-pr.js";
 import { triggerJulesFeedbackHandler, TriggerJulesFeedbackInputSchema } from "../tools/jules/trigger-feedback.js";
-import { ddgsSearchHandler, DdgsSearchInputSchema } from "../tools/ddgs.search.js";
 import fs from "fs/promises";
 import { existsSync, readFileSync } from "fs";
 import path from "path";
 import { spawnSync } from "child_process";
-import { fileURLToPath } from "url";
+import { createMcpHttpServer } from "./http.js";
 export class BoomtickMCPServer {
     server;
     constructor() {
@@ -98,55 +94,56 @@ export class BoomtickMCPServer {
                 resources: MCP_RESOURCES,
             };
         });
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+            return {
+                resourceTemplates: MCP_RESOURCE_TEMPLATES,
+            };
+        });
         this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             const uri = request.params.uri;
-            if (uri === "repo://package-json") {
-                const content = await fs.readFile(path.join(config.repoPath, "package.json"), "utf-8");
+            if (uri === "mcp://workspace/agent-contract" ||
+                uri === "mcp://workspace/agent_contract" ||
+                uri === "repo://agent-contract") {
+                const contractPath = path.join(config.repoPath, ".agents", "AGENT_CONTRACT.md");
+                const content = await fs.readFile(contractPath, "utf-8");
                 return {
-                    contents: [{ uri, mimeType: "application/json", text: content }],
+                    contents: [{ uri, mimeType: "text/markdown", text: content }],
+                };
+            }
+            if (uri === "mcp://git/changed-files" ||
+                uri === "repo://changed-files") {
+                const changedFiles = await getChangedFilesHandler(GetChangedFilesInputSchema.parse({}));
+                return {
+                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(changedFiles, null, 2) }],
                 };
             }
-            if (uri === "repo://routes") {
-                const routeMap = await getRouteMapHandler({});
+            if (uri === "repo://package-json" || uri === "mcp://workspace/package-json") {
+                const content = await fs.readFile(path.join(config.repoPath, "package.json"), "utf-8");
                 return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(routeMap, null, 2) }],
+                    contents: [{ uri, mimeType: "application/json", text: content }],
                 };
             }
-            if (uri === "repo://design-tokens") {
+            if (uri === "repo://design-tokens" || uri === "mcp://workspace/design-tokens") {
                 const tokensPath = path.join(config.repoPath, "src/styles/design-tokens.ts");
                 const content = await fs.readFile(tokensPath, "utf-8");
                 return {
                     contents: [{ uri, mimeType: "text/typescript", text: content }],
                 };
             }
-            if (uri.startsWith("repo://diff/")) {
+            if (uri.startsWith("mcp://git/diff/") || uri.startsWith("repo://diff/")) {
                 const prNumber = parseInt(uri.split("/").pop() || "");
                 const diff = await getPrDiffHandler({ prNumber });
                 return {
                     contents: [{ uri, mimeType: "text/plain", text: diff.diffText }],
                 };
             }
-            if (uri.startsWith("repo://ci/")) {
+            if (uri.startsWith("mcp://ci/logs/") || uri.startsWith("repo://ci/")) {
                 const prNumber = parseInt(uri.split("/").pop() || "");
                 const logs = await readCiLogsHandler({ prNumber });
                 return {
                     contents: [{ uri, mimeType: "application/json", text: JSON.stringify(logs, null, 2) }],
                 };
             }
-            if (uri.startsWith("repo://lighthouse/")) {
-                const branch = uri.split("/").pop() || "";
-                const report = await runLighthouseHandler({ route: "/", worktreePath: `../boomtick-mcp-rescue-${branch}` });
-                return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(report, null, 2) }],
-                };
-            }
-            if (uri.startsWith("repo://playwright/")) {
-                const branch = uri.split("/").pop() || "";
-                const report = await runPlaywrightHandler({ worktreePath: `../boomtick-mcp-rescue-${branch}` });
-                return {
-                    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(report, null, 2) }],
-                };
-            }
             throw new Error(`Resource not found: ${uri}`);
         });
     }
@@ -187,9 +184,6 @@ export class BoomtickMCPServer {
                     case "repo.get.package.scripts":
                     case "repo.get_package_scripts":
                         return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(normArgs)));
-                    case "repo.get.route.map":
-                    case "repo.get_route_map":
-                        return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(normArgs)));
                     case "repo.read.ci.logs":
                     case "repo.read_ci_logs":
                         return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(normArgs)));
@@ -204,12 +198,6 @@ export class BoomtickMCPServer {
                     case "repo.run.tests":
                     case "repo.run_tests":
                         return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
-                    case "repo.run.lighthouse":
-                    case "repo.run_lighthouse":
-                        return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(normArgs)));
-                    case "repo.run.playwright":
-                    case "repo.run_playwright":
-                        return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(normArgs)));
                     case "repo.commit.patch":
                     case "repo.commit_patch":
                         return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(normArgs)));
@@ -261,9 +249,6 @@ export class BoomtickMCPServer {
                     case "jules.trigger.feedback":
                     case "jules.trigger_feedback":
                         return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(normArgs)));
-                    case "agent.search.ddgs":
-                    case "agent.search_ddgs":
-                        return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(normArgs)));
                     default:
                         return createErrorResult(`Tool not found: ${request.params.name}`);
                 }
@@ -273,7 +258,7 @@ export class BoomtickMCPServer {
             }
         });
     }
-    async run() {
+    prepareEnvironmentAndPreflight() {
         const projectRoot = config.repoPath || process.cwd();
         const homeDir = process.env.HOME || "";
         const extraPaths = [];
@@ -313,9 +298,9 @@ export class BoomtickMCPServer {
             .join(path.delimiter);
         // 3. SAFE REPOSITORY RESOLUTION
         const repoPath = config.repoPath || projectRoot;
-        // 4. SECURE, UNIX-ONLY PRE-FLIGHT CHECK FOR TD-CLI
+        // 4. SECURE, UNIX-ONLY PRE-FLIGHT CHECK FOR TD
         try {
-            const result = spawnSync("td-cli", ["doctor"], {
+            const result = spawnSync("td", ["doctor"], {
                 encoding: "utf-8",
                 cwd: repoPath,
                 shell: false // Explicitly disabled to clear Semgrep rules
@@ -327,24 +312,33 @@ export class BoomtickMCPServer {
                 console.error("status:", result.status);
                 console.error("stdout:", result.stdout);
                 console.error("stderr:", result.stderr);
-                throw new Error(`td-cli doctor returned exit code: ${result.status}`);
+                throw new Error(`td doctor returned exit code: ${result.status}`);
             }
-            console.error("✅ td-cli verified on PATH securely");
+            console.error("✅ td verified on PATH securely");
         }
         catch (error) {
-            console.error("❌ Fatal: td-cli is not resolvable on PATH. MCP tools will fail.");
+            console.error("❌ Fatal: td is not resolvable on PATH. MCP tools will fail.");
             console.error("Please ensure the project is installed: pip install -e .");
-            console.error("❌ Fatal: td-cli pre-flight check failed:", error instanceof Error ? error.message : String(error));
+            console.error("❌ Fatal: td pre-flight check failed:", error instanceof Error ? error.message : String(error));
             process.exit(1);
         }
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const ddgsScriptPath = path.join(__dirname, "..", "tools", "ddgs_search.py");
-        try {
-            await fs.access(ddgsScriptPath);
-        }
-        catch (err) {
-            console.error(`❌ Fatal: ddgs_search.py not found at ${ddgsScriptPath}`);
-            process.exit(1);
+    }
+    async startHttp(port = parseInt(process.env.PORT || process.env.HTTP_PORT || "3000", 10), bearerToken) {
+        this.prepareEnvironmentAndPreflight();
+        const mcpHttp = createMcpHttpServer({ port, bearerToken, mcpServer: this.server });
+        return await mcpHttp.listen(port);
+    }
+    async run() {
+        this.prepareEnvironmentAndPreflight();
+        const isHttp = process.env.MCP_TRANSPORT === "http" ||
+            process.argv.includes("--http") ||
+            (process.env.PORT !== undefined && !process.argv.includes("--stdio")) ||
+            (process.env.HTTP_PORT !== undefined && !process.argv.includes("--stdio"));
+        if (isHttp) {
+            const port = parseInt(process.env.PORT || process.env.HTTP_PORT || "3000", 10);
+            const mcpHttp = createMcpHttpServer({ port, mcpServer: this.server });
+            await mcpHttp.listen(port);
+            return;
         }
         const transport = new StdioServerTransport();
         await this.server.connect(transport);

package/dist/mcp/server.test.js

@@ -2,11 +2,8 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { BoomtickMCPServer } from "./server.js";
 import fs from "fs/promises";
 import * as healthModule from "./tools.js";
-import * as routeMapModule from "../tools/repo.get_route_map.js";
 import * as prDiffModule from "../tools/github.get_pr_diff.js";
 import * as ciLogsModule from "../tools/repo.read_ci_logs.js";
-import * as lighthouseModule from "../tools/repo.run_lighthouse.js";
-import * as playwrightModule from "../tools/repo.run_playwright.js";
 vi.mock("fs/promises");
 vi.mock("../config.js", () => ({
     config: {
@@ -86,28 +83,37 @@ describe("BoomtickMCPServer", () => {
             expect(result.resources).toBeDefined();
             expect(Array.isArray(result.resources)).toBe(true);
         });
+        it("should return resource templates list", async () => {
+            const handler = requestHandlers.get("resources/templates/list");
+            expect(handler).toBeDefined();
+            const result = await handler({ method: "resources/templates/list" });
+            expect(result.resourceTemplates).toBeDefined();
+            expect(Array.isArray(result.resourceTemplates)).toBe(true);
+        });
     });
     describe("ReadResource", () => {
-        it("should handle repo://package-json", async () => {
+        it("should handle mcp://workspace/agent-contract", async () => {
             const handler = requestHandlers.get("resources/read");
-            vi.mocked(fs.readFile).mockResolvedValue('{"name": "test"}');
+            vi.mocked(fs.readFile).mockResolvedValue("# Agent Contract\nRule 1");
             const result = await handler({
                 method: "resources/read",
-                params: { uri: "repo://package-json" },
+                params: { uri: "mcp://workspace/agent-contract" },
             });
+            expect(fs.readFile).toHaveBeenCalledWith("/mock/repo/.agents/AGENT_CONTRACT.md", "utf-8");
             expect(result).toEqual({
-                contents: [{ uri: "repo://package-json", mimeType: "application/json", text: '{"name": "test"}' }],
+                contents: [{ uri: "mcp://workspace/agent-contract", mimeType: "text/markdown", text: "# Agent Contract\nRule 1" }],
             });
         });
-        it("should handle repo://routes", async () => {
+        it("should handle repo://package-json", async () => {
             const handler = requestHandlers.get("resources/read");
-            vi.spyOn(routeMapModule, "getRouteMapHandler").mockResolvedValue({ routes: ["/"] });
+            vi.mocked(fs.readFile).mockResolvedValue('{"name": "test"}');
             const result = await handler({
                 method: "resources/read",
-                params: { uri: "repo://routes" },
+                params: { uri: "repo://package-json" },
+            });
+            expect(result).toEqual({
+                contents: [{ uri: "repo://package-json", mimeType: "application/json", text: '{"name": "test"}' }],
             });
-            expect(result.contents[0].uri).toBe("repo://routes");
-            expect(JSON.parse(result.contents[0].text)).toEqual({ routes: ["/"] });
         });
         it("should handle repo://design-tokens", async () => {
             const handler = requestHandlers.get("resources/read");
@@ -141,26 +147,6 @@ describe("BoomtickMCPServer", () => {
             expect(result.contents[0].uri).toBe("repo://ci/42");
             expect(JSON.parse(result.contents[0].text)).toEqual({ status: "success" });
         });
-        it("should handle repo://lighthouse/:branch", async () => {
-            const handler = requestHandlers.get("resources/read");
-            vi.spyOn(lighthouseModule, "runLighthouseHandler").mockResolvedValue({ score: 100 });
-            const result = await handler({
-                method: "resources/read",
-                params: { uri: "repo://lighthouse/feature-x" },
-            });
-            expect(result.contents[0].uri).toBe("repo://lighthouse/feature-x");
-            expect(JSON.parse(result.contents[0].text)).toEqual({ score: 100 });
-        });
-        it("should handle repo://playwright/:branch", async () => {
-            const handler = requestHandlers.get("resources/read");
-            vi.spyOn(playwrightModule, "runPlaywrightHandler").mockResolvedValue({ passed: true });
-            const result = await handler({
-                method: "resources/read",
-                params: { uri: "repo://playwright/feature-x" },
-            });
-            expect(result.contents[0].uri).toBe("repo://playwright/feature-x");
-            expect(JSON.parse(result.contents[0].text)).toEqual({ passed: true });
-        });
         it("should throw when resource is unknown", async () => {
             const handler = requestHandlers.get("resources/read");
             await expect(handler({
@@ -188,6 +174,7 @@ describe("BoomtickMCPServer", () => {
             });
             expect(result).toEqual({
                 content: [{ type: "text", text: JSON.stringify({ status: "ok" }, null, 2) }],
+                structuredContent: { status: "ok" },
             });
         });
         it("should return error result for unknown tool", async () => {