@arii/boomtick-mcp 0.4.2 → 0.6.0

package/dist/config.test.js

@@ -15,12 +15,12 @@ describe("config", () => {
         process.env = originalEnv;
     });
     describe("initializeConfig", () => {
-        it("should load dynamic config from td-cli config view using active cwd", async () => {
+        it("should load dynamic config from td config view using active cwd", async () => {
             const mockConfig = { github_repo: "owner/repo", base_branch: "origin/main", vite_base_path: "/app/" };
             vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
             const { initializeConfig } = await import("./config.js");
             const result = initializeConfig();
-            expect(execSync).toHaveBeenCalledWith("td-cli config view", expect.objectContaining({
+            expect(execSync).toHaveBeenCalledWith("td config view", expect.objectContaining({
                 cwd: process.cwd()
             }));
             expect(result).toEqual(mockConfig);
@@ -93,7 +93,7 @@ describe("config", () => {
             delete process.env.GITHUB_REPOSITORY;
             delete process.env.GH_REPO;
             vi.mocked(execSync).mockImplementation(() => {
-                throw new Error("td-cli failed");
+                throw new Error("td failed");
             });
             process.env.NODE_ENV = "production";
             process.env.CI = "false";

package/dist/lib/git.js

@@ -59,3 +59,47 @@ export async function removeWorktree(worktreePath) {
     await runCommand("git", ["worktree", "remove", "--force", worktreePath]);
     await runCommand("git", ["worktree", "prune"]);
 }
+export async function getChangedFiles(base = "main", head = "HEAD", cwd) {
+    const result = await runCommand("git", ["diff", "--name-status", "-z", `${base}...${head}`], { cwd });
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to get changed files: ${result.stderr}`);
+    }
+    const tokens = result.stdout.split("\0").filter((t) => t.length > 0);
+    const files = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const status = tokens[i];
+        if (status.startsWith("R") || status.startsWith("C")) {
+            const oldPath = tokens[i + 1];
+            const newPath = tokens[i + 2];
+            if (oldPath && newPath) {
+                files.push({ status, path: newPath, oldPath });
+            }
+            i += 3;
+        }
+        else {
+            const filePath = tokens[i + 1];
+            if (filePath) {
+                files.push({ status, path: filePath });
+            }
+            i += 2;
+        }
+    }
+    return files;
+}
+export async function getMergeConflictFiles(baseBranch = "main", headRef = "HEAD", cwd) {
+    const result = await runCommand("git", ["merge-tree", "--write-tree", "--name-only", baseBranch, headRef], { cwd });
+    // git merge-tree returns exit code 1 if conflicts are present, 0 if clean merge
+    if (result.exitCode !== 0 && result.exitCode !== 1) {
+        throw new Error(`Git merge-tree failed: ${result.stderr}`);
+    }
+    const lines = result.stdout
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+    // First line is tree hash if successful or conflict output
+    // When conflicts exist, git merge-tree --write-tree --name-only outputs conflicted filenames
+    // Skip tree hash line if present (40 hex chars)
+    const files = lines.filter((line) => !/^[0-9a-f]{40}$/i.test(line));
+    return files;
+}

package/dist/lib/git.test.js

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { getChangedFiles, getMergeConflictFiles } from "./git.js";
+import * as shell from "./shell.js";
+vi.mock("./shell.js", () => ({
+    runCommand: vi.fn(),
+}));
+describe("Git Helpers", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe("getChangedFiles", () => {
+        it("should parse null-delimited git diff output correctly", async () => {
+            // Mock git diff output with null character delimiters:
+            // Status M -> file1.txt
+            // Status A -> file2.txt
+            // Status R100 -> old.txt -> new.txt
+            const mockStdout = "M\0file1.txt\0A\0file2.txt\0R100\0old.txt\0new.txt\0";
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                exitCode: 0,
+                stdout: mockStdout,
+                stderr: "",
+                durationMs: 10,
+                command: "git diff --name-status -z main...HEAD",
+            });
+            const result = await getChangedFiles("main", "HEAD");
+            expect(shell.runCommand).toHaveBeenCalledWith("git", ["diff", "--name-status", "-z", "main...HEAD"], { cwd: undefined });
+            expect(result).toEqual([
+                { status: "M", path: "file1.txt" },
+                { status: "A", path: "file2.txt" },
+                { status: "R100", path: "new.txt", oldPath: "old.txt" },
+            ]);
+        });
+        it("should throw error if git diff fails", async () => {
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                exitCode: 1,
+                stdout: "",
+                stderr: "fatal: bad revision",
+                durationMs: 10,
+                command: "git diff --name-status -z invalid...HEAD",
+            });
+            await expect(getChangedFiles("invalid", "HEAD")).rejects.toThrow("Failed to get changed files: fatal: bad revision");
+        });
+    });
+    describe("getMergeConflictFiles", () => {
+        it("should parse git merge-tree output when conflicts exist", async () => {
+            // Output with 40-char tree hash followed by conflicting filenames
+            const mockStdout = "5d71843ed2e051b2be91361db7bea0fc4ee1e5a0\nfile1.txt\nsrc/file2.ts\n";
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                exitCode: 1, // merge-tree exits 1 on conflicts
+                stdout: mockStdout,
+                stderr: "",
+                durationMs: 10,
+                command: "git merge-tree --write-tree --name-only main feature",
+            });
+            const conflicts = await getMergeConflictFiles("main", "feature");
+            expect(shell.runCommand).toHaveBeenCalledWith("git", ["merge-tree", "--write-tree", "--name-only", "main", "feature"], { cwd: undefined });
+            expect(conflicts).toEqual(["file1.txt", "src/file2.ts"]);
+        });
+        it("should return empty array when no conflicts exist", async () => {
+            const mockStdout = "5d71843ed2e051b2be91361db7bea0fc4ee1e5a0\n";
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                exitCode: 0,
+                stdout: mockStdout,
+                stderr: "",
+                durationMs: 10,
+                command: "git merge-tree --write-tree --name-only main feature",
+            });
+            const conflicts = await getMergeConflictFiles("main", "feature");
+            expect(conflicts).toEqual([]);
+        });
+        it("should throw error if git merge-tree exits with unexpected exit code", async () => {
+            vi.mocked(shell.runCommand).mockResolvedValueOnce({
+                exitCode: 128,
+                stdout: "",
+                stderr: "fatal: not a valid object name",
+                durationMs: 10,
+                command: "git merge-tree --write-tree --name-only invalid feature",
+            });
+            await expect(getMergeConflictFiles("invalid", "feature")).rejects.toThrow("Git merge-tree failed: fatal: not a valid object name");
+        });
+    });
+});

package/dist/lib/result.js

@@ -1,4 +1,7 @@
 export function createSuccessResult(data) {
+    const structuredContent = typeof data === "object" && data !== null
+        ? data
+        : { result: data };
     return {
         content: [
             {
@@ -6,6 +9,7 @@ export function createSuccessResult(data) {
                 text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
             },
         ],
+        structuredContent,
     };
 }
 export function createErrorResult(message) {

package/dist/lib/result.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { createSuccessResult, createErrorResult } from "./result.js";
 describe("result utils", () => {
     describe("createSuccessResult", () => {
-        it("should format string data directly without JSON stringifying", () => {
+        it("should format string data directly without JSON stringifying and provide structuredContent", () => {
             const result = createSuccessResult("simple string message");
             expect(result).toEqual({
                 content: [
@@ -11,10 +11,11 @@ describe("result utils", () => {
                         text: "simple string message",
                     },
                 ],
+                structuredContent: { result: "simple string message" },
             });
             expect(result.isError).toBeUndefined();
         });
-        it("should format object data as pretty-printed JSON string", () => {
+        it("should format object data as pretty-printed JSON string and provide structuredContent", () => {
             const objData = { foo: "bar", count: 42 };
             const result = createSuccessResult(objData);
             expect(result).toEqual({
@@ -24,6 +25,7 @@ describe("result utils", () => {
                         text: JSON.stringify(objData, null, 2),
                     },
                 ],
+                structuredContent: objData,
             });
             expect(result.isError).toBeUndefined();
         });

package/dist/lib/shell.js

@@ -5,7 +5,7 @@ import fs from "fs";
 export const ALLOWED_COMMANDS = {
     git: "git",
     gh: "gh",
-    "td-cli": "td-cli",
+    td: "td",
     pnpm: "pnpm",
     ls: "ls",
     rm: "rm",
@@ -20,16 +20,16 @@ export async function runCommand(cmd, args, options = {}) {
     const safeCmd = cmd;
     const start = Date.now();
     const timeout = options.timeout || 60000;
-    // Resolve path for 'gh' or 'td-cli' if specified
+    // Resolve path for 'gh' or 'td' if specified
     let finalCmd = ALLOWED_COMMANDS[safeCmd];
     if (safeCmd === "gh") {
         finalCmd = config.ghPath;
     }
-    else if (safeCmd === "td-cli") {
+    else if (safeCmd === "td") {
         // If we have a repo-relative .venv, prioritize it
-        const venvBin = path.join(config.repoPath, ".venv", "bin", "td-cli");
-        const localVenvBin = path.join(process.cwd(), ".venv", "bin", "td-cli");
-        const parentVenvBin = path.join(config.repoPath, "..", ".venv", "bin", "td-cli");
+        const venvBin = path.join(config.repoPath, ".venv", "bin", "td");
+        const localVenvBin = path.join(process.cwd(), ".venv", "bin", "td");
+        const parentVenvBin = path.join(config.repoPath, "..", ".venv", "bin", "td");
         // In standalone mode, config.repoPath is the boomtick-pkg root.
         // We check common venv locations to ensure we call the isolated binary.
         if (fs.existsSync(venvBin)) {

package/dist/mcp/definitions.js

@@ -1,4 +1,4 @@
-import { HealthCheckInputJsonSchema, SearchPRsInputJsonSchema, GetPrDiffInputJsonSchema, CheckoutBranchInputJsonSchema, GetMergeConflictFilesInputJsonSchema, GetChangedFilesInputJsonSchema, GetPackageScriptsInputJsonSchema, GetRouteMapInputJsonSchema, ReadCiLogsInputJsonSchema, RepoLogsInputJsonSchema, CreateBranchInputJsonSchema, CreateRepairBranchInputJsonSchema, RunTestsInputJsonSchema, RunLighthouseInputJsonSchema, RunPlaywrightInputJsonSchema, CommitPatchInputJsonSchema, OpenReplacementPrInputJsonSchema, CreatePullRequestInputJsonSchema, CommentTriageSummaryInputJsonSchema, GetPrInputJsonSchema, IssueViewInputJsonSchema, IssueUpdateInputJsonSchema, IssueCommentInputJsonSchema, CreateIssueInputJsonSchema, GetCommandSchemaInputJsonSchema, ReadAgentContextInputJsonSchema as ReadAgentContextSchema, CreateJulesSessionInputJsonSchema, JulesSessionIdInputJsonSchema, JulesSendMessageInputJsonSchema, JulesListSessionsInputJsonSchema, SearchDdgsInputJsonSchema, } from "../tools/contract.js";
+import { HealthCheckInputJsonSchema, SearchPRsInputJsonSchema, GetPrDiffInputJsonSchema, CheckoutBranchInputJsonSchema, GetMergeConflictFilesInputJsonSchema, GetChangedFilesInputJsonSchema, GetPackageScriptsInputJsonSchema, ReadCiLogsInputJsonSchema, RepoLogsInputJsonSchema, CreateBranchInputJsonSchema, CreateRepairBranchInputJsonSchema, RunTestsInputJsonSchema, CommitPatchInputJsonSchema, OpenReplacementPrInputJsonSchema, CreatePullRequestInputJsonSchema, CommentTriageSummaryInputJsonSchema, GetPrInputJsonSchema, IssueViewInputJsonSchema, IssueUpdateInputJsonSchema, IssueCommentInputJsonSchema, CreateIssueInputJsonSchema, GetCommandSchemaInputJsonSchema, ReadAgentContextInputJsonSchema as ReadAgentContextSchema, CreateJulesSessionInputJsonSchema, JulesSessionIdInputJsonSchema, JulesSendMessageInputJsonSchema, JulesListSessionsInputJsonSchema, GetPrReviewsInputJsonSchema, GetPrCommitsInputJsonSchema, GetWorkflowRunsInputJsonSchema, } from "../tools/contract.js";
 export const MCP_PROMPTS = [
     {
         name: "conflict-scout",
@@ -27,16 +27,28 @@ export const MCP_PROMPTS = [
 ];
 export const MCP_RESOURCES = [
     {
-        uri: "repo://package-json",
-        name: "package.json",
+        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: "The root package.json file of the repository.",
+        description: "List of changed files in the repository.",
     },
     {
-        uri: "repo://routes",
-        name: "Route Map",
+        uri: "repo://package-json",
+        name: "package.json",
         mimeType: "application/json",
-        description: "The mapping of application routes to content files.",
+        description: "The root package.json file of the repository.",
     },
     {
         uri: "repo://design-tokens",
@@ -44,200 +56,236 @@ export const MCP_RESOURCES = [
         mimeType: "application/json",
         description: "The design tokens used in the repository.",
     },
+];
+export const MCP_RESOURCE_TEMPLATES = [
     {
-        uri: "repo://repair-report/{branch}",
-        name: "Repair Report",
-        mimeType: "application/json",
-        description: "The validation report for a specific repair branch.",
+        uriTemplate: "mcp://git/diff/{prNumber}",
+        name: "Git PR Diff",
+        mimeType: "text/plain",
+        description: "Diff and changed files for a pull request.",
     },
     {
-        uri: "repo://lighthouse/{branch}",
-        name: "Lighthouse Report",
+        uriTemplate: "mcp://ci/logs/{prNumber}",
+        name: "CI Logs",
         mimeType: "application/json",
-        description: "Lighthouse CI report for a specific branch.",
+        description: "CI logs for a pull request.",
     },
     {
-        uri: "repo://playwright/{branch}",
-        name: "Playwright Report",
+        uriTemplate: "repo://repair-report/{branch}",
+        name: "Repair Report",
         mimeType: "application/json",
-        description: "Playwright test report for a specific branch.",
+        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,
-    },
-    {
-        name: "repo.get_route_map",
-        description: "Get the mapping of routes to content files.",
-        inputSchema: GetRouteMapInputJsonSchema,
+        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,
-    },
-    {
-        name: "repo.run_lighthouse",
-        description: "Run Lighthouse CI audits.",
-        inputSchema: RunLighthouseInputJsonSchema,
-    },
-    {
-        name: "repo.run_playwright",
-        description: "Run Playwright E2E tests.",
-        inputSchema: RunPlaywrightInputJsonSchema,
+        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,
-    },
-    {
-        name: "agent.search_ddgs",
-        description: "Search the web using DuckDuckGo (via ddgs python library).",
-        inputSchema: SearchDdgsInputJsonSchema,
+        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);
+            });
+        }),
+    };
+}