@arii/boomtick-mcp 0.6.1 → 0.6.2

package/dist/tools/jules/shared.js

@@ -1,50 +1,2 @@
-import { runCommand } from "../../lib/shell.js";
-function tryParseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-export async function runTDCli(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 returned error: ${output.message ?? "Unknown error"}`);
-    }
-    if (result.exitCode !== 0) {
-        throw new Error(`td command failed (${args.join(" ")}): ${result.stderr || stdout}`);
-    }
-    if (!output) {
-        throw new Error(`td returned non-JSON output with exit code 0: ${stdout}`);
-    }
-    return output;
-}
-export function parseJulesSession(data) {
-    const name = data.name || "";
-    const id = name.startsWith("sessions/") ? name.substring(9) : name;
-    let status = "PENDING";
-    if (data.state === "SUCCEEDED" || data.state === "COMPLETED")
-        status = "COMPLETED";
-    else if (data.state === "FAILED" || data.state === "CANCELLED" || data.state === "TERMINATED")
-        status = "FAILED";
-    else if (data.state === "IN_PROGRESS")
-        status = "IN_PROGRESS";
-    let pullRequestUrl;
-    if (data.outputs && Array.isArray(data.outputs)) {
-        for (const out of data.outputs) {
-            if (out.pullRequest && out.pullRequest.url) {
-                pullRequestUrl = out.pullRequest.url;
-                break;
-            }
-        }
-    }
-    return {
-        id,
-        status,
-        createdAt: data.createTime ? new Date(data.createTime) : new Date(),
-        pullRequestUrl,
-    };
-}
+export * from "./cli.js";
+export * from "./session.js";

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

@@ -1,16 +1,8 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const TriggerJulesFeedbackInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function triggerJulesFeedbackHandler(input) {
-    const result = await runCommand("td", ["agent", "trigger-feedback", input.sessionId]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to trigger feedback: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to trigger feedback: ${output.message}`);
-    }
-    return output;
+    return await runTDCli(["agent", "trigger-feedback", input.sessionId], "trigger feedback");
 }

