@arii/boomtick-mcp 0.6.0 → 0.6.2

package/dist/tools/jules/cli.js

@@ -0,0 +1,31 @@
+import { runCommand } from "../../lib/shell.js";
+function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export async function runTDCli(args, actionName) {
+    const result = await runCommand("td", args);
+    const stdout = result.stdout.trim();
+    const output = stdout.startsWith("{") ? tryParseJson(stdout) : null;
+    if (output?.status === "error") {
+        const errorMsg = output.message ?? "Unknown error";
+        if (actionName) {
+            throw new Error(`Failed to ${actionName}: ${errorMsg}`);
+        }
+        throw new Error(`td returned error: ${errorMsg}`);
+    }
+    if (result.exitCode !== 0) {
+        if (actionName) {
+            throw new Error(`Failed to ${actionName}: ${result.stderr || stdout}`);
+        }
+        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;
+}

package/dist/tools/jules/get-messages.js

@@ -1,17 +1,10 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const GetJulesMessagesInputSchema = z.object({
     sessionId: z.string(),
 });
 export async function getJulesMessagesHandler(input) {
-    const result = await runCommand("td", ["agent", "messages", input.sessionId]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to get messages: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to get messages: ${output.message}`);
-    }
+    const output = await runTDCli(["agent", "messages", input.sessionId], "get messages");
     return {
         id: input.sessionId.replace("sessions/", ""),
         messages: output.messages,

package/dist/tools/jules/list-sessions.js

@@ -1,43 +1,12 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
+import { parseJulesSession } from "./session.js";
 export const ListJulesSessionsInputSchema = z.object({
     pageSize: z.number().optional(),
     pageToken: z.string().optional(),
 });
 export async function listJulesSessionsHandler(input) {
-    const result = await runCommand("td", ["agent", "sync"]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to list sessions: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to list sessions: ${output.message}`);
-    }
+    const output = await runTDCli(["agent", "sync"], "list sessions");
     const sessions = output.sessions || [];
-    return sessions.map((session) => {
-        const name = session.name || "";
-        const id = name.startsWith("sessions/") ? name.substring(9) : name;
-        let status = "PENDING";
-        if (session.state === "SUCCEEDED" || session.state === "COMPLETED")
-            status = "COMPLETED";
-        else if (session.state === "FAILED" || session.state === "CANCELLED" || session.state === "TERMINATED")
-            status = "FAILED";
-        else if (session.state === "IN_PROGRESS")
-            status = "IN_PROGRESS";
-        let pullRequestUrl;
-        if (session.outputs && Array.isArray(session.outputs)) {
-            for (const out of session.outputs) {
-                if (out.pullRequest && out.pullRequest.url) {
-                    pullRequestUrl = out.pullRequest.url;
-                    break;
-                }
-            }
-        }
-        return {
-            id,
-            status,
-            createdAt: session.createTime ? new Date(session.createTime) : new Date(),
-            pullRequestUrl,
-        };
-    });
+    return sessions.map((session) => parseJulesSession(session));
 }

package/dist/tools/jules/send-message.js

@@ -1,19 +1,12 @@
 import { z } from "zod";
-import { runCommand } from "../../lib/shell.js";
+import { runTDCli } from "./cli.js";
 export const SendJulesMessageInputSchema = z.object({
     sessionId: z.union([z.string(), z.array(z.string())]),
     message: z.string(),
 });
 export async function sendJulesMessageHandler(input) {
     const sessionIds = Array.isArray(input.sessionId) ? input.sessionId.join(",") : input.sessionId;
-    const result = await runCommand("td", ["agent", "send", sessionIds, input.message]);
-    if (result.exitCode !== 0) {
-        throw new Error(`Failed to send message: ${result.stderr}`);
-    }
-    const output = JSON.parse(result.stdout);
-    if (output.status === "error") {
-        throw new Error(`Failed to send message: ${output.message}`);
-    }
+    await runTDCli(["agent", "send", sessionIds, input.message], "send message");
     return {
         id: Array.isArray(input.sessionId) ? input.sessionId.map(id => id.replace("sessions/", "")) : input.sessionId.replace("sessions/", ""),
         status: "success",

package/dist/tools/jules/session.js

@@ -0,0 +1,26 @@
+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,
+    };
+}

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.get_workflow_runs.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { runCommand } from "../lib/shell.js";
 import { resolveRepo } from "../lib/git.js";
 import { sanitizeError } from "../lib/error_utils.js";
-const GetWorkflowRunsInputSchema = z.object({
+export const GetWorkflowRunsInputSchema = z.object({
     branch: z.string().optional().describe("Filter workflow runs by branch name."),
     event: z.string().optional().describe("Filter workflow runs by event (e.g. push, pull_request)."),
     repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),

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.0",
+  "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, "../../../../");
+}