@arii/boomtick-mcp 0.6.1 → 0.6.2

package/src/tools/jules/get-messages.ts

@@ -1,21 +1,12 @@
 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: z.infer<typeof GetJulesMessagesInputSchema>) {
-  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/", ""),

package/src/tools/jules/list-sessions.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { JulesSession, JulesStatus } from "../types.js";
-import { runCommand } from "../../lib/shell.js";
+import { JulesSession } from "../types.js";
+import { runTDCli } from "./cli.js";
+import { parseJulesSession } from "./session.js";
 
 export const ListJulesSessionsInputSchema = z.object({
   pageSize: z.number().optional(),
@@ -8,43 +9,8 @@ export const ListJulesSessionsInputSchema = z.object({
 });
 
 export async function listJulesSessionsHandler(input: z.infer<typeof ListJulesSessionsInputSchema>): Promise<JulesSession[]> {
-  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: any) => {
-    const name = session.name || "";
-    const id = name.startsWith("sessions/") ? name.substring(9) : name;
-
-    let status: JulesStatus = "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: string | undefined;
-    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: any) => parseJulesSession(session));
 }

package/src/tools/jules/send-message.ts

@@ -1,5 +1,5 @@
 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())]),
@@ -8,16 +8,7 @@ export const SendJulesMessageInputSchema = z.object({
 
 export async function sendJulesMessageHandler(input: z.infer<typeof SendJulesMessageInputSchema>) {
   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/", ""),

package/src/tools/jules/session.ts

@@ -0,0 +1,28 @@
+import { JulesSession, JulesStatus } from "../types.js";
+
+export function parseJulesSession(data: any): JulesSession {
+  const name = data.name || "";
+  const id = name.startsWith("sessions/") ? name.substring(9) : name;
+
+  let status: JulesStatus = "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: string | undefined;
+  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/src/tools/jules/shared.ts

@@ -1,63 +1,2 @@
-import { JulesSession, JulesStatus } from "../types.js";
-import { runCommand } from "../../lib/shell.js";
-
-export interface TDCliResponse {
-  status?: string;
-  message?: string;
-  [key: string]: any;
-}
-
-function tryParseJson(text: string): TDCliResponse | null {
-  try {
-    return JSON.parse(text) as TDCliResponse;
-  } catch {
-    return null;
-  }
-}
-
-export async function runTDCli(args: string[]): Promise<TDCliResponse> {
-  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: any): JulesSession {
-  const name = data.name || "";
-  const id = name.startsWith("sessions/") ? name.substring(9) : name;
-
-  let status: JulesStatus = "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: string | undefined;
-  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/src/tools/jules/trigger-feedback.ts

@@ -1,21 +1,10 @@
 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: z.infer<typeof TriggerJulesFeedbackInputSchema>) {
-  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/src/tools/repo.check_jules_status.test.ts

@@ -0,0 +1,55 @@
+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",
+            },
+          },
+        ],
+      }),
+    } as any);
+
+    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/src/tools/repo.check_jules_status.ts

@@ -0,0 +1,176 @@
+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 interface JulesStatusResult {
+  sessionId: string;
+  status: "COMPLETED" | "FAILED" | "IN_PROGRESS" | "TIMED_OUT" | "NOT_FOUND";
+  rawState?: string;
+  completed: boolean;
+  remediationBranch?: string;
+  pullRequestUrl?: string;
+  idempotencyHash?: string;
+  isDuplicate?: boolean;
+  message?: string;
+}
+
+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: string, failureLog: string): string {
+  const hash = crypto.createHash("sha256");
+  return hash.update(`${commitSha}:${failureLog.trim()}`).digest("hex");
+}
+
+export async function checkJulesStatusHandler(input: z.infer<typeof CheckJulesStatusInputSchema>): Promise<JulesStatusResult> {
+  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: string | undefined;
+  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: any = 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: JulesStatusResult["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: string | undefined;
+    let pullRequestUrl: string | undefined;
+
+    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/src/tools/repo.run_tests.ts

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