agent-messenger 2.12.0 → 2.12.2

package/docs/content/docs/sdk/telegrambot.mdx

@@ -0,0 +1,216 @@
+---
+title: Telegram Bot
+description: TypeScript SDK reference for Telegram Bot — client, real-time long-polling listener, credential management, and types.
+---
+
+## Installation
+
+```bash
+npm install agent-messenger
+```
+
+```typescript
+import {
+  TelegramBotClient,
+  TelegramBotCredentialManager,
+  TelegramBotError,
+  TelegramBotListener,
+} from 'agent-messenger/telegrambot'
+```
+
+## TelegramBotClient
+
+The main client wrapping Telegram's HTTP [Bot API](https://core.telegram.org/bots/api). Includes automatic 429 (rate-limit) handling using `retry_after`, network retries with exponential backoff, and structured errors via `TelegramBotError`.
+
+```typescript
+const client = await new TelegramBotClient().login({ token: 'YOUR_BOT_TOKEN' })
+```
+
+Or use stored credentials — read from `~/.config/agent-messenger/telegrambot-credentials.json` (managed by `agent-telegrambot auth set`):
+
+```typescript
+const client = await new TelegramBotClient().login()
+```
+
+### Authentication
+
+```typescript
+const me = await client.getMe()
+// → TelegramBotUser { id, is_bot, first_name, username?, ... }
+```
+
+### Messages
+
+```typescript
+// Send text message
+const msg = await client.sendMessage(chatId, 'Hello', {
+  parse_mode: 'HTML',
+  reply_to_message_id: 42,
+  disable_notification: true,
+})
+
+// Edit a chat message
+await client.editMessageText({ chat_id: chatId, message_id: msg.message_id }, 'Edited text')
+
+// Edit an inline-mode message (returned by inline query results)
+await client.editMessageText({ inline_message_id: 'abc123' }, 'Edited text')
+
+// Delete
+await client.deleteMessage(chatId, msg.message_id)
+
+// Forward
+await client.forwardMessage(toChatId, fromChatId, messageId)
+
+// Upload document (multipart)
+await client.sendDocument(chatId, '/path/to/file.pdf', { caption: 'Report' })
+```
+
+### Chats
+
+```typescript
+// Full chat info (title, description, member count, etc.)
+const chat = await client.getChat(chatId)
+
+// Single member's status
+const member = await client.getChatMember(chatId, userId)
+
+// Member count for groups, supergroups, channels
+const count = await client.getChatMemberCount(chatId)
+```
+
+### Reactions
+
+```typescript
+// Set a reaction (Telegram replaces previous bot reaction)
+await client.setMessageReaction(chatId, messageId, [{ type: 'emoji', emoji: '👍' }])
+
+// Clear all bot reactions
+await client.setMessageReaction(chatId, messageId, [])
+```
+
+### Updates (Manual Polling)
+
+If you don't need the listener abstraction, you can call `getUpdates` directly:
+
+```typescript
+const updates = await client.getUpdates({
+  offset: 0,
+  limit: 100,
+  timeout: 30,
+  allowed_updates: ['message', 'callback_query'],
+})
+```
+
+## TelegramBotListener
+
+A long-polling listener for real-time updates. Telegram Bot API does not support WebSockets — long-polling is the canonical streaming mode used by frameworks like grammy and telegraf. No public HTTPS endpoint required.
+
+```typescript
+import { TelegramBotClient, TelegramBotListener } from 'agent-messenger/telegrambot'
+
+const client = await new TelegramBotClient().login({ token: 'YOUR_BOT_TOKEN' })
+const listener = new TelegramBotListener(client, {
+  timeoutSeconds: 30,
+  limit: 100,
+  allowedUpdates: ['message', 'callback_query'],
+  dropPendingUpdates: false,
+})
+
+listener.on('connected', ({ user }) => {
+  console.log(`Connected as @${user.username}`)
+})
+
+listener.on('message', (message) => {
+  console.log(`${message.chat.id}: ${message.text}`)
+})
+
+listener.on('callback_query', (query) => {
+  console.log(`Button clicked: ${query.data}`)
+})
+
+listener.on('disconnected', () => {
+  console.log('Disconnected, will retry…')
+})
+
+listener.on('error', (error) => {
+  console.error('Fatal error:', error)
+})
+
+await listener.start()
+```
+
+### Lifecycle
+
+- `start()` — Removes any active webhook (mutex with polling), calls `getMe` to confirm auth, then enters the polling loop.
+- `stop()` — Aborts the in-flight `getUpdates` request and stops the loop. Safe to call multiple times.
+
+### Events
+
+| Event                 | Payload                       | Notes                                                                   |
+| --------------------- | ----------------------------- | ----------------------------------------------------------------------- |
+| `connected`           | `{ user: TelegramBotUser }`   | Once after `start()` succeeds                                           |
+| `disconnected`        | `[]`                          | After a recoverable error; listener will retry with exponential backoff |
+| `error`               | `[Error]`                     | Fatal error (Unauthorized 401, Conflict 409). Listener stops.           |
+| `message`             | `[TelegramMessage]`           | New text/media messages in private chats and groups                     |
+| `edited_message`      | `[TelegramMessage]`           | Message edited                                                          |
+| `channel_post`        | `[TelegramMessage]`           | New post in a channel where the bot is admin                            |
+| `edited_channel_post` | `[TelegramMessage]`           | Channel post edited                                                     |
+| `callback_query`      | `[TelegramCallbackQuery]`     | Inline keyboard button pressed                                          |
+| `inline_query`        | `[TelegramInlineQuery]`       | Inline-mode query (`@yourbot ...`)                                      |
+| `my_chat_member`      | `[TelegramChatMemberUpdated]` | Bot's own membership status changed                                     |
+| `chat_member`         | `[TelegramChatMemberUpdated]` | Other member's status changed (requires opt-in)                         |
+| `telegram_update`     | `[TelegramUpdate]`            | Catch-all — every raw update                                            |
+
+### Reconnection
+
+On recoverable errors (network failure, 5xx, transient API errors), the listener emits `disconnected` and retries with exponential backoff capped at 30 seconds. On `Unauthorized` (401) or `Conflict` (409 — another polling instance is running), it emits `error` and stops; restart your process after fixing the cause.
+
+## TelegramBotCredentialManager
+
+```typescript
+const manager = new TelegramBotCredentialManager()
+
+// Store credentials
+await manager.setCredentials({ token, bot_id, bot_name })
+
+// Retrieve current
+const creds = await manager.getCredentials()
+
+// Multi-bot support
+const all = await manager.listAll()
+await manager.setCurrent('deploy')
+await manager.removeBot('alert')
+await manager.clearCredentials()
+```
+
+Credentials are stored under `~/.config/agent-messenger/telegrambot-credentials.json` with `0600` file permissions. Override the directory with the `AGENT_MESSENGER_CONFIG_DIR` environment variable, or pass `new TelegramBotCredentialManager(customDir)`.
+
+## Error Handling
+
+All client methods throw `TelegramBotError` with a `code` property:
+
+| Code                | Meaning                                         |
+| ------------------- | ----------------------------------------------- |
+| `missing_token`     | Empty token passed to `login`                   |
+| `not_authenticated` | Used a method before `.login()`                 |
+| `no_credentials`    | No stored credentials and none provided         |
+| `unauthorized`      | 401 — invalid token                             |
+| `conflict`          | 409 — another polling instance running          |
+| `forbidden`         | 403 — bot kicked or user hasn't started the bot |
+| `bad_request`       | 400 — usually invalid chat ID or message ID     |
+| `not_found`         | 404                                             |
+| `rate_limited`      | 429 (after retries exhausted)                   |
+| `network_error`     | Fetch failed after retries                      |
+| `invalid_response`  | Telegram returned non-JSON                      |
+
+```typescript
+import { TelegramBotError } from 'agent-messenger/telegrambot'
+
+try {
+  await client.sendMessage(chatId, 'Hello')
+} catch (error) {
+  if (error instanceof TelegramBotError && error.code === 'forbidden') {
+    console.log('User has not started the bot yet')
+  }
+}
+```

