agent-messenger 2.4.0 → 2.5.0

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.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'

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')
+  })
+})

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

@@ -0,0 +1,42 @@
+import { Command } from 'commander'
+
+import { formatOutput } from '@/shared/utils/output'
+
+import type { WorkspaceOption } from './shared'
+import { getClient } from './shared'
+
+interface WhoamiResult {
+  id?: string
+  name?: string
+  homepage_url?: string
+  description?: string
+  error?: string
+}
+
+export async function whoamiAction(options: WorkspaceOption): Promise<WhoamiResult> {
+  try {
+    const client = await getClient(options)
+    const channel = await client.getChannel()
+    return {
+      id: channel.id,
+      name: channel.name,
+      homepage_url: channel.homepageUrl,
+      description: channel.description,
+    }
+  } 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 const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated bot')
+  .option('--workspace <id>', 'Workspace ID to use')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(async (opts: WorkspaceOption) => {
+    cliOutput(await whoamiAction(opts), opts.pretty)
+  })

package/src/platforms/discord/cli.ts

@@ -20,6 +20,7 @@ import {
   snapshotCommand,
   threadCommand,
   userCommand,
+  whoamiCommand,
 } from './commands'
 import { ensureDiscordAuth } from './ensure-auth'
 
@@ -60,6 +61,7 @@ program.addCommand(reactionCommand)
 program.addCommand(snapshotCommand)
 program.addCommand(threadCommand)
 program.addCommand(userCommand)
+program.addCommand(whoamiCommand)
 
 program.parse(process.argv)
 

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

@@ -13,3 +13,4 @@ export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
 export { threadCommand } from './thread'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,91 @@
+import { afterEach, beforeEach, expect, spyOn, test } from 'bun:test'
+
+import { DiscordClient } from '@/platforms/discord/client'
+import { DiscordCredentialManager } from '@/platforms/discord/credential-manager'
+import { whoamiAction, whoamiCommand } from '@/platforms/discord/commands/whoami'
+
+let credManagerSpy: ReturnType<typeof spyOn>
+let clientTestAuthSpy: ReturnType<typeof spyOn>
+let consoleLogSpy: ReturnType<typeof spyOn>
+let processExitSpy: ReturnType<typeof spyOn>
+
+const mockConfig = {
+  token: 'test-discord-token',
+}
+
+const mockUser = {
+  id: 'user123',
+  username: 'testuser',
+  global_name: 'Test User',
+  avatar: 'avatar_hash',
+  bot: false,
+}
+
+beforeEach(() => {
+  credManagerSpy = spyOn(DiscordCredentialManager.prototype, 'load').mockResolvedValue(mockConfig)
+  clientTestAuthSpy = spyOn(DiscordClient.prototype, 'testAuth').mockResolvedValue(mockUser)
+  consoleLogSpy = spyOn(console, 'log').mockImplementation(() => {})
+  processExitSpy = spyOn(process, 'exit').mockImplementation((_code?: number) => undefined as never)
+})
+
+afterEach(() => {
+  credManagerSpy?.mockRestore()
+  clientTestAuthSpy?.mockRestore()
+  consoleLogSpy?.mockRestore()
+  processExitSpy?.mockRestore()
+})
+
+test('whoami command is defined with correct name and description', () => {
+  expect(whoamiCommand).toBeDefined()
+  expect(whoamiCommand.name()).toBe('whoami')
+  expect(whoamiCommand.description()).toBe('Show current authenticated user')
+})
+
+test('whoami command has --pretty option', () => {
+  const options = whoamiCommand.options
+  const hasPretty = options.some((opt: { long?: string }) => opt.long === '--pretty')
+  expect(hasPretty).toBe(true)
+})
+
+test('whoami outputs expected user fields', async () => {
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({
+      id: 'user123',
+      username: 'testuser',
+      global_name: 'Test User',
+      avatar: 'avatar_hash',
+      bot: false,
+    }),
+  )
+})
+
+test('whoami outputs pretty-printed JSON when pretty is true', async () => {
+  await whoamiAction({ pretty: true })
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify(
+      {
+        id: 'user123',
+        username: 'testuser',
+        global_name: 'Test User',
+        avatar: 'avatar_hash',
+        bot: false,
+      },
+      null,
+      2,
+    ),
+  )
+})
+
+test('whoami exits with error when not authenticated', async () => {
+  credManagerSpy.mockResolvedValue({ token: undefined })
+
+  await whoamiAction({})
+
+  expect(consoleLogSpy).toHaveBeenCalledWith(
+    JSON.stringify({ error: 'Not authenticated. Run "auth extract" first.' }),
+  )
+  expect(processExitSpy).toHaveBeenCalledWith(1)
+})

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

