telegram-approval-buttons 4.1.0 → 5.0.1

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.0.1] - 2026-03-01
+
+### Fixed
+- **Reverted plugin ID to `telegram-approval-buttons`** — v5.0.0 renamed it to `approval-buttons`, causing a config warning on every startup. The plugin ID now matches the npm package name again. No config changes needed for users upgrading from v4.x.
+- Normalized all file headers to use consistent naming
+
+## [5.0.0] - 2026-02-24
+
+### Added
+- **Slack inline button support** — approval buttons now work in Slack via Block Kit interactive messages
+- New files: `lib/slack-api.ts`, `lib/slack-formatter.ts`, `tests/slack-formatter.test.ts`
+- Auto-detects Slack credentials from `channels.slack` config or `SLACK_BOT_TOKEN` / `SLACK_CHANNEL_ID` env vars
+- `/approvalstatus` now shows both Telegram and Slack connectivity
+- Multi-channel architecture: either or both channels can be independently enabled
+
+### Changed
+- **Cleaner approval messages** — removed verbose internal fields (Security, Ask, Host) from both Telegram and Slack formats. Messages now focus on: command, CWD, agent, and expiry
+
+### Contributors
+
+Thanks to [@sjkey](https://github.com/sjkey) for contributing Slack support and the message simplification improvements in this release 🙏
+
 ## [4.1.0] - 2026-02-20
 
 ### Changed

package/README.md

@@ -1,6 +1,6 @@
-# 🔐 Telegram Approval Buttons for OpenClaw
+# 🔐 Approval Buttons for OpenClaw
 
-> One-tap `exec` approvals in Telegram — no more typing `/approve <uuid> allow-once`.
+> One-tap `exec` approvals in **Telegram** and **Slack** — no more typing `/approve <uuid> allow-once`.
 
 ## What does this look like?
 
@@ -10,13 +10,14 @@
 
 ## What does this do?
 
-OpenClaw's Discord has built-in approval buttons. **Telegram doesn't** — you're stuck typing long `/approve` commands. This plugin fixes that.
+OpenClaw's Discord has built-in approval buttons. **Telegram and Slack don't** — you're stuck typing long `/approve` commands. This plugin fixes that for both.
 
 **Features:**
 - ✅ **One-tap approvals** — Allow Once · 🔏 Always · ❌ Deny
+- 💬 **Multi-channel** — works on Telegram (inline keyboard) and Slack (Block Kit buttons)
 - 🔄 **Auto-resolve** — edits the message after decision (removes buttons, shows result)
 - ⏰ **Expiry handling** — stale approvals auto-cleaned and marked as expired
-- 🩺 **Self-diagnostics** — `/approvalstatus` checks health and stats
+- 🩺 **Self-diagnostics** — `/approvalstatus` checks health and stats for both channels
 - 🛡️ **Graceful fallback** — if buttons fail, the original text goes through
 - 📦 **Zero dependencies** — uses only Node.js built-in `fetch`
 
@@ -101,8 +102,10 @@ Then send `/approvalstatus` in your Telegram chat. You should see:
 ```
 🟢 Approval Buttons Status
 
-Config: chatId=✓ · token=✓
-Telegram: ✓ connected (@your_bot)
+Telegram: chatId=✓ · token=✓
+  ✓ connected (@your_bot)
+Slack: not configured
+
 Pending: 0 · Processed: 0
 Uptime: 1m
 ```
@@ -162,10 +165,12 @@ The plugin **auto-detects** `botToken` and `chatId` from your Telegram channel c
       "telegram-approval-buttons": {
         "enabled": true,
         "config": {
-          "chatId": "123456789",       // Override auto-detected chat ID
-          "botToken": "123:ABC...",     // Override auto-detected bot token
-          "staleMins": 10,             // Minutes before stale cleanup (default: 10)
-          "verbose": false             // Diagnostic logging (default: false)
+          "chatId": "123456789",          // Telegram chat ID
+          "botToken": "123:ABC...",        // Telegram bot token
+          "slackBotToken": "xoxb-...",     // Slack bot OAuth token (optional)
+          "slackChannelId": "C0123456",    // Slack channel/DM ID (optional)
+          "staleMins": 10,                // Minutes before stale cleanup (default: 10)
+          "verbose": false                // Diagnostic logging (default: false)
         }
       }
     }
@@ -202,8 +207,6 @@ A: Yes, but the bot needs to be an admin or it needs permission to edit its own
 | `/approvalstatus` says "unknown command" | Plugin didn't load. Run `openclaw plugins install telegram-approval-buttons` and restart the gateway. |
 | No buttons appear | Check `tools.exec.ask` is not `"off"`. Run `/approvalstatus` to check config. |
 | Buttons show but nothing happens | Bot needs message editing permission. Use a private chat or make bot admin. |
-| `/approvalstatus` says "token=✗" | Set `botToken` in plugin config. See Step 2. |
-| `/approvalstatus` says "chatId=✗" | Set `chatId` in plugin config. See Step 2. |
 | Buttons say "expired" | Approval timed out before you tapped. Adjust `staleMins` if needed. |
 
 ## Architecture
@@ -213,9 +216,11 @@ telegram-approval-buttons/
 ├── index.ts                  # Entry point — orchestration only
 ├── types.ts                  # Shared TypeScript interfaces
 ├── lib/
-│   ├── telegram-api.ts       # Telegram Bot API client (isolated)
+│   ├── telegram-api.ts       # Telegram Bot API client
+│   ├── slack-api.ts          # Slack Web API client
 │   ├── approval-parser.ts    # Parse OpenClaw approval text format
 │   ├── message-formatter.ts  # HTML formatting for Telegram messages
+│   ├── slack-formatter.ts    # Block Kit formatting for Slack messages
 │   ├── approval-store.ts     # In-memory pending approval tracker
 │   └── diagnostics.ts        # Config resolution, health checks
 ├── openclaw.plugin.json      # Plugin manifest
@@ -226,6 +231,11 @@ telegram-approval-buttons/
 
 Issues and PRs welcome. Each file in `lib/` is self-contained with a single responsibility.
 
