@arii/boomtick-mcp 0.6.0 → 0.6.2

package/src/config.ts

@@ -1,7 +1,9 @@
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
-import { execSync } from "child_process";
+import { findRepoRoot } from "./config/repo.js";
+import { getGithubToken } from "./config/github.js";
+import { initializeConfig, getCachedDynamicConfig } from "./config/dynamic.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -14,93 +16,14 @@ if (fs.existsSync(envPath) && typeof process.loadEnvFile === "function") {
   }
 }
 
-function getGithubToken(): string | undefined {
-  if (process.env.GITHUB_TOKEN) {
-    return process.env.GITHUB_TOKEN;
-  }
-  try {
-    const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    if (token) {
-      return token;
-    }
-  } catch (e) { /* ignore to allow fallback */ }
-  return undefined;
-}
-
-let cachedDynamicConfig: any = null;
-
-/**
- * Explicitly initializes dynamic configuration from the Python CLI.
- * Should be called once during server startup.
- */
-export function initializeConfig() {
-  if (cachedDynamicConfig !== null) {
-    return cachedDynamicConfig;
-  }
-
-  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 config view`;
-    const output = execSync(cmd, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    cachedDynamicConfig = JSON.parse(output);
-    return cachedDynamicConfig;
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    const errorPrefix = `CRITICAL: Failed to load dynamic config from Python CLI. Ensure Python 3 is installed and cli is in your PYTHONPATH. Details: ${message}`;
-
-    if (process.env.NODE_ENV === "development" || process.env.CI === "true") {
-      throw new Error(errorPrefix);
-    } else {
-      console.warn(errorPrefix);
-    }
-    // Set an empty object to prevent repeated attempts if initialization fails in non-blocking mode
-    cachedDynamicConfig = {};
-  }
-  return cachedDynamicConfig;
-}
-
-function findRepoRoot() {
-  if (process.env.BOOMTICK_REPO_PATH) {
-    return process.env.BOOMTICK_REPO_PATH;
-  }
-
-  // Traverse up from process.cwd() to find project_config.json, workspace.json, or .git
-  let current = process.cwd();
-  while (current !== path.parse(current).root) {
-    if (
-      fs.existsSync(path.join(current, "project_config.json")) ||
-      fs.existsSync(path.join(current, "workspace.json")) ||
-      fs.existsSync(path.join(current, ".git"))
-    ) {
-      return current;
-    }
-    current = path.dirname(current);
-  }
-
-  // Fallback to __dirname search if discovery from cwd fails
-  current = __dirname;
-  while (current !== path.parse(current).root) {
-    if (
-      fs.existsSync(path.join(current, "project_config.json")) ||
-      fs.existsSync(path.join(current, "workspace.json")) ||
-      fs.existsSync(path.join(current, ".git"))
-    ) {
-      return current;
-    }
-    current = path.dirname(current);
-  }
-  // Fallback to the monolithic relative path if discovery fails
-  return path.resolve(__dirname, "../../../");
-}
+export { initializeConfig };
 
 export const config = {
-  get githubToken() { return getGithubToken(); },
+  get githubToken() {
+    return getGithubToken();
+  },
   get githubOwner() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     const repoString = cachedDynamicConfig?.github_repo;
     if (typeof repoString === "string" && repoString.includes("/")) {
       return repoString.split("/")[0];
@@ -113,6 +36,7 @@ export const config = {
     throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
   },
   get githubRepo() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     const repoString = cachedDynamicConfig?.github_repo;
     if (typeof repoString === "string" && repoString.includes("/")) {
       return repoString.split("/")[1];
@@ -128,16 +52,19 @@ export const config = {
     return findRepoRoot();
   },
   get defaultBaseBranch() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     return process.env.DEFAULT_BASE_BRANCH || cachedDynamicConfig?.base_branch?.split("/").pop() || "main";
   },
   get viteBasePath() {
-    const path = process.env.VITE_BASE_PATH || cachedDynamicConfig?.vite_base_path;
-    if (!path) {
+    const cachedDynamicConfig = getCachedDynamicConfig();
+    const pathValue = process.env.VITE_BASE_PATH || cachedDynamicConfig?.vite_base_path;
+    if (!pathValue) {
       throw new Error("VITE_BASE_PATH must be set via environment variable or project_config.json");
     }
-    return path;
+    return pathValue;
   },
   get ghPath() {
+    const cachedDynamicConfig = getCachedDynamicConfig();
     return process.env.GH_PATH || cachedDynamicConfig?.gh_path || "gh";
-  }
+  },
 };

package/src/http.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { BoomtickMCPServer } from "./mcp/server.js";
+import { initializeConfig } from "./config.js";
+
+initializeConfig();
+
+process.env.MCP_TRANSPORT = "http";
+
+const server = new BoomtickMCPServer();
+server.run().catch((error) => {
+  console.error("Fatal error running HTTP server:", error);
+  process.exit(1);
+});

package/src/mcp/definitions.ts

@@ -2,9 +2,12 @@ import { Tool, Prompt, Resource, ResourceTemplate } from "@modelcontextprotocol/
 import {
   HealthCheckInputJsonSchema,
   SearchPRsInputJsonSchema,
+  SearchPRsResponseJsonSchema,
   GetPrDiffInputJsonSchema,
+  PrDiffResponseJsonSchema,
   CheckoutBranchInputJsonSchema,
   GetMergeConflictFilesInputJsonSchema,
+  GetMergeConflictFilesResponseJsonSchema,
   GetChangedFilesInputJsonSchema,
   GetPackageScriptsInputJsonSchema,
   ReadCiLogsInputJsonSchema,
@@ -12,6 +15,7 @@ import {
   CreateBranchInputJsonSchema,
   CreateRepairBranchInputJsonSchema,
   RunTestsInputJsonSchema,
+  RunTestsResponseJsonSchema,
   CommitPatchInputJsonSchema,
   OpenReplacementPrInputJsonSchema,
   CreatePullRequestInputJsonSchema,
@@ -19,8 +23,10 @@ import {
   GetPrInputJsonSchema,
   IssueViewInputJsonSchema,
   IssueUpdateInputJsonSchema,
+  IssueUpdateResponseJsonSchema,
   IssueCommentInputJsonSchema,
   CreateIssueInputJsonSchema,
+  CreateIssueResponseJsonSchema,
   GetCommandSchemaInputJsonSchema,
   ReadAgentContextInputJsonSchema as ReadAgentContextSchema,
   CreateJulesSessionInputJsonSchema,
@@ -78,6 +84,12 @@ export const MCP_RESOURCES: Resource[] = [
     mimeType: "application/json",
     description: "List of changed files in the repository.",
   },
+  {
+    uri: "mcp://ci/latest-run",
+    name: "Latest CI Run",
+    mimeType: "application/json",
+    description: "Recent CI exit statuses, workflow runs, and annotations.",
+  },
   {
     uri: "repo://package-json",
     name: "package.json",
@@ -130,7 +142,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "github.search_open_prs",
     description: "Search for open pull requests in the repository.",
     inputSchema: SearchPRsInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: SearchPRsResponseJsonSchema as any,
   },
   {
     name: "repo.read_agent_context",
@@ -142,7 +154,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     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,
+    outputSchema: PrDiffResponseJsonSchema as any,
   },
   {
     name: "github.checkout_branch",
@@ -154,7 +166,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     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,
+    outputSchema: GetMergeConflictFilesResponseJsonSchema as any,
   },
   {
     name: "repo.get_changed_files",
@@ -198,11 +210,27 @@ const BASE_MCP_TOOLS: Tool[] = [
     inputSchema: CreateRepairBranchInputJsonSchema as any,
     outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
   },
+  {
+    name: "repo.check_jules_status",
+    description: "Check or poll the status of a Jules remediation session and verify its branch or PR status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "The unique ID or task ID of the Jules session." },
+        commitSha: { type: "string", description: "Commit SHA for idempotency key verification." },
+        failureLog: { type: "string", description: "Failure log content for idempotency key calculation." },
+        poll: { type: "boolean", description: "Whether to poll until session completion or timeout." },
+        timeoutMs: { type: "integer", description: "Timeout in milliseconds when polling." },
+        intervalMs: { type: "integer", description: "Polling interval in milliseconds." },
+      },
+    } 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,
+    outputSchema: RunTestsResponseJsonSchema as any,
   },
   {
     name: "repo.commit_patch",
@@ -262,7 +290,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     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,
+    outputSchema: IssueUpdateResponseJsonSchema as any,
   },
   {
     name: "github.issue_comment",
@@ -274,7 +302,7 @@ const BASE_MCP_TOOLS: Tool[] = [
     name: "github.create_issue",
     description: "Create a new GitHub issue.",
     inputSchema: CreateIssueInputJsonSchema as any,
-    outputSchema: DEFAULT_OUTPUT_SCHEMA as any,
+    outputSchema: CreateIssueResponseJsonSchema as any,
   },
   {
     name: "jules.create_session",

package/src/mcp/http.test.ts

@@ -1,7 +1,7 @@
 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";
+import { BoomtickMCPServer } from "./server.js";
 
 describe("createMcpHttpServer", () => {
   let mcpServer: Server;
@@ -18,19 +18,48 @@ describe("createMcpHttpServer", () => {
     }
   });
 
-  it("should respond with OAuth protected resource metadata on /.well-known/oauth-protected-resource", async () => {
+  it("should respond with RFC 9728 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);
+    expect(res.headers.get("content-type")).toContain("application/json");
+
     const body = await res.json();
     expect(body.resource).toBe("mcp://boomtick-mcp");
-    expect(body.authorization_servers).toBeDefined();
+    expect(body.authorization_servers).toEqual(["https://auth.boomtick.dev"]);
     expect(body.scopes_supported).toEqual(["mcp:read", "mcp:write"]);
+    expect(body.bearer_methods_supported).toEqual(["header"]);
+    expect(body.resource_documentation).toBe("https://github.com/arii/boomtick");
+  });
+
+  it("should handle HEAD requests for /.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`, {
+      method: "HEAD",
+    });
+    expect(res.status).toBe(200);
+    const text = await res.text();
+    expect(text).toBe("");
+  });
+
+  it("should handle OPTIONS preflight CORS requests", async () => {
+    httpServerObj = createMcpHttpServer({ port: 0, mcpServer });
+    port = await httpServerObj.listen(0);
+
+    const res = await fetch(`http://localhost:${port}/sse`, {
+      method: "OPTIONS",
+    });
+    expect(res.status).toBe(204);
+    expect(res.headers.get("access-control-allow-origin")).toBe("*");
+    expect(res.headers.get("access-control-allow-methods")).toContain("GET");
+    expect(res.headers.get("access-control-allow-headers")).toContain("Authorization");
   });
 
