@arii/boomtick-mcp 0.5.0 → 0.6.0

package/dist/tools/jules/shared.js

@@ -8,17 +8,17 @@ function tryParseJson(text) {
     }
 }
 export async function runTDCli(args) {
-    const result = await runCommand("td-cli", args);
+    const result = await runCommand("td", args);
     const stdout = result.stdout.trim();
     const output = stdout.startsWith("{") ? tryParseJson(stdout) : null;
     if (output?.status === "error") {
-        throw new Error(`td-cli returned error: ${output.message ?? "Unknown error"}`);
+        throw new Error(`td returned error: ${output.message ?? "Unknown error"}`);
     }
     if (result.exitCode !== 0) {
-        throw new Error(`td-cli command failed (${args.join(" ")}): ${result.stderr || stdout}`);
+        throw new Error(`td command failed (${args.join(" ")}): ${result.stderr || stdout}`);
     }
     if (!output) {
-        throw new Error(`td-cli returned non-JSON output with exit code 0: ${stdout}`);
+        throw new Error(`td returned non-JSON output with exit code 0: ${stdout}`);
     }
     return output;
 }

package/dist/tools/jules/trigger-feedback.js

@@ -4,7 +4,7 @@ export const TriggerJulesFeedbackInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function triggerJulesFeedbackHandler(input) {
-    const result = await runCommand("td-cli", ["agent", "trigger-feedback", input.sessionId]);
+    const result = await runCommand("td", ["agent", "trigger-feedback", input.sessionId]);
     if (result.exitCode !== 0) {
         throw new Error(`Failed to trigger feedback: ${result.stderr}`);
     }

package/dist/tools/jules/trigger-feedback.test.js

@@ -13,28 +13,28 @@ describe("triggerJulesFeedbackHandler", () => {
         teardownTestEnv();
         vi.clearAllMocks();
     });
-    it("should return success output from td-cli", async () => {
+    it("should return success output from td", async () => {
         vi.mocked(shell.runCommand).mockResolvedValue({
             stdout: JSON.stringify({ status: "success", feedback: "All checks passed successfully. You may proceed." }),
             stderr: "",
             exitCode: 0,
             durationMs: 0,
-            command: "td-cli agent trigger-feedback"
+            command: "td agent trigger-feedback"
         });
         const result = await triggerJulesFeedbackHandler({ sessionId: "123" });
         expect(result.status).toBe("success");
         expect(result.feedback).toBe("All checks passed successfully. You may proceed.");
-        expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+        expect(shell.runCommand).toHaveBeenCalledWith("td", [
             "agent", "trigger-feedback", "123"
         ]);
     });
-    it("should throw error if td-cli returns error", async () => {
+    it("should throw error if td returns error", async () => {
         vi.mocked(shell.runCommand).mockResolvedValue({
             stdout: JSON.stringify({ status: "error", message: "Session not found" }),
             stderr: "",
             exitCode: 0,
             durationMs: 0,
-            command: "td-cli agent trigger-feedback"
+            command: "td agent trigger-feedback"
         });
         await expect(triggerJulesFeedbackHandler({ sessionId: "123" }))
             .rejects.toThrow("Failed to trigger feedback: Session not found");

package/dist/tools/repo.get_command_schema.js

@@ -6,11 +6,11 @@ export const GetCommandSchemaInputSchema = z.object({
 export async function getCommandSchemaHandler(args) {
     // Sanitize input to prevent command injection (allow only alphanumeric, spaces, hyphens, and underscores)
     const sanitizedPath = args.commandPath.replace(/[^a-zA-Z0-9-_ ]/g, "");
-    const result = await runCommand("td-cli", ["schema", sanitizedPath]);
+    const result = await runCommand("td", ["schema", sanitizedPath]);
     if (result.exitCode !== 0) {
         // Log stderr for debugging but don't expose it to the user
         // Using comma-separated arguments to satisfy semgrep unsafe-formatstring
-        console.error("td-cli schema failed for", sanitizedPath, ":", result.stderr);
+        console.error("td schema failed for", sanitizedPath, ":", result.stderr);
         throw new Error(`Failed to get command schema for '${sanitizedPath}'`);
     }
     try {

package/dist/tools/repo.get_workflow_runs.js

@@ -17,7 +17,7 @@ export async function getWorkflowRunsHandler(args) {
     if (params.event) {
         cliArgs.push("--event", params.event);
     }
-    const result = await runCommand("td-cli", cliArgs);
+    const result = await runCommand("td", cliArgs);
     if (result.exitCode !== 0) {
         throw new Error(`Failed to fetch workflow runs: ${sanitizeError(result.stderr)}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",

package/scripts/sync-mcp-schemas.ts

@@ -19,6 +19,7 @@ function isWritable(dir: string): boolean {
 interface ToolDefinition {
   name: string;
   inputSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
 }
 
 /**
@@ -73,6 +74,7 @@ async function syncSchemas() {
       name: tool.name,
       description: tool.description,
       parameters: tool.inputSchema,
+      outputSchema: tool.outputSchema,
     };
     const schemaContent = JSON.stringify(exportedSchema, null, 2);
     const fileName = `${tool.name}.json`;

package/src/config.test.ts

@@ -20,14 +20,14 @@ describe("config", () => {
   });
 
   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);
@@ -119,7 +119,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";

package/src/config.ts

@@ -41,7 +41,7 @@ export function initializeConfig() {
   try {
     // Attempt to load core properties from the Python CLI in the active workspace
     const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
-    const cmd = `td-cli config view`;
+    const cmd = `td config view`;
     const output = execSync(cmd, {
       cwd,
       encoding: "utf-8",

package/src/lib/result.test.ts

@@ -3,7 +3,7 @@ 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: [
@@ -12,11 +12,12 @@ 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({
@@ -26,6 +27,7 @@ describe("result utils", () => {
             text: JSON.stringify(objData, null, 2),
           },
         ],
+        structuredContent: objData,
       });
       expect(result.isError).toBeUndefined();
     });

package/src/lib/result.ts

@@ -5,6 +5,11 @@ export interface ToolResult extends CallToolResult {
 }
 
 export function createSuccessResult(data: any): ToolResult {
+  const structuredContent =
+    typeof data === "object" && data !== null
+      ? data
+      : { result: data };
+
   return {
     content: [
       {
@@ -12,6 +17,7 @@ export function createSuccessResult(data: any): ToolResult {
         text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
       },
     ],
+    structuredContent,
   };
 }
 

package/src/lib/shell.ts

@@ -6,7 +6,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",
@@ -39,15 +39,15 @@ export async function runCommand(
   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] as string;
   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.

package/src/mcp/definitions.ts

@@ -1,4 +1,4 @@
-import { Tool, Prompt, Resource } from "@modelcontextprotocol/sdk/types.js";
+import { Tool, Prompt, Resource, ResourceTemplate } from "@modelcontextprotocol/sdk/types.js";
 import {
   HealthCheckInputJsonSchema,
   SearchPRsInputJsonSchema,
@@ -60,6 +60,24 @@ export const MCP_PROMPTS: Prompt[] = [
 ];
 
 export const MCP_RESOURCES: Resource[] = [
+  {
+    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",
@@ -72,184 +90,239 @@ export const MCP_RESOURCES: Resource[] = [
     mimeType: "application/json",
     description: "The design tokens used in the repository.",
   },
+];
+
+export const MCP_RESOURCE_TEMPLATES: ResourceTemplate[] = [
+  {
+    uriTemplate: "mcp://git/diff/{prNumber}",
+    name: "Git PR Diff",
+    mimeType: "text/plain",
+    description: "Diff and changed files for a pull request.",
+  },
   {
-    uri: "repo://repair-report/{branch}",
+    uriTemplate: "mcp://ci/logs/{prNumber}",
+    name: "CI Logs",
+    mimeType: "application/json",
+    description: "CI logs for a pull request.",
+  },
+  {
+    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,
+} as const;
+
 const BASE_MCP_TOOLS: Tool[] = [
   {
     name: "boomtick.health",
     description: "Check the health and configuration of the MCP server.",
     inputSchema: HealthCheckInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.search_open_prs",
     description: "Search for open pull requests in the repository.",
     inputSchema: SearchPRsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.read_agent_context",
     description: "Read the full repository index including file tree, CLI schema, and MCP tools.",
     inputSchema: ReadAgentContextSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.get_pr_diff",
     description: "Get the diff and changed files for a pull request.",
     inputSchema: GetPrDiffInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.checkout_branch",
     description: "Checkout a specific branch in the repository or worktree.",
     inputSchema: CheckoutBranchInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.get_merge_conflict_files",
     description: "Detect files that conflict when a PR is merged with the base branch.",
     inputSchema: GetMergeConflictFilesInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.get_changed_files",
     description: "Get the list of changed files between two refs.",
     inputSchema: GetChangedFilesInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     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 as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.get_package_scripts",
     description: "Get the scripts defined in package.json.",
     inputSchema: GetPackageScriptsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.read_ci_logs",
     description: "Read CI logs for a given pull request.",
     inputSchema: ReadCiLogsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.logs",
     description: "Stream or grep combined CI logs for all jobs in a pull request.",
     inputSchema: RepoLogsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.create_branch",
     description: "Creates a new clean git branch from a target base branch.",
     inputSchema: CreateBranchInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     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 as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.run_tests",
     description: "Run repository tests and checks.",
     inputSchema: RunTestsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.commit_patch",
     description: "Commit verified repair changes in a worktree.",
     inputSchema: CommitPatchInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.open_replacement_pr",
     description: "Open a new PR that replaces or repairs the original PR.",
     inputSchema: OpenReplacementPrInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     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 as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.comment_triage_summary",
     description: "Comment on the original PR with a diagnosis and replacement link.",
     inputSchema: CommentTriageSummaryInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.get_pr",
     description: "Get details of a GitHub PR including title, state, and URLs.",
     inputSchema: GetPrInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.get_pr_reviews",
     description: "Get top-level reviews, verdicts, states, and bodies for a GitHub PR.",
     inputSchema: GetPrReviewsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.get_pr_commits",
     description: "List commits and commit metadata (SHAs, authors, messages) for a GitHub PR.",
     inputSchema: GetPrCommitsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "repo.get_workflow_runs",
     description: "List recent GitHub Actions workflow runs for the repository.",
     inputSchema: GetWorkflowRunsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.issue_view",
     description: "View details of a GitHub issue including title, body, and state.",
     inputSchema: IssueViewInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.issue_update",
     description: "Update a GitHub issue's body, labels, and/or state.",
     inputSchema: IssueUpdateInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.issue_comment",
     description: "Add a new comment to a GitHub issue.",
     inputSchema: IssueCommentInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "github.create_issue",
     description: "Create a new GitHub issue.",
     inputSchema: CreateIssueInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.create_session",
     description: "Create a Jules session that performs work externally and may generate a GitHub pull request.",
     inputSchema: CreateJulesSessionInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.get_session",
     description: "Get the status and details of a Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.send_message",
     description: "Send a message to an active Jules session.",
     inputSchema: JulesSendMessageInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.get_messages",
     description: "Get the message history of a Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.list_sessions",
     description: "List all Jules sessions.",
     inputSchema: JulesListSessionsInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.cancel_session",
     description: "Cancel an ongoing Jules session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     name: "jules.get_pr",
     description: "Get the generated pull request url associated with an active Jules agent session.",
     inputSchema: JulesSessionIdInputJsonSchema as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
   {
     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 as any,
+    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
 ];
 

package/src/mcp/http.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import http from "node:http";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { createMcpHttpServer } from "./http.js";
+
+describe("createMcpHttpServer", () => {
+  let mcpServer: Server;
+  let httpServerObj: ReturnType<typeof createMcpHttpServer>;
+  let port: number;
+
+  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");
+  });
+});