Best way to forward received json-rpc messages to an external webhook

[Mincka]

Hi,
I use the json-rpc implementation (with @haberda addon), and I would like to send events to Home Assistant to get the messages.
I tried many combinations of commands and the best thing I managed to get is this one liner.

wscat -c 10.0.0.9:8080/v1/receive/+XXXXXXXX --slash | jq --unbuffered -c -r '.envelope | select( .dataMessage != null)' | sed -u "s/^/'/;s/$/'/" | xargs -I{} curl -N -d '{}' -H "Content-Type: application/json" -X POST http://10.0.0.9:8123/api/webhook/-XXXXXXXXXXXXXXXXX

select( .dataMessage != null) is used to exclude "Start typing / Stop typing" messages.

It mainly works but because of xargs, it fails for specific cases like the presence of unmatching single quote. I didn't manage to find a proper way to fully escape the messages.

So, I can get the messages as events in HA, parse them and do what I want with them:
{{ trigger.json.sourceName }} says "{{ trigger.json.dataMessage.message }}"

Any idea to have a better / easiest way to do it?

Would it make sense to have such JSON forwarder implemented in this project as an advanced option? The minimal implementation would be to specify the webhook endpoint. The filtering of messages would be the responsibility of the receiving client.

[bbernhard]

Any idea to have a better / easiest way to do it?

I haven't tried it yet, but maybe it would be easier to do something like this in a scripting language like Python?

Would it make sense to have such JSON forwarder implemented in this project as an advanced option? The minimal implementation would be to specify the webhook endpoint.

I guess that is something that we could add 👍

[placq]

+1 for this feature! I found this discussion after trying to solve the exact same problem: creating a real-time, event-driven way to handle incoming messages in json-rpc mode.

A native, built-in JSON forwarder that calls a specified webhook endpoint, as suggested in this issue, would be a game-changing feature for many automation use cases (like in my case integrating with n8n).
I just wanted to say that I am also very interested to see this feature implemented in the future.

Thanks for your great work!

[willcharlton]

Exactly. Same here. I'm currently polling and it is a terrible solution. Webhooks would be a massive game changer.

[bbernhard]

will be part of the next release. If you want to do some early testing, let me know. I can provide you a test version

[bbernhard]

Here you go: bbernhard/signal-cli-rest-api:0.191-dev

The webhook URL can be specified in the docker-compose.yml file like this:

services:
  signal-cli-rest-api:
    environment:
      - RECEIVE_WEBHOOK_URL=<http_url>

• the RECEIVE_WEBHOOK_URL paramter currently only works in json-rpc mode
• for every message that is received (that also includes that start typing and stop typing events), a POST request is done on the specified URL

I wanted to keep the whole thing as simple as possible. That means, it is neither possible to control the data structure, nor the HTTP method (it is always a POST), nor the authentication method (if any is needed).