-  it("should reject requests when Bearer token is missing or invalid", async () => {
+  it("should reject protected requests when Bearer token is missing or invalid", async () => {
     httpServerObj = createMcpHttpServer({ port: 0, bearerToken: "secret123", mcpServer });
     port = await httpServerObj.listen(0);
 
@@ -38,6 +67,7 @@ describe("createMcpHttpServer", () => {
     const res1 = await fetch(`http://localhost:${port}/sse`);
     expect(res1.status).toBe(401);
     expect(res1.headers.get("www-authenticate")).toContain('Bearer realm="boomtick-mcp"');
+    expect(res1.headers.get("www-authenticate")).toContain('error="invalid_token"');
 
     // Request with wrong token
     const res2 = await fetch(`http://localhost:${port}/sse`, {
@@ -45,7 +75,7 @@ describe("createMcpHttpServer", () => {
     });
     expect(res2.status).toBe(401);
 
-    // Request with valid token
+    // Public resource metadata accessible with or without token
     const res3 = await fetch(`http://localhost:${port}/.well-known/oauth-protected-resource`, {
       headers: { Authorization: "Bearer secret123" },
     });
@@ -69,4 +99,34 @@ describe("createMcpHttpServer", () => {
     const body = await res.json();
     expect(body.error).toContain("Server misconfiguration");
   });
+
+  it("should return 400 for message requests without session or invalid session", async () => {
+    httpServerObj = createMcpHttpServer({ port: 0, bearerToken: "secret123", mcpServer });
+    port = await httpServerObj.listen(0);
+
+    const res = await fetch(`http://localhost:${port}/messages?sessionId=invalid_session`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer secret123",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", method: "ping", id: 1 }),
+    });
+
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.error).toContain("Session not found or expired");
+  });
+
+  it("should allow BoomtickMCPServer to start HTTP server via run() when transport is http", async () => {
+    process.env.MCP_TRANSPORT = "http";
+    process.env.PORT = "0";
+    process.env.BOOMTICK_MCP_BEARER_TOKEN = "test-token";
+
+    const boomtickServer = new BoomtickMCPServer();
+    await boomtickServer.run();
+
+    // Verify instance initialized properly
+    expect(boomtickServer).toBeInstanceOf(BoomtickMCPServer);
+  });
 });

package/src/mcp/http.ts

@@ -21,7 +21,7 @@ export function createMcpHttpServer(options: HttpServerOptions) {
   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-Methods", "GET, POST, OPTIONS, HEAD");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
 
     if (req.method === "OPTIONS") {
@@ -32,22 +32,28 @@ export function createMcpHttpServer(options: HttpServerOptions) {
 
     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") {
+    // Endpoint 1: RFC 9728 OAuth Protected Resource Metadata Discovery
+    if (url.pathname === "/.well-known/oauth-protected-resource" && (req.method === "GET" || req.method === "HEAD")) {
+      const metadata = {
+        resource: process.env.MCP_RESOURCE_URI || process.env.BOOMTICK_RESOURCE_URI || "mcp://boomtick-mcp",
+        authorization_servers: [
+          process.env.MCP_OAUTH_AUTH_SERVER || "https://auth.boomtick.dev",
+        ],
+        scopes_supported: ["mcp:read", "mcp:write"],
+        bearer_methods_supported: ["header"],
+        resource_documentation: process.env.MCP_RESOURCE_DOCS || "https://github.com/arii/boomtick",
+      };
+
       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"],
-        })
-      );
+      if (req.method === "HEAD") {
+        res.end();
+      } else {
+        res.end(JSON.stringify(metadata, null, 2));
+      }
       return;
     }
 
-    // Bearer Token Validation for SSE & Messages endpoints
+    // Bearer Token / OAuth 2.1 Validation for Protected Routes (/sse & /messages)
     if (url.pathname === "/sse" || url.pathname === "/messages") {
       if (!bearerToken) {
         res.writeHead(500, { "Content-Type": "application/json" });
@@ -67,7 +73,7 @@ export function createMcpHttpServer(options: HttpServerOptions) {
       if (!isMatch) {
         res.writeHead(401, {
           "Content-Type": "application/json",
-          "WWW-Authenticate": 'Bearer realm="boomtick-mcp", error="invalid_token"',
+          "WWW-Authenticate": 'Bearer realm="boomtick-mcp", error="invalid_token", error_description="Invalid or missing Bearer token"',
         });
         res.end(JSON.stringify({ error: "unauthorized", message: "Invalid or missing Bearer token" }));
         return;

package/src/mcp/server.test.ts

@@ -5,6 +5,9 @@ import fs from "fs/promises";
 import * as healthModule from "./tools.js";
 import * as prDiffModule from "../tools/github.get_pr_diff.js";
 import * as ciLogsModule from "../tools/repo.read_ci_logs.js";
+import * as prReviewsModule from "../tools/github.get_pr_reviews.js";
+import * as prCommitsModule from "../tools/github.get_pr_commits.js";
+import * as workflowRunsModule from "../tools/repo.get_workflow_runs.js";
 
 vi.mock("fs/promises");
 vi.mock("../config.js", () => ({
@@ -97,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 () => {
@@ -185,6 +192,35 @@ 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://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");
 
@@ -223,6 +259,31 @@ describe("BoomtickMCPServer", () => {
       });
     });
 
+    it("should execute github_get_pr_reviews and github_get_pr_commits via underscore or dot name", async () => {
+      const handler = requestHandlers.get("tools/call");
+      vi.spyOn(prReviewsModule, "getPrReviewsHandler").mockResolvedValue({ reviews: [] } as any);
+      vi.spyOn(prCommitsModule, "getPrCommitsHandler").mockResolvedValue({ commits: [] } as any);
+      vi.spyOn(workflowRunsModule, "getWorkflowRunsHandler").mockResolvedValue({ runs: [] } as any);
+
+      const resReviews = await handler!({
+        method: "tools/call",
+        params: { name: "github_get_pr_reviews", arguments: { prNumber: 123 } },
+      });
+      expect(resReviews.structuredContent).toEqual({ reviews: [] });
+
+      const resCommits = await handler!({
+        method: "tools/call",
+        params: { name: "github_get_pr_commits", arguments: { prNumber: 123 } },
+      });
+      expect(resCommits.structuredContent).toEqual({ commits: [] });
+
+      const resWorkflow = await handler!({
+        method: "tools/call",
+        params: { name: "repo_get_workflow_runs", arguments: {} },
+      });
+      expect(resWorkflow.structuredContent).toEqual({ runs: [] });
+    });
+
     it("should return error result for unknown tool", async () => {
       const handler = requestHandlers.get("tools/call");
 

package/src/mcp/server.ts

@@ -24,14 +24,18 @@ import { getCommandSchemaHandler, GetCommandSchemaInputSchema } from "../tools/r
 import { getPackageScriptsHandler, GetPackageScriptsInputSchema } from "../tools/repo.get_package_scripts.js";
 import { readCiLogsHandler, ReadCiLogsInputSchema } from "../tools/repo.read_ci_logs.js";
 import { repoLogsHandler, RepoLogsInputSchema } from "../tools/repo.logs.js";
+import { getWorkflowRunsHandler, GetWorkflowRunsInputSchema } from "../tools/repo.get_workflow_runs.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 { 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";
 import { createPullRequestHandler, CreatePullRequestInputSchema } from "../tools/github.create_pull_request.js";
 import { getPrHandler, GetPrInputSchema } from "../tools/github.get_pr.js";
+import { getPrReviewsHandler, GetPrReviewsInputSchema } from "../tools/github.get_pr_reviews.js";
+import { getPrCommitsHandler, GetPrCommitsInputSchema } from "../tools/github.get_pr_commits.js";
 import { issueViewHandler, IssueViewInputSchema } from "../tools/github.issue_view.js";
 import { issueUpdateHandler, IssueUpdateInputSchema } from "../tools/github.issue_update.js";
 import { issueCommentHandler, IssueCommentInputSchema } from "../tools/github.issue_comment.js";
@@ -147,6 +151,16 @@ export class BoomtickMCPServer {
           contents: [{ uri, mimeType: "application/json", text: JSON.stringify(changedFiles, 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 {
@@ -222,12 +236,18 @@ export class BoomtickMCPServer {
             return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(normArgs)));
           case "repo.logs":
             return createSuccessResult(await repoLogsHandler(RepoLogsInputSchema.parse(normArgs)));
+          case "repo.get.workflow.runs":
+          case "repo.get_workflow_runs":
+            return createSuccessResult(await getWorkflowRunsHandler(GetWorkflowRunsInputSchema.parse(normArgs)));
           case "repo.create.branch":
           case "repo.create_branch":
             return createSuccessResult(await createBranchHandler(CreateBranchInputSchema.parse(normArgs)));
           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)));
@@ -246,6 +266,12 @@ export class BoomtickMCPServer {
           case "github.get.pr":
           case "github.get_pr":
             return createSuccessResult(await getPrHandler(GetPrInputSchema.parse(normArgs)));
+          case "github.get.pr.reviews":
+          case "github.get_pr_reviews":
+            return createSuccessResult(await getPrReviewsHandler(GetPrReviewsInputSchema.parse(normArgs)));
+          case "github.get.pr.commits":
+          case "github.get_pr_commits":
+            return createSuccessResult(await getPrCommitsHandler(GetPrCommitsInputSchema.parse(normArgs)));
           case "github.issue.view":
           case "github.issue_view":
             return createSuccessResult(await issueViewHandler(IssueViewInputSchema.parse(normArgs)));
@@ -371,24 +397,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;
     }