@arii/boomtick-mcp 0.6.1 → 0.7.0

package/src/mcp/server.test.ts

@@ -100,12 +100,16 @@ describe("BoomtickMCPServer", () => {
   });
 
   describe("ListResources", () => {
-    it("should return resources list", async () => {
+    it("should return resources list containing workspace resources", async () => {
       const handler = requestHandlers.get("resources/list");
       expect(handler).toBeDefined();
       const result = await handler!({ method: "resources/list" });
       expect(result.resources).toBeDefined();
       expect(Array.isArray(result.resources)).toBe(true);
+      const uris = result.resources.map((r: any) => r.uri);
+      expect(uris).toContain("mcp://workspace/agent-contract");
+      expect(uris).toContain("mcp://git/changed-files");
+      expect(uris).toContain("mcp://ci/latest-run");
     });
 
     it("should return resource templates list", async () => {
@@ -188,6 +192,62 @@ describe("BoomtickMCPServer", () => {
       expect(JSON.parse(result.contents[0].text)).toEqual({ status: "success" });
     });
 
+    it("should handle mcp://git/changed-files", async () => {
+      const handler = requestHandlers.get("resources/read");
+      const changedFilesModule = await import("../tools/repo.get_changed_files.js");
+      vi.spyOn(changedFilesModule, "getChangedFilesHandler").mockResolvedValue({ files: ["src/index.ts"] } as any);
+
+      const result = await handler!({
+        method: "resources/read",
+        params: { uri: "mcp://git/changed-files" },
+      });
+
+      expect(result.contents[0].uri).toBe("mcp://git/changed-files");
+      expect(result.contents[0].mimeType).toBe("application/json");
+      expect(JSON.parse(result.contents[0].text)).toEqual({ files: ["src/index.ts"] });
+    });
+
+    it("should handle mcp://workspace/project-config", async () => {
+      const handler = requestHandlers.get("resources/read");
+      vi.mocked(fs.readFile).mockResolvedValue('{"packageName": "boomtick"}');
+
+      const result = await handler!({
+        method: "resources/read",
+        params: { uri: "mcp://workspace/project-config" },
+      });
+
+      expect(result.contents[0].uri).toBe("mcp://workspace/project-config");
+      expect(result.contents[0].mimeType).toBe("application/json");
+      expect(JSON.parse(result.contents[0].text)).toEqual({ packageName: "boomtick" });
+    });
+
+    it("should handle mcp://git/status", async () => {
+      const handler = requestHandlers.get("resources/read");
+
+      const result = await handler!({
+        method: "resources/read",
+        params: { uri: "mcp://git/status" },
+      });
+
+      expect(result.contents[0].uri).toBe("mcp://git/status");
+      expect(result.contents[0].mimeType).toBe("application/json");
+      expect(JSON.parse(result.contents[0].text)).toHaveProperty("status");
+    });
+
+    it("should handle mcp://ci/latest-run", async () => {
+      const handler = requestHandlers.get("resources/read");
+      vi.spyOn(workflowRunsModule, "getWorkflowRunsHandler").mockResolvedValue({ workflowRuns: [{ id: 1, status: "completed", conclusion: "success" }] } as any);
+
+      const result = await handler!({
+        method: "resources/read",
+        params: { uri: "mcp://ci/latest-run" },
+      });
+
+      expect(result.contents[0].uri).toBe("mcp://ci/latest-run");
+      expect(result.contents[0].mimeType).toBe("application/json");
+      expect(JSON.parse(result.contents[0].text)).toEqual({ workflowRuns: [{ id: 1, status: "completed", conclusion: "success" }] });
+    });
+
     it("should throw when resource is unknown", async () => {
       const handler = requestHandlers.get("resources/read");
 
@@ -208,6 +268,17 @@ describe("BoomtickMCPServer", () => {
       expect(result.tools).toBeDefined();
       expect(Array.isArray(result.tools)).toBe(true);
     });
+
+    it("should ensure all tools have typed outputSchema and none are empty or untyped DEFAULT_OUTPUT_SCHEMA", async () => {
+      const handler = requestHandlers.get("tools/list");
+      const result = await handler!({ method: "tools/list" });
+      for (const tool of result.tools) {
+        expect(tool.outputSchema).toBeDefined();
+        expect(tool.outputSchema.type).toBe("object");
+        expect(tool.outputSchema.properties).toBeDefined();
+        expect(Object.keys(tool.outputSchema.properties).length).toBeGreaterThan(0);
+      }
+    });
   });
 
   describe("CallTool", () => {

package/src/mcp/server.ts

@@ -20,6 +20,7 @@ import { getMergeConflictFilesHandler, GetMergeConflictFilesInputSchema } from "
 import { checkoutBranchHandler, CheckoutBranchInputSchema } from "../tools/github.checkout_branch.js";
 import { getChangedFilesHandler, GetChangedFilesInputSchema } from "../tools/repo.get_changed_files.js";
 import { readAgentContextHandler, ReadAgentContextInputSchema } from "../tools/repo.read_agent_context.js";
+import { multiExecHandler, MultiExecInputSchema } from "../tools/repo.multi_exec.js";
 import { getCommandSchemaHandler, GetCommandSchemaInputSchema } from "../tools/repo.get_command_schema.js";
 import { getPackageScriptsHandler, GetPackageScriptsInputSchema } from "../tools/repo.get_package_scripts.js";
 import { readCiLogsHandler, ReadCiLogsInputSchema } from "../tools/repo.read_ci_logs.js";
@@ -28,6 +29,7 @@ import { getWorkflowRunsHandler, GetWorkflowRunsInputSchema } from "../tools/rep
 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 { checkJulesStatusHandler, CheckJulesStatusInputSchema } from "../tools/repo.check_jules_status.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";
@@ -141,6 +143,22 @@ export class BoomtickMCPServer {
           contents: [{ uri, mimeType: "text/markdown", text: content }],
         };
       }
+      if (
+        uri === "mcp://workspace/project-config" ||
+        uri === "mcp://workspace/project_config" ||
+        uri === "repo://project-config"
+      ) {
+        const configPath = path.join(config.repoPath, "project_config.json");
+        let content = "{}";
+        try {
+          content = await fs.readFile(configPath, "utf-8");
+        } catch {
+          // Fallback if file doesn't exist
+        }
+        return {
+          contents: [{ uri, mimeType: "application/json", text: content }],
+        };
+      }
       if (
         uri === "mcp://git/changed-files" ||
         uri === "repo://changed-files"
@@ -150,6 +168,32 @@ export class BoomtickMCPServer {
           contents: [{ uri, mimeType: "application/json", text: JSON.stringify(changedFiles, null, 2) }],
         };
       }
+      if (
+        uri === "mcp://git/status" ||
+        uri === "repo://git-status" ||
+        uri === "repo://status"
+      ) {
+        let statusText = "";
+        try {
+          const res = spawnSync("git", ["status", "--porcelain"], { cwd: config.repoPath, encoding: "utf-8" });
+          statusText = res.stdout || "";
+        } catch {
+          // Fallback if git fails
+        }
+        return {
+          contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ status: statusText.trim() }, null, 2) }],
+        };
+      }
+      if (
+        uri === "mcp://ci/latest-run" ||
+        uri === "repo://ci/latest-run" ||
+        uri === "repo://ci-latest-run"
+      ) {
+        const workflowRuns = await getWorkflowRunsHandler(GetWorkflowRunsInputSchema.parse({}));
+        return {
+          contents: [{ uri, mimeType: "application/json", text: JSON.stringify(workflowRuns, 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 {
@@ -202,6 +246,9 @@ export class BoomtickMCPServer {
           case "repo.read.agent.context":
           case "repo.read_agent_context":
             return createSuccessResult(await readAgentContextHandler(ReadAgentContextInputSchema.parse(normArgs)));
+          case "repo.multi.exec":
+          case "repo.multi_exec":
+            return createSuccessResult(await multiExecHandler(MultiExecInputSchema.parse(normArgs)));
           case "github.get.pr.diff":
           case "github.get_pr_diff":
             return createSuccessResult(await getPrDiffHandler(GetPrDiffInputSchema.parse(normArgs)));
@@ -234,6 +281,9 @@ export class BoomtickMCPServer {
           case "repo.create.repair.branch":
           case "repo.create_repair_branch":
             return createSuccessResult(await createRepairBranchHandler(CreateRepairBranchInputSchema.parse(normArgs)));
+          case "repo.check.jules.status":
+          case "repo.check_jules_status":
+            return createSuccessResult(await checkJulesStatusHandler(CheckJulesStatusInputSchema.parse(normArgs)));
           case "repo.run.tests":
           case "repo.run_tests":
             return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
@@ -383,24 +433,35 @@ export class BoomtickMCPServer {
     }
   }
 
-  async startHttp(port = parseInt(process.env.PORT || process.env.HTTP_PORT || "3000", 10), bearerToken?: string) {
-    this.prepareEnvironmentAndPreflight();
-    const mcpHttp = createMcpHttpServer({ port, bearerToken, mcpServer: this.server });
-    return await mcpHttp.listen(port);
-  }
-
   async run() {
     this.prepareEnvironmentAndPreflight();
 
+    const args = process.argv.slice(2);
+    let port = parseInt(process.env.PORT || process.env.HTTP_PORT || "3000", 10);
+    let bearerToken = process.env.BOOMTICK_MCP_BEARER_TOKEN || process.env.MCP_BEARER_TOKEN || process.env.AUTH_TOKEN;
+
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--port" && i + 1 < args.length) {
+        port = parseInt(args[i + 1], 10);
+        i++;
+      } else if (args[i].startsWith("--port=")) {
+        port = parseInt(args[i].split("=")[1], 10);
+      } else if (args[i] === "--bearer-token" && i + 1 < args.length) {
+        bearerToken = args[i + 1];
+        i++;
+      } else if (args[i].startsWith("--bearer-token=")) {
+        bearerToken = args[i].split("=")[1];
+      }
+    }
+
     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"));
+      args.includes("--http") ||
+      (process.env.PORT !== undefined && !args.includes("--stdio")) ||
+      (process.env.HTTP_PORT !== undefined && !args.includes("--stdio"));
 
     if (isHttp) {
-      const port = parseInt(process.env.PORT || process.env.HTTP_PORT || "3000", 10);
-      const mcpHttp = createMcpHttpServer({ port, mcpServer: this.server });
+      const mcpHttp = createMcpHttpServer({ port, bearerToken, mcpServer: this.server });
       await mcpHttp.listen(port);
       return;
     }