@openacp/cli 0.6.10 → 2026.41.1

package/dist/adapter-ZOANORGM.js

@@ -1,799 +0,0 @@
-import "./chunk-LGP2YGRL.js";
-import {
-  ChannelAdapter
-} from "./chunk-LBIKITQT.js";
-import "./chunk-NAMYZIS5.js";
-import "./chunk-WTZDAYZX.js";
-import "./chunk-UKT3G5IA.js";
-import "./chunk-34M4OS5P.js";
-import "./chunk-MKHUZLII.js";
-import "./chunk-2CJ46J3C.js";
-import "./chunk-LCRLAV4G.js";
-import "./chunk-JKBFUAJK.js";
-import "./chunk-VOIJ6OY4.js";
-import "./chunk-JHYXKVV2.js";
-import "./chunk-33RP6K2O.js";
-import {
-  createChildLogger
-} from "./chunk-GAK6PIBW.js";
-import "./chunk-VUNV25KB.js";
-
-// src/adapters/slack/adapter.ts
-import fs from "fs";
-import { App } from "@slack/bolt";
-import { WebClient } from "@slack/web-api";
-
-// src/adapters/slack/send-queue.ts
-import PQueue from "p-queue";
-var METHOD_RPM = {
-  "chat.postMessage": 50,
-  // Tier 3
-  "chat.update": 50,
-  // Tier 3
-  "conversations.create": 20,
-  // Tier 2
-  "conversations.rename": 20,
-  // Tier 2
-  "conversations.archive": 20,
-  // Tier 2
-  "conversations.invite": 20,
-  // Tier 2
-  "conversations.join": 20,
-  // Tier 2
-  "conversations.unarchive": 20,
-  // Tier 2
-  "conversations.info": 50
-  // Tier 3
-};
-var SlackSendQueue = class {
-  constructor(client) {
-    this.client = client;
-    for (const [method, rpm] of Object.entries(METHOD_RPM)) {
-      this.queues.set(method, new PQueue({
-        interval: Math.ceil(6e4 / rpm),
-        intervalCap: 1,
-        carryoverConcurrencyCount: true
-      }));
-    }
-  }
-  queues = /* @__PURE__ */ new Map();
-  async enqueue(method, params) {
-    const queue = this.queues.get(method);
-    if (!queue) throw new Error(`Unknown Slack method: ${method}`);
-    return queue.add(() => this.client.apiCall(method, params));
-  }
-};
-
-// src/adapters/slack/utils.ts
-function isAudioClip(file) {
-  return file.mimetype === "video/mp4" && file.name?.startsWith("audio_message") || file.mimetype?.startsWith("audio/");
-}
-var SECTION_LIMIT = 3e3;
-function splitSafe(text, limit = SECTION_LIMIT) {
-  if (text.length <= limit) return [text];
-  const chunks = [];
-  let remaining = text;
-  while (remaining.length > 0) {
-    if (remaining.length <= limit) {
-      chunks.push(remaining);
-      break;
-    }
-    let cut = remaining.lastIndexOf("\n", limit);
-    if (cut <= 0) cut = limit;
-    chunks.push(remaining.slice(0, cut));
-    remaining = remaining.slice(cut).trimStart();
-  }
-  return chunks;
-}
-
-// src/adapters/slack/formatter.ts
-function markdownToMrkdwn(text) {
-  return text.replace(/^#{1,6}\s+(.+)$/gm, "\0BOLD\0$1\0BOLD\0").replace(/\*\*(.+?)\*\*/g, "\0BOLD\0$1\0BOLD\0").replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "_$1_").replace(/\x00BOLD\x00(.+?)\x00BOLD\x00/g, "*$1*").replace(/~~(.+?)~~/g, "~$1~").replace(/\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g, "<$2|$1>").replace(/^[ \t]*[-*]\s+/gm, "\u2022 ").trim();
-}
-var SECTION_LIMIT2 = 3e3;
-function section(text) {
-  return { type: "section", text: { type: "mrkdwn", text: text.slice(0, SECTION_LIMIT2) } };
-}
-function context(text) {
-  return { type: "context", elements: [{ type: "mrkdwn", text }] };
-}
-var SlackFormatter = class {
-  formatOutgoing(message) {
-    switch (message.type) {
-      case "text": {
-        const text = message.text ?? "";
-        if (!text.trim()) return [];
-        const converted = markdownToMrkdwn(text);
-        return splitSafe(converted).map((chunk) => section(chunk));
-      }
-      case "thought":
-        return [context(`\u{1F4AD} _${(message.text ?? "").slice(0, 500)}_`)];
-      case "tool_call": {
-        const name = message.metadata?.name ?? "tool";
-        const input = message.metadata?.input;
-        const inputStr = input ? `
-\`\`\`
-${JSON.stringify(input, null, 2).slice(0, 500)}
-\`\`\`` : "";
-        return [context(`\u{1F527} \`${name}\`${inputStr}`)];
-      }
-      case "tool_update": {
-        const name = message.metadata?.name ?? "tool";
-        const status = message.metadata?.status ?? "done";
-        const icon = status === "error" ? "\u274C" : "\u2705";
-        return [context(`${icon} \`${name}\` \u2014 ${status}`)];
-      }
-      case "plan":
-        return [
-          { type: "divider" },
-          section(`\u{1F4CB} *Plan*
-${message.text ?? ""}`)
-        ];
-      case "usage": {
-        const meta = message.metadata ?? {};
-        const parts = [
-          meta.input_tokens != null ? `in: ${meta.input_tokens}` : null,
-          meta.output_tokens != null ? `out: ${meta.output_tokens}` : null,
-          meta.cost_usd != null ? `$${Number(meta.cost_usd).toFixed(4)}` : null
-        ].filter((p) => p !== null);
-        return parts.length ? [context(`\u{1F4CA} ${parts.join(" \xB7 ")}`)] : [];
-      }
-      case "session_end":
-        return this.formatSessionEnd(message.text);
-      case "error":
-        return [section(`\u26A0\uFE0F *Error:* ${message.text ?? "Unknown error"}`)];
-      default:
-        return [];
-    }
-  }
-  formatPermissionRequest(req) {
-    return [
-      section(`\u{1F510} *Permission Request*
-${req.description}`),
-      {
-        type: "actions",
-        block_id: `perm_${req.id}`,
-        elements: req.options.map((opt) => ({
-          type: "button",
-          text: { type: "plain_text", text: opt.label, emoji: true },
-          value: `${req.id}:${opt.id}`,
-          action_id: `perm_action_${opt.id}_${req.id}`,
-          style: opt.isAllow ? "primary" : "danger"
-        }))
-      }
-    ];
-  }
-  formatNotification(text) {
-    return [section(text)];
-  }
-  formatSessionEnd(reason) {
-    return [
-      { type: "divider" },
-      context(`\u2705 Session ended${reason ? ` \u2014 ${reason}` : ""}`)
-    ];
-  }
-};
-
-// src/adapters/slack/slug.ts
-import { customAlphabet } from "nanoid";
-var nanoidAlpha = customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 4);
-function toSlug(name, prefix = "openacp") {
-  const base = name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 60);
-  const suffix = nanoidAlpha();
-  return `${prefix}-${base}-${suffix}`.replace(/-+/g, "-");
-}
-
-// src/adapters/slack/channel-manager.ts
-var SlackChannelManager = class {
-  constructor(queue, config) {
-    this.queue = queue;
-    this.config = config;
-  }
-  async createChannel(sessionId, sessionName) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt++) {
-      const finalSlug = toSlug(sessionName, this.config.channelPrefix ?? "openacp");
-      try {
-        const res = await this.queue.enqueue(
-          "conversations.create",
-          { name: finalSlug, is_private: true }
-        );
-        const channelId = res.channel.id;
-        const userIds = this.config.allowedUserIds ?? [];
-        if (userIds.length > 0) {
-          await this.queue.enqueue("conversations.invite", {
-            channel: channelId,
-            users: userIds.join(",")
-          });
-        }
-        return { channelId, channelSlug: finalSlug };
-      } catch (err) {
-        if (err?.data?.error === "name_taken" && attempt < 2) {
-          lastError = err;
-          continue;
-        }
-        throw err;
-      }
-    }
-    throw lastError;
-  }
-  async archiveChannel(channelId) {
-    await this.queue.enqueue("conversations.archive", { channel: channelId });
-  }
-  async notifyChannel(text) {
-    if (this.config.notificationChannelId) {
-      await this.queue.enqueue("chat.postMessage", {
-        channel: this.config.notificationChannelId,
-        text
-      });
-    }
-  }
-};
-
-// src/adapters/slack/permission-handler.ts
-var SlackPermissionHandler = class {
-  constructor(queue, onResponse) {
-    this.queue = queue;
-    this.onResponse = onResponse;
-  }
-  pendingMessages = /* @__PURE__ */ new Map();
-  trackPendingMessage(requestId, channelId, messageTs) {
-    this.pendingMessages.set(requestId, { channelId, messageTs });
-  }
-  async cleanupSession(channelId) {
-    for (const [requestId, info] of this.pendingMessages) {
-      if (info.channelId !== channelId) continue;
-      await this.queue.enqueue("chat.update", {
-        channel: info.channelId,
-        ts: info.messageTs,
-        blocks: []
-      });
-      this.pendingMessages.delete(requestId);
-    }
-  }
-  register(app) {
-    app.action(
-      /^perm_action_/,
-      async ({ ack, body, action }) => {
-        await ack();
-        const value = action.value ?? "";
-        const colonIdx = value.indexOf(":");
-        if (colonIdx === -1) return;
-        const requestId = value.slice(0, colonIdx);
-        const optionId = value.slice(colonIdx + 1);
-        this.onResponse(requestId, optionId);
-        this.pendingMessages.delete(requestId);
-        const message = body.message;
-        if (message) {
-          await this.queue.enqueue("chat.update", {
-            channel: body.channel?.id ?? "",
-            ts: message.ts,
-            text: `\u2705 Permission response: *${optionId}*`,
-            blocks: []
-          });
-        }
-      }
-    );
-  }
-};
-
-// src/adapters/slack/event-router.ts
-var log = createChildLogger({ module: "slack-event-router" });
-var SlackEventRouter = class {
-  constructor(sessionLookup, onIncoming, botUserId, notificationChannelId, onNewSession, config, globalAllowedUserIds = []) {
-    this.sessionLookup = sessionLookup;
-    this.onIncoming = onIncoming;
-    this.botUserId = botUserId;
-    this.notificationChannelId = notificationChannelId;
-    this.onNewSession = onNewSession;
-    this.config = config;
-    this.globalAllowedUserIds = globalAllowedUserIds;
-  }
-  isAllowedUser(userId) {
-    const slackAllowed = this.config.allowedUserIds ?? [];
-    const allowed = slackAllowed.length > 0 ? slackAllowed : this.globalAllowedUserIds;
-    if (allowed.length === 0) return true;
-    return allowed.includes(userId);
-  }
-  register(app) {
-    app.message(async ({ message }) => {
-      log.debug({ message }, "Slack raw message event");
-      const msg = message;
-      if (msg.bot_id) return;
-      const subtype = msg.subtype;
-      if (subtype && subtype !== "file_share") return;
-      const channelId = msg.channel;
-      const text = msg.text ?? "";
-      const userId = msg.user ?? "";
-      const files = msg.files?.map((f) => ({
-        id: f.id,
-        name: f.name,
-        mimetype: f.mimetype,
-        size: f.size,
-        url_private: f.url_private
-      }));
-      log.debug({ channelId, userId, text }, "Slack message received");
-      if (userId === this.botUserId) return;
-      if (!this.isAllowedUser(userId)) {
-        log.warn({ userId }, "slack: message from non-allowed user rejected");
-        return;
-      }
-      const session = this.sessionLookup(channelId);
-      if (session) {
-        log.debug({ channelId, sessionSlug: session.channelSlug }, "Routing to session");
-        this.onIncoming(session.channelSlug, text, userId, files);
-        return;
-      }
-      log.debug({ channelId, notificationChannelId: this.notificationChannelId }, "No session found for channel");
-      if (this.notificationChannelId && channelId === this.notificationChannelId) {
-        this.onNewSession(text, userId);
-        return;
-      }
-    });
-  }
-};
-
-// src/adapters/slack/text-buffer.ts
-var log2 = createChildLogger({ module: "slack-text-buffer" });
-var FLUSH_IDLE_MS = 2e3;
-var SlackTextBuffer = class {
-  constructor(channelId, sessionId, queue) {
-    this.channelId = channelId;
-    this.sessionId = sessionId;
-    this.queue = queue;
-  }
-  buffer = "";
-  timer;
-  flushPromise;
-  lastMessageTs;
-  lastPostedText;
-  append(text) {
-    if (!text) return;
-    this.buffer += text;
-    this.resetTimer();
-  }
-  resetTimer() {
-    if (this.timer) clearTimeout(this.timer);
-    this.timer = setTimeout(() => {
-      this.timer = void 0;
-      this.flush().catch((err) => log2.error({ err, sessionId: this.sessionId }, "Text buffer flush error"));
-    }, FLUSH_IDLE_MS);
-  }
-  async flush() {
-    if (this.flushPromise) return this.flushPromise;
-    const text = this.buffer.trim();
-    if (!text) return;
-    this.buffer = "";
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
-    }
-    this.flushPromise = (async () => {
-      try {
-        const converted = markdownToMrkdwn(text);
-        const chunks = splitSafe(converted);
-        for (const chunk of chunks) {
-          if (!chunk.trim()) continue;
-          const result = await this.queue.enqueue("chat.postMessage", {
-            channel: this.channelId,
-            text: chunk,
-            blocks: [{ type: "section", text: { type: "mrkdwn", text: chunk } }]
-          });
-          this.lastMessageTs = result?.ts;
-          this.lastPostedText = chunk;
-        }
-      } finally {
-        this.flushPromise = void 0;
-        if (this.buffer.trim()) {
-          await this.flush();
-        }
-      }
-    })();
-    return this.flushPromise;
-  }
-  destroy() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = void 0;
-    }
-    this.buffer = "";
-  }
-  /** Remove [TTS]...[/TTS] blocks — from buffer if unflushed, or edit posted message */
-  async stripTtsBlock() {
-    if (/\[TTS\][\s\S]*?\[\/TTS\]/.test(this.buffer)) {
-      this.buffer = this.buffer.replace(/\[TTS\][\s\S]*?\[\/TTS\]/g, "").replace(/\s{2,}/g, " ").trim();
-      return;
-    }
-    if (this.lastMessageTs && this.lastPostedText && /\[TTS\][\s\S]*?\[\/TTS\]/.test(this.lastPostedText)) {
-      const cleaned = this.lastPostedText.replace(/\[TTS\][\s\S]*?\[\/TTS\]/g, "").replace(/\s{2,}/g, " ").trim();
-      if (cleaned) {
-        await this.queue.enqueue("chat.update", {
-          channel: this.channelId,
-          ts: this.lastMessageTs,
-          text: cleaned,
-          blocks: [{ type: "section", text: { type: "mrkdwn", text: cleaned } }]
-        });
-      }
-      this.lastPostedText = cleaned;
-    }
-  }
-};
-
-// src/adapters/slack/adapter.ts
-var log3 = createChildLogger({ module: "slack" });
-var SlackAdapter = class extends ChannelAdapter {
-  app;
-  webClient;
-  queue;
-  formatter;
-  channelManager;
-  permissionHandler;
-  eventRouter;
-  sessions = /* @__PURE__ */ new Map();
-  textBuffers = /* @__PURE__ */ new Map();
-  botUserId = "";
-  slackConfig;
-  fileService;
-  constructor(core, config) {
-    super(core, config);
-    this.slackConfig = config;
-    this.formatter = new SlackFormatter();
-  }
-  async start() {
-    const { botToken, appToken, signingSecret } = this.slackConfig;
-    if (!botToken || !appToken || !signingSecret) {
-      throw new Error("Slack adapter requires botToken, appToken, and signingSecret");
-    }
-    this.app = new App({
-      token: botToken,
-      appToken,
-      signingSecret,
-      socketMode: true
-    });
-    this.webClient = new WebClient(botToken);
-    this.queue = new SlackSendQueue(this.webClient);
-    this.fileService = this.core.fileService;
-    const authResult = await this.webClient.auth.test();
-    if (!authResult.user_id) {
-      throw new Error("Slack auth.test() did not return user_id \u2014 verify botToken is valid");
-    }
-    this.botUserId = authResult.user_id;
-    log3.info({ botUserId: this.botUserId }, "Slack bot authenticated");
-    this.channelManager = new SlackChannelManager(this.queue, this.slackConfig);
-    this.permissionHandler = new SlackPermissionHandler(
-      this.queue,
-      (requestId, optionId) => {
-        for (const [sessionId, _meta] of this.sessions) {
-          const session = this.core.sessionManager.getSession(sessionId);
-          if (session && session.permissionGate.requestId === requestId) {
-            session.permissionGate.resolve(optionId);
-            log3.info({ sessionId, requestId, optionId }, "Permission resolved");
-            return;
-          }
-        }
-        log3.warn({ requestId, optionId }, "No matching session found for permission response");
-      }
-    );
-    this.permissionHandler.register(this.app);
-    this.eventRouter = new SlackEventRouter(
-      (slackChannelId) => {
-        for (const meta of this.sessions.values()) {
-          if (meta.channelId === slackChannelId) return meta;
-        }
-        return void 0;
-      },
-      (sessionChannelSlug, text, userId, files) => {
-        const processFiles = async () => {
-          if (!files?.length) return void 0;
-          const audioFiles = files.filter((f) => isAudioClip(f));
-          if (!audioFiles.length) return void 0;
-          const attachments = [];
-          for (const file of audioFiles) {
-            const buffer = await this.downloadSlackFile(file.url_private);
-            if (!buffer) continue;
-            const mimeType = file.mimetype === "video/mp4" ? "audio/mp4" : file.mimetype;
-            const sessionId = this.core.sessionManager.getSessionByThread("slack", sessionChannelSlug)?.id;
-            if (!sessionId) continue;
-            const att = await this.fileService.saveFile(sessionId, file.name, buffer, mimeType);
-            attachments.push(att);
-          }
-          return attachments.length > 0 ? attachments : void 0;
-        };
-        processFiles().then((attachments) => {
-          this.core.handleMessage({
-            channelId: "slack",
-            threadId: sessionChannelSlug,
-            userId,
-            text,
-            attachments
-          }).catch((err) => log3.error({ err }, "handleMessage error"));
-        }).catch((err) => log3.error({ err }, "Failed to process audio files"));
-      },
-      this.botUserId,
-      this.slackConfig.notificationChannelId,
-      // onNewSession: reply with guidance when user messages the notification channel
-      async (_text, _userId) => {
-        if (this.slackConfig.notificationChannelId) {
-          await this.queue.enqueue("chat.postMessage", {
-            channel: this.slackConfig.notificationChannelId,
-            text: "\u{1F4AC} To start a new session, use the `/openacp-new` slash command in any channel."
-          }).catch((err) => log3.warn({ err }, "Failed to send onNewSession reply"));
-        }
-      },
-      this.slackConfig,
-      this.core.configManager.get().security.allowedUserIds
-    );
-    this.eventRouter.register(this.app);
-    await this.app.start();
-    log3.info("Slack adapter started (Socket Mode)");
-    if (this.slackConfig.autoCreateSession !== false) {
-      await this._createStartupSession();
-    }
-  }
-  async downloadSlackFile(url) {
-    try {
-      const resp = await fetch(url, {
-        headers: { Authorization: `Bearer ${this.slackConfig.botToken}` }
-      });
-      if (!resp.ok) {
-        log3.warn({ status: resp.status }, "Failed to download Slack file");
-        return null;
-      }
-      const contentType = resp.headers.get("content-type") ?? "";
-      if (contentType.includes("text/html")) {
-        log3.warn("Slack file download returned HTML instead of binary \u2014 bot likely missing files:read scope. Reinstall the Slack app with files:read scope.");
-        return null;
-      }
-      return Buffer.from(await resp.arrayBuffer());
-    } catch (err) {
-      log3.error({ err }, "Error downloading Slack file");
-      return null;
-    }
-  }
-  async uploadAudioFile(channelId, att) {
-    const fileBuffer = await fs.promises.readFile(att.filePath);
-    await this.webClient.files.uploadV2({
-      channel_id: channelId,
-      file: fileBuffer,
-      filename: att.fileName
-    });
-  }
-  async _createStartupSession() {
-    try {
-      let reuseChannelId = this.slackConfig.startupChannelId;
-      if (reuseChannelId) {
-        try {
-          const info = await this.queue.enqueue(
-            "conversations.info",
-            { channel: reuseChannelId }
-          );
-          const channel = info?.channel;
-          if (!channel || typeof channel.is_archived !== "boolean") {
-            log3.warn({ reuseChannelId }, "Unexpected conversations.info response shape, creating new channel");
-            reuseChannelId = void 0;
-          } else if (channel.is_archived) {
-            await this.queue.enqueue("conversations.unarchive", { channel: reuseChannelId });
-            log3.info({ channelId: reuseChannelId }, "Unarchived startup channel for reuse");
-          }
-        } catch {
-          reuseChannelId = void 0;
-        }
-      }
-      if (reuseChannelId) {
-        let hasSession = false;
-        for (const m of this.sessions.values()) {
-          if (m.channelId === reuseChannelId) {
-            hasSession = true;
-            break;
-          }
-        }
-        if (!hasSession) {
-          const session = await this.core.handleNewSession("slack", void 0, void 0, { createThread: false });
-          const slug = `startup-${session.id.slice(0, 8)}`;
-          this.sessions.set(session.id, { channelId: reuseChannelId, channelSlug: slug });
-          session.threadId = slug;
-          await this.core.sessionManager.patchRecord(session.id, {
-            platform: { topicId: slug }
-          });
-          log3.info({ sessionId: session.id, channelId: reuseChannelId }, "Reused startup channel");
-        }
-      } else {
-        const session = await this.core.handleNewSession("slack", void 0, void 0, { createThread: true });
-        if (!session.threadId) {
-          log3.error({ sessionId: session.id }, "Startup session created without threadId");
-          return;
-        }
-        const meta = this.sessions.get(session.id);
-        if (meta) {
-          await this.core.configManager.save(
-            { channels: { slack: { startupChannelId: meta.channelId } } }
-          );
-          log3.info({ sessionId: session.id, channelId: meta.channelId }, "Saved startup channel to config");
-        }
-      }
-      if (this.slackConfig.notificationChannelId) {
-        const startupMeta = [...this.sessions.values()].find(
-          (m) => m.channelId === (reuseChannelId ?? this.slackConfig.startupChannelId)
-        );
-        if (startupMeta) {
-          await this.queue.enqueue("chat.postMessage", {
-            channel: this.slackConfig.notificationChannelId,
-            text: `\u2705 OpenACP ready \u2014 chat with the agent in <#${startupMeta.channelId}>`
-          });
-        }
-      }
-    } catch (err) {
-      log3.error({ err }, "Failed to create/reuse Slack startup session");
-    }
-  }
-  async stop() {
-    for (const [sessionId, buf] of this.textBuffers) {
-      try {
-        await buf.flush();
-      } catch (err) {
-        log3.warn({ err, sessionId }, "Flush failed during stop");
-      }
-      buf.destroy();
-    }
-    this.textBuffers.clear();
-    await this.app.stop();
-    log3.info("Slack adapter stopped");
-  }
-  // --- ChannelAdapter implementations ---
-  async createSessionThread(sessionId, name) {
-    const meta = await this.channelManager.createChannel(sessionId, name);
-    this.sessions.set(sessionId, meta);
-    log3.info({ sessionId, channelId: meta.channelId, slug: meta.channelSlug }, "Session channel created");
-    return meta.channelSlug;
-  }
-  async renameSessionThread(sessionId, newName) {
-    const meta = this.sessions.get(sessionId);
-    if (!meta) return;
-    const newSlug = toSlug(newName, this.slackConfig.channelPrefix ?? "openacp");
-    try {
-      await this.queue.enqueue("conversations.rename", {
-        channel: meta.channelId,
-        name: newSlug
-      });
-      meta.channelSlug = newSlug;
-      const session = this.core.sessionManager.getSession(sessionId);
-      if (session) session.threadId = newSlug;
-      const existingRecord = this.core.sessionManager.getSessionRecord(sessionId);
-      await this.core.sessionManager.patchRecord(sessionId, {
-        name: newName,
-        platform: { ...existingRecord?.platform ?? {}, topicId: newSlug }
-      });
-      log3.info({ sessionId, newSlug }, "Session channel renamed");
-    } catch (err) {
-      log3.warn({ err, sessionId }, "Failed to rename Slack channel");
-    }
-  }
-  async deleteSessionThread(sessionId) {
-    const meta = this.sessions.get(sessionId);
-    if (!meta) return;
-    try {
-      await this.permissionHandler.cleanupSession(meta.channelId);
-    } catch (err) {
-      log3.warn({ err, sessionId }, "Failed to clean up permission buttons");
-    }
-    try {
-      await this.channelManager.archiveChannel(meta.channelId);
-      log3.info({ sessionId, channelId: meta.channelId }, "Session channel archived");
-    } catch (err) {
-      log3.warn({ err, sessionId }, "Failed to archive Slack channel");
-    }
-    this.sessions.delete(sessionId);
-    const buf = this.textBuffers.get(sessionId);
-    if (buf) {
-      buf.destroy();
-      this.textBuffers.delete(sessionId);
-    }
-  }
-  getTextBuffer(sessionId, channelId) {
-    let buf = this.textBuffers.get(sessionId);
-    if (!buf) {
-      buf = new SlackTextBuffer(channelId, sessionId, this.queue);
-      this.textBuffers.set(sessionId, buf);
-    }
-    return buf;
-  }
-  async sendMessage(sessionId, content) {
-    const meta = this.sessions.get(sessionId);
-    if (!meta) {
-      log3.warn({ sessionId }, "No Slack channel for session, skipping message");
-      return;
-    }
-    if (content.type === "text") {
-      const buf = this.getTextBuffer(sessionId, meta.channelId);
-      buf.append(content.text ?? "");
-      return;
-    }
-    if (content.type === "session_end" || content.type === "error") {
-      const buf = this.textBuffers.get(sessionId);
-      if (buf) {
-        try {
-          await buf.flush();
-        } catch (err) {
-          log3.warn({ err, sessionId }, "Flush failed on session_end");
-        }
-        buf.destroy();
-        this.textBuffers.delete(sessionId);
-      }
-    }
-    if (content.type === "attachment" && content.attachment) {
-      if (content.attachment.type === "audio") {
-        try {
-          await this.uploadAudioFile(meta.channelId, content.attachment);
-          const buf = this.textBuffers.get(sessionId);
-          if (buf) await buf.stripTtsBlock();
-        } catch (err) {
-          log3.error({ err, sessionId }, "Failed to upload audio to Slack");
-        }
-      }
-      return;
-    }
-    const blocks = this.formatter.formatOutgoing(content);
-    if (blocks.length === 0) return;
-    try {
-      await this.queue.enqueue("chat.postMessage", {
-        channel: meta.channelId,
-        text: content.text ?? content.type,
-        blocks
-      });
-    } catch (err) {
-      log3.error({ err, sessionId, type: content.type }, "Failed to post Slack message");
-    }
-  }
-  // NOTE: Async flow — different from Telegram adapter.
-  // Telegram: sendPermissionRequest awaits user response inline.
-  // Slack: posts interactive buttons and returns immediately.
-  // Resolution happens asynchronously via the Bolt action handler in
-  // SlackPermissionHandler, which calls the PermissionResponseCallback
-  // passed during construction. The callback iterates sessions to find
-  // the matching permissionGate and resolves it.
-  async sendPermissionRequest(sessionId, request) {
-    const meta = this.sessions.get(sessionId);
-    if (!meta) return;
-    log3.info({ sessionId, requestId: request.id }, "Sending Slack permission request");
-    const blocks = this.formatter.formatPermissionRequest(request);
-    try {
-      const result = await this.queue.enqueue("chat.postMessage", {
-        channel: meta.channelId,
-        text: `Permission request: ${request.description}`,
-        blocks
-      });
-      const ts = result?.ts;
-      if (ts) {
-        this.permissionHandler.trackPendingMessage(request.id, meta.channelId, ts);
-      }
-    } catch (err) {
-      log3.error({ err, sessionId }, "Failed to post Slack permission request");
-    }
-  }
-  async sendNotification(notification) {
-    if (!this.slackConfig.notificationChannelId) return;
-    const emoji = {
-      completed: "\u2705",
-      error: "\u274C",
-      permission: "\u{1F510}",
-      input_required: "\u{1F4AC}"
-    };
-    const icon = emoji[notification.type] ?? "\u2139\uFE0F";
-    const text = `${icon} *${notification.sessionName ?? "Session"}*
-${notification.summary}`;
-    const blocks = this.formatter.formatNotification(text);
-    try {
-      await this.queue.enqueue("chat.postMessage", {
-        channel: this.slackConfig.notificationChannelId,
-        text,
-        blocks
-      });
-    } catch (err) {
-      log3.warn({ err, sessionId: notification.sessionId }, "Failed to send Slack notification");
-    }
-  }
-};
-export {
-  SlackAdapter
-};
-//# sourceMappingURL=adapter-ZOANORGM.js.map