package/e2e/config.ts

@@ -242,6 +242,30 @@ export async function validateTelegramEnvironment(): Promise<boolean> {
   return true
 }
 
+// Telegram Bot Test Environment
+export const TELEGRAMBOT_TEST_CHAT_ID = process.env.E2E_TELEGRAMBOT_CHAT_ID || ''
+
+export async function validateTelegramBotEnvironment(): Promise<boolean> {
+  if (!TELEGRAMBOT_TEST_CHAT_ID) {
+    console.warn('Skipping Telegram Bot E2E: set E2E_TELEGRAMBOT_CHAT_ID to run against a dedicated test chat.')
+    return false
+  }
+
+  const { runCLI, parseJSON } = await import('./helpers')
+
+  const result = await runCLI('telegrambot', ['auth', 'status'])
+  if (result.exitCode !== 0) {
+    throw new Error('Telegram Bot authentication failed. Run: agent-telegrambot auth set <token>')
+  }
+
+  const data = parseJSON<{ valid: boolean }>(result.stdout)
+  if (!data?.valid) {
+    throw new Error('Telegram Bot credentials invalid or expired. Run: agent-telegrambot auth set <token>')
+  }
+
+  return true
+}
+
 // WhatsApp Test Environment
 export const WHATSAPP_TEST_CHAT_ID = process.env.E2E_WHATSAPP_CHAT_ID || ''
 

