@arii/boomtick-mcp 0.5.0 → 0.6.0

package/dist/mcp/definitions.js

@@ -26,6 +26,24 @@ export const MCP_PROMPTS = [
     },
 ];
 export const MCP_RESOURCES = [
+    {
+        uri: "mcp://workspace/agent-contract",
+        name: "Agent Contract",
+        mimeType: "text/markdown",
+        description: "The agent contract specification file (.agents/AGENT_CONTRACT.md).",
+    },
+    {
+        uri: "repo://agent-contract",
+        name: "Agent Contract (Legacy URI)",
+        mimeType: "text/markdown",
+        description: "The agent contract specification file (.agents/AGENT_CONTRACT.md).",
+    },
+    {
+        uri: "mcp://git/changed-files",
+        name: "Git Changed Files",
+        mimeType: "application/json",
+        description: "List of changed files in the repository.",
+    },
     {
         uri: "repo://package-json",
         name: "package.json",
@@ -38,183 +56,236 @@ export const MCP_RESOURCES = [
         mimeType: "application/json",
         description: "The design tokens used in the repository.",
     },
+];
+export const MCP_RESOURCE_TEMPLATES = [
+    {
+        uriTemplate: "mcp://git/diff/{prNumber}",
+        name: "Git PR Diff",
+        mimeType: "text/plain",
+        description: "Diff and changed files for a pull request.",
+    },
+    {
+        uriTemplate: "mcp://ci/logs/{prNumber}",
+        name: "CI Logs",
+        mimeType: "application/json",
+        description: "CI logs for a pull request.",
+    },
     {
-        uri: "repo://repair-report/{branch}",
+        uriTemplate: "repo://repair-report/{branch}",
         name: "Repair Report",
         mimeType: "application/json",
         description: "The validation report for a specific repair branch.",
     },
 ];
+const DEFAULT_OUTPUT_SCHEMA = {
+    type: "object",
+    properties: {},
+    additionalProperties: true,
+};
 const BASE_MCP_TOOLS = [
     {
         name: "boomtick.health",
         description: "Check the health and configuration of the MCP server.",
         inputSchema: HealthCheckInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.search_open_prs",
         description: "Search for open pull requests in the repository.",
         inputSchema: SearchPRsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.read_agent_context",
         description: "Read the full repository index including file tree, CLI schema, and MCP tools.",
         inputSchema: ReadAgentContextSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.get_pr_diff",
         description: "Get the diff and changed files for a pull request.",
         inputSchema: GetPrDiffInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.checkout_branch",
         description: "Checkout a specific branch in the repository or worktree.",
         inputSchema: CheckoutBranchInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.get_merge_conflict_files",
         description: "Detect files that conflict when a PR is merged with the base branch.",
         inputSchema: GetMergeConflictFilesInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.get_changed_files",
         description: "Get the list of changed files between two refs.",
         inputSchema: GetChangedFilesInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.get_command_schema",
-        description: "Retrieve a lightweight, targeted schema for a specific td-cli subcommand. Use this instead of reading the entire cli-schema.json to save tokens.",
+        description: "Retrieve a lightweight, targeted schema for a specific td subcommand. Use this instead of reading the entire cli-schema.json to save tokens.",
         inputSchema: GetCommandSchemaInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.get_package_scripts",
         description: "Get the scripts defined in package.json.",
         inputSchema: GetPackageScriptsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.read_ci_logs",
         description: "Read CI logs for a given pull request.",
         inputSchema: ReadCiLogsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.logs",
         description: "Stream or grep combined CI logs for all jobs in a pull request.",
         inputSchema: RepoLogsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.create_branch",
         description: "Creates a new clean git branch from a target base branch.",
         inputSchema: CreateBranchInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.create_repair_branch",
         description: "Creates a fresh worktree and a new repair branch for an existing PR. This isolates the repair work from the main codebase.",
         inputSchema: CreateRepairBranchInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.run_tests",
         description: "Run repository tests and checks.",
         inputSchema: RunTestsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.commit_patch",
         description: "Commit verified repair changes in a worktree.",
         inputSchema: CommitPatchInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.open_replacement_pr",
         description: "Open a new PR that replaces or repairs the original PR.",
         inputSchema: OpenReplacementPrInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.create_pull_request",
         description: "Creates a pull request on GitHub using the MCP server's integrated credentials. Bypasses terminal CLI constraints.",
         inputSchema: CreatePullRequestInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.comment_triage_summary",
         description: "Comment on the original PR with a diagnosis and replacement link.",
         inputSchema: CommentTriageSummaryInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.get_pr",
         description: "Get details of a GitHub PR including title, state, and URLs.",
         inputSchema: GetPrInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.get_pr_reviews",
         description: "Get top-level reviews, verdicts, states, and bodies for a GitHub PR.",
         inputSchema: GetPrReviewsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.get_pr_commits",
         description: "List commits and commit metadata (SHAs, authors, messages) for a GitHub PR.",
         inputSchema: GetPrCommitsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "repo.get_workflow_runs",
         description: "List recent GitHub Actions workflow runs for the repository.",
         inputSchema: GetWorkflowRunsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.issue_view",
         description: "View details of a GitHub issue including title, body, and state.",
         inputSchema: IssueViewInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.issue_update",
         description: "Update a GitHub issue's body, labels, and/or state.",
         inputSchema: IssueUpdateInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.issue_comment",
         description: "Add a new comment to a GitHub issue.",
         inputSchema: IssueCommentInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "github.create_issue",
         description: "Create a new GitHub issue.",
         inputSchema: CreateIssueInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.create_session",
         description: "Create a Jules session that performs work externally and may generate a GitHub pull request.",
         inputSchema: CreateJulesSessionInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.get_session",
         description: "Get the status and details of a Jules session.",
         inputSchema: JulesSessionIdInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.send_message",
         description: "Send a message to an active Jules session.",
         inputSchema: JulesSendMessageInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.get_messages",
         description: "Get the message history of a Jules session.",
         inputSchema: JulesSessionIdInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.list_sessions",
         description: "List all Jules sessions.",
         inputSchema: JulesListSessionsInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.cancel_session",
         description: "Cancel an ongoing Jules session.",
         inputSchema: JulesSessionIdInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.get_pr",
         description: "Get the generated pull request url associated with an active Jules agent session.",
         inputSchema: JulesSessionIdInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
     {
         name: "jules.trigger_feedback",
         description: "Automatically collect CI status/logs for the PR associated with a Jules session and send them back as feedback.",
         inputSchema: JulesSessionIdInputJsonSchema,
+        outputSchema: DEFAULT_OUTPUT_SCHEMA,
     },
 ];
 export const MCP_TOOLS = BASE_MCP_TOOLS.flatMap((tool) => {

package/dist/mcp/http.js

@@ -0,0 +1,91 @@
+import http from "node:http";
+import crypto from "node:crypto";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+export function createMcpHttpServer(options) {
+    const { port = 3000, bearerToken = process.env.BOOMTICK_MCP_BEARER_TOKEN || process.env.MCP_BEARER_TOKEN || process.env.AUTH_TOKEN, mcpServer, } = options;
+    const transports = new Map();
+    const server = http.createServer(async (req, res) => {
+        // CORS Headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        // Endpoint 1: OAuth Protected Resource metadata
+        if (url.pathname === "/.well-known/oauth-protected-resource" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                resource: "mcp://boomtick-mcp",
+                "authorization_servers": [
+                    process.env.MCP_OAUTH_AUTH_SERVER || "https://auth.boomtick.dev",
+                ],
+                scopes_supported: ["mcp:read", "mcp:write"],
+            }));
+            return;
+        }
+        // Bearer Token Validation for SSE & Messages endpoints
+        if (url.pathname === "/sse" || url.pathname === "/messages") {
+            if (!bearerToken) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Server misconfiguration: bearerToken is required for HTTP transport" }));
+                return;
+            }
+            const authHeader = req.headers.authorization;
+            const expectedAuth = `Bearer ${bearerToken}`;
+            const authBuffer = Buffer.from(authHeader || "");
+            const expectedBuffer = Buffer.from(expectedAuth);
+            const isMatch = Boolean(authHeader) &&
+                authBuffer.length === expectedBuffer.length &&
+                crypto.timingSafeEqual(authBuffer, expectedBuffer);
+            if (!isMatch) {
+                res.writeHead(401, {
+                    "Content-Type": "application/json",
+                    "WWW-Authenticate": 'Bearer realm="boomtick-mcp", error="invalid_token"',
+                });
+                res.end(JSON.stringify({ error: "unauthorized", message: "Invalid or missing Bearer token" }));
+                return;
+            }
+        }
+        // Endpoint 2: SSE stream setup
+        if (url.pathname === "/sse" && req.method === "GET") {
+            const transport = new SSEServerTransport("/messages", res);
+            transports.set(transport.sessionId, transport);
+            transport.onclose = () => {
+                transports.delete(transport.sessionId);
+            };
+            await mcpServer.connect(transport);
+            return;
+        }
+        // Endpoint 3: POST messages
+        if (url.pathname === "/messages" && req.method === "POST") {
+            const sessionId = url.searchParams.get("sessionId");
+            const transport = sessionId ? transports.get(sessionId) : null;
+            if (transport) {
+                await transport.handlePostMessage(req, res);
+            }
+            else {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Session not found or expired" }));
+            }
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+    return {
+        server,
+        listen: (customPort) => new Promise((resolve) => {
+            const p = customPort ?? port;
+            server.listen(p, () => {
+                const addr = server.address();
+                const actualPort = typeof addr === "object" && addr ? addr.port : p;
+                console.error(`Boomtick MCP Server running on HTTP port ${actualPort}`);
+                resolve(actualPort);
+            });
+        }),
+    };
+}

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";
@@ -40,6 +40,7 @@ import fs from "fs/promises";
 import { existsSync, readFileSync } from "fs";
 import path from "path";
 import { spawnSync } from "child_process";
+import { createMcpHttpServer } from "./http.js";
 export class BoomtickMCPServer {
     server;
     constructor() {
@@ -93,29 +94,50 @@ 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") {
+            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: "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://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: 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 {
@@ -236,7 +258,7 @@ export class BoomtickMCPServer {
             }
         });
     }
-    async run() {
+    prepareEnvironmentAndPreflight() {
         const projectRoot = config.repoPath || process.cwd();
         const homeDir = process.env.HOME || "";
         const extraPaths = [];
@@ -276,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
@@ -290,16 +312,34 @@ 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);
         }
+    }
+    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);
         console.error("Boomtick MCP Server running on stdio");

package/dist/mcp/server.test.js

@@ -83,8 +83,27 @@ 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 mcp://workspace/agent-contract", async () => {
+            const handler = requestHandlers.get("resources/read");
+            vi.mocked(fs.readFile).mockResolvedValue("# Agent Contract\nRule 1");
+            const result = await handler({
+                method: "resources/read",
+                params: { uri: "mcp://workspace/agent-contract" },
+            });
+            expect(fs.readFile).toHaveBeenCalledWith("/mock/repo/.agents/AGENT_CONTRACT.md", "utf-8");
+            expect(result).toEqual({
+                contents: [{ uri: "mcp://workspace/agent-contract", mimeType: "text/markdown", text: "# Agent Contract\nRule 1" }],
+            });
+        });
         it("should handle repo://package-json", async () => {
             const handler = requestHandlers.get("resources/read");
             vi.mocked(fs.readFile).mockResolvedValue('{"name": "test"}');
@@ -155,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 () => {