agent-messenger 2.3.0 → 2.5.0

package/skills/agent-wechatbot/SKILL.md

@@ -0,0 +1,394 @@
+---
+name: agent-wechatbot
+description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
+version: 2.5.0
+allowed-tools: Bash(agent-wechatbot:*)
+metadata:
+  openclaw:
+    requires:
+      bins:
+        - agent-wechatbot
+    install:
+      - kind: node
+        package: agent-messenger
+        bins: [agent-wechatbot]
+---
+
+# Agent WeChatBot
+
+A TypeScript CLI tool that enables AI agents and humans to send messages through WeChat Official Account API. Designed for customer engagement, template notifications, and CI/CD integrations using App ID + App Secret authentication.
+
+## Key Concepts
+
+Before diving in, a few things about WeChat Official Account API:
+
+- **Send-only** — The Official Account API delivers inbound messages via webhooks only. This CLI cannot list or read received messages.
+- **Customer service messages** — You can send free-form text, image, and news (article) messages to users who have interacted with your account within the last 48 hours.
+- **Template messages** — Pre-approved message templates can be sent at any time. Templates must be created and approved in the WeChat Official Account admin panel.
+- **App ID** — Your Official Account's unique application identifier. Found in the WeChat Official Account admin panel under Development > Basic Configuration.
+- **App Secret** — Your application's secret key, paired with the App ID. Found in the same location.
+- **OpenID** — Each follower has a unique OpenID scoped to your Official Account. Use `user list` to retrieve follower OpenIDs.
+- **IP Whitelist** — Your server IP must be added to the Official Account's IP whitelist, or API calls will fail with error `40164`.
+- **Rate limits** — WeChat enforces API call frequency limits. Customer service messages are limited per account per day.
+
+## Quick Start
+
+```bash
+# Set your API credentials
+agent-wechatbot auth set your-app-id your-app-secret
+
+# Verify authentication
+agent-wechatbot auth status
+
+# Send a text message (recipient must have interacted within 48h)
+agent-wechatbot message send oXXXXXXXXXXXXXXX "Hello from the CLI!"
+
+# List available templates
+agent-wechatbot template list --pretty
+
+# List followers
+agent-wechatbot user list --pretty
+```
+
+## Authentication
+
+### API Credential Setup
+
+agent-wechatbot uses App ID + App Secret pairs from the WeChat Official Account admin panel:
+
+```bash
+# Set credentials (validates against WeChat API before saving)
+agent-wechatbot auth set your-app-id your-app-secret
+
+# Check auth status
+agent-wechatbot auth status
+
+# Clear stored credentials
+agent-wechatbot auth clear
+```
+
+### Multi-Account Management
+
+```bash
+# List stored accounts
+agent-wechatbot auth list
+
+# Switch active account
+agent-wechatbot auth use <account-id>
+
+# Remove a stored account
+agent-wechatbot auth remove <account-id>
+```
+
+## Memory
+
+The agent maintains a `~/.config/agent-messenger/MEMORY.md` file as persistent memory across sessions. This is agent-managed, the CLI does not read or write this file. Use the `Read` and `Write` tools to manage your memory file.
+
+### Reading Memory
+
+At the **start of every task**, read `~/.config/agent-messenger/MEMORY.md` using the `Read` tool to load any previously discovered account IDs, template names, follower OpenIDs, and preferences.
+
+- If the file doesn't exist yet, that's fine. Proceed without it and create it when you first have useful information to store.
+- If the file can't be read (permissions, missing directory), proceed without memory. Don't error out.
+
+### Writing Memory
+
+After discovering useful information, update `~/.config/agent-messenger/MEMORY.md` using the `Write` tool. Write triggers include:
+
+- After discovering account IDs and App IDs (from `auth list`, `auth status`, etc.)
+- After discovering template names and their parameters (from `template list`, etc.)
+- After discovering follower OpenIDs (from `user list`, `user get`, etc.)
+- After the user gives you an alias or preference ("call this the notifications account", "my main template is X")
+
+When writing, include the **complete file content**. The `Write` tool overwrites the entire file.
+
+### What to Store
+
+- Account IDs (App IDs) with names
+- Template IDs with their required parameters
+- Frequently used follower OpenIDs with context
+- User-given aliases ("notifications account", "marketing account")
+- Any user preference expressed during interaction
+
+### What NOT to Store
+
+Never store App Secrets or any credentials. Never store full message content (just context). Never store personal user data.
+
+### Handling Stale Data
+
+If a memorized template returns an error (template not found, account invalid), remove it from `MEMORY.md`. Don't blindly trust memorized data. Verify when something seems off. Prefer re-listing over using a memorized value that might be stale.
+
+### Format / Example
+
+```markdown
+# Agent Messenger Memory
+
+## WeChat Accounts
+
+- `wx1234567890` - Acme Notifications
+
+## Templates (Acme Notifications)
+
+- `TM00001` - Order confirmation, params: [order_id, customer_name]
+- `TM00002` - Shipping update, params: [tracking_number]
+
+## Frequent Recipients
+
+- `oABCD1234` - Test user (internal QA)
+- `oEFGH5678` - VIP customer
+
+## Aliases
+
+- "notifications" -> `wx1234567890` (Acme Notifications)
+
+## Notes
+
+- IP whitelist configured for 203.0.113.10
+- Customer service messages limited to 48h interaction window
+```
+
+> Memory lets you skip repeated `template list` calls. When you already know a template ID from a previous session, use it directly.
+
+## Commands
+
+### Auth Commands
+
+```bash
+# Set account credentials (validates against API)
+agent-wechatbot auth set <app-id> <app-secret>
+
+# Check auth status
+agent-wechatbot auth status
+agent-wechatbot auth status --account <account-id>
+
+# List stored accounts
+agent-wechatbot auth list
+
+# Switch active account
+agent-wechatbot auth use <account-id>
+
+# Remove a stored account
+agent-wechatbot auth remove <account-id>
+
+# Clear all credentials
+agent-wechatbot auth clear
+```
+
+### Whoami Command
+
+```bash
+# Show current authenticated bot
+agent-wechatbot whoami
+agent-wechatbot whoami --pretty
+agent-wechatbot whoami --account <account-id>
+```
+
+### Message Commands
+
+```bash
+# Send a text message (customer service, within 48h window)
+agent-wechatbot message send <open-id> <text>
+agent-wechatbot message send oABCD1234 "Your order has shipped!"
+
+# Send an image message (customer service, within 48h window)
+agent-wechatbot message send-image <open-id> <media-id>
+agent-wechatbot message send-image oABCD1234 MEDIA_ID_HERE
+
+# Send a news/article message (customer service, within 48h window)
+agent-wechatbot message send-news <open-id> --title "Title" --description "Desc" --url "https://..." --picurl "https://..."
+```
+
+### Template Commands
+
+```bash
+# List message templates
+agent-wechatbot template list
+
+# Send a template message
+agent-wechatbot template send <open-id> <template-id>
+agent-wechatbot template send oABCD1234 TM00001 --data '{"order_id":{"value":"ORD-9876"},"customer_name":{"value":"Alice"}}' --url "https://example.com/order/9876"
+
+# Delete a template
+agent-wechatbot template delete <template-id>
+```
+
+### User Commands
+
+```bash
+# List followers (paginated)
+agent-wechatbot user list
+agent-wechatbot user list --next-openid oLAST_OPENID
+
+# Get user info by OpenID
+agent-wechatbot user get <open-id>
+agent-wechatbot user get oABCD1234 --lang en
+```
+
+## Output Format
+
+### JSON (Default)
+
+All commands output JSON by default for AI consumption:
+
+```json
+{
+  "success": true,
+  "app_id": "wx1234567890",
+  "account_name": "wx1234567890"
+}
+```
+
+### Pretty (Human-Readable)
+
+Use `--pretty` flag for formatted output:
+
+```bash
+agent-wechatbot template list --pretty
+```
+
+## Global Options
+
+| Option           | Description                            |
+| ---------------- | -------------------------------------- |
+| `--pretty`       | Human-readable output instead of JSON  |
+| `--account <id>` | Use a specific account for this command |
+
+## Common Patterns
+
+### Send a customer service message within 48h window
+
+Customer service messages can be sent to users who have interacted with your account within the last 48 hours:
+
+```bash
+# Send a text reply
+agent-wechatbot message send oABCD1234 "Thanks for reaching out! We'll look into this right away."
+
+# Send a news article
+agent-wechatbot message send-news oABCD1234 \
+  --title "Your Order Update" \
+  --description "Your order #12345 has been shipped" \
+  --url "https://example.com/orders/12345" \
+  --picurl "https://example.com/images/shipping.jpg"
+```
+
+### Send a template notification (anytime)
+
+Template messages can be sent at any time, regardless of the 48h window:
+
+```bash
+# List templates to find the right one
+agent-wechatbot template list --pretty
+
+# Send a template message with data
+agent-wechatbot template send oABCD1234 TM00001 \
+  --data '{"order_id":{"value":"ORD-9876"},"status":{"value":"Shipped"}}' \
+  --url "https://example.com/orders/9876"
+```
+
+### List and inspect followers
+
+```bash
+# Get first page of followers
+agent-wechatbot user list --pretty
+
+# Get next page
+agent-wechatbot user list --next-openid oLAST_OPENID --pretty
+
+# Get details for a specific follower
+agent-wechatbot user get oABCD1234 --pretty
+```
+
+### CI/CD deployment notification
+
+```bash
+agent-wechatbot template send oABCD1234 deployment_alert \
+  --data '{"version":{"value":"v2.1.0"},"environment":{"value":"production"},"status":{"value":"success"}}'
+```
+
+## Error Handling
+
+All commands return consistent error format:
+
+```json
+{
+  "error": "No credentials. Run \"auth set <app-id> <app-secret>\" first."
+}
+```
+
+Common errors: `No credentials`, `Account not found`, `Invalid credentials`, `WeChat API error (errcode: 40001)`, `IP not in whitelist (errcode: 40164)`, `Rate limit exceeded (errcode: 45009)`.
+
+## Configuration
+
+Credentials stored in `~/.config/agent-messenger/wechatbot-credentials.json` (0600 permissions).
+
+Config format:
+
+```json
+{
+  "current": { "account_id": "wx1234567890" },
+  "accounts": {
+    "wx1234567890": {
+      "app_id": "wx1234567890",
+      "app_secret": "...",
+      "account_name": "wx1234567890"
+    }
+  }
+}
+```
+
+## Limitations
+
+- **Cannot list or read received messages** — WeChat Official Account API delivers inbound messages via webhooks only. This CLI is send-only.
+- **Customer service messages require 48h window** — Free-form text, image, and news messages only work within 48 hours of the user's last interaction.
+- **Template messages require pre-approval** — Templates must be created and approved in the WeChat admin panel before use.
+- **IP whitelist required** — Your server's IP must be added to the Official Account's whitelist, or you'll get error `40164`.
+- **Media IDs required for images** — Images must be uploaded to WeChat's media platform first. The CLI accepts media IDs, not URLs.
+- **No group chat support** — Official Account API communicates with individual followers only.
+- **No real-time events / WebSocket connection** — Inbound messages require a separate webhook server.
+- **No message editing or deletion**
+- **No voice or video calls**
+- **Access tokens expire** — Tokens are valid for 7200 seconds. The CLI handles automatic refresh.
+
+## Troubleshooting
+
+### `agent-wechatbot: command not found`
+
+**`agent-wechatbot` is NOT the npm package name.** The npm package is `agent-messenger`.
+
+If the package is installed globally, use `agent-wechatbot` directly:
+
+```bash
+agent-wechatbot message send oABCD1234 "Hello"
+```
+
+If the package is NOT installed, run it directly with `npx -y`:
+
+```bash
+npx -y agent-messenger wechatbot message send oABCD1234 "Hello"
+```
+
+> **Note**: If the user prefers a different package runner (e.g., `bunx`, `pnpx`, `pnpm dlx`), use that instead.
+
+**NEVER run `npx agent-wechatbot`, `bunx agent-wechatbot`, or `pnpm dlx agent-wechatbot`**. It will fail or install a wrong package since `agent-wechatbot` is not the npm package name.
+
+### How to get API credentials
+
+1. Log in to the [WeChat Official Account admin panel](https://mp.weixin.qq.com/)
+2. Navigate to **Development > Basic Configuration**
+3. Copy your **App ID** and **App Secret** (you may need to reset the secret if you don't have it saved)
+4. Add your server's IP to the **IP Whitelist**
+5. Run `agent-wechatbot auth set <app-id> <app-secret>`
+
+### IP whitelist errors (40164)
+
+If you get error `40164`, your server's IP is not in the Official Account's whitelist. Add it in the admin panel under **Development > Basic Configuration > IP Whitelist**.
+
+### Token errors (40001, 42001)
+
+These indicate an expired or invalid access token. The CLI handles automatic token refresh, but if you see persistent errors:
+- Verify your App Secret hasn't been reset in the admin panel
+- Re-run `agent-wechatbot auth set <app-id> <app-secret>` with the current credentials
+
+### Rate limiting (45009)
+
+WeChat enforces API call frequency limits. If you hit error `45009`, wait before retrying. For bulk operations, add delays between requests.

package/skills/agent-whatsapp/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsapp
 description: Interact with WhatsApp - send messages, read chats, manage conversations
-version: 2.3.0
+version: 2.5.0
 allowed-tools: Bash(agent-whatsapp:*)
 metadata:
   openclaw:
@@ -16,7 +16,7 @@ metadata:
 
 # Agent WhatsApp
 
-A Baileys-backed WhatsApp CLI for AI agents. Links as a companion device via pairing code, so your phone stays connected. Each command connects on demand and disconnects when done.
+A Baileys-backed WhatsApp CLI for AI agents. Links as a companion device via QR code or pairing code, so your phone stays connected. Each command connects on demand and disconnects when done.
 
 Use one of these entrypoints:
 - Global install: `agent-whatsapp ...`
@@ -27,6 +27,7 @@ Use one of these entrypoints:
 Before diving in, a few things about WhatsApp's architecture:
 
 - **JID** (Jabber ID) = WhatsApp's address format. Individual: `1234567890@s.whatsapp.net`. Group: `123456789-123345@g.us`. You can pass plain phone numbers and the CLI resolves them to JIDs automatically.
+- **QR code auth** = links the CLI as a companion device by scanning a QR code displayed in the terminal or browser. Open WhatsApp > Linked Devices > Link a Device and scan the code.
 - **Pairing code auth** = links the CLI as a companion device using a numeric code displayed in your terminal. Enter it in WhatsApp on your phone under Linked Devices.
 - **Connect-on-demand** = the CLI opens a WebSocket connection for each command and disconnects afterward. There's no persistent background process.
 - **Multi-account** = multiple WhatsApp accounts can be linked. Use `auth list` and `auth use` to switch between them.
@@ -34,7 +35,10 @@ Before diving in, a few things about WhatsApp's architecture:
 ## Quick Start
 
 ```bash
-# Link as companion device (enter the pairing code on your phone)
+# Link as companion device via QR code (scan with your phone)
+agent-whatsapp auth login --qr
+
+# Or link via pairing code (enter the code on your phone)
 agent-whatsapp auth login --phone +1234567890
 
 # List chats
@@ -46,7 +50,10 @@ agent-whatsapp message send +1234567890 "Hello from agent-whatsapp"
 
 ## Authentication Flow
 
-WhatsApp uses pairing code authentication. The CLI registers as a companion (linked) device, so your phone session is never affected.
+WhatsApp supports two authentication methods. Both register the CLI as a companion (linked) device, so your phone session is never affected.
+
+- **QR code** (`--qr`): A QR code is displayed in the terminal and opened in the browser. Scan it with WhatsApp on your phone. No phone number needed.
+- **Pairing code** (`--phone`): A numeric code is displayed. Enter it in WhatsApp on your phone under Linked Devices > Link with phone number.
 
 ### Agent Behavior (MANDATORY)
 
@@ -60,28 +67,36 @@ agent-whatsapp auth list
 
 If accounts exist, use `agent-whatsapp auth use <account-id>` and retry the original command.
 
-**Step 2: If no accounts, ask for phone number**
+**Step 2: If no accounts, start QR login (preferred)**
+
+```bash
+agent-whatsapp auth login --qr
+# -> QR code displayed in terminal + opened in browser
+# -> {"next_action":"scan_qr","qr_url":"...","message":"Scan with WhatsApp on your phone"}
+```
+
+Tell the user to scan the QR code with WhatsApp: Settings > Linked Devices > Link a Device > scan the QR code.
 
-Ask the user for their WhatsApp phone number (international format, e.g. `+1234567890`). This is the ONLY thing the user needs to provide.
+**Alternative: Pairing code login**
 
-**Step 3: Start login**
+If QR scanning is not possible (e.g. headless environment), ask for the phone number and use pairing code:
 
 ```bash
 agent-whatsapp auth login --phone +1234567890
-# -> {"next_action":"enter_pairing_code","pairing_code":"A1B2-C3D4","message":"Enter this code in WhatsApp on your phone: Linked Devices > Link a Device."}
+# -> {"pairing_code":"A1B2-C3D4","message":"Enter this code in WhatsApp > Linked Devices > Link with phone number"}
 ```
 
-Tell the user the pairing code and ask them to enter it on their phone: open WhatsApp > Settings > Linked Devices > Link a Device > enter the code.
+Tell the user the pairing code and ask them to enter it on their phone.
 
-**Step 4: Wait for confirmation**
+**Step 3: Wait for confirmation**
 
-The CLI polls until the user confirms on their phone. Once confirmed:
+The CLI waits until the user confirms on their phone. Once confirmed:
 
 ```bash
 # -> {"authenticated":true,...}
 ```
 
-**Step 5: Retry the original command**
+**Step 4: Retry the original command**
 
 After successful auth, immediately execute whatever the user originally asked for.
 
@@ -169,6 +184,9 @@ If a memorized JID returns an error, remove it from `MEMORY.md`. Don't blindly t
 ### Auth Commands
 
 ```bash
+# Link as companion device via QR code (no phone number needed)
+agent-whatsapp auth login --qr
+
 # Link as companion device via pairing code
 agent-whatsapp auth login --phone +1234567890
 
@@ -187,6 +205,17 @@ agent-whatsapp auth logout
 agent-whatsapp auth logout --account <id>
 ```
 
+### Whoami Command
+
+```bash
+# Show current authenticated user
+agent-whatsapp whoami
+agent-whatsapp whoami --pretty
+agent-whatsapp whoami --account <account-id>
+```
+
+Output includes the authenticated user's identity information.
+
 ### Chat Commands
 
 ```bash
@@ -319,13 +348,13 @@ All commands return consistent error format:
 
 ```json
 {
-  "error": "No WhatsApp account linked. Run: agent-whatsapp auth login --phone <number>"
+  "error": "No WhatsApp account linked. Run: agent-whatsapp auth login --qr"
 }
 ```
 
 Common errors:
 
-- `No WhatsApp account linked` - not authenticated. Run `auth login --phone <number>`.
+- `No WhatsApp account linked` - not authenticated. Run `auth login --qr` or `auth login --phone <number>`.
 - `Connection timeout` - WebSocket connection to WhatsApp failed. Retry the command.
 - `Invalid JID` - malformed phone number or JID. Use international format with `+` prefix.
 - `Not a group participant` - can't send to a group you're not a member of.
@@ -361,6 +390,14 @@ pnpm dlx --package agent-messenger agent-whatsapp chat list --pretty
 
 **NEVER run `npx agent-whatsapp`, `bunx agent-whatsapp`, or `pnpm dlx agent-whatsapp`** without `--package agent-messenger`. It will fail or install a wrong package since `agent-whatsapp` is not the npm package name.
 
+### QR code not scanning
+
+1. Make sure WhatsApp is open on your phone
+2. Go to Settings > Linked Devices > Link a Device
+3. Point your phone camera at the QR code in the terminal or browser
+4. If the QR code expires, run `auth login --qr` again for a fresh code
+5. If QR scanning fails, try pairing code: `auth login --phone <number>`
+
 ### Pairing code not working
 
 1. Make sure WhatsApp is open on your phone
@@ -369,6 +406,17 @@ pnpm dlx --package agent-messenger agent-whatsapp chat list --pretty
 4. Enter the pairing code shown in the terminal
 5. If the code expires, run `auth login --phone <number>` again for a fresh code
 
+### Empty chat list after linking a new device
+
+WhatsApp companion devices receive their chat list from the primary phone — there's no server API to fetch it directly. On a freshly linked device, `chat list` may return only group chats (or nothing at all) for individual/DM conversations.
+
+- **Keep your phone online** with WhatsApp open during and after linking. The phone pushes history to the new device; if it's off or WhatsApp is killed, nothing arrives.
+- **Wait a few minutes** and run `chat list` again. History trickles in over time and is saved locally, so subsequent runs will show more chats.
+- **Groups always work** immediately — they're fetched from the server, not from history sync.
+- **Sending a message** to a known phone number will make that chat appear even if it wasn't in the initial sync.
+
+This is a WhatsApp protocol limitation, not a bug.
+
 ### Connection drops
 
 WhatsApp may disconnect linked devices that are inactive for extended periods. If commands start failing:
@@ -378,5 +426,5 @@ WhatsApp may disconnect linked devices that are inactive for extended periods. I
 agent-whatsapp auth status
 
 # Re-link if needed
-agent-whatsapp auth login --phone +1234567890
+agent-whatsapp auth login --qr
 ```

package/skills/agent-whatsapp/references/authentication.md

@@ -2,7 +2,37 @@
 
 ## Overview
 
-agent-whatsapp uses pairing code authentication via [Baileys](https://github.com/WhiskeySockets/Baileys). The CLI registers as a companion (linked) device, so your phone session is never affected. Each command connects on demand and disconnects when done.
+agent-whatsapp uses [Baileys](https://github.com/WhiskeySockets/Baileys) to authenticate via QR code or pairing code. The CLI registers as a companion (linked) device, so your phone session is never affected. Each command connects on demand and disconnects when done.
+
+## QR Code Login
+
+### How It Works
+
+1. The CLI generates a QR code and displays it in the terminal (and opens it in the browser)
+2. You scan the QR code with WhatsApp on your phone: Settings > Linked Devices > Link a Device
+3. Session credentials are stored locally for future commands
+
+### Starting Login
+
+```bash
+agent-whatsapp auth login --qr
+```
+
+In interactive mode, a QR code is rendered in the terminal and opened in the browser. In non-interactive mode, JSON output is emitted:
+
+```json
+{"next_action":"scan_qr","qr_url":"...","qr_html_path":"/tmp/whatsapp-qr-....html","message":"Scan with WhatsApp on your phone"}
+```
+
+After scanning:
+
+```json
+{"authenticated":true,"account_id":"qr-default"}
+```
+
+### QR Code Refresh
+
+Baileys emits a new QR code every ~20 seconds. The terminal QR updates automatically. The browser tab is only opened once. If the QR expires after ~2 minutes, run `auth login --qr` again.
 
 ## Pairing Code Login
 
@@ -10,8 +40,8 @@ agent-whatsapp uses pairing code authentication via [Baileys](https://github.com
 
 1. You provide your phone number in international format (e.g. `+1234567890`)
 2. The CLI generates a numeric pairing code and displays it
-3. You enter the code on your phone: WhatsApp > Settings > Linked Devices > Link a Device
-4. The CLI polls until you confirm on your phone
+3. You enter the code on your phone: WhatsApp > Settings > Linked Devices > Link with phone number
+4. The CLI waits until you confirm on your phone
 5. Session credentials are stored locally for future commands
 
 ### Starting Login
@@ -34,7 +64,7 @@ After confirmation on your phone:
 
 ### Login Failures
 
-If the pairing code expires (typically after 60 seconds), run `auth login` again for a fresh code. If your phone isn't connected to the internet, the pairing will time out.
+If the pairing code expires (typically after 60 seconds), run `auth login --phone <number>` again for a fresh code. If your phone isn't connected to the internet, the pairing will time out.
 
 ## Multi-Account Management
 
@@ -121,7 +151,7 @@ Output when not authenticated:
 
 ```json
 {
-  "error": "No WhatsApp account linked. Run: agent-whatsapp auth login --phone <number>"
+  "error": "No WhatsApp account configured. Run \"auth login --qr\" or \"auth login --phone <phone-number>\" first."
 }
 ```
 
@@ -163,7 +193,7 @@ If commands start failing with auth errors:
 agent-whatsapp auth status
 
 # Re-link if needed
-agent-whatsapp auth login --phone +1234567890
+agent-whatsapp auth login --qr
 
 # Verify it worked
 agent-whatsapp auth status

package/skills/agent-whatsappbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-whatsappbot
 description: Interact with WhatsApp using Cloud API credentials - send messages, manage templates
-version: 2.3.0
+version: 2.5.0
 allowed-tools: Bash(agent-whatsappbot:*)
 metadata:
   openclaw:
@@ -169,6 +169,15 @@ agent-whatsappbot auth remove <account-id>
 agent-whatsappbot auth clear
 ```
 
+### Whoami Command
+
+```bash
+# Show current authenticated bot
+agent-whatsappbot whoami
+agent-whatsappbot whoami --pretty
+agent-whatsappbot whoami --account <account-id>
+```
+
 ### Message Commands
 
 ```bash

package/src/platforms/channeltalk/cli.ts

@@ -12,6 +12,7 @@ import {
   createManagerCommand,
   createMessageCommand,
   createSnapshotCommand,
+  createWhoamiCommand,
 } from './commands'
 import { ensureChannelAuth } from './ensure-auth'
 
@@ -45,6 +46,7 @@ program.addCommand(createGroupCommand())
 program.addCommand(createManagerCommand())
 program.addCommand(createBotCommand())
 program.addCommand(createSnapshotCommand())
+program.addCommand(createWhoamiCommand())
 
 program.parseAsync(process.argv)
 

package/src/platforms/channeltalk/commands/index.ts

@@ -5,3 +5,4 @@ export { createGroupCommand, groupCommand } from './group'
 export { createManagerCommand, managerCommand } from './manager'
 export { createMessageCommand, messageCommand } from './message'
 export { createSnapshotCommand, snapshotCommand } from './snapshot'
+export { createWhoamiCommand, whoamiCommand } from './whoami'