However, there is a way to accomplish all of that with Plugins. So, you could register a custom POST endpoint and then set this custom endpoint in the RECEIVE_WEBHOOK_URL (e.g: RECEIVE_WEBHOOK_URL=http://127.0.0.1:8080/v1/plugins/webhookreceiver). In the lua script implementation of the custom endpoint you can then modify the data as needed (i.e change the payload, add authentication, etc) and call the actual webhook endpoint.

I think that should make it quite flexible.

If someone implements a custom webhook endpoint for a specific platform and wants to share that with the community: PRs are highly appreciated and welcome! Since the feature is brand new, there is also no documentation for that yet. So, if someone wants to help with that - I'd also appreciate that a lot!

[Mincka]

Thanks a lot. It will take a bit of time on my side to do the setup with this version since I'm using the HA addon.
I'll need to resetup my phone with a separate container.

[willcharlton]

I'll start using/testing this today. My current implementation is a flask app that polls the /receive endpoint for messages and it's just not fast enough so thank you in advance for putting this together.

[bbernhard]

I'll start using/testing this today. My current implementation is a flask app that polls the /receive endpoint for messages and it's just not fast enough so thank you in advance for putting this together.

Just out of interest: Why can't you use the websocket connection directly with the json-rpc mode?

[willcharlton]

I'll start using/testing this today. My current implementation is a flask app that polls the /receive endpoint for messages and it's just not fast enough so thank you in advance for putting this together.

Just out of interest: Why can't you use the websocket connection directly with the json-rpc mode?

I tried to make a websocket connection once before but I couldn't figure it out (its probably due to me not reading your docs, admittedly). I came across this thread and then ditched what I was doing for your dev image (from above).

[willcharlton]

I wanted to reach out with gratitude for your excellent work on the this project, specifically this webhook functionality. Thanks to the guidance provided here, I was able to successfully implement a robust webhook-based messaging system for my project.

Implementation Details

Here's how I integrated it:

Docker Configuration

# docker-compose.yml
signal_cli:
  image: bbernhard/signal-cli-rest-api:0.191-dev
  environment:
    - MODE=json-rpc
    - WEBHOOK_URL=http://server:8000/api/signal/webhook
  ports:
    - "8080:8080"
  volumes:
    - signal_cli_config:/home/.local/share/signal-cli
  depends_on:
    - server

Python Webhook Handler Example

# signal_webhook.py
from fastapi import APIRouter, Request
import structlog

router = APIRouter()
logger = structlog.get_logger(__name__)

@router.post("/api/signal/webhook")
async def handle_signal_webhook(request: Request):
    """Handle incoming Signal webhook events"""
    try:
        payload = await request.json()
        
        # Handle different webhook event types
        if payload.get("method") == "receive":
            params = payload.get("params", {})
            if "envelope" in params:
                envelope = params["envelope"]
                
                # Extract message details
                if "dataMessage" in envelope:
                    message = envelope["dataMessage"].get("message", "")
                    source_number = envelope.get("sourceNumber", "")
                    timestamp = envelope.get("timestamp")
                    
                    # Process the message through AI system
                    await process_incoming_message(
                        phone_number=source_number,
                        message=message,
                        timestamp=timestamp
                    )
                    
                    return {"status": "processed"}
        
        # Handle other event types (typing indicators, receipts, etc.)
        return {"status": "ignored", "reason": "non_message_event"}
        
    except Exception as e:
        logger.error("Webhook processing error", error=str(e))
        return {"status": "error", "message": str(e)}

Please let me know if/when this gets merged into the mainline. Thank you so much it worked great!

[Mincka]

Thanks for testing this version. On my side, I won't be able to test this version outside of HA add-on, but it will also answer to my original request based on what I see once available there.

[quenthal]

Python Webhook Handler Example

# signal_webhook.py
from fastapi import APIRouter, Request
import structlog

router = APIRouter()
logger = structlog.get_logger(__name__)

@router.post("/api/signal/webhook")
async def handle_signal_webhook(request: Request):
    """Handle incoming Signal webhook events"""
    try:
        payload = await request.json()
        
        # Handle different webhook event types
        if payload.get("method") == "receive":
            params = payload.get("params", {})
            if "envelope" in params:
                envelope = params["envelope"]
                
                # Extract message details
                if "dataMessage" in envelope:
                    message = envelope["dataMessage"].get("message", "")
                    source_number = envelope.get("sourceNumber", "")
                    timestamp = envelope.get("timestamp")
                    
                    # Process the message through AI system
                    await process_incoming_message(
                        phone_number=source_number,
                        message=message,
                        timestamp=timestamp
                    )
                    
                    return {"status": "processed"}
        
        # Handle other event types (typing indicators, receipts, etc.)
        return {"status": "ignored", "reason": "non_message_event"}
        
    except Exception as e:
        logger.error("Webhook processing error", error=str(e))
        return {"status": "error", "message": str(e)}

Please let me know if/when this gets merged into the mainline. Thank you so much it worked great!

This got me thinking; small handler pushing these to mqtt. Instead of "polling" webhook sensor in Home Assistant, keeping everything neat on HA side using mqtt..