@@ -0,0 +1,36 @@
+import { Command } from 'commander'
+import { handleError } from '@/shared/utils/error-handler'
+import { formatOutput } from '@/shared/utils/output'
+import { DiscordClient } from '../client'
+import { DiscordCredentialManager } from '../credential-manager'
+
+export async function whoamiAction(options: { pretty?: boolean }): Promise<void> {
+  try {
+    const credManager = new DiscordCredentialManager()
+    const config = await credManager.load()
+
+    if (!config.token) {
+      console.log(formatOutput({ error: 'Not authenticated. Run "auth extract" first.' }, options.pretty))
+      return process.exit(1)
+    }
+
+    const client = await new DiscordClient().login({ token: config.token })
+    const user = await client.testAuth()
+
+    const output = {
+      id: user.id,
+      username: user.username,
+      global_name: user.global_name,
+      avatar: user.avatar,
+      bot: user.bot,
+    }
+    console.log(formatOutput(output, options.pretty))
+  } catch (error) {
+    handleError(error as Error)
+  }
+}
+
+export const whoamiCommand = new Command('whoami')
+  .description('Show current authenticated user')
+  .option('--pretty', 'Pretty print JSON output')
+  .action(whoamiAction)

package/src/platforms/discordbot/cli.ts

@@ -13,6 +13,7 @@ import {
   snapshotCommand,
   threadCommand,
   userCommand,
+  whoamiCommand,
 } from './commands/index'
 
 const program = new Command()
@@ -25,6 +26,7 @@ program
   .option('--server <id>', 'Server ID to use')
 
 program.addCommand(authCommand)
+program.addCommand(whoamiCommand)
 program.addCommand(serverCommand)
 program.addCommand(messageCommand)
 program.addCommand(channelCommand)

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

@@ -7,3 +7,4 @@ export { serverCommand } from './server'
 export { snapshotCommand } from './snapshot'
 export { threadCommand } from './thread'
 export { userCommand } from './user'
+export { whoamiCommand } from './whoami'

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

@@ -0,0 +1,96 @@
+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 mockTestAuth = mock(() =>
+  Promise.resolve({
+    id: 'bot-user-id',
+    username: 'testbot',
+    global_name: 'Test Bot',
+    avatar: 'avatar123',
+    bot: true,
+  }),
+)
+
+mock.module('../client', () => ({
+  DiscordBotClient: class MockDiscordBotClient {
+    async login(_credentials?: any) {
+      return this
+    }
+    testAuth = mockTestAuth
+  },
+}))
+
+import { DiscordBotCredentialManager } from '../credential-manager'
+import { whoamiAction } from './whoami'
+
+describe('whoami command', () => {
+  let tempDir: string
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `discordbot-whoami-test-${Date.now()}`)
+    await mkdir(tempDir, { recursive: true })
+    originalEnv = { ...process.env }
+    delete process.env.E2E_DISCORDBOT_TOKEN
+    mockTestAuth.mockClear()
+  })
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true })
+    }
+    process.env = originalEnv
+  })
+
+  test('returns auth info for current bot', async () => {
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'bot1',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.id).toBe('bot-user-id')
+    expect(result.username).toBe('testbot')
+    expect(result.global_name).toBe('Test Bot')
+    expect(result.avatar).toBe('avatar123')
+    expect(result.bot).toBe(true)
+    expect(result.error).toBeUndefined()
+  })
+
+  test('returns auth info for specific --bot', async () => {
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'deploy',
+      bot_name: 'Deploy Bot',
+    })
+
+    const result = await whoamiAction({ bot: 'deploy', _credManager: manager })
+
+    expect(result.id).toBe('bot-user-id')
+    expect(result.username).toBe('testbot')
+    expect(mockTestAuth).toHaveBeenCalledTimes(1)
+  })
+
+  test('returns error when client throws', async () => {
+    mockTestAuth.mockImplementationOnce(() => Promise.reject(new Error('API Error')))
+
+    const manager = new DiscordBotCredentialManager(tempDir)
+    await manager.setCredentials({
+      token: 'bot-token-123',
+      bot_id: 'bot1',
+      bot_name: 'Test Bot',
+    })
+
+    const result = await whoamiAction({ _credManager: manager })
+
+    expect(result.error).toBeDefined()
+    expect(result.error).toContain('API Error')
+  })
+})