agent-messenger 2.4.0 → 2.6.0

package/skills/agent-slackbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slackbot
 description: Interact with Slack workspaces using bot tokens - send messages, read channels, manage reactions
-version: 2.4.0
+version: 2.6.0
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:
@@ -165,6 +165,15 @@ If a memorized ID returns an error (channel not found, user not found), remove i
 
 ## Commands
 
+### Whoami Command
+
+```bash
+# Show current authenticated bot
+agent-slackbot whoami
+agent-slackbot whoami --pretty
+agent-slackbot whoami --bot <bot-id>
+```
+
 ### Message Commands
 
 ```bash

package/skills/agent-teams/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-teams
 description: Interact with Microsoft Teams - send messages, read channels, manage reactions
-version: 2.4.0
+version: 2.6.0
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw:
@@ -161,6 +161,16 @@ agent-teams auth switch-account work
 agent-teams auth switch-account personal
 ```
 
+### Whoami Command
+
+```bash
+# Show current authenticated user
+agent-teams whoami
+agent-teams whoami --pretty
+```
+
+Output includes the authenticated user's identity information.
+
 ### Message Commands
 
 ```bash

package/skills/agent-telegram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-telegram
 description: Interact with Telegram through TDLib - authenticate, inspect chats, and send messages
-version: 2.4.0
+version: 2.6.0
 allowed-tools: Bash(agent-telegram:*)
 ---
 
@@ -103,6 +103,11 @@ agent-telegram auth logout    # Logout
 ## Common Commands
 
 ```bash
+# Show current authenticated user
+agent-telegram whoami
+agent-telegram whoami --pretty
+agent-telegram whoami --account <account-id>
+
 # Search chats by title or username
 agent-telegram chat search "project"
 

package/skills/agent-webex/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-webex
 description: Interact with Cisco Webex - send messages, read spaces, manage memberships
-version: 2.4.0
+version: 2.6.0
 allowed-tools: Bash(agent-webex:*)
 metadata:
   openclaw:
@@ -188,6 +188,16 @@ agent-webex auth status
 agent-webex auth logout
 ```
 
+### Whoami Command
+
+```bash
+# Show current authenticated user
+agent-webex whoami
+agent-webex whoami --pretty
+```
+
+Output includes the authenticated user's identity information.
+
 ### Space Commands
 
 ```bash

package/skills/agent-wechatbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-wechatbot
 description: Interact with WeChat Official Account using API credentials - send messages, manage templates, list followers
-version: 2.4.0
+version: 2.6.0
 allowed-tools: Bash(agent-wechatbot:*)
 metadata:
   openclaw:
@@ -174,6 +174,15 @@ agent-wechatbot auth remove <account-id>
 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

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.4.0
+version: 2.6.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"}
+```
 
-Ask the user for their WhatsApp phone number (international format, e.g. `+1234567890`). This is the ONLY thing the user needs to provide.
+Tell the user to scan the QR code with WhatsApp: Settings > Linked Devices > Link a Device > scan the QR code.
 
-**Step 3: Start login**
+**Alternative: Pairing code 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
@@ -389,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.4.0
+version: 2.6.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'

package/src/platforms/channeltalk/commands/whoami.test.ts

@@ -0,0 +1,64 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+
+const mockGetAccount = mock(() =>
+  Promise.resolve({
+    id: 'account-1',
+    name: 'Test User',
+    email: 'test@example.com',
+    emailVerified: true,
+    language: 'en',
+    country: 'US',
+    createdAt: 1700000000000,
+  }),
+)
+
+mock.module('./shared', () => ({
+  getClient: async () => ({
+    getAccount: mockGetAccount,
+  }),
+  getCurrentWorkspaceId: async () => 'ws-1',
+}))
+
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  beforeEach(() => {
+    mockGetAccount.mockReset()
+    mockGetAccount.mockImplementation(() =>
+      Promise.resolve({
+        id: 'account-1',
+        name: 'Test User',
+        email: 'test@example.com',
+        emailVerified: true,
+        language: 'en',
+        country: 'US',
+        createdAt: 1700000000000,
+      }),
+    )
+  })
+
+  test('whoamiAction returns account info', async () => {
+    const result = await whoamiAction({})
+
+    expect(mockGetAccount).toHaveBeenCalled()
+    expect(result.account).toEqual({
+      id: 'account-1',
+      name: 'Test User',
+      email: 'test@example.com',
+      email_verified: true,
+      language: 'en',
+      country: 'US',
+      created_at: 1700000000000,
+    })
+    expect(result.error).toBeUndefined()
+  })
+
+  test('whoamiAction returns error when getAccount fails', async () => {
+    mockGetAccount.mockImplementation(() => Promise.reject(new Error('Not authenticated')))
+
+    const result = await whoamiAction({})
+
+    expect(result.error).toBe('Not authenticated')
+    expect(result.account).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,62 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import { getClient } from './shared'
+
+interface ActionOptions {
+  workspace?: string
+  pretty?: boolean
+}
+
+interface WhoamiResult {
+  account?: {
+    id: string
+    name: string
+    email: string
+    email_verified: boolean
+    language: string
+    country: string
+    created_at: number
+  }
+  error?: string
+}
+
+export async function whoamiAction(options: ActionOptions = {}): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const account = await client.getAccount()
+    return {
+      account: {
+        id: account.id,
+        name: account.name,
+        email: account.email,
+        email_verified: account.emailVerified,
+        language: account.language,
+        country: account.country,
+        created_at: account.createdAt,
+      },
+    }
+  } catch (error) {
+    return { error: (error as Error).message }
+  }
+}
+
+function cliOutput(result: WhoamiResult, pretty?: boolean): void {
+  console.log(formatOutput(result, pretty))
+  if (result.error) {
+    process.exit(1)
+  }
+}
+
+export function createWhoamiCommand(): Command {
+  return new Command('whoami')
+    .description('Show current authenticated user')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--pretty', 'Pretty print JSON output')
+    .action(async (opts: ActionOptions) => {
+      cliOutput(await whoamiAction(opts), opts.pretty)
+    })
+}
+
+export const whoamiCommand = createWhoamiCommand()

package/src/platforms/channeltalkbot/cli.ts

@@ -11,6 +11,7 @@ import {
   managerCommand,
   messageCommand,
   snapshotCommand,
+  whoamiCommand,
 } from './commands/index'
 
 const program = new Command()
@@ -24,6 +25,7 @@ program
   .option('--bot <name>', 'Bot name to use for sending messages')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(messageCommand)
 program.addCommand(chatCommand)
 program.addCommand(groupCommand)

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

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

package/src/platforms/channeltalkbot/commands/whoami.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
+import { existsSync, rmSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const mockGetChannel = mock(() =>
+  Promise.resolve({
+    id: 'channel-id-123',
+    name: 'Test Channel',
+    homepageUrl: 'https://test.channel.io',
+    description: 'Test channel description',
+  }),
+)
+
+mock.module('../client', () => ({
+  ChannelBotClient: class MockChannelBotClient {
+    async login(_credentials?: { accessKey: string; accessSecret: string }) {
+      return this
+    }
+    getChannel = mockGetChannel
+  },
+}))
+
+import { ChannelBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `channeltalkbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_CHANNELBOT_ACCESS_KEY
+    delete process.env.E2E_CHANNELBOT_ACCESS_SECRET
+    mockGetChannel.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns channel info for current workspace', async () => {
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Test Workspace',
+      access_key: 'key123',
+      access_secret: 'secret123',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.id).toBe('channel-id-123')
+    expect(result.name).toBe('Test Channel')
+    expect(result.homepage_url).toBe('https://test.channel.io')
+    expect(result.description).toBe('Test channel description')
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns channel info for specific --workspace', async () => {
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Workspace 1',
+      access_key: 'key1',
+      access_secret: 'secret1',
+    })
+    await manager.setCredentials({
+      workspace_id: 'workspace2',
+      workspace_name: 'Workspace 2',
+      access_key: 'key2',
+      access_secret: 'secret2',
+    })
+
+    const result = await whoamiAction({ workspace: 'workspace1', _credManager: manager })
+
+    expect(result.id).toBe('channel-id-123')
+    expect(result.name).toBe('Test Channel')
+    expect(mockGetChannel).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockGetChannel.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new ChannelBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      workspace_id: 'workspace1',
+      workspace_name: 'Test Workspace',
+      access_key: 'key123',
+      access_secret: 'secret123',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})