It injects the service anywhere in the code

You’re getting a different PHP object for each instantiation. So, unless you’re explicitly calling connect() with the new object, you’re not getting a connection at all, and send() won’t possibly work.

If you are explicitly calling connect() in the new object, then you’re getting a different connection. This may or may not be ok for your requirements, it depends what you’re trying to do.

So, if you need to both receive and send, your best bet would probably be to have one PHP client script act as a long-lived listener. It would just sit and wait to receive messages. Then when you need to send a message, you’d create a new client object, make a new connection, send the message, and then immediately disconnect. If the receiving side needs to know which client sent the message, that information would have to be embedded in the message, because it would come from a different connection.

Alternatively, you might be able to simply use an HTTP POST to send your messages.

Also Alternatively, you might be able to use SSE via Mercure.

If none of those is possible, then you’ve got a non-trivial problem to work around. Whatever data you need to build the message that you want to send will need to be somehow passed into the long-lived listener script, so that it can perform the send using the same connection that it already has open. This could be done with a lightweight message queue, so your infinite listener loop would listen for websocket messages and then check the queue for new pending sends, and send anything it finds there. This is rather roundabout though, and you should be able to make use of one of the simpler methods.

Ok it looks like using ZeroMQ has solved the problem. It saves the collated WS connection, which I can then use anywhere in the code as I wanted.

I created a pusher class with a method to distribute messages to all collated connections (onOpen):

class Pusher implements MessageComponentInterface
{
protected SplObjectStorage $clients;
...
public function onOpen($conn): void
{
    // Store the new connection to send messages to later
    $this->clients->attach($conn);

    dump("New connection!");
}
...
public function onPushingOutMessage($entry): void
{
    if (is_array($entry)) {
        $entry = json_encode($entry);
    }

    /** @var WebSocket $client */
    foreach ($this->clients as $client) {
        $client->send($entry);
    }

    dump("Pushed message $entry to all connected clients");
}
...

I have added a ZeroMQ class that connects to WS:

class ZeroMQTransport
{
    // Name of method that MessageComponent interfaces should implement to handle pushed updates to websocket clients
    public const string PUSH_HANDLER = 'onPushingOutMessage';
    public const string DSN = 'tcp://127.0.0.1:XXXX';// XXXX - TCP port

    private ZMQSocket $socket;

    public function __construct(private readonly PayloadBuilder $messageBuilder)
    {
        $context = new ZMQContext();
        $socket = $context->getSocket(ZMQ::SOCKET_PUSH, static::PUSH_HANDLER);
        $socket->connect(static::DSN);

        $this->socket = $socket;
    }

    public function send(MessageInterface $message): void
    {
        $payload = $this->messageBuilder->build($message);
        try {
            $this->socket->send($payload);
        } catch (ZMQSocketException $e) {
            echo $e->getMessage();
        }
    }

    public function __destruct()
    {
        $this->socket->disconnect(self::DSN);
    }

    private function __clone() {}

    public function __wakeup()
    {
        throw new Exception("Cannot unserialize singleton");
    }
}

An updated connect method in the WS client:

public function connect(): void
{
    // Listen for the web server to make a ZeroMQ push
    $context = new Context($this->loop);
    $pull = $context->getSocket(ZMQ::SOCKET_PULL);
    try {
        $pull->bind(ZeroMQTransport::DSN);
    } catch (ZMQSocketException $e) {
        $this->logger->error('Error in initializing the socket listener: ' . $e->getMessage() . "nStack: " . $e->getTraceAsString());
    }

    $pull->on('message', function ($payload) {
        $this->pusher->onPushingOutMessage($payload);
    });

    $connector = new Connector($this->loop);

    $connector($this->url)->then(function (WebSocket $conn) {
        $this->logger->info("Connected to WebSocket");
        $conn->on('message', function ($msg) {
            dump("Received message: $msg");
            $this->logger->info("Received message: $msg");
            $this->onMessage($msg);
        });

        $conn->on('error', function (Exception $exception) use ($conn) {
            $this->logger->error("Connection error");
            $this->pusher->onError($conn, $exception);
        });

        $conn->on('close', function ($code = null, $reason = null) use ($conn) {
            $this->logger->error("Connection closed ($code - $reason)");
            $this->pusher->onClose($conn);
        });

        $this->connection = $conn;
        $this->pusher->onOpen($conn);
    }, function (Exception $e) {
        $this->logger->critical("Could not connect: {$e->getMessage()}");
    });
}

Now I can send a WS message and catch the response in my listener:

$this->zeroMQTransport->send($message);