agent-messenger 1.14.0 → 2.0.0

package/skills/agent-kakaotalk/references/common-patterns.md

@@ -0,0 +1,403 @@
+# Common Patterns
+
+## Overview
+
+This guide covers typical workflows for AI agents interacting with KakaoTalk using agent-kakaotalk.
+
+## Pattern 1: Send a Simple Message
+
+**Use case**: Post a message to a chat room
+
+```bash
+#!/bin/bash
+
+CHAT_ID="9876543210"
+
+# Direct approach
+agent-kakaotalk message send "$CHAT_ID" "Deployment completed successfully!"
+
+# With error handling
+RESULT=$(agent-kakaotalk message send "$CHAT_ID" "Hello world")
+SUCCESS=$(echo "$RESULT" | jq -r '.success')
+if [ "$SUCCESS" = "true" ]; then
+  echo "Message sent!"
+else
+  echo "Failed: $(echo "$RESULT" | jq -r '.error // "Unknown error"')"
+  exit 1
+fi
+```
+
+**When to use**: Simple one-off messages where you know the chat ID.
+
+**Note**: You must know the chat ID. Use `agent-kakaotalk chat list` to discover chat IDs.
+
+## Pattern 2: Discover Chat Rooms
+
+**Use case**: Find the right chat room to send a message to
+
+```bash
+#!/bin/bash
+
+# List all chats sorted by recent activity
+CHATS=$(agent-kakaotalk chat list)
+
+# Find a specific chat by display name
+TARGET_CHAT=$(echo "$CHATS" | jq -r '.[] | select(.display_name | contains("Alice")) | .chat_id')
+
+if [ -z "$TARGET_CHAT" ]; then
+  echo "Chat not found"
+  exit 1
+fi
+
+echo "Found chat: $TARGET_CHAT"
+agent-kakaotalk message send "$TARGET_CHAT" "Hey Alice!"
+```
+
+**When to use**: First time interacting with a chat, or when the user references a chat by name.
+
+## Pattern 3: Monitor Chat for New Messages
+
+**Use case**: Watch a chat room and respond to new messages
+
+```bash
+#!/bin/bash
+
+CHAT_ID="9876543210"
+LAST_LOG_ID=""
+
+while true; do
+  # Get latest message
+  MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" -n 1)
+  LATEST_LOG_ID=$(echo "$MESSAGES" | jq -r '.[-1].log_id // ""')
+
+  # Check if new message
+  if [ "$LATEST_LOG_ID" != "$LAST_LOG_ID" ] && [ -n "$LAST_LOG_ID" ]; then
+    TEXT=$(echo "$MESSAGES" | jq -r '.[-1].message // ""')
+    AUTHOR=$(echo "$MESSAGES" | jq -r '.[-1].author_id // ""')
+
+    echo "New message from $AUTHOR: $TEXT"
+
+    # Process message here
+  fi
+
+  LAST_LOG_ID="$LATEST_LOG_ID"
+  sleep 10
+done
+```
+
+**When to use**: Building a simple bot that reacts to messages.
+
+**Limitations**: Polling-based, not real-time. Each poll establishes a LOCO connection, so use reasonable intervals (10s+).
+
+## Pattern 4: Read Recent Chat History
+
+**Use case**: Catch up on what happened in a chat
+
+```bash
+#!/bin/bash
+
+CHAT_ID="9876543210"
+
+# Get last 50 messages
+MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" -n 50)
+
+# Display summary
+MSG_COUNT=$(echo "$MESSAGES" | jq 'length')
+echo "Found $MSG_COUNT messages"
+
+# Show messages
+echo "$MESSAGES" | jq -r '.[] | "\(.author_id): \(.message // "[non-text]")"'
+```
+
+**When to use**: Context gathering, summarizing conversations, catching up on missed messages.
+
+## Pattern 5: Fetch More Messages
+
+**Use case**: Read more messages than the default 20
+
+The CLI handles internal pagination automatically — it fetches in batches of 80 from the LOCO protocol, deduplicates, and returns the last N messages. Just increase `-n`:
+
+```bash
+#!/bin/bash
+
+CHAT_ID="9876543210"
+
+# Get last 100 messages (CLI handles internal batching)
+MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" -n 100)
+
+MSG_COUNT=$(echo "$MESSAGES" | jq 'length')
+echo "Fetched $MSG_COUNT messages"
+
+# Get last 500 messages
+MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" -n 500)
+```
+
+Use `--from` to fetch messages **newer** than a known point (forward only):
+
+```bash
+CHAT_ID="9876543210"
+LAST_SEEN="123456789"
+
+# Get only messages that arrived after that point
+NEW_MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" --from "$LAST_SEEN")
+```
+
+**When to use**: Reading long chat histories, catching up on new messages since last check.
+
+**Pagination details**: The sync loop uses the chat's latest `logId` (from `loginResult.chatDatas`) as an upper bound so it only fetches messages up to the current point, avoiding unbounded history scans. As a safety net, pagination is capped at 50 pages (50 × 80 = ~4,000 raw messages). If the cap is hit, a warning is printed to stderr and the returned messages may be incomplete.
+
+## Pattern 6: Multi-Chat Broadcast
+
+**Use case**: Send the same message to multiple chats
+
+```bash
+#!/bin/bash
+
+MESSAGE="Team meeting in 10 minutes!"
+CHAT_IDS=("9876543210" "1111111111" "2222222222")
+
+for chat_id in "${CHAT_IDS[@]}"; do
+  echo "Sending to $chat_id..."
+  RESULT=$(agent-kakaotalk message send "$chat_id" "$MESSAGE")
+
+  SUCCESS=$(echo "$RESULT" | jq -r '.success')
+  if [ "$SUCCESS" = "true" ]; then
+    echo "  ✓ Sent"
+  else
+    echo "  ✗ Failed"
+  fi
+
+  # Rate limit: be gentle with the LOCO protocol
+  sleep 2
+done
+```
+
+**When to use**: Announcements, notifications across multiple chats.
+
+## Pattern 7: Multi-Account Operations
+
+**Use case**: Manage and operate across multiple KakaoTalk accounts
+
+```bash
+#!/bin/bash
+
+# List all configured accounts
+agent-kakaotalk auth list
+
+# Switch the default account
+agent-kakaotalk auth use 9876543210
+
+# Send from a specific account without switching default
+agent-kakaotalk message send "$CHAT_ID" "Hello from account A" --account 1111111111
+
+# List chats from a specific account
+agent-kakaotalk chat list --account 2222222222
+
+# Check auth status of a specific account
+agent-kakaotalk auth status --account 1111111111
+```
+
+**When to use**: Managing multiple KakaoTalk identities, sending messages as different accounts, or checking status across accounts.
+
+## Pattern 8: Unread Message Summary
+
+**Use case**: Check which chats have unread messages
+
+```bash
+#!/bin/bash
+
+# Get all chats
+CHATS=$(agent-kakaotalk chat list)
+
+# Filter chats with unread messages
+UNREAD=$(echo "$CHATS" | jq '[.[] | select(.unread_count > 0)]')
+UNREAD_COUNT=$(echo "$UNREAD" | jq 'length')
+
+echo "You have unread messages in $UNREAD_COUNT chats:"
+echo ""
+
+echo "$UNREAD" | jq -r '.[] | "  \(.display_name // "Unknown") — \(.unread_count) unread"'
+```
+
+**When to use**: Morning catch-up, checking for urgent messages, triage.
+
+## Pattern 9: Error Handling and Retry
+
+**Use case**: Robust message sending with retries
+
+```bash
+#!/bin/bash
+
+send_with_retry() {
+  local chat_id=$1
+  local message=$2
+  local max_attempts=3
+  local attempt=1
+
+  while [ $attempt -le $max_attempts ]; do
+    echo "Attempt $attempt/$max_attempts..."
+
+    RESULT=$(agent-kakaotalk message send "$chat_id" "$message" 2>&1)
+    SUCCESS=$(echo "$RESULT" | jq -r '.success // false')
+
+    if [ "$SUCCESS" = "true" ]; then
+      echo "Message sent!"
+      return 0
+    fi
+
+    ERROR=$(echo "$RESULT" | jq -r '.error // "Unknown error"')
+    echo "Failed: $ERROR"
+
+    # Don't retry auth errors
+    if echo "$ERROR" | grep -q "No KakaoTalk credentials"; then
+      echo "Not authenticated. Run: agent-kakaotalk auth login"
+      return 1
+    fi
+
+    if [ $attempt -lt $max_attempts ]; then
+      SLEEP_TIME=$((attempt * 3))
+      echo "Retrying in ${SLEEP_TIME}s..."
+      sleep $SLEEP_TIME
+    fi
+
+    attempt=$((attempt + 1))
+  done
+
+  echo "Failed after $max_attempts attempts"
+  return 1
+}
+
+# Usage
+send_with_retry "9876543210" "Important message!"
+```
+
+**When to use**: Production scripts, critical notifications, unreliable networks.
+
+## Best Practices
+
+### 1. Cache Chat IDs
+
+```bash
+# Good — discover once, reuse
+CHATS=$(agent-kakaotalk chat list)
+WORK_CHAT=$(echo "$CHATS" | jq -r '.[] | select(.display_name | contains("Work")) | .chat_id')
+agent-kakaotalk message send "$WORK_CHAT" "Hello"
+agent-kakaotalk message send "$WORK_CHAT" "Another message"
+
+# Bad — list chats before every send
+agent-kakaotalk chat list  # Wasteful
+agent-kakaotalk message send "..." "Hello"
+agent-kakaotalk chat list  # Wasteful
+agent-kakaotalk message send "..." "Another"
+```
+
+### 2. Use Memory for Known IDs
+
+Store frequently used chat IDs in `~/.config/agent-messenger/MEMORY.md` to skip `chat list` calls in future sessions.
+
+### 3. Respect Rate Limits
+
+```bash
+# Good — pause between operations
+for chat_id in "${CHATS[@]}"; do
+  agent-kakaotalk message send "$chat_id" "$MSG"
+  sleep 2
+done
+
+# Bad — rapid-fire
+for chat_id in "${CHATS[@]}"; do
+  agent-kakaotalk message send "$chat_id" "$MSG"
+done
+```
+
+### 4. Check Auth Before Multi-Step Workflows
+
+```bash
+# Good — verify auth upfront
+STATUS=$(agent-kakaotalk auth status)
+if echo "$STATUS" | jq -e '.error' > /dev/null 2>&1; then
+  echo "Not authenticated"
+  exit 1
+fi
+
+# Proceed with workflow
+agent-kakaotalk chat list
+agent-kakaotalk message send ...
+```
+
+## Anti-Patterns
+
+### ❌ Don't Poll Too Frequently
+
+```bash
+# Bad — LOCO connection per poll
+while true; do
+  agent-kakaotalk message list "$CHAT_ID" -n 1
+  sleep 1  # Too aggressive
+done
+
+# Good — reasonable interval
+while true; do
+  agent-kakaotalk message list "$CHAT_ID" -n 1
+  sleep 10
+done
+```
+
+### ❌ Don't Ignore Errors
+
+```bash
+# Bad
+agent-kakaotalk message send "$CHAT_ID" "Hello"
+
+# Good
+RESULT=$(agent-kakaotalk message send "$CHAT_ID" "Hello")
+if ! echo "$RESULT" | jq -e '.success' > /dev/null 2>&1; then
+  echo "Failed: $(echo "$RESULT" | jq -r '.error // .message // "Unknown"')"
+  exit 1
+fi
+```
+
+### ❌ Don't Spam Chats
+
+```bash
+# Bad — sends 100 separate messages
+for i in {1..100}; do
+  agent-kakaotalk message send "$CHAT_ID" "Item $i"
+done
+
+# Good — batch into single message
+MESSAGE="Updates:"
+for i in {1..100}; do
+  MESSAGE="${MESSAGE}"$'\n'"$i. Item $i"
+done
+agent-kakaotalk message send "$CHAT_ID" "$MESSAGE"
+```
+
+## SDK Client Lifecycle
+
+When using `KakaoTalkClient` programmatically, note that calling `close()` is permanent — any subsequent method call throws a `KakaoTalkError` with code `client_closed`. Create a new `KakaoTalkClient` instance if you need to reconnect. Always use `try/finally` to ensure `close()` runs:
+
+```typescript
+import { KakaoTalkClient } from 'agent-messenger/kakaotalk'
+
+const client = await new KakaoTalkClient().login()
+try {
+  const chats = await client.getChats()
+  const firstChat = chats[0]
+  if (!firstChat) throw new Error('No chats available')
+  await client.sendMessage(firstChat.chat_id, 'Hello!')
+} finally {
+  client.close()
+}
+```
+
+### Auto-Reconnect
+
+`getChats`, `getMessages`, and `sendMessage` automatically reconnect once when the LOCO session dies (e.g. the KakaoTalk desktop app reclaims the session or the network drops). The reconnect is transparent — callers don't need to handle session-drop errors.
+
+Reconnect only triggers on actual session death. Operation-level errors (invalid chat ID, server rejection, etc.) are thrown immediately without retry, so side effects like `sendMessage` are never duplicated.
+
+## See Also
+
+- [Authentication Guide](authentication.md) - Setting up credentials
+- [Templates](../templates/) - Runnable example scripts

