Delve MCP

Instructions

Implementation Reference

• src/handlers/debug.ts:6-93 (handler)

  Handler function for debug tools. The 'replay' tool is routed here from server.ts, but lacks a specific switch case and would throw 'Unknown debug command'.

  export async function handleDebugCommands(name: string, args: any) {
    switch (name) {
      case "debug": {
        const pkg = (args?.package as string) || ".";
        const buildFlags = args?.buildFlags as string | undefined;
        const cmdArgs: string[] = [];
        
        if (buildFlags) {
          cmdArgs.push("--build-flags", buildFlags);
        }
  
        const session = await startDebugSession("debug", pkg, cmdArgs);
        return {
          content: [{
            type: "text",
            text: `Started debug session ${session.id} for package ${pkg}`
          }]
        };
      }
  
      case "attach": {
        const pid = Number(args?.pid);
        if (!pid) {
          throw new Error("Process ID is required");
        }
  
        const session = await startDebugSession("attach", pid.toString());
        return {
          content: [{
            type: "text",
            text: `Attached to process ${pid} with session ${session.id}`
          }]
        };
      }
  
      case "exec": {
        const binary = String(args?.binary);
        const cmdArgs = (args?.args as string[]) || [];
  
        const session = await startDebugSession("exec", binary, cmdArgs);
        return {
          content: [{
            type: "text",
            text: `Started debug session ${session.id} for binary ${binary}`
          }]
        };
      }
  
      case "test": {
        const pkg = (args?.package as string) || ".";
        const testFlags = (args?.testFlags as string[]) || [];
  
        const session = await startDebugSession("test", pkg, ["--", ...testFlags]);
        return {
          content: [{
            type: "text",
            text: `Started test debug session ${session.id} for package ${pkg}`
          }]
        };
      }
  
      case "core": {
        const { executable, corePath } = args;
        const session = await startDebugSession("core", executable, [corePath]);
        return {
          content: [{
            type: "text",
            text: `Started core dump analysis session ${session.id} for ${executable} with core ${corePath}`
          }]
        };
      }
  
      case "dap": {
        const { clientAddr } = args;
        const cmdArgs = clientAddr ? ["--client-addr", clientAddr] : [];
        
        const session = await startDebugSession("dap", "", cmdArgs);
        return {
          content: [{
            type: "text",
            text: `Started DAP server session ${session.id}${clientAddr ? ` connecting to ${clientAddr}` : ''}`
          }]
        };
      }
  
      default:
        throw new Error("Unknown debug command");
    }

• src/server.ts:301-318 (schema)

  Input schema for the 'replay' MCP tool, defining tracePath as required and onProcess as optional.

  {
    name: "replay",
    description: "Replay an rr trace",
    inputSchema: {
      type: "object",
      properties: {
        tracePath: {
          type: "string",
          description: "Path to the rr trace directory"
        },
        onProcess: {
          type: "number",
          description: "Optional PID to pass to rr"
        }
      },
      required: ["tracePath"]
    }
  },

• src/server.ts:405-408 (registration)

  Registration logic in CallToolRequest handler that routes calls to the 'replay' tool to the debug handler.

  // Debug commands
  if (["debug", "attach", "exec", "test", "core", "dap", "replay", "trace"].includes(name)) {
    return handleDebugCommands(name, args);
  }

• src/types.ts:18-18 (schema)

  Type definition for DebugSession.type includes 'replay'.

  type: string; // 'debug' | 'attach' | 'exec' | 'test' | 'core' | 'replay' | 'trace' | 'dap'