Railway MCP Server

Instructions

Implementation Reference

• src/tools/domain.tool.ts:89-91 (handler)

  Handler function for the domain_check tool that proxies to the domain service.

  async ({ domain }) => {
    return domainService.checkDomainAvailability(domain);
  }

• src/tools/domain.tool.ts:86-88 (schema)

  Input schema definition using Zod for the domain_check tool.

  {
    domain: z.string().describe("Domain name to check availability for")
  },

• src/tools/domain.tool.ts:72-92 (registration)

  Tool definition and registration via createTool, including name, description, schema, and handler.

    "domain_check",
    formatToolDescription({
      type: 'API',
      description: "Check if a domain is available for use",
      bestFor: [
        "Validating domain availability",
        "Pre-deployment checks",
        "Domain planning"
      ],
      relations: {
        nextSteps: ["domain_create"],
        related: ["domain_list"]
      }
    }),
    {
      domain: z.string().describe("Domain name to check availability for")
    },
    async ({ domain }) => {
      return domainService.checkDomainAvailability(domain);
    }
  ),

• src/tools/index.ts:16-37 (registration)

  Registers all tools, including domain_check from domainTools, to the MCP server.

  export function registerAllTools(server: McpServer) {
    // Collect all tools
    const allTools = [
      ...databaseTools,
      ...deploymentTools,
      ...domainTools,
      ...projectTools,
      ...serviceTools,
      ...tcpProxyTools,
      ...variableTools,
      ...configTools,
      ...volumeTools,
      ...templateTools,
    ] as Tool[];
  
    // Register each tool with the server
    allTools.forEach((tool) => {
      server.tool(
        ...tool
      );
    });
  } 

• src/services/domain.service.ts:130-148 (helper)

  Core helper function in DomainService that checks domain availability via the Railway client API and returns formatted MCP tool result.

  async checkDomainAvailability(domain: string): Promise<CallToolResult> {
    try {
      const result = await this.client.domains.serviceDomainAvailable(domain);
      
      if (result.available) {
        return createSuccessResponse({
          text: `Domain ${domain} is available`,
          data: result
        });
      } else {
        return createSuccessResponse({
          text: `Domain ${domain} is not available: ${result.message}`,
          data: result
        });
      }
    } catch (error) {
      return createErrorResponse(`Error checking domain availability: ${formatError(error)}`);
    }
  }