package/e2e/helpers.ts

@@ -15,6 +15,7 @@ export async function runCLI(platform: string, args: string[]): Promise<CLIResul
     channeltalk: 'agent-channeltalk',
     webex: 'agent-webex',
     telegram: 'agent-telegram',
+    telegrambot: 'agent-telegrambot',
     whatsapp: 'agent-whatsapp',
     whatsappbot: 'agent-whatsappbot',
     line: 'agent-line',

package/e2e/telegrambot.e2e.test.ts

@@ -0,0 +1,185 @@
+import { afterEach, beforeAll, describe, expect, it } from 'bun:test'
+
+import { TELEGRAMBOT_TEST_CHAT_ID, validateTelegramBotEnvironment } from './config'
+import { generateTestId, parseJSON, runCLI, waitForRateLimit } from './helpers'
+
+let telegramBotAvailable = false
+let trackedMessageIds: number[] = []
+
+async function deleteTrackedMessages(): Promise<void> {
+  for (const messageId of trackedMessageIds) {
+    try {
+      await runCLI('telegrambot', ['message', 'delete', TELEGRAMBOT_TEST_CHAT_ID, String(messageId), '--force'])
+      await waitForRateLimit(300)
+    } catch {
+      // best-effort cleanup
+    }
+  }
+  trackedMessageIds = []
+}
+
+describe('Telegram Bot E2E Tests', () => {
+  beforeAll(async () => {
+    telegramBotAvailable = await validateTelegramBotEnvironment()
+  })
+
+  afterEach(async () => {
+    if (trackedMessageIds.length > 0) {
+      await deleteTrackedMessages()
+    }
+    await waitForRateLimit()
+  })
+
+  describe('auth', () => {
+    it('auth status returns valid bot info', async () => {
+      if (!telegramBotAvailable) return
+
+      const result = await runCLI('telegrambot', ['auth', 'status'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<{ valid: boolean; bot_id: string }>(result.stdout)
+      expect(data?.valid).toBe(true)
+      expect(data?.bot_id).toBeTruthy()
+    })
+
+    it('auth list returns bots array', async () => {
+      if (!telegramBotAvailable) return
+
+      const result = await runCLI('telegrambot', ['auth', 'list'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<{ bots: Array<{ bot_id: string }> }>(result.stdout)
+      expect(Array.isArray(data?.bots)).toBe(true)
+    })
+  })
+
+  describe('whoami', () => {
+    it('whoami returns bot identity', async () => {
+      if (!telegramBotAvailable) return
+
+      const result = await runCLI('telegrambot', ['whoami'])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<{ id: number; is_bot: boolean }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      expect(data?.is_bot).toBe(true)
+    })
+  })
+
+  describe('chat', () => {
+    it('chat info returns chat details', async () => {
+      if (!telegramBotAvailable) return
+
+      const result = await runCLI('telegrambot', ['chat', 'info', TELEGRAMBOT_TEST_CHAT_ID])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<{ id: number; type: string }>(result.stdout)
+      expect(data?.id).toBeTruthy()
+      expect(data?.type).toBeTruthy()
+    })
+  })
+
+  describe('message', () => {
+    it('message send delivers message and returns id', async () => {
+      if (!telegramBotAvailable) return
+
+      const testId = generateTestId()
+      const result = await runCLI('telegrambot', ['message', 'send', TELEGRAMBOT_TEST_CHAT_ID, `Bot e2e ${testId}`])
+      expect(result.exitCode).toBe(0)
+
+      const data = parseJSON<{ message: { message_id: number; chat_id: number; text: string } }>(result.stdout)
+      expect(data?.message?.message_id).toBeTruthy()
+      expect(data?.message?.text).toContain(testId)
+      if (data?.message?.message_id) trackedMessageIds.push(data.message.message_id)
+    })
+
+    it('message update edits previously sent message', async () => {
+      if (!telegramBotAvailable) return
+
+      const testId = generateTestId()
+      const sendResult = await runCLI('telegrambot', [
+        'message',
+        'send',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        `Original ${testId}`,
+      ])
+      const sent = parseJSON<{ message: { message_id: number } }>(sendResult.stdout)
+      expect(sent?.message?.message_id).toBeTruthy()
+      if (sent?.message?.message_id) trackedMessageIds.push(sent.message.message_id)
+
+      await waitForRateLimit()
+
+      const updateResult = await runCLI('telegrambot', [
+        'message',
+        'update',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        String(sent!.message.message_id),
+        `Edited ${testId}`,
+      ])
+      expect(updateResult.exitCode).toBe(0)
+    })
+
+    it('message delete removes message', async () => {
+      if (!telegramBotAvailable) return
+
+      const testId = generateTestId()
+      const sendResult = await runCLI('telegrambot', [
+        'message',
+        'send',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        `Delete me ${testId}`,
+      ])
+      const sent = parseJSON<{ message: { message_id: number } }>(sendResult.stdout)
+      expect(sent?.message?.message_id).toBeTruthy()
+
+      await waitForRateLimit()
+
+      const deleteResult = await runCLI('telegrambot', [
+        'message',
+        'delete',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        String(sent!.message.message_id),
+        '--force',
+      ])
+      expect(deleteResult.exitCode).toBe(0)
+    })
+  })
+
+  describe('reaction', () => {
+    it('reaction set and clear lifecycle', async () => {
+      if (!telegramBotAvailable) return
+
+      const testId = generateTestId()
+      const sendResult = await runCLI('telegrambot', [
+        'message',
+        'send',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        `Reaction test ${testId}`,
+      ])
+      const sent = parseJSON<{ message: { message_id: number } }>(sendResult.stdout)
+      expect(sent?.message?.message_id).toBeTruthy()
+      if (sent?.message?.message_id) trackedMessageIds.push(sent.message.message_id)
+
+      await waitForRateLimit(2000)
+
+      const setResult = await runCLI('telegrambot', [
+        'reaction',
+        'set',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        String(sent!.message.message_id),
+        '👍',
+      ])
+      expect(setResult.exitCode).toBe(0)
+
+      await waitForRateLimit(2000)
+
+      const clearResult = await runCLI('telegrambot', [
+        'reaction',
+        'clear',
+        TELEGRAMBOT_TEST_CHAT_ID,
+        String(sent!.message.message_id),
+      ])
+      expect(clearResult.exitCode).toBe(0)
+    }, 15000)
+  })
+})

package/examples/telegrambot-listen.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env bun
+// Run `agent-telegrambot auth set <token>` first so login() can pick up stored creds.
+import { TelegramBotClient } from '../src/platforms/telegrambot/client'
+import { TelegramBotListener } from '../src/platforms/telegrambot/listener'
+
+async function main() {
+  const client = await new TelegramBotClient().login()
+
+  const listener = new TelegramBotListener(client, {
+    allowedUpdates: ['message', 'edited_message', 'callback_query', 'my_chat_member'],
+  })
+
+  listener.on('connected', ({ user }) => {
+    console.log(`Connected as @${user.username ?? user.first_name} (id: ${user.id})`)
+    console.log('Listening for events. Press Ctrl+C to stop.\n')
+  })
+
+  listener.on('disconnected', () => {
+    console.log('[disconnected] retrying...')
+  })
+
+  listener.on('message', (message) => {
+    if (message.from?.is_bot) return
+    const time = new Date(message.date * 1000).toLocaleTimeString()
+    const sender = message.from?.username ?? message.from?.first_name ?? 'unknown'
+    console.log(`[${time}] message in ${message.chat.id} <${sender}>: ${message.text ?? '(non-text)'}`)
+  })
+
+  listener.on('edited_message', (message) => {
+    console.log(`[edit] message ${message.message_id} in ${message.chat.id}`)
+  })
+
+  listener.on('callback_query', (query) => {
+    console.log(`[callback] data=${query.data ?? '(none)'} from ${query.from.username ?? query.from.id}`)
+  })
+
+  listener.on('my_chat_member', (event) => {
+    console.log(`[my_chat_member] ${event.chat.id}: ${event.old_chat_member.status} -> ${event.new_chat_member.status}`)
+  })
+
+  listener.on('error', (err) => {
+    console.error(`[error] ${err.message}`)
+  })
+
+  process.on('SIGINT', () => {
+    console.log('\nStopping...')
+    listener.stop()
+    process.exit(130)
+  })
+
+  await listener.start()
+}
+
+main()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-messenger",
-  "version": "2.12.0",
-  "description": "Multi-platform messaging CLI for AI agents (Slack, Discord, Teams, Webex, Telegram, WhatsApp, LINE, Instagram, KakaoTalk, Channel Talk)",
+  "version": "2.12.2",
+  "description": "Multi-platform messaging CLI for AI agents (Slack, Discord, Teams, Webex, Telegram, Telegram Bot, WhatsApp, LINE, Instagram, KakaoTalk, Channel Talk)",
   "repository": {
     "type": "git",
     "url": "https://github.com/agent-messenger/agent-messenger"
@@ -19,6 +19,7 @@
     "agent-slackbot": "dist/src/platforms/slackbot/cli.js",
     "agent-teams": "dist/src/platforms/teams/cli.js",
     "agent-telegram": "dist/src/platforms/telegram/cli.js",
+    "agent-telegrambot": "dist/src/platforms/telegrambot/cli.js",
     "agent-webex": "dist/src/platforms/webex/cli.js",
     "agent-wechatbot": "dist/src/platforms/wechatbot/cli.js",
     "agent-whatsapp": "dist/src/platforms/whatsapp/cli.js",
@@ -71,6 +72,9 @@
       ],
       "channeltalkbot": [
         "./dist/src/platforms/channeltalkbot/index.d.ts"
+      ],
+      "telegrambot": [
+        "./dist/src/platforms/telegrambot/index.d.ts"
       ]
     }
   },
@@ -135,6 +139,10 @@
     "./channeltalkbot": {
       "types": "./dist/src/platforms/channeltalkbot/index.d.ts",
       "default": "./dist/src/platforms/channeltalkbot/index.js"
+    },
+    "./telegrambot": {
+      "types": "./dist/src/platforms/telegrambot/index.d.ts",
+      "default": "./dist/src/platforms/telegrambot/index.js"
     }
   },
   "scripts": {

package/scripts/postbuild.ts

@@ -9,6 +9,7 @@ const cliFiles = [
   'dist/src/platforms/channeltalk/cli.js',
   'dist/src/platforms/channeltalkbot/cli.js',
   'dist/src/platforms/telegram/cli.js',
+  'dist/src/platforms/telegrambot/cli.js',
 ]
 
 for (const file of cliFiles) {

package/skills/agent-channeltalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalk
 description: Interact with Channel Talk using extracted desktop app or browser credentials - read chats, send messages, search messages, manage groups
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-channeltalk:*)
 metadata:
   openclaw:

package/skills/agent-channeltalkbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-channeltalkbot
 description: Interact with Channel Talk workspaces using API credentials - send messages, read chats, manage groups and bots
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-channeltalkbot:*)
 metadata:
   openclaw:

package/skills/agent-discord/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-discord
 description: Interact with Discord servers - send messages, read channels, manage reactions
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-discord:*)
 metadata:
   openclaw:

package/skills/agent-discordbot/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-discordbot
 description: Interact with Discord servers using bot tokens - send messages, read channels, manage reactions
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-discordbot:*)
 metadata:
   openclaw:

package/skills/agent-instagram/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-instagram
 description: Interact with Instagram DMs - send messages, read conversations, manage accounts
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-instagram:*)
 metadata:
   openclaw:

package/skills/agent-kakaotalk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-kakaotalk
 description: Interact with KakaoTalk - send messages, read chats, manage conversations
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-kakaotalk:*)
 metadata:
   openclaw:
@@ -56,7 +56,7 @@ Registers the CLI as a sub-device (tablet slot by default). Your desktop app kee
 agent-kakaotalk auth login
 ```
 
-In interactive mode, this prompts for email and password. The CLI first tries to extract cached credentials from the desktop app so you may not need to type anything.
+In interactive mode, this prompts for email and password. On macOS and Windows, the CLI first tries to extract cached credentials from the desktop app so you may not need to type anything. On Linux there is no desktop app, so always pass credentials explicitly via `--email` and `--password` (or `--password-file`).
 
 For AI agents (non-interactive), provide credentials via flags:
 
@@ -488,8 +488,7 @@ See the [KakaoTalk SDK documentation](https://agent-messenger.dev/docs/sdk/kakao
 
 ## Limitations
 
-- macOS and Windows only (desktop app needed for auto-extracting email/password during login)
-- No Linux support (KakaoTalk desktop not available on Linux)
+- Auto-extraction of email/password from the desktop app is **macOS and Windows only** (KakaoTalk desktop is not available on Linux). Linux users must pass `--email` and `--password` (or `--password-file`) explicitly — the LOCO protocol, login flow, and all messaging features work on Linux.
 - No file upload or download
 - No channel/chat room creation or management
 - No friend list management
@@ -526,7 +525,15 @@ pnpm dlx --package agent-messenger agent-kakaotalk chat list --pretty
 
 ### Password prompt on fresh install
 
-On fresh installs, the desktop app (macOS or Windows) may hash or omit the password from its cache, so the CLI cannot extract it automatically. The CLI will prompt for the password once to register the device — via a native dialog on macOS (AppKit) and Windows (PowerShell WinForms), or via a TTY prompt if a terminal is available. After registration, the password is never needed again.
+On fresh installs, the desktop app (macOS or Windows) may hash or omit the password from its cache, so the CLI cannot extract it automatically. The CLI will prompt for the password once to register the device — via a native dialog on macOS (AppKit), Windows (PowerShell WinForms), or Linux (`zenity` / `kdialog`), or via a TTY prompt if a terminal is available. After registration, the password is never needed again.
+
+On Linux there is no desktop app to extract from, so always provide credentials explicitly:
+
+```bash
+agent-kakaotalk auth login --email user@example.com --password-file /tmp/.kakao-pw
+```
+
+`--password-file` reads the file then immediately deletes it, so the password never appears in shell history or process listings.
 
 When the CLI returns `{"next_action": "run_interactive", ...}`, use a tmux session to let the user type their password securely. See "Handling `run_interactive`" above for the exact steps.
 

package/skills/agent-line/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-line
 description: Interact with LINE - send messages, read chats, manage conversations
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-line:*)
 metadata:
   openclaw:

package/skills/agent-slack/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: agent-slack
 description: Interact with Slack workspaces - send messages, read channels, manage reactions
-version: 2.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-slack:*)
 metadata:
   openclaw:

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.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-slackbot:*)
 metadata:
   openclaw:

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.12.0
+version: 2.12.2
 allowed-tools: Bash(agent-teams:*)
 metadata:
   openclaw: