REMnux MCP Server

Instructions

Implementation Reference

• src/handlers/check-tools.ts:6-73 (handler)

  The main handler function that checks tool availability. It collects command names from the tool registry, verifies container connectivity, runs batch 'which' commands to check if tools are installed, and returns a summary with available/missing counts and individual tool statuses.

  export async function handleCheckTools(deps: HandlerDeps) {
    const startTime = Date.now();
    const { connector } = deps;
  
    // Collect unique command names from the tool registry
    const toolNames = new Set<string>();
    for (const def of toolRegistry.all()) {
      // Extract the command name (first word)
      const cmdName = def.command.split(/\s/)[0];
      toolNames.add(cmdName);
    }
  
    const tools: Array<{ tool: string; available: boolean; path?: string }> = [];
  
    // Verify container connectivity before checking individual tools
    try {
      await connector.executeShell("true", { timeout: 5000 });
    } catch (error) {
      return formatError("check_tools", toREMnuxError(error), startTime);
    }
  
    try {
      // Batch all tool checks in a single shell call for consistent PATH handling
      // This matches the approach used in suggest-tools.ts
      const uniqueCommands = [...toolNames];
      const availableCommands = new Map<string, string>();
  
      if (uniqueCommands.length > 0) {
        const checks = uniqueCommands.map((c) => `which ${c} 2>/dev/null`).join("; ");
        const result = await connector.executeShell(checks, { timeout: 30000 });
  
        // Parse "which" output - each line is a path if command was found
        for (const line of (result.stdout || "").split("\n")) {
          const path = line.trim();
          if (path && path.startsWith("/")) {
            // Extract command name from path (e.g., "/usr/bin/speakeasy" -> "speakeasy")
            const cmdName = path.split("/").pop();
            if (cmdName) {
              availableCommands.set(cmdName, path);
            }
          }
        }
      }
  
      // Build results for each tool
      const results = uniqueCommands.map((name) => {
        const path = availableCommands.get(name);
        if (path) {
          return { tool: name, available: true, path };
        }
        return { tool: name, available: false };
      });
      tools.push(...results);
    } catch {
      // Graceful degradation: mark all tools as unavailable if which calls fail
      for (const name of toolNames) {
        tools.push({ tool: name, available: false });
      }
    }
  
    const available = tools.filter(t => t.available).length;
    const missing = tools.filter(t => !t.available).length;
  
    return formatResponse("check_tools", {
      summary: { total: tools.length, available, missing },
      tools: tools.sort((a, b) => a.tool.localeCompare(b.tool)),
    }, startTime);
  }

• src/schemas/tools.ts:53-54 (schema)

  Schema definition for check_tools tool - empty object (no input parameters required) with inferred TypeScript type.

  export const checkToolsSchema = z.object({});
  export type CheckToolsArgs = z.infer<typeof checkToolsSchema>;

• src/index.ts:217-223 (registration)

  MCP tool registration in the main index file. Registers the check_tools tool with its name, description, schema shape, and handler function reference.

  // Tool: check_tools - Check tool availability
  server.tool(
    "check_tools",
    "Check which REMnux analysis tools are installed and available. Returns a summary of installed vs missing tools across all file type categories.",
    checkToolsSchema.shape,
    () => handleCheckTools(deps)
  );