+## Contributors
+
+- [@JairFC](https://github.com/JairFC) — creator and maintainer
+- [@sjkey](https://github.com/sjkey) — Slack support and message simplification (v5.0.0)
+
 ## License
 
 [MIT](LICENSE)

package/index.ts

@@ -1,10 +1,10 @@
 // ─────────────────────────────────────────────────────────────────────────────
-// telegram-approval-buttons · index.ts (v4.1.0)
+// telegram-approval-buttons · index.ts (v5.0.1)
 // Plugin entry point — orchestration only, all logic lives in lib/
 //
-// Adds inline keyboard buttons to exec approval messages in Telegram.
+// Adds inline keyboard/button approval messages to Telegram and Slack.
 // When a user taps a button, OpenClaw processes the /approve command
-// automatically via its callback_query → synthetic text message pipeline.
+// automatically via the channel's callback mechanism.
 // ─────────────────────────────────────────────────────────────────────────────
 
 import type { PluginConfig } from "./types.js";
@@ -12,6 +12,7 @@ import type { PluginConfig } from "./types.js";
 // ── Modules ─────────────────────────────────────────────────────────────────
 
 import { TelegramApi } from "./lib/telegram-api.js";
+import { SlackApi } from "./lib/slack-api.js";
 import { ApprovalStore } from "./lib/approval-store.js";
 import { parseApprovalText, detectApprovalResult } from "./lib/approval-parser.js";
 import {
@@ -21,6 +22,12 @@ import {
   buildApprovalKeyboard,
   formatHealthCheck,
 } from "./lib/message-formatter.js";
+import {
+  formatSlackApprovalRequest,
+  formatSlackApprovalResolved,
+  formatSlackApprovalExpired,
+  slackFallbackText,
+} from "./lib/slack-formatter.js";
 import {
   resolveConfig,
   runHealthCheck,
@@ -30,7 +37,7 @@ import {
 
 // ── Constants ───────────────────────────────────────────────────────────────
 
-const PLUGIN_VERSION = "4.1.0";
+const PLUGIN_VERSION = "5.0.1";
 const TAG = "telegram-approval-buttons";
 
 // ── Plugin registration ─────────────────────────────────────────────────────
@@ -43,6 +50,7 @@ function register(api: any): void {
 
   const pluginCfg: PluginConfig = api.pluginConfig ?? {};
   const telegramCfg = api.config?.channels?.telegram ?? {};
+  const slackCfg = api.config?.channels?.slack ?? {};
 
   const config = resolveConfig(
     {
@@ -51,51 +59,74 @@ function register(api: any): void {
         token: telegramCfg.token || telegramCfg.botToken,
         allowFrom: telegramCfg.allowFrom,
       },
+      slackChannelConfig: {
+        token: slackCfg.token,
+        botToken: slackCfg.botToken,
+        allowFrom: slackCfg.allowFrom,
+      },
       env: {
         TELEGRAM_BOT_TOKEN: process.env.TELEGRAM_BOT_TOKEN,
         TELEGRAM_CHAT_ID: process.env.TELEGRAM_CHAT_ID,
+        SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN,
+        SLACK_CHANNEL_ID: process.env.SLACK_CHANNEL_ID,
       },
     },
     log,
   );
 
   if (!config) {
-    log.warn(`[${TAG}] v${PLUGIN_VERSION} loaded (DISABLED — missing config)`);
+    log.warn(`[${TAG}] v${PLUGIN_VERSION} loaded (DISABLED — no channels configured)`);
     return;
   }
 
   logStartupDiagnostics(config, log);
 
-  // ─── 2. Initialize modules ───────────────────────────────────────────
+  // ─── 2. Initialize API clients ────────────────────────────────────────
+
+  const tg = config.telegram
+    ? new TelegramApi(config.telegram.botToken, config.verbose ? log : undefined)
+    : null;
 
-  const tg = new TelegramApi(config.botToken, config.verbose ? log : undefined);
+  const slack = config.slack
+    ? new SlackApi(config.slack.botToken, config.verbose ? log : undefined)
+    : null;
+
+  // ─── 3. Initialize store with expiry handler ──────────────────────────
 
   const store = new ApprovalStore(
     config.staleMins * 60_000,
     config.verbose ? log : undefined,
-    // onExpired: edit the Telegram message to show "expired"
+    // onExpired: edit the message to show "expired"
     (entry) => {
-      tg.editMessageText(
-        config.chatId,
-        entry.messageId,
-        formatApprovalExpired(entry.info),
-      ).catch(() => { });
+      if (entry.channel === "telegram" && tg && config.telegram) {
+        tg.editMessageText(
+          config.telegram.chatId,
+          entry.messageId,
+          formatApprovalExpired(entry.info),
+        ).catch(() => { });
+      } else if (entry.channel === "slack" && slack && config.slack) {
+        slack.updateMessage(
+          config.slack.channelId,
+          entry.slackTs,
+          "Exec Approval Expired",
+          formatSlackApprovalExpired(entry.info),
+        ).catch(() => { });
+      }
     },
   );
 
-  // ─── 3. Register background service (cleanup timer) ──────────────────
+  // ─── 4. Register background service (cleanup timer) ──────────────────
 
   api.registerService({
     id: `${TAG}-cleanup`,
     start: () => {
       store.start();
-      // Non-blocking connectivity check
-      runStartupChecks(tg, log).catch(() => { });
+      runStartupChecks(tg, slack, log).catch(() => { });
     },
     stop: () => store.stop(),
   });
 
-  // ─── 4. Register /approvalstatus command ─────────────────────────────
+  // ─── 5. Register /approvalstatus command ─────────────────────────────
 
   api.registerCommand({
     name: "approvalstatus",
@@ -103,12 +134,12 @@ function register(api: any): void {
     acceptsArgs: false,
     requireAuth: true,
     handler: async () => {
-      const health = await runHealthCheck(config, tg, store, startedAt);
+      const health = await runHealthCheck(config, tg, slack, store, startedAt);
       return { text: formatHealthCheck(health) };
     },
   });
 
-  // ─── 5. Register message_sending hook ────────────────────────────────
+  // ─── 6. Register message_sending hook ────────────────────────────────
 
   api.on(
     "message_sending",
@@ -116,69 +147,119 @@ function register(api: any): void {
       event: { to: string; content: string; metadata?: Record<string, unknown> },
       ctx: { channelId: string; accountId?: string },
     ) => {
-      // Only intercept Telegram messages
-      if (ctx.channelId !== "telegram") return;
-
-      // ── 5a. Check for approval resolution ───────────────────────────
-      const resolution = detectApprovalResult(event.content, store.entries());
-      if (resolution) {
-        const entry = store.resolve(resolution.id);
-        if (entry) {
-          log.info(
-            `[${TAG}] resolved ${resolution.id.slice(0, 8)}… → ${resolution.action}`,
-          );
-          const edited = await tg.editMessageText(
-            config.chatId,
-            entry.messageId,
-            formatApprovalResolved(entry.info, resolution.action),
-          );
-          if (edited && config.verbose) {
-            log.info(`[${TAG}] edited msg=${entry.messageId}`);
-          }
-        }
-        // Don't cancel — let resolution messages pass through
-        return;
+      // ── Telegram ──────────────────────────────────────────────────
+      if (ctx.channelId === "telegram" && tg && config.telegram) {
+        return handleTelegram(event, config.telegram.chatId, tg, store, log);
       }
 
-      // ── 5b. Check for new approval request ─────────────────────────
-      const info = parseApprovalText(event.content);
-      if (!info) return;
-
-      // Duplicate guard
-      if (store.has(info.id)) {
-        if (config.verbose) {
-          log.info(`[${TAG}] skipping duplicate ${info.id.slice(0, 8)}…`);
-        }
-        return { cancel: true };
+      // ── Slack ─────────────────────────────────────────────────────
+      if (ctx.channelId === "slack" && slack && config.slack) {
+        return handleSlack(event, config.slack.channelId, slack, store, log);
       }
+    },
+  );
 
-      log.info(`[${TAG}] intercepting ${info.id.slice(0, 8)}…`);
+  // ─── Done ─────────────────────────────────────────────────────────────
+
+  const channels = [config.telegram && "Telegram", config.slack && "Slack"]
+    .filter(Boolean)
+    .join(" + ");
+  log.info(`[${TAG}] v${PLUGIN_VERSION} loaded ✓ (${channels})`);
+}
 
-      // Send formatted message with inline buttons
-      const messageId = await tg.sendMessage(
-        config.chatId,
-        formatApprovalRequest(info),
-        buildApprovalKeyboard(info.id),
+// ─── Channel handlers ───────────────────────────────────────────────────────
+
+async function handleTelegram(
+  event: { content: string },
+  chatId: string,
+  tg: TelegramApi,
+  store: ApprovalStore,
+  log: any,
+): Promise<{ cancel: true } | void> {
+  // Check for approval resolution
+  const resolution = detectApprovalResult(event.content, store.entries());
+  if (resolution) {
+    const entry = store.resolve(resolution.id);
+    if (entry && entry.channel === "telegram") {
+      log.info(`[${TAG}] telegram resolved ${resolution.id.slice(0, 8)}… → ${resolution.action}`);
+      await tg.editMessageText(
+        chatId,
+        entry.messageId,
+        formatApprovalResolved(entry.info, resolution.action),
       );
+    }
+    return;
+  }
 
-      if (messageId === null) {
-        log.warn(`[${TAG}] send failed for ${info.id.slice(0, 8)}… — falling back to plain text`);
-        // Don't cancel: let the plain-text message through as fallback
-        return;
-      }
+  // Check for new approval request
+  const info = parseApprovalText(event.content);
+  if (!info) return;
 
-      // Track it
-      store.add(info.id, messageId, info);
-      log.info(`[${TAG}] sent buttons for ${info.id.slice(0, 8)}… (msg=${messageId})`);
+  if (store.has(info.id)) return { cancel: true };
 
-      // Cancel the original plain-text message
-      return { cancel: true };
-    },
+  log.info(`[${TAG}] telegram intercepting ${info.id.slice(0, 8)}…`);
+
+  const messageId = await tg.sendMessage(
+    chatId,
+    formatApprovalRequest(info),
+    buildApprovalKeyboard(info.id),
   );
 
-  // ─── Done ─────────────────────────────────────────────────────────────
+  if (messageId === null) {
+    log.warn(`[${TAG}] telegram send failed for ${info.id.slice(0, 8)}… — falling back`);
+    return;
+  }
+
+  store.add(info.id, "telegram", { messageId }, info);
+  log.info(`[${TAG}] telegram sent buttons for ${info.id.slice(0, 8)}… (msg=${messageId})`);
+  return { cancel: true };
+}
+
+async function handleSlack(
+  event: { content: string },
+  channelId: string,
+  slackApi: SlackApi,
+  store: ApprovalStore,
+  log: any,
+): Promise<{ cancel: true } | void> {
+  // Check for approval resolution
+  const resolution = detectApprovalResult(event.content, store.entries());
+  if (resolution) {
+    const entry = store.resolve(resolution.id);
+    if (entry && entry.channel === "slack") {
+      log.info(`[${TAG}] slack resolved ${resolution.id.slice(0, 8)}… → ${resolution.action}`);
+      await slackApi.updateMessage(
+        channelId,
+        entry.slackTs,
+        `Exec ${resolution.action}`,
+        formatSlackApprovalResolved(entry.info, resolution.action),
+      );
+    }
+    return;
+  }
+
+  // Check for new approval request
+  const info = parseApprovalText(event.content);
+  if (!info) return;
+
+  if (store.has(info.id)) return { cancel: true };
+
+  log.info(`[${TAG}] slack intercepting ${info.id.slice(0, 8)}…`);
+
+  const ts = await slackApi.postMessage(
+    channelId,
+    slackFallbackText(info),
+    formatSlackApprovalRequest(info),
+  );
+
+  if (ts === null) {
+    log.warn(`[${TAG}] slack send failed for ${info.id.slice(0, 8)}… — falling back`);
+    return;
+  }
 
-  log.info(`[${TAG}] v${PLUGIN_VERSION} loaded ✓`);
+  store.add(info.id, "slack", { slackTs: ts }, info);
+  log.info(`[${TAG}] slack sent buttons for ${info.id.slice(0, 8)}… (ts=${ts})`);
+  return { cancel: true };
 }
 
 // ─── Plugin export ──────────────────────────────────────────────────────────
@@ -187,7 +268,7 @@ export default {
   id: "telegram-approval-buttons",
   name: "Telegram Approval Buttons",
   description:
-    "Adds inline keyboard buttons to exec approval messages in Telegram. " +
+    "Adds inline buttons to exec approval messages in Telegram and Slack. " +
     "Tap to approve/deny without typing commands.",
   version: PLUGIN_VERSION,
   kind: "extension" as const,

package/lib/approval-store.ts

@@ -3,7 +3,7 @@
 // In-memory store for pending approvals with TTL-based cleanup
 // ─────────────────────────────────────────────────────────────────────────────
 
-import type { ApprovalAction, ApprovalInfo, Logger, SentApproval } from "../types.js";
+import type { ApprovalChannel, ApprovalInfo, Logger, SentApproval } from "../types.js";
 
 /**
  * Manages the lifecycle of pending approval requests.
@@ -57,9 +57,16 @@ export class ApprovalStore {
   /**
    * Track a newly sent approval message.
    */
-  add(approvalId: string, messageId: number, info: ApprovalInfo): void {
+  add(
+    approvalId: string,
+    channel: ApprovalChannel,
+    ref: { messageId?: number; slackTs?: string },
+    info: ApprovalInfo,
+  ): void {
     this.pending.set(approvalId, {
-      messageId,
+      channel,
+      messageId: ref.messageId ?? 0,
+      slackTs: ref.slackTs ?? "",
       info,
       sentAt: Date.now(),
     });

package/lib/diagnostics.ts

@@ -5,6 +5,7 @@
 
 import type { HealthCheck, Logger, PluginConfig, ResolvedConfig } from "../types.js";
 import type { TelegramApi } from "./telegram-api.js";
+import type { SlackApi } from "./slack-api.js";
 import type { ApprovalStore } from "./approval-store.js";
 
 // ─── Config resolution ─────────────────────────────────────────────────────
@@ -12,62 +13,96 @@ import type { ApprovalStore } from "./approval-store.js";
 export interface ConfigSources {
   pluginConfig: PluginConfig;
   telegramChannelConfig: { token?: string; allowFrom?: (string | number)[] };
-  env: { TELEGRAM_BOT_TOKEN?: string; TELEGRAM_CHAT_ID?: string };
+  slackChannelConfig: { token?: string; botToken?: string; allowFrom?: (string | number)[] };
+  env: {
+    TELEGRAM_BOT_TOKEN?: string;
+    TELEGRAM_CHAT_ID?: string;
+    SLACK_BOT_TOKEN?: string;
+    SLACK_CHANNEL_ID?: string;
+  };
 }
 
 /**
  * Resolve plugin configuration from multiple sources with priority:
  * 1. pluginConfig (explicit config in openclaw.json)
- * 2. channels.telegram (shared Telegram config)
+ * 2. channels.telegram / channels.slack (shared channel config)
  * 3. Environment variables (fallback)
  *
- * Returns null with diagnostic messages if critical config is missing.
+ * Returns null only if BOTH Telegram and Slack are unconfigurable.
+ * Either channel can be independently enabled/disabled.
  */
 export function resolveConfig(
   sources: ConfigSources,
   log: Logger,
 ): ResolvedConfig | null {
-  const { pluginConfig, telegramChannelConfig, env } = sources;
+  const { pluginConfig, telegramChannelConfig, slackChannelConfig, env } = sources;
 
-  // ── Bot token resolution ────────────────────────────────────────────
-  const botToken =
+  // ── Telegram config ─────────────────────────────────────────────────
+  const tgBotToken =
     pluginConfig.botToken ||
     telegramChannelConfig.token ||
     env.TELEGRAM_BOT_TOKEN ||
     "";
 
-  if (!botToken) {
-    log.warn(
-      "[diagnostics] No bot token found. Check: " +
-        "pluginConfig.botToken → channels.telegram.token → TELEGRAM_BOT_TOKEN env",
-    );
-  }
+  let tgChatId = pluginConfig.chatId || env.TELEGRAM_CHAT_ID || "";
 
-  // ── Chat ID resolution ──────────────────────────────────────────────
-  let chatId = pluginConfig.chatId || env.TELEGRAM_CHAT_ID || "";
-
-  // Auto-repair: extract from allowFrom if not explicitly set
-  if (!chatId && Array.isArray(telegramChannelConfig.allowFrom)) {
+  if (!tgChatId && Array.isArray(telegramChannelConfig.allowFrom)) {
     const first = telegramChannelConfig.allowFrom[0];
     const candidate = String(first ?? "");
     if (/^-?\d+$/.test(candidate)) {
-      chatId = candidate;
+      tgChatId = candidate;
       log.info(
-        `[diagnostics] Auto-resolved chatId from channels.telegram.allowFrom: ${chatId}`,
+        `[diagnostics] Auto-resolved Telegram chatId from channels.telegram.allowFrom: ${tgChatId}`,
       );
     }
   }
 
-  if (!chatId) {
-    log.warn(
-      "[diagnostics] No chatId found. Set pluginConfig.chatId, " +
-        "TELEGRAM_CHAT_ID env, or channels.telegram.allowFrom",
-    );
+  const telegram =
+    tgBotToken && tgChatId
+      ? { chatId: tgChatId, botToken: tgBotToken }
+      : null;
+
+  if (!telegram) {
+    log.info("[diagnostics] Telegram not configured (optional)");
+  }
+
+  // ── Slack config ────────────────────────────────────────────────────
+  const slackBotToken =
+    pluginConfig.slackBotToken ||
+    slackChannelConfig.botToken ||
+    slackChannelConfig.token ||
+    env.SLACK_BOT_TOKEN ||
+    "";
+
+  let slackChannelId = pluginConfig.slackChannelId || env.SLACK_CHANNEL_ID || "";
+
+  // Auto-detect from Slack channel's allowFrom (user/channel ID)
+  if (!slackChannelId && Array.isArray(slackChannelConfig.allowFrom)) {
+    const first = slackChannelConfig.allowFrom[0];
+    const candidate = String(first ?? "");
+    // Slack IDs start with U (user), D (DM), C (channel), G (group)
+    if (/^[UDCGW][A-Z0-9]+$/.test(candidate)) {
+      slackChannelId = candidate;
+      log.info(
+        `[diagnostics] Auto-resolved Slack channelId from channels.slack.allowFrom: ${slackChannelId}`,
+      );
+    }
+  }
+
+  const slack =
+    slackBotToken && slackChannelId
+      ? { channelId: slackChannelId, botToken: slackBotToken }
+      : null;
+
+  if (!slack) {
+    log.info("[diagnostics] Slack not configured (optional)");
   }
 
-  // ── Missing critical config ─────────────────────────────────────────
-  if (!botToken || !chatId) {
-    log.error("[diagnostics] Plugin disabled due to missing configuration");
+  // ── At least one channel required ─────────────────────────────────
+  if (!telegram && !slack) {
+    log.error(
+      "[diagnostics] Plugin disabled — neither Telegram nor Slack is configured",
+    );
     return null;
   }
 
@@ -79,27 +114,31 @@ export function resolveConfig(
 
   const verbose = pluginConfig.verbose === true;
 
-  return { chatId, botToken, staleMins, verbose };
+  return { telegram, slack, staleMins, verbose };
 }
 
 // ─── Health check ───────────────────────────────────────────────────────────
 
 /**
- * Run a full health check: config validation + Telegram connectivity + store stats.
+ * Run a full health check: config + connectivity + store stats.
  */
 export async function runHealthCheck(
   config: ResolvedConfig | null,
   tg: TelegramApi | null,
+  slackApi: SlackApi | null,
   store: ApprovalStore,
   startedAt: number,
 ): Promise<HealthCheck> {
   const health: HealthCheck = {
     ok: false,
     config: {
-      chatId: !!config?.chatId,
-      botToken: !!config?.botToken,
+      telegramChatId: !!config?.telegram?.chatId,
+      telegramToken: !!config?.telegram?.botToken,
+      slackToken: !!config?.slack?.botToken,
+      slackChannel: !!config?.slack?.channelId,
     },
     telegram: { reachable: false },
+    slack: { reachable: false },
     store: {
       pending: store.pendingCount,
       totalProcessed: store.processedCount,
@@ -107,22 +146,33 @@ export async function runHealthCheck(
     uptime: Date.now() - startedAt,
   };
 
-  // Config check
-  if (!config || !tg) {
+  // Telegram connectivity
+  if (config?.telegram && tg) {
+    const me = await tg.getMe();
+    if (me.ok) {
+      health.telegram.reachable = true;
+      health.telegram.botUsername = me.username;
+    } else {
+      health.telegram.error = me.error;
+    }
+  } else {
     health.telegram.error = "not configured";
-    return health;
   }
 
-  // Telegram connectivity check
-  const me = await tg.getMe();
-  if (me.ok) {
-    health.telegram.reachable = true;
-    health.telegram.botUsername = me.username;
-    health.ok = true;
+  // Slack connectivity
+  if (config?.slack && slackApi) {
+    const auth = await slackApi.authTest();
+    if (auth.ok) {
+      health.slack.reachable = true;
+      health.slack.teamName = auth.teamName;
+    } else {
+      health.slack.error = auth.error;
+    }
   } else {
-    health.telegram.error = me.error;
+    health.slack.error = "not configured";
   }
 
+  health.ok = health.telegram.reachable || health.slack.reachable;
   return health;
 }
 
@@ -135,30 +185,49 @@ export function logStartupDiagnostics(
   config: ResolvedConfig,
   log: Logger,
 ): void {
-  const maskedToken = config.botToken.slice(0, 6) + "…" + config.botToken.slice(-4);
-  const maskedChatId = config.chatId.slice(0, 3) + "…" + config.chatId.slice(-2);
+  const channels: string[] = [];
+
+  if (config.telegram) {
+    const maskedToken = config.telegram.botToken.slice(0, 6) + "…" + config.telegram.botToken.slice(-4);
+    const maskedChatId = config.telegram.chatId.slice(0, 3) + "…" + config.telegram.chatId.slice(-2);
+    channels.push(`telegram(chatId=${maskedChatId}, token=${maskedToken})`);
+  }
+
+  if (config.slack) {
+    const maskedToken = config.slack.botToken.slice(0, 8) + "…" + config.slack.botToken.slice(-4);
+    const maskedChannel = config.slack.channelId.slice(0, 3) + "…" + config.slack.channelId.slice(-2);
+    channels.push(`slack(channel=${maskedChannel}, token=${maskedToken})`);
+  }
+
   log.info(
-    `[diagnostics] Config OK → chatId=${maskedChatId}, ` +
-      `token=${maskedToken}, staleMins=${config.staleMins}, ` +
-      `verbose=${config.verbose}`,
+    `[diagnostics] Config OK → ${channels.join(", ")}, ` +
+    `staleMins=${config.staleMins}, verbose=${config.verbose}`,
   );
 }
 
 /**
  * Run async startup checks (non-blocking).
- * Verifies Telegram API connectivity and logs the result.
  */
 export async function runStartupChecks(
-  tg: TelegramApi,
+  tg: TelegramApi | null,
+  slackApi: SlackApi | null,
   log: Logger,
 ): Promise<void> {
-  const me = await tg.getMe();
-  if (me.ok) {
-    log.info(`[diagnostics] Telegram connected → @${me.username}`);
-  } else {
-    log.warn(
-      `[diagnostics] Telegram unreachable: ${me.error}. ` +
-        "Plugin will still attempt to send messages.",
-    );
+  if (tg) {
+    const me = await tg.getMe();
+    if (me.ok) {
+      log.info(`[diagnostics] Telegram connected → @${me.username}`);
+    } else {
+      log.warn(`[diagnostics] Telegram unreachable: ${me.error}`);
+    }
+  }
+
+  if (slackApi) {
+    const auth = await slackApi.authTest();
+    if (auth.ok) {
+      log.info(`[diagnostics] Slack connected → ${auth.teamName}`);
+    } else {
+      log.warn(`[diagnostics] Slack unreachable: ${auth.error}`);
+    }
   }
 }

package/lib/message-formatter.ts

@@ -23,17 +23,12 @@ export function escapeHtml(text: string): string {
 export function formatApprovalRequest(info: ApprovalInfo): string {
   const e = escapeHtml;
   return [
-    `🔐 <b>Exec Approval Request</b>`,
-    ``,
-    `🤖 Agent: <b>${e(info.agent)}</b>`,
-    `🖥️ Host: <b>${e(info.host)}</b>`,
-    `📁 CWD: <code>${e(info.cwd)}</code>`,
+    `🔐 <b>Exec Approval</b>`,
     ``,
     `<pre>${e(info.command)}</pre>`,
     ``,
-    `🛡️ Security: ${e(info.security)}`,
-    `❓ Ask: ${e(info.ask)}`,
-    `⏱️ Expires: ${e(info.expires)}`,
+    `📁 <code>${e(info.cwd)}</code>`,
+    `🤖 ${e(info.agent)} · ⏱️ ${e(info.expires)}`,
     `🆔 <code>${e(info.id)}</code>`,
   ].join("\n");
 }
@@ -65,15 +60,11 @@ export function formatApprovalResolved(
   const label = ACTION_LABELS[action] ?? action;
 
   return [
-    `${icon} <b>Exec ${label}</b>`,
-    ``,
-    `🤖 Agent: <b>${e(info.agent)}</b>`,
-    `🖥️ Host: <b>${e(info.host)}</b>`,
-    `📁 CWD: <code>${e(info.cwd)}</code>`,
+    `${icon} <b>${label}</b>`,
     ``,
     `<pre>${e(info.command)}</pre>`,
     ``,
-    `🆔 <code>${e(info.id)}</code>`,
+    `🤖 ${e(info.agent)} · 🆔 <code>${e(info.id)}</code>`,
   ].join("\n");
 }
 
@@ -107,26 +98,24 @@ export function buildApprovalKeyboard(approvalId: string): object {
 export function formatApprovalExpired(info: ApprovalInfo): string {
   const e = escapeHtml;
   return [
-    `⏰ <b>Exec Approval Expired</b>`,
-    ``,
-    `🤖 Agent: <b>${e(info.agent)}</b>`,
-    `🖥️ Host: <b>${e(info.host)}</b>`,
+    `⏰ <b>Expired</b>`,
     ``,
     `<pre>${e(info.command)}</pre>`,
     ``,
-    `🆔 <code>${e(info.id)}</code>`,
+    `🤖 ${e(info.agent)} · 🆔 <code>${e(info.id)}</code>`,
   ].join("\n");
 }
 
 // ─── Health / diagnostics format ────────────────────────────────────────────
 
 /**
- * Format a health check result for display in Telegram.
+ * Format a health check result for display.
  */
 export function formatHealthCheck(health: {
   ok: boolean;
-  config: { chatId: boolean; botToken: boolean };
+  config: { telegramChatId: boolean; telegramToken: boolean; slackToken: boolean; slackChannel: boolean };
   telegram: { reachable: boolean; botUsername?: string; error?: string };
+  slack: { reachable: boolean; teamName?: string; error?: string };
   store: { pending: number; totalProcessed: number };
   uptime: number;
 }): string {
@@ -134,16 +123,36 @@ export function formatHealthCheck(health: {
   const lines = [
     `${health.ok ? "🟢" : "🔴"} Approval Buttons Status`,
     ``,
-    `Config: chatId=${health.config.chatId ? "✓" : "✗"} · token=${health.config.botToken ? "✓" : "✗"}`,
   ];
 
-  if (health.telegram.reachable) {
-    lines.push(`Telegram: ✓ connected (@${health.telegram.botUsername ?? "?"})`);
+  // Telegram status
+  const tgConfigured = health.config.telegramChatId && health.config.telegramToken;
+  if (tgConfigured) {
+    lines.push(`Telegram: chatId=${health.config.telegramChatId ? "✓" : "✗"} · token=${health.config.telegramToken ? "✓" : "✗"}`);
+    if (health.telegram.reachable) {
+      lines.push(`  ✓ connected (@${health.telegram.botUsername ?? "?"})`);
+    } else {
+      lines.push(`  ✗ ${health.telegram.error ?? "unreachable"}`);
+    }
   } else {
-    lines.push(`Telegram: ✗ ${health.telegram.error ?? "unreachable"}`);
+    lines.push(`Telegram: not configured`);
+  }
+
+  // Slack status
+  const slackConfigured = health.config.slackToken && health.config.slackChannel;
+  if (slackConfigured) {
+    lines.push(`Slack: token=${health.config.slackToken ? "✓" : "✗"} · channel=${health.config.slackChannel ? "✓" : "✗"}`);
+    if (health.slack.reachable) {
+      lines.push(`  ✓ connected (${health.slack.teamName ?? "?"})`);
+    } else {
+      lines.push(`  ✗ ${health.slack.error ?? "unreachable"}`);
+    }
+  } else {
+    lines.push(`Slack: not configured`);
   }
 
   lines.push(
+    ``,
     `Pending: ${health.store.pending} · Processed: ${health.store.totalProcessed}`,
     `Uptime: ${uptimeMin}m`,
   );

package/lib/slack-api.ts

@@ -0,0 +1,138 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// telegram-approval-buttons · lib/slack-api.ts
+// Isolated Slack Web API wrapper — only depends on fetch (Node built-in)
+// ─────────────────────────────────────────────────────────────────────────────
+
+import type { Logger } from "../types.js";
+
+const API_BASE = "https://slack.com/api/";
+const REQUEST_TIMEOUT_MS = 10_000;
+
+// ─── Internal helpers ───────────────────────────────────────────────────────
+
+interface SlackResponse<T = unknown> {
+  ok: boolean;
+  error?: string;
+  ts?: string;
+  channel?: string;
+  [key: string]: unknown;
+}
+
+async function slackFetch<T = unknown>(
+  token: string,
+  method: string,
+  body: Record<string, unknown>,
+  log?: Logger,
+): Promise<SlackResponse<T>> {
+  const url = `${API_BASE}${method}`;
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timer);
+
+    const data = (await res.json()) as SlackResponse<T>;
+    if (!data.ok && log) {
+      log.warn(`[slack-api] ${method} failed: ${data.error}`);
+    }
+    return data;
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log?.error(`[slack-api] ${method} network error: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Slack Web API client.
+ * Instantiate with a bot OAuth token; all methods are self-contained.
+ */
+export class SlackApi {
+  constructor(
+    private readonly token: string,
+    private readonly log?: Logger,
+  ) { }
+
+  // ── Connectivity ────────────────────────────────────────────────────────
+
+  /**
+   * Call auth.test to verify the bot token and get bot info.
+   */
+  async authTest(): Promise<{ ok: true; botId: string; teamName: string } | { ok: false; error: string }> {
+    const res = await slackFetch<{ bot_id: string; team: string }>(
+      this.token,
+      "auth.test",
+      {},
+      this.log,
+    );
+    if (res.ok) {
+      return {
+        ok: true,
+        botId: (res as any).bot_id ?? (res as any).user_id ?? "unknown",
+        teamName: (res as any).team ?? "unknown",
+      };
+    }
+    return { ok: false, error: res.error ?? "unknown error" };
+  }
+
+  // ── Messaging ───────────────────────────────────────────────────────────
+
+  /**
+   * Send a message with Block Kit blocks to a channel or DM.
+   * For DMs, pass the user's Slack ID as channelId — Slack opens the DM automatically.
+   * Returns the message timestamp (ts) on success, null on failure.
+   */
+  async postMessage(
+    channelId: string,
+    text: string,
+    blocks: object[],
+  ): Promise<string | null> {
+    const res = await slackFetch(
+      this.token,
+      "chat.postMessage",
+      {
+        channel: channelId,
+        text, // fallback for notifications
+        blocks,
+      },
+      this.log,
+    );
+    return res.ok ? (res.ts as string ?? null) : null;
+  }
+
+  /**
+   * Update an existing message's text and blocks.
+   * Returns true on success.
+   */
+  async updateMessage(
+    channelId: string,
+    ts: string,
+    text: string,
+    blocks: object[],
+  ): Promise<boolean> {
+    const res = await slackFetch(
+      this.token,
+      "chat.update",
+      {
+        channel: channelId,
+        ts,
+        text,
+        blocks,
+      },
+      this.log,
+    );
+    return res.ok;
+  }
+}

package/lib/slack-formatter.ts

@@ -0,0 +1,137 @@
+// ─────────────────────────────────────────────────────────────────────────────
+// telegram-approval-buttons · lib/slack-formatter.ts
+// Block Kit message formatting for Slack (approval requests & resolutions)
+// ─────────────────────────────────────────────────────────────────────────────
+
+import type { ApprovalAction, ApprovalInfo } from "../types.js";
+
+// ─── Approval request format ────────────────────────────────────────────────
+
+/**
+ * Format an approval request as Slack Block Kit blocks.
+ */
+export function formatSlackApprovalRequest(info: ApprovalInfo): object[] {
+  return [
+    {
+      type: "header",
+      text: { type: "plain_text", text: "Exec Approval", emoji: true },
+    },
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `\`\`\`${info.command}\`\`\`` },
+    },
+    {
+      type: "context",
+      elements: [
+        { type: "mrkdwn", text: `${info.agent} · \`${info.cwd}\` · ${info.expires}` },
+        { type: "mrkdwn", text: `ID: \`${info.id}\`` },
+      ],
+    },
+    ...buildSlackApprovalActions(info.id),
+  ];
+}
+
+/**
+ * Build the actions block with approval buttons.
+ */
+function buildSlackApprovalActions(approvalId: string): object[] {
+  return [
+    {
+      type: "actions",
+      block_id: `approval_${approvalId}`,
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: "Allow Once", emoji: true },
+          style: "primary",
+          action_id: "approval_allow_once",
+          value: `/approve ${approvalId} allow-once`,
+        },
+        {
+          type: "button",
+          text: { type: "plain_text", text: "Always Allow", emoji: true },
+          action_id: "approval_allow_always",
+          value: `/approve ${approvalId} allow-always`,
+        },
+        {
+          type: "button",
+          text: { type: "plain_text", text: "Deny", emoji: true },
+          style: "danger",
+          action_id: "approval_deny",
+          value: `/approve ${approvalId} deny`,
+        },
+      ],
+    },
+  ];
+}
+
+// ─── Resolved approval format ───────────────────────────────────────────────
+
+const ACTION_ICONS: Record<ApprovalAction, string> = {
+  "allow-once": ":white_check_mark:",
+  "allow-always": ":lock:",
+  deny: ":x:",
+};
+
+const ACTION_LABELS: Record<ApprovalAction, string> = {
+  "allow-once": "Allowed (once)",
+  "allow-always": "Always allowed",
+  deny: "Denied",
+};
+
+/**
+ * Format a resolved approval as Slack Block Kit blocks (no buttons).
+ */
+export function formatSlackApprovalResolved(
+  info: ApprovalInfo,
+  action: ApprovalAction,
+): object[] {
+  const icon = ACTION_ICONS[action] ?? ":white_check_mark:";
+  const label = ACTION_LABELS[action] ?? action;
+
+  return [
+    {
+      type: "header",
+      text: { type: "plain_text", text: label, emoji: true },
+    },
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `\`\`\`${info.command}\`\`\`` },
+    },
+    {
+      type: "context",
+      elements: [{ type: "mrkdwn", text: `${icon} ${info.agent} · ID: \`${info.id}\`` }],
+    },
+  ];
+}
+
+// ─── Stale approval format ──────────────────────────────────────────────────
+
+/**
+ * Format a stale/expired approval as Slack Block Kit blocks (no buttons).
+ */
+export function formatSlackApprovalExpired(info: ApprovalInfo): object[] {
+  return [
+    {
+      type: "header",
+      text: { type: "plain_text", text: "Expired", emoji: true },
+    },
+    {
+      type: "section",
+      text: { type: "mrkdwn", text: `\`\`\`${info.command}\`\`\`` },
+    },
+    {
+      type: "context",
+      elements: [{ type: "mrkdwn", text: `:clock1: ${info.agent} · ID: \`${info.id}\`` }],
+    },
+  ];
+}
+
+// ─── Fallback text ──────────────────────────────────────────────────────────
+
+/**
+ * Plain-text fallback for Slack notifications (shown in push notifications).
+ */
+export function slackFallbackText(info: ApprovalInfo): string {
+  return `Exec Approval Request — ${info.command} (${info.agent}@${info.host})`;
+}

package/lib/telegram-api.ts

@@ -61,7 +61,7 @@ export class TelegramApi {
   constructor(
     private readonly token: string,
     private readonly log?: Logger,
-  ) {}
+  ) { }
 
   // ── Connectivity ────────────────────────────────────────────────────────
 

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "telegram-approval-buttons",
   "name": "Telegram Approval Buttons",
-  "description": "Adds inline keyboard buttons to exec approval messages in Telegram. Tap to approve/deny without typing commands.",
-  "version": "4.1.0",
+  "description": "Adds inline buttons to exec approval messages in Telegram and Slack. Tap to approve/deny without typing commands.",
+  "version": "5.0.1",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -15,6 +15,14 @@
         "type": "string",
         "description": "Telegram bot token. Falls back to channels.telegram.token or TELEGRAM_BOT_TOKEN env."
       },
+      "slackBotToken": {
+        "type": "string",
+        "description": "Slack bot OAuth token. Falls back to channels.slack.token or SLACK_BOT_TOKEN env."
+      },
+      "slackChannelId": {
+        "type": "string",
+        "description": "Slack channel or DM ID for approval buttons. Falls back to channels.slack.allowFrom[0] or SLACK_CHANNEL_ID env."
+      },
       "staleMins": {
         "type": "number",
         "description": "Minutes before a pending approval is considered stale and cleaned up.",
@@ -31,14 +39,26 @@
     "chatId": {
       "label": "Telegram Chat ID",
       "placeholder": "123456789",
-      "help": "Auto-detected from channels.telegram.allowFrom if not set."
+      "help": "Auto-detected from channels.telegram.allowFrom if not set.",
+      "advanced": false
     },
     "botToken": {
-      "label": "Bot Token",
+      "label": "Telegram Bot Token",
       "sensitive": true,
       "placeholder": "Auto-detected from channels.telegram.token",
       "help": "Only needed if different from the main Telegram channel token."
     },
+    "slackBotToken": {
+      "label": "Slack Bot Token",
+      "sensitive": true,
+      "placeholder": "Auto-detected from channels.slack.token",
+      "help": "Only needed if different from the main Slack channel token."
+    },
+    "slackChannelId": {
+      "label": "Slack Channel/DM ID",
+      "placeholder": "U0123456789 or D0123456789",
+      "help": "Your Slack user ID for DM buttons, or a channel ID. Auto-detected from channels.slack.allowFrom if not set."
+    },
     "staleMins": {
       "label": "Stale Timeout (min)",
       "placeholder": "10",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "telegram-approval-buttons",
-  "version": "4.1.0",
-  "description": "Inline keyboard buttons for exec approval messages in Telegram — tap to approve/deny without typing commands",
+  "version": "5.0.1",
+  "description": "Inline buttons for exec approval messages in Telegram and Slack — tap to approve/deny without typing commands",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -16,6 +16,7 @@
     "openclaw",
     "openclaw-plugin",
     "telegram",
+    "slack",
     "approval",
     "exec",
     "inline-keyboard",

package/types.ts

@@ -25,12 +25,21 @@ export interface ApprovalInfo {
   expires: string;
 }
 
+/**
+ * Which channel the approval was sent on.
+ */
+export type ApprovalChannel = "telegram" | "slack";
+
 /**
  * A tracked approval that was sent with inline buttons.
  */
 export interface SentApproval {
-  /** Telegram message_id of our formatted message */
+  /** Which channel sent this approval */
+  channel: ApprovalChannel;
+  /** Telegram message_id (set when channel is "telegram") */
   messageId: number;
+  /** Slack message timestamp (set when channel is "slack") */
+  slackTs: string;
   /** Parsed approval details */
   info: ApprovalInfo;
   /** Unix timestamp (ms) when the message was sent */
@@ -60,6 +69,10 @@ export interface PluginConfig {
   chatId?: string;
   /** Telegram bot token (optional — falls back to channels.telegram.token) */
   botToken?: string;
+  /** Slack bot OAuth token (optional — falls back to channels.slack.token) */
+  slackBotToken?: string;
+  /** Slack channel/DM ID to send approval buttons to (optional — falls back to channels.slack config) */
+  slackChannelId?: string;
   /** Stale approval timeout in minutes (default: 10) */
   staleMins?: number;
   /** Enable verbose diagnostic logging (default: false) */
@@ -67,11 +80,27 @@ export interface PluginConfig {
 }
 
 /**
- * Resolved (validated) configuration with all defaults applied.
+ * Resolved Telegram configuration.
  */
-export interface ResolvedConfig {
+export interface ResolvedTelegramConfig {
   chatId: string;
   botToken: string;
+}
+
+/**
+ * Resolved Slack configuration.
+ */
+export interface ResolvedSlackConfig {
+  channelId: string;
+  botToken: string;
+}
+
+/**
+ * Resolved (validated) configuration with all defaults applied.
+ */
+export interface ResolvedConfig {
+  telegram: ResolvedTelegramConfig | null;
+  slack: ResolvedSlackConfig | null;
   staleMins: number;
   verbose: boolean;
 }
@@ -81,8 +110,9 @@ export interface ResolvedConfig {
  */
 export interface HealthCheck {
   ok: boolean;
-  config: { chatId: boolean; botToken: boolean };
+  config: { telegramChatId: boolean; telegramToken: boolean; slackToken: boolean; slackChannel: boolean };
   telegram: { reachable: boolean; botUsername?: string; error?: string };
+  slack: { reachable: boolean; teamName?: string; error?: string };
   store: { pending: number; totalProcessed: number };
   uptime: number;
 }