wispy-cli 1.1.2 → 1.2.2

package/lib/channels/index.mjs

@@ -1,6 +1,6 @@
 /**
  * Channel Manager — loads config, starts/stops adapters, routes messages
- * v0.7: uses core/engine.mjs and core/session.mjs for AI and session management
+ * v1.2: Harness-integrated channel approval flow (Telegram text, Discord buttons, Slack Block Kit)
  *
  * Config: ~/.wispy/channels.json
  *   {
@@ -45,6 +45,207 @@ export async function saveChannelsConfig(cfg) {
 
 let _sharedEngine = null;
 
+// Pending approval callbacks keyed by a unique request ID
+// { [reqId]: { resolve, timeout } }
+const _pendingApprovals = new Map();
+
+let _approvalIdCounter = 0;
+
+function makeApprovalId() {
+  return `appr-${Date.now().toString(36)}-${(++_approvalIdCounter).toString(36)}`;
+}
+
+const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Format an approval request message for text-based channels (Telegram, etc.)
+ */
+function formatApprovalText(action, reqId) {
+  const riskMap = {
+    run_command: "HIGH 🔴",
+    git: "HIGH 🔴",
+    keychain: "HIGH 🔴",
+    delete_file: "HIGH 🔴",
+    write_file: "MEDIUM 🟡",
+    file_edit: "MEDIUM 🟡",
+  };
+  const risk = riskMap[action.toolName] ?? "MEDIUM 🟡";
+  const args = action.args ?? {};
+  const detail = args.command
+    ? `📋 Command: \`${args.command}\``
+    : args.path
+    ? `📂 Path: \`${args.path}\``
+    : `📋 Args: \`${JSON.stringify(args).slice(0, 80)}\``;
+
+  return (
+    `⚠️ *Permission Required*\n\n` +
+    `🔧 Tool: \`${action.toolName}\`\n` +
+    `${detail}\n` +
+    `⚡ Risk: ${risk}\n` +
+    `🆔 Request: \`${reqId}\`\n\n` +
+    `Reply with:\n` +
+    `✅ \`yes\` to approve\n` +
+    `❌ \`no\` to deny\n` +
+    `👁️ \`preview\` for dry-run`
+  );
+}
+
+/**
+ * Handle an incoming approval response from a user (text reply).
+ * Returns true if this was an approval reply.
+ */
+function handleApprovalReply(text) {
+  const normalized = text.trim().toLowerCase();
+  // Check for pending approvals — any pending if user says yes/no/preview
+  if (!["yes", "no", "preview"].includes(normalized)) return false;
+
+  // Resolve the most recent pending approval
+  const entries = [..._pendingApprovals.entries()];
+  if (entries.length === 0) return false;
+
+  // Take the oldest unresolved (FIFO)
+  const [reqId, pending] = entries[0];
+  _pendingApprovals.delete(reqId);
+  clearTimeout(pending.timeout);
+
+  if (normalized === "yes") {
+    pending.resolve({ approved: true, dryRun: false });
+  } else if (normalized === "preview") {
+    pending.resolve({ approved: false, dryRun: true });
+  } else {
+    pending.resolve({ approved: false, dryRun: false });
+  }
+  return true;
+}
+
+/**
+ * Create a channel-aware approval handler for the permission manager.
+ * Sends an approval request to the channel and waits for reply.
+ */
+function makeChannelApprovalHandler(adapter, chatId, channelType) {
+  return async (action) => {
+    const reqId = makeApprovalId();
+
+    return new Promise(async (resolve) => {
+      // Timeout: auto-deny after 5 minutes
+      const timeout = setTimeout(() => {
+        _pendingApprovals.delete(reqId);
+        resolve(false);
+      }, APPROVAL_TIMEOUT_MS);
+
+      _pendingApprovals.set(reqId, { resolve: ({ approved }) => resolve(approved), timeout });
+
+      // Send approval request
+      try {
+        if (channelType === "discord") {
+          await _sendDiscordApprovalRequest(adapter, chatId, action, reqId, (result) => {
+            _pendingApprovals.delete(reqId);
+            clearTimeout(timeout);
+            resolve(result.approved);
+          });
+        } else if (channelType === "slack") {
+          await _sendSlackApprovalRequest(adapter, chatId, action, reqId, (result) => {
+            _pendingApprovals.delete(reqId);
+            clearTimeout(timeout);
+            resolve(result.approved);
+          });
+        } else {
+          // Telegram and fallback — text-based
+          const msg = formatApprovalText(action, reqId);
+          await adapter.sendMessage(chatId, msg);
+        }
+      } catch (err) {
+        console.error(`[channels] Failed to send approval request: ${err.message}`);
+        _pendingApprovals.delete(reqId);
+        clearTimeout(timeout);
+        resolve(false);
+      }
+    });
+  };
+}
+
+async function _sendDiscordApprovalRequest(adapter, chatId, action, reqId, callback) {
+  // Discord: send a message with action row buttons
+  try {
+    const { ActionRowBuilder, ButtonBuilder, ButtonStyle } = await import("discord.js");
+    const row = new ActionRowBuilder().addComponents(
+      new ButtonBuilder()
+        .setCustomId(`wispy_approve_${reqId}`)
+        .setLabel("✅ Approve")
+        .setStyle(ButtonStyle.Success),
+      new ButtonBuilder()
+        .setCustomId(`wispy_deny_${reqId}`)
+        .setLabel("❌ Deny")
+        .setStyle(ButtonStyle.Danger),
+      new ButtonBuilder()
+        .setCustomId(`wispy_preview_${reqId}`)
+        .setLabel("👁️ Preview")
+        .setStyle(ButtonStyle.Secondary),
+    );
+
+    const riskMap = { run_command: "HIGH 🔴", git: "HIGH 🔴", keychain: "HIGH 🔴", write_file: "MEDIUM 🟡", file_edit: "MEDIUM 🟡" };
+    const risk = riskMap[action.toolName] ?? "MEDIUM 🟡";
+    const args = action.args ?? {};
+    const detail = args.command ? `Command: \`${args.command}\`` : args.path ? `Path: \`${args.path}\`` : `Args: \`${JSON.stringify(args).slice(0, 60)}\``;
+
+    const channel = await adapter._client?.channels?.fetch(chatId);
+    if (channel?.send) {
+      const sentMsg = await channel.send({
+        content: `⚠️ **Permission Required**\n🔧 Tool: \`${action.toolName}\`\n${detail}\n⚡ Risk: ${risk}`,
+        components: [row],
+      });
+
+      // Store callback for button interaction
+      adapter._approvalCallbacks = adapter._approvalCallbacks ?? new Map();
+      adapter._approvalCallbacks.set(reqId, { callback, sentMsg });
+    }
+  } catch {
+    // Fallback to text
+    const msg = formatApprovalText(action, reqId);
+    await adapter.sendMessage(chatId, msg);
+  }
+}
+
+async function _sendSlackApprovalRequest(adapter, chatId, action, reqId, callback) {
+  // Slack: send Block Kit with buttons
+  try {
+    const riskMap = { run_command: "HIGH 🔴", git: "HIGH 🔴", keychain: "HIGH 🔴", write_file: "MEDIUM 🟡", file_edit: "MEDIUM 🟡" };
+    const risk = riskMap[action.toolName] ?? "MEDIUM 🟡";
+    const args = action.args ?? {};
+    const detail = args.command ? `*Command:* \`${args.command}\`` : args.path ? `*Path:* \`${args.path}\`` : `*Args:* \`${JSON.stringify(args).slice(0, 60)}\``;
+
+    const blocks = [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `⚠️ *Permission Required*\n🔧 Tool: \`${action.toolName}\`\n${detail}\n⚡ Risk: ${risk}`,
+        },
+      },
+      {
+        type: "actions",
+        elements: [
+          { type: "button", text: { type: "plain_text", text: "✅ Approve" }, style: "primary", action_id: `wispy_approve_${reqId}` },
+          { type: "button", text: { type: "plain_text", text: "❌ Deny" }, style: "danger", action_id: `wispy_deny_${reqId}` },
+          { type: "button", text: { type: "plain_text", text: "👁️ Preview" }, action_id: `wispy_preview_${reqId}` },
+        ],
+      },
+    ];
+
+    if (adapter._app?.client) {
+      await adapter._app.client.chat.postMessage({ channel: chatId, blocks, text: `Permission required for ${action.toolName}` });
+      adapter._approvalCallbacks = adapter._approvalCallbacks ?? new Map();
+      adapter._approvalCallbacks.set(reqId, { callback });
+    } else {
+      const msg = formatApprovalText(action, reqId);
+      await adapter.sendMessage(chatId, msg);
+    }
+  } catch {
+    const msg = formatApprovalText(action, reqId);
+    await adapter.sendMessage(chatId, msg);
+  }
+}
+
 async function getEngine() {
   if (_sharedEngine) return _sharedEngine;
 
@@ -65,15 +266,25 @@ Respond in the same language the user writes in.`;
 /**
  * Process a user message and return Wispy's response.
  * Uses core/engine.mjs for AI and core/session.mjs for per-chat sessions.
+ *
+ * @param {string} channelName
+ * @param {string|number} chatId
+ * @param {string} userText
+ * @param {{ adapter?, channelType? }} opts
  */
-export async function processUserMessage(channelName, chatId, userText) {
+export async function processUserMessage(channelName, chatId, userText, opts = {}) {
+  // Check if this is a pending approval reply
+  if (handleApprovalReply(userText)) {
+    return null; // handled — no AI response needed
+  }
+
   // Handle __CLEAR__ signal
   if (userText === "__CLEAR__") {
     const key = `${channelName}:${chatId}`;
     const session = await sessionManager.getOrCreate(key, { channel: channelName });
     sessionManager.clear(session.id);
     await sessionManager.save(session.id);
-    return null; // Caller should send confirmation
+    return null;
   }
 
   const engine = await getEngine();
@@ -85,14 +296,25 @@ export async function processUserMessage(channelName, chatId, userText) {
   const key = `${channelName}:${chatId}`;
   const session = await sessionManager.getOrCreate(key, { channel: channelName, chatId: String(chatId) });
 
+  // Set up channel-specific approval handler
+  if (opts.adapter) {
+    engine.permissions.setApprovalHandler(
+      makeChannelApprovalHandler(opts.adapter, chatId, opts.channelType ?? channelName)
+    );
+  }
+
   try {
     const result = await engine.processMessage(session.id, userText, {
       systemPrompt: CHANNEL_SYSTEM_PROMPT,
       noSave: false,
+      channel: channelName,
     });
     return result.content;
   } catch (err) {
     return `❌ Error: ${err.message.slice(0, 200)} 🌿`;
+  } finally {
+    // Reset approval handler to CLI default after each message
+    engine.permissions.setApprovalHandler(null);
   }
 }
 
@@ -138,7 +360,10 @@ export class ChannelManager {
         adapter.onMessage(async ({ chatId, userId, username, text }) => {
           console.log(`[${name}] ${username}: ${text.slice(0, 80)}`);
           try {
-            const reply = await processUserMessage(name, chatId, text);
+            const reply = await processUserMessage(name, chatId, text, {
+              adapter,
+              channelType: name,
+            });
             if (reply) {
               await adapter.sendMessage(chatId, reply);
             }