package/skills/agent-kakaotalk/templates/chat-summary.sh

@@ -0,0 +1,121 @@
+#!/bin/bash
+#
+# chat-summary.sh - Generate a summary of your KakaoTalk chats
+#
+# Usage:
+#   ./chat-summary.sh [--json]
+#
+# Options:
+#   --json  Output raw JSON instead of formatted text
+#
+# Example:
+#   ./chat-summary.sh
+#   ./chat-summary.sh --json > summary.json
+
+set -euo pipefail
+
+OUTPUT_JSON=false
+if [ $# -gt 0 ] && [ "$1" = "--json" ]; then
+  OUTPUT_JSON=true
+fi
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+if ! command -v agent-kakaotalk &> /dev/null; then
+  echo -e "${RED}Error: agent-kakaotalk not found${NC}" >&2
+  echo "" >&2
+  echo "Install it with:" >&2
+  echo "  npm install -g agent-messenger" >&2
+  exit 1
+fi
+
+# Check authentication
+AUTH_STATUS=$(agent-kakaotalk auth status 2>&1) || true
+
+if echo "$AUTH_STATUS" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Not authenticated!${NC}" >&2
+  echo "" >&2
+  echo "Run this to authenticate:" >&2
+  echo "  agent-kakaotalk auth login" >&2
+  exit 1
+fi
+
+ACCOUNT_ID=$(echo "$AUTH_STATUS" | jq -r '.account_id // "Unknown"')
+DEVICE_TYPE=$(echo "$AUTH_STATUS" | jq -r '.device_type // "Unknown"')
+
+echo -e "${YELLOW}Fetching chat list...${NC}" >&2
+CHATS=$(agent-kakaotalk chat list 2>&1) || true
+
+if echo "$CHATS" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Failed to get chat list${NC}" >&2
+  ERROR_MSG=$(echo "$CHATS" | jq -r '.error // "Unknown error"')
+  echo -e "${RED}Error: $ERROR_MSG${NC}" >&2
+  exit 1
+fi
+
+if [ "$OUTPUT_JSON" = true ]; then
+  echo "$CHATS"
+  exit 0
+fi
+
+CHAT_COUNT=$(echo "$CHATS" | jq 'length')
+UNREAD_CHATS=$(echo "$CHATS" | jq '[.[] | select(.unread_count > 0)] | length')
+TOTAL_UNREAD=$(echo "$CHATS" | jq '[.[].unread_count // 0] | add // 0')
+
+echo ""
+echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BOLD}${BLUE}  KakaoTalk Chat Summary${NC}"
+echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo -e "${BOLD}Account:${NC}     $ACCOUNT_ID"
+echo -e "${BOLD}Device:${NC}      $DEVICE_TYPE"
+echo -e "${BOLD}Total chats:${NC} $CHAT_COUNT"
+echo -e "${BOLD}Unread:${NC}      $UNREAD_CHATS chats ($TOTAL_UNREAD messages)"
+echo ""
+
+# Show chats with unread messages
+if [ "$UNREAD_CHATS" -gt 0 ]; then
+  echo -e "${BOLD}${CYAN}Unread Chats:${NC}"
+  echo "$CHATS" | jq -r '
+    [.[] | select(.unread_count > 0)] |
+    sort_by(-.unread_count) |
+    .[] |
+    "  \(.display_name // "Unknown") — \(.unread_count) unread (ID: \(.chat_id))"
+  '
+  echo ""
+fi
+
+# Show recent chats
+echo -e "${BOLD}${CYAN}Recent Chats:${NC}"
+echo "$CHATS" | jq -r '
+  .[0:10] |
+  .[] |
+  "  \(.display_name // "Unknown") (ID: \(.chat_id)) — \(.active_members // "?") members"
+'
+if [ "$CHAT_COUNT" -gt 10 ]; then
+  echo "  ... and $((CHAT_COUNT - 10)) more"
+fi
+echo ""
+
+# Show quick actions
+echo -e "${BOLD}${CYAN}Quick Actions:${NC}"
+echo ""
+FIRST_CHAT=$(echo "$CHATS" | jq -r '.[0].chat_id // "CHAT_ID"')
+echo -e "  ${GREEN}# Send message to most recent chat${NC}"
+echo -e "  agent-kakaotalk message send $FIRST_CHAT \"Hello!\""
+echo ""
+echo -e "  ${GREEN}# Read messages from a chat${NC}"
+echo -e "  agent-kakaotalk message list $FIRST_CHAT -n 20"
+echo ""
+echo -e "  ${GREEN}# List all chats with details${NC}"
+echo -e "  agent-kakaotalk chat list --pretty"
+echo ""
+
+echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""

