home / skills / openclaw / skills / jami-skill

This skill automates light VoIP calls and messaging via Jami, enabling peer-to-peer communication without infrastructure.

npx playbooks add skill openclaw/skills --skill jami-skill

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
3.6 KB
---
name: jami
description: Make automated calls via Jami (GNU Ring). Use for light VoIP calling, messaging, and peer-to-peer communication without infrastructure.
---

# Jami Calling Skill

Automate phone calls and messaging using Jami (free, decentralized, peer-to-peer VoIP).

## Quick Start

### Installation
```bash
# macOS - Download from jami.net or use Homebrew cask (if available)
brew install --cask jami

# Or download directly from https://jami.net/download/

# Linux
sudo apt install jami  # Debian/Ubuntu
```

### Setup
1. Install Jami app
2. Create/register a Jami account
3. Get your Jami ID (looks like a long hex string)
4. Configure in Clawdbot

### Make a Call
```bash
jami account list                    # List registered accounts
jami call <jami_id> <contact_id>    # Initiate call
jami hangup <call_id>               # End call
```

### Send Message
```bash
jami message send <contact_id> "Hello"
```

## CLI Usage

### Account Management
```bash
jami account list                    # List all accounts
jami account info <account_id>       # Show account details
jami account register <username>     # Register new account
jami account enable <account_id>     # Enable account
jami account disable <account_id>    # Disable account
```

### Calling
```bash
# Initiate call
jami call <account_id> <contact_id>

# List active calls
jami call list

# Get call status
jami call status <call_id>

# End call
jami hangup <call_id>

# Set volume
jami audio volume <volume_percent>
```

### Contacts & Messaging
```bash
# Add contact
jami contact add <account_id> <contact_id>

# List contacts
jami contact list <account_id>

# Send message
jami message send <contact_id> "Message text"

# Receive messages (daemon mode)
jami message listen
```

## Automated Calling Examples

### Simple outbound call
```bash
#!/bin/bash
ACCOUNT_ID="your_jami_account_id"
CONTACT_ID="contact_jami_id"

jami call $ACCOUNT_ID $CONTACT_ID
sleep 30  # Call duration
jami hangup
```

### Call with message
```bash
#!/bin/bash
ACCOUNT_ID="your_account"
CONTACT_ID="contact_id"

# Call
jami call $ACCOUNT_ID $CONTACT_ID

# Send message during/after call
jami message send $CONTACT_ID "Automated call from Clawdbot"

# Hangup after message
sleep 5
jami hangup
```

### Listen for incoming calls
```bash
jami daemon --listening  # Start daemon
jami call list          # Monitor calls
```

## Clawdbot Integration

### Configuration (in TOOLS.md)
```
## Jami Configuration
- Account ID: [your_jami_account_hex_id]
- Contacts: 
  - name: contact_jami_id (hex string)
  - name: contact_jami_id
```

### Usage in Clawdbot
```
"Make a call to [contact]"
"Send message to [contact]"
"Hang up current call"
"List my Jami contacts"
```

## How Jami Works

**Decentralized:** No central server. Calls go peer-to-peer.
**DHT:** Uses Distributed Hash Table to find contacts.
**Secure:** Encryption built-in.
**Free:** No costs, no accounts, no subscriptions.
**Open Source:** Full source available.

## Limitations

- Need both parties running Jami (or on a compatible VoIP network)
- No traditional phone numbers (uses Jami IDs instead)
- Requires internet (VoIP)
- Audio quality depends on connection
- No built-in automated IVR (you'd handle that in scripts)

## Advanced: Self-Hosted

For serious automated calling, you can self-host a SIP gateway:
```bash
# Asterisk bridge (connect Jami to traditional phone systems)
# FreeSWITCH (lightweight alternative)
```

But for light calling, basic Jami CLI is sufficient.

## Bundled Resources

- `scripts/jami_caller.sh` - Make calls from CLI
- `scripts/jami_listener.sh` - Listen for incoming calls
- `references/jami_api.md` - Full Jami CLI reference
- `assets/jami_ids.txt` - Local contact database

Overview

This skill automates peer-to-peer VoIP calls and messaging using Jami (GNU Ring). It provides CLI-driven call control, contact management, and simple scripting hooks for outbound, inbound, and hybrid call/message workflows. Use it to run light, decentralized calling without relying on centralized telephony providers. The skill is designed for lightweight automation, testing, and privacy-focused communication.

How this skill works

The skill wraps the Jami command-line client to list accounts, initiate and hang up calls, manage contacts, and send messages. Scripts can call jami call, jami hangup, jami message send, and jami daemon commands to automate flows and listen for incoming calls. It relies on Jami's peer-to-peer networking and DHT for contact discovery, so both endpoints must run Jami and have network connectivity.

When to use it

  • Automated outbound calls or notifications between peers without a central PBX.
  • Lightweight VoIP experiments, testing, or demos where privacy and decentralization matter.
  • Scripted messaging alongside calls (e.g., send a text during or after a call).
  • Listening for and reacting to incoming calls in an unattended agent or bot.
  • Connecting Jami to a self-hosted SIP gateway for bridging to traditional phone networks (advanced).

Best practices

  • Verify both parties have working Jami clients and known Jami IDs (hex strings).
  • Run the Jami daemon for reliable incoming call/message handling when unattended.
  • Keep call scripts idempotent and include explicit hangup timeouts to avoid stuck calls.
  • Monitor audio levels and network quality; VoIP quality depends on bandwidth and latency.
  • Use a local contact file or the bundled assets/jami_ids.txt for reproducible automation.

Example use cases

  • Cron-driven status alerts: place a short Jami call to a monitoring peer when an event fires.
  • Interactive assistant: accept incoming Jami calls and trigger scripted responses or messages.
  • Automated outreach: call a contact, play or deliver a message, then hang up after a timeout.
  • Development testing: simulate many peer-to-peer call flows using the provided caller/listener scripts.
  • Bridge scenario: connect Jami to an Asterisk gateway for routing to PSTN in hybrid deployments.

FAQ

Do I need a central server to use this skill?

No. Jami is decentralized and the skill operates peer-to-peer using Jami IDs and DHT.

Can I call traditional phone numbers?

Not directly. Jami uses its own IDs; bridging to phone numbers requires a SIP gateway or PBX bridge.

How do I handle incoming calls unattended?

Run jami daemon --listening and use the provided listener scripts to monitor call events and react.