package/dist/tools/repo.check_jules_status.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { config } from "../config.js";
+export const CheckJulesStatusInputSchema = z.object({
+    sessionId: z.string().optional().describe("The unique ID or task ID of the Jules session."),
+    commitSha: z.string().optional().describe("Commit SHA for idempotency key verification."),
+    failureLog: z.string().optional().describe("Failure log content for idempotency key calculation."),
+    poll: z.boolean().optional().describe("Whether to poll until session completion or timeout."),
+    timeoutMs: z.number().int().optional().describe("Timeout in milliseconds when polling."),
+    intervalMs: z.number().int().optional().describe("Polling interval in milliseconds."),
+});
+function calculateHash(commitSha, failureLog) {
+    const hash = crypto.createHash("sha256");
+    return hash.update(`${commitSha}:${failureLog.trim()}`).digest("hex");
+}
+export async function checkJulesStatusHandler(input) {
+    let resolvedTaskId = input.sessionId || process.env.TASK_ID;
+    if (!resolvedTaskId) {
+        return {
+            sessionId: "",
+            status: "NOT_FOUND",
+            completed: false,
+            message: "No session ID provided.",
+        };
+    }
+    const sessionId = resolvedTaskId.startsWith("sessions/") ? resolvedTaskId : `sessions/${resolvedTaskId}`;
+    const apiKey = process.env.JULES_API_KEY;
+    if (!apiKey) {
+        return {
+            sessionId,
+            status: "NOT_FOUND",
+            completed: false,
+            message: "JULES_API_KEY environment variable not set.",
+        };
+    }
+    const commitSha = input.commitSha || process.env.GITHUB_SHA || process.env.COMMIT_SHA;
+    let idempotencyHash;
+    let isDuplicate = false;
+    if (commitSha && input.failureLog) {
+        idempotencyHash = calculateHash(commitSha, input.failureLog);
+        const artifactsDir = path.join(config.repoPath || process.cwd(), "artifacts");
+        const hashTrackingFile = path.join(artifactsDir, `.jules-dispatch-${sessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}.hash`);
+        if (fs.existsSync(hashTrackingFile)) {
+            try {
+                const existingHash = fs.readFileSync(hashTrackingFile, "utf8").trim();
+                if (existingHash === idempotencyHash) {
+                    isDuplicate = true;
+                }
+            }
+            catch (e) {
+                console.warn("⚠️ Could not read previous Jules dispatch hash file during status check:", e);
+            }
+        }
+    }
+    const url = `https://jules.googleapis.com/v1alpha/${sessionId}`;
+    const poll = input.poll ?? false;
+    const timeoutMs = input.timeoutMs ?? 60000;
+    const intervalMs = input.intervalMs ?? 5000;
+    const startTime = Date.now();
+    const fetchSession = async () => {
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-goog-api-key": apiKey,
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return await response.json();
+    };
+    while (true) {
+        let sessionData = null;
+        try {
+            sessionData = await fetchSession();
+        }
+        catch (e) {
+            console.warn(`⚠️ Error fetching Jules session status for ${sessionId}:`, e);
+        }
+        if (!sessionData) {
+            return {
+                sessionId,
+                status: "NOT_FOUND",
+                completed: false,
+                idempotencyHash,
+                isDuplicate,
+                message: `Failed to retrieve session data for ${sessionId}`,
+            };
+        }
+        const rawState = sessionData.state || "UNKNOWN";
+        let status = "IN_PROGRESS";
+        if (rawState === "SUCCEEDED" || rawState === "COMPLETED") {
+            status = "COMPLETED";
+        }
+        else if (rawState === "FAILED" || rawState === "CANCELLED" || rawState === "TERMINATED") {
+            status = "FAILED";
+        }
+        else if (rawState === "IN_PROGRESS" || rawState === "PENDING") {
+            status = "IN_PROGRESS";
+        }
+        let remediationBranch;
+        let pullRequestUrl;
+        if (sessionData.sourceContext?.githubRepoContext?.startingBranch) {
+            remediationBranch = sessionData.sourceContext.githubRepoContext.startingBranch;
+        }
+        if (Array.isArray(sessionData.outputs)) {
+            for (const output of sessionData.outputs) {
+                if (output?.pullRequest?.url) {
+                    pullRequestUrl = output.pullRequest.url;
+                }
+                if (output?.pullRequest?.branch || output?.gitBranch) {
+                    remediationBranch = output?.pullRequest?.branch || output?.gitBranch;
+                }
+            }
+        }
+        const completed = status === "COMPLETED";
+        if (!poll || status === "COMPLETED" || status === "FAILED") {
+            return {
+                sessionId,
+                status,
+                rawState,
+                completed,
+                remediationBranch,
+                pullRequestUrl,
+                idempotencyHash,
+                isDuplicate,
+                message: `Session state: ${rawState}`,
+            };
+        }
+        if (Date.now() - startTime >= timeoutMs) {
+            return {
+                sessionId,
+                status: "TIMED_OUT",
+                rawState,
+                completed: false,
+                remediationBranch,
+                pullRequestUrl,
+                idempotencyHash,
+                isDuplicate,
+                message: `Polling timed out after ${timeoutMs}ms (current state: ${rawState})`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}

package/dist/tools/repo.check_jules_status.test.js

@@ -0,0 +1,47 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { checkJulesStatusHandler } from "./repo.check_jules_status.js";
+describe("repo.check_jules_status MCP Tool Handler", () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        process.env = { ...originalEnv };
+        delete process.env.TASK_ID;
+        delete process.env.JULES_API_KEY;
+        global.fetch = vi.fn();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        vi.restoreAllMocks();
+    });
+    it("returns NOT_FOUND status if no session ID or JULES_API_KEY is available", async () => {
+        const result = await checkJulesStatusHandler({});
+        expect(result.status).toBe("NOT_FOUND");
+        expect(result.completed).toBe(false);
+    });
+    it("checks Jules session status and returns response object", async () => {
+        process.env.JULES_API_KEY = "test-api-key";
+        vi.mocked(global.fetch).mockResolvedValue({
+            ok: true,
+            json: vi.fn().mockResolvedValue({
+                name: "sessions/test-session-123",
+                state: "SUCCEEDED",
+                outputs: [
+                    {
+                        pullRequest: {
+                            url: "https://github.com/org/repo/pull/100",
+                            branch: "remediation-branch-123",
+                        },
+                    },
+                ],
+            }),
+        });
+        const result = await checkJulesStatusHandler({
+            sessionId: "test-session-123",
+        });
+        expect(result.sessionId).toBe("sessions/test-session-123");
+        expect(result.status).toBe("COMPLETED");
+        expect(result.completed).toBe(true);
+        expect(result.remediationBranch).toBe("remediation-branch-123");
+        expect(result.pullRequestUrl).toBe("https://github.com/org/repo/pull/100");
+    });
+});

