How to add new client to vless via AlterInbound?

[Kolyall]

How to add new client via AlterInbound?

I want to add new client via grpcurl
Here is my new client:

{
            "email": "v2@vless-tcp-xtls",
            "id": "22216ed4-2c78-4ce1-99ae-bb01b7a1b444",
            "flow": "xtls-rprx-vision"
          }

I want to add him to inbound with tag "vless":

"inbounds": [
    {
      "tag": "vless",
      "port": 443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "email": "general@vless-tcp-xtls",
            "id": "111851ae-f74f-485d-ad1a-cebb99713333",
            "flow": "xtls-rprx-vision"
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "tcp",
        "security": "reality",
        "realitySettings": {
          "dest": "www.cloudflare.com:443",
          "serverNames": [
            "www.cloudflare.com"
          ],
          "privateKey": "***",
          "shortIds": [
            "",
            "0123456789abcdef"
          ]
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ],
        "routeOnly": true
      }
    }
  ]

I tried :
Create alter_inbound_request.json

echo '{
  "tag": "vless",
  "operation": {
    "type": "add",
    "value": {
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "email": "v2@vless-tcp-xtls",
            "id": "22216ed4-2c78-4ce1-99ae-bb01b7a1b444",
            "flow": "xtls-rprx-vision"
          }
        ]
      }
    }
  }
}' > alter_inbound_request.json

Exec :

grpcurl -plaintext -d @ 127.0.0.1:8080 xray.app.proxyman.command.HandlerService/AlterInbound < alter_inbound_request.json

But error is:

Error invoking method "xray.app.proxyman.command.HandlerService/AlterInbound": error getting request data: bad input: expecting string ; instead got {

[vrnobody]

I don't think that's possible currently.

$ grpcurl -plaintext 127.0.0.1:2025 describe xray.app.proxyman.command.HandlerService.AlterInbound

xray.app.proxyman.command.HandlerService.AlterInbound is a method:
rpc AlterInbound ( .xray.app.proxyman.command.AlterInboundRequest ) returns ( .xray.app.proxyman.command.AlterInboundResponse );

$ grpcurl -plaintext 127.0.0.1:2025 describe .xray.app.proxyman.command.AlterInboundRequest

xray.app.proxyman.command.AlterInboundRequest is a message:
message AlterInboundRequest {
  string tag = 1;
  .xray.common.serial.TypedMessage operation = 2;
}

The AlterInbound() function requires an operation parameter of type TypedMessage. TypedMessage is a custom type of xray-core. Basically, it is a serialized protobuf message. The relevant source code is here.

$ xray api inbounduser -s 127.0.0.1:2025 -tag=vless
{
    "users": [
        {
            "account": {
                "_TypedMessage_": "xray.proxy.vless.Account",
                "flow": "xtls-rprx-vision",
                "id": "111851ae-f74f-485d-ad1a-cebb99713333"
            },
            "email": "general@vless-tcp-xtls"
        }
    ]
}

The original type of operation is xray.proxy.vless.Account. But xray-core does not provide command line tools to convert JSON config into TypedMessage.

So I think that's impossible.

[GerasimovRM]

@Kolyall Were you able to solve this? I'm stuck on the same issue and trying to figure it out too

[SydMehdiMusavian]

Why don't you use proto files?

[vrnobody]

Why don't you use proto files?

To me, it's about decoupling. If xray-core provides a complete command-line API, then I don't need to compile anything or write any program.

I am not sure what you mean by "use proto files". Can you provide an example of the original question?

[SydMehdiMusavian]

My friend, I will explain to you now
Why are some projects using grpc and not completing their own api?
1 - High data transfer speed
2 - Reduced data volume compared to json, xml, etc.
3 - Easier communication between languages and platforms
4 - Can be supported by powerful programming languages and . . .

The xray project is using grpc to build its API
Why?
Because we are seeing .proto files in xray core
To get a clear idea of its structure, go here
there
grpc = Allows you to remotely call functions on the server without interfering with the execution of the desired service (xray)
Now how do the server and grpc understand each other?
With .proto files
The proto file is a text file that defines the structure (like json) of messages (the data structure that we are going to send and receive) and services (functions that are implemented on the server side and that we can call with grpc) for communication between the server and grpc. You can say it's a contract 👨‍💻.
I will give an example for better understanding.

syntax = "proto3";

package stats;

service StatsService {
  rpc GetUserCount (Empty) returns (UserCountResponse);
}

message Empty {}

message UserCountResponse {
  int32 count = 1;
}

This is a simple proto file where we have a service called StatsService and a method called GetUserCount that takes no input.
We assume that the server side has been programmed and the functions have been implemented. Now, in order for our client side to be able to call its functions, we need to compile the proto file so that we can access it with whatever language we are writing code in. In this example, the language in question is Python.
We compile the proto file with Python like this
(Please install the required tools before running)
python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. stats.proto
Now you have two files
1 - stats_pb2.py
2 - stats_pb2_grpc.py
each of which has specific content, for example in the first file you can find the messages of the proto file

# Import gRPC library to handle client-server communication
import grpc

# Import the generated classes from the .proto file
import stats_pb2            # Contains message classes (e.g., Empty, UserCountResponse)
import stats_pb2_grpc       # Contains the client stub (StatsServiceStub)

def run():
    # Create a gRPC channel to communicate with the server on localhost, port 50051
    channel = grpc.insecure_channel('localhost:50051')

    # Create a stub (client) to call the remote methods defined in StatsService
    stub = stats_pb2_grpc.StatsServiceStub(channel)

    # Call the GetUserCount RPC method with an Empty message as input
    response = stub.GetUserCount(stats_pb2.Empty())

    # Print the result (number of users) returned by the server
    print(f"userCount : {response.count}")

# Entry point: if this file is executed directly, run the client
if __name__ == '__main__':
    run()

You run this code and that's it
Of course, this is an example and requires server-side programming to be complete

Is everything clear?

[vrnobody]

Yes, it's clear now. Appreciated!