package/skills/agent-kakaotalk/templates/monitor-chat.sh

@@ -0,0 +1,160 @@
+#!/bin/bash
+#
+# monitor-chat.sh - Monitor a KakaoTalk chat for new messages
+#
+# Usage:
+#   ./monitor-chat.sh <chat-id> [interval]
+#
+# Arguments:
+#   chat-id  - Numeric chat room ID
+#   interval - Polling interval in seconds (default: 10)
+#
+# Example:
+#   ./monitor-chat.sh 9876543210
+#   ./monitor-chat.sh 9876543210 30
+
+set -euo pipefail
+
+# Check arguments
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 <chat-id> [interval]"
+  echo ""
+  echo "Examples:"
+  echo "  $0 9876543210          # Monitor chat, poll every 10s"
+  echo "  $0 9876543210 30       # Monitor chat, poll every 30s"
+  echo ""
+  echo "Find chat IDs with:"
+  echo "  agent-kakaotalk chat list --pretty"
+  exit 1
+fi
+
+CHAT_ID="$1"
+INTERVAL="${2:-10}"  # Default 10 seconds
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# State tracking
+LAST_LOG_ID=""
+FIRST_RUN=true
+
+# Function to format timestamp
+format_time() {
+  local ts=$1
+  # KakaoTalk sends timestamps in seconds
+  date -r "$ts" "+%Y-%m-%d %H:%M:%S" 2>/dev/null || echo "$ts"
+}
+
+# Function to truncate text
+truncate_text() {
+  local text=$1
+  local max_length=100
+
+  if [ ${#text} -gt $max_length ]; then
+    echo "${text:0:$max_length}..."
+  else
+    echo "$text"
+  fi
+}
+
+# Function to check for new messages
+check_messages() {
+  # Get latest message
+  MESSAGES=$(agent-kakaotalk message list "$CHAT_ID" -n 1 2>&1) || true
+
+  # Check if response is valid JSON array
+  if ! echo "$MESSAGES" | jq -e '.[0]' > /dev/null 2>&1; then
+    if echo "$MESSAGES" | jq -e '.error' > /dev/null 2>&1; then
+      ERROR_MSG=$(echo "$MESSAGES" | jq -r '.error // "Unknown error"')
+      echo -e "${RED}Error: $ERROR_MSG${NC}"
+    fi
+    return 1
+  fi
+
+  # Extract latest message
+  LATEST_LOG_ID=$(echo "$MESSAGES" | jq -r '.[-1].log_id // ""')
+
+  # No messages in chat
+  if [ -z "$LATEST_LOG_ID" ]; then
+    if [ "$FIRST_RUN" = true ]; then
+      echo -e "${YELLOW}No messages in chat yet${NC}"
+    fi
+    return 0
+  fi
+
+  # Check if new message
+  if [ "$LATEST_LOG_ID" != "$LAST_LOG_ID" ]; then
+    # Skip notification on first run (just initialize)
+    if [ "$FIRST_RUN" = false ] && [ -n "$LAST_LOG_ID" ]; then
+      # Extract message details
+      TEXT=$(echo "$MESSAGES" | jq -r '.[-1].message // "[non-text]"')
+      AUTHOR_ID=$(echo "$MESSAGES" | jq -r '.[-1].author_id // "Unknown"')
+      SENT_AT=$(echo "$MESSAGES" | jq -r '.[-1].sent_at // ""')
+
+      # Format timestamp
+      TIME=""
+      if [ -n "$SENT_AT" ]; then
+        TIME=$(format_time "$SENT_AT")
+      fi
+
+      # Display new message
+      echo ""
+      echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+      echo -e "${BLUE}New message in chat $CHAT_ID${NC}"
+      echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+      echo -e "Time:    $TIME"
+      echo -e "From:    $AUTHOR_ID"
+      echo -e "Message: $(truncate_text "$TEXT")"
+      echo -e "Log ID:  $LATEST_LOG_ID"
+      echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    fi
+
+    LAST_LOG_ID="$LATEST_LOG_ID"
+  fi
+
+  FIRST_RUN=false
+  return 0
+}
+
+# Check if agent-kakaotalk is installed
+if ! command -v agent-kakaotalk &> /dev/null; then
+  echo -e "${RED}Error: agent-kakaotalk not found${NC}"
+  echo ""
+  echo "Install it with:"
+  echo "  npm install -g agent-messenger"
+  exit 1
+fi
+
+# Check authentication
+echo "Checking authentication..."
+AUTH_STATUS=$(agent-kakaotalk auth status 2>&1) || true
+
+if echo "$AUTH_STATUS" | jq -e '.error' > /dev/null 2>&1; then
+  echo -e "${RED}Not authenticated!${NC}"
+  echo ""
+  echo "Run this to authenticate:"
+  echo "  agent-kakaotalk auth login"
+  exit 1
+fi
+
+ACCOUNT_ID=$(echo "$AUTH_STATUS" | jq -r '.account_id // "Unknown"')
+echo -e "${GREEN}✓ Authenticated as: $ACCOUNT_ID${NC}"
+echo ""
+
+# Start monitoring
+echo -e "${YELLOW}Monitoring chat $CHAT_ID (polling every ${INTERVAL}s)...${NC}"
+echo -e "${YELLOW}Press Ctrl+C to stop${NC}"
+echo ""
+
+# Trap Ctrl+C for clean exit
+trap 'echo -e "\n${YELLOW}Monitoring stopped${NC}"; exit 0' INT
+
+# Main monitoring loop
+while true; do
+  check_messages
+  sleep "$INTERVAL"
+done