package/dist/tools/repo.run_tests.js

@@ -61,5 +61,17 @@ export async function runTestsHandler(args) {
             break;
         }
     }
-    return { success, results };
+    const exitCode = results.length > 0 ? results[results.length - 1].exitCode : 0;
+    const failedTests = [];
+    for (const res of results) {
+        if (res.exitCode !== 0) {
+            failedTests.push(res.command);
+        }
+    }
+    return {
+        passed: success,
+        exitCode,
+        failedTests,
+        results,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",
@@ -13,7 +13,8 @@
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "boomtick-mcp": "dist/index.js"
+    "boomtick-mcp": "dist/index.js",
+    "boomtick-mcp-http": "dist/http.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",

package/scripts/sync-contracts.ts

@@ -216,9 +216,18 @@ async function syncContracts() {
   if (!fs.existsSync(path.join(rootDir, 'pnpm-workspace.yaml'))) {
     rootDir = path.dirname(rootDir);
   }
-  const pythonScriptPath = path.join(rootDir, 'cli/dev_tools/schema_gen.py');
   console.log(`Regenerating cli-schema.json...`);
-  execFileSync('python3', [pythonScriptPath], { cwd: rootDir, stdio: 'inherit' });
+  const cliDir = path.join(rootDir, 'cli');
+  const existingPythonPath = process.env.PYTHONPATH || '';
+  const newPythonPath = existingPythonPath ? `${existingPythonPath}${path.delimiter}${cliDir}` : cliDir;
+  execFileSync('python3', ['-m', 'dev_tools.schema_gen'], {
+    cwd: rootDir,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      PYTHONPATH: newPythonPath,
+    },
+  });
 
   // Then perform the original Zod contract generation
   let jsonSchemaToZod;

package/src/config/dynamic.ts

@@ -0,0 +1,36 @@
+import { execSync } from "child_process";
+
+let cachedDynamicConfig: any = null;
+
+export function initializeConfig() {
+  if (cachedDynamicConfig !== null) {
+    return cachedDynamicConfig;
+  }
+
+  try {
+    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);
+    }
+    cachedDynamicConfig = {};
+  }
+  return cachedDynamicConfig;
+}
+
+export function getCachedDynamicConfig(): any {
+  return cachedDynamicConfig;
+}

package/src/config/github.ts

@@ -0,0 +1,16 @@
+import { execSync } from "child_process";
+
+export 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 {
+    /* ignore to allow fallback */
+  }
+  return undefined;
+}

package/src/config/repo.ts

@@ -0,0 +1,36 @@
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export function findRepoRoot(): string {
+  if (process.env.BOOMTICK_REPO_PATH) {
+    return process.env.BOOMTICK_REPO_PATH;
+  }
+
+  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);
+  }
+
+  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);
+  }
+  return path.resolve(__dirname, "../../../../");
+}

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);
+});