@cuylabs/channel-slack-agent-core 0.1.0

package/dist/chunk-IXY3BXU5.js

@@ -0,0 +1,689 @@
+// src/interactive/store.ts
+function createInMemorySlackInteractiveRequestStore() {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    async get(requestId) {
+      const record = records.get(requestId);
+      return record ? cloneRecord(record) : void 0;
+    },
+    async upsert(record) {
+      const existing = records.get(record.id);
+      if (existing?.status === "resolved") {
+        return cloneRecord(existing);
+      }
+      const next = existing ? {
+        ...existing,
+        ...record,
+        target: record.target ?? existing.target,
+        resolution: record.resolution ?? existing.resolution,
+        updatedAt: nowIso()
+      } : { ...record };
+      records.set(record.id, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async attachTarget(requestId, target) {
+      const existing = records.get(requestId);
+      if (!existing) return void 0;
+      const next = {
+        ...existing,
+        target: cloneTarget(target),
+        updatedAt: nowIso()
+      };
+      records.set(requestId, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async resolve(requestId, resolution) {
+      const existing = records.get(requestId);
+      if (!existing) return void 0;
+      if (existing.status === "resolved") {
+        return cloneRecord(existing);
+      }
+      const next = {
+        ...existing,
+        status: "resolved",
+        resolution: cloneResolution(resolution),
+        updatedAt: nowIso()
+      };
+      records.set(requestId, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async delete(requestId) {
+      records.delete(requestId);
+    }
+  };
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneRecord(record) {
+  return {
+    ...record,
+    request: structuredClone(record.request),
+    ...record.target ? { target: cloneTarget(record.target) } : {},
+    ...record.resolution ? { resolution: cloneResolution(record.resolution) } : {}
+  };
+}
+function cloneTarget(target) {
+  return { ...target };
+}
+function cloneResolution(resolution) {
+  return structuredClone(resolution);
+}
+
+// src/interactive/blocks.ts
+var MAX_BLOCK_TEXT = 2800;
+function buildApprovalRequestMessage(request, actionIds) {
+  const rememberScopes = request.rememberScopes ?? [];
+  const canRemember = rememberScopes.length > 0 || Boolean(request.defaultRememberScope);
+  const text = `Approval required for ${request.tool}`;
+  return {
+    text,
+    blocks: [
+      section(
+        `*Approval required*
+${escapeMrkdwn(request.description || request.tool)}`
+      ),
+      fields([
+        `*Tool*
+${escapeMrkdwn(request.tool)}`,
+        `*Risk*
+${escapeMrkdwn(request.risk)}`
+      ]),
+      section(`*Arguments*
+\`\`\`${truncate(formatArgs(request.args))}\`\`\``),
+      {
+        type: "actions",
+        elements: [
+          button("Allow", "primary", actionIds.approvalAllow, {
+            requestId: request.id
+          }),
+          button("Deny", "danger", actionIds.approvalDeny, {
+            requestId: request.id
+          }),
+          ...canRemember ? [
+            button("Remember", void 0, actionIds.approvalRemember, {
+              requestId: request.id,
+              rememberScope: request.defaultRememberScope ?? rememberScopes[0]
+            })
+          ] : []
+        ]
+      }
+    ]
+  };
+}
+function buildHumanInputRequestMessage(request, actionIds) {
+  const text = request.title || "Input required";
+  const confirmLabel = request.confirmLabel ?? "Submit";
+  const denyLabel = request.denyLabel ?? "Cancel";
+  if (request.kind === "confirm") {
+    return {
+      text,
+      blocks: [
+        section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(request.question)}`),
+        {
+          type: "actions",
+          elements: [
+            button(confirmLabel, "primary", actionIds.humanConfirm, {
+              requestId: request.id
+            }),
+            button(denyLabel, "danger", actionIds.humanDeny, {
+              requestId: request.id
+            })
+          ]
+        }
+      ]
+    };
+  }
+  return {
+    text,
+    blocks: [
+      section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(request.question)}`),
+      {
+        type: "actions",
+        elements: [
+          button(confirmLabel, "primary", actionIds.humanOpen, {
+            requestId: request.id
+          }),
+          button(denyLabel, "danger", actionIds.humanDeny, {
+            requestId: request.id
+          })
+        ]
+      }
+    ]
+  };
+}
+function buildResolvedMessage(label, resolution) {
+  const text = resolution.kind === "approval" ? resolution.action === "deny" ? "Approval denied" : "Approval granted" : "Input submitted";
+  return {
+    text,
+    blocks: [section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(label)}`)]
+  };
+}
+function buildHumanInputModal(request, actionIds) {
+  const title = truncatePlain(request.title || "Input required", 24);
+  const submit = truncatePlain(request.confirmLabel ?? "Submit", 24);
+  const close = truncatePlain(request.denyLabel ?? "Cancel", 24);
+  if (request.kind === "choice") {
+    const options = (request.options ?? []).slice(0, 100).map((option) => ({
+      text: {
+        type: "plain_text",
+        text: truncatePlain(option.label, 75)
+      },
+      value: option.value ?? option.label,
+      ...option.description ? {
+        description: {
+          type: "plain_text",
+          text: truncatePlain(option.description, 75)
+        }
+      } : {}
+    }));
+    return {
+      type: "modal",
+      callback_id: actionIds.humanSubmit,
+      private_metadata: JSON.stringify({ requestId: request.id }),
+      title: { type: "plain_text", text: title },
+      submit: { type: "plain_text", text: submit },
+      close: { type: "plain_text", text: close },
+      blocks: [
+        {
+          type: "input",
+          block_id: "input",
+          label: {
+            type: "plain_text",
+            text: truncatePlain(request.question, 200)
+          },
+          element: {
+            type: request.allowMultiple ? "checkboxes" : "radio_buttons",
+            action_id: "value",
+            options
+          }
+        }
+      ]
+    };
+  }
+  return {
+    type: "modal",
+    callback_id: actionIds.humanSubmit,
+    private_metadata: JSON.stringify({ requestId: request.id }),
+    title: { type: "plain_text", text: title },
+    submit: { type: "plain_text", text: submit },
+    close: { type: "plain_text", text: close },
+    blocks: [
+      {
+        type: "input",
+        block_id: "input",
+        label: {
+          type: "plain_text",
+          text: truncatePlain(request.question, 200)
+        },
+        element: {
+          type: "plain_text_input",
+          action_id: "value",
+          multiline: true,
+          ...request.placeholder ? {
+            placeholder: {
+              type: "plain_text",
+              text: truncatePlain(request.placeholder, 150)
+            }
+          } : {}
+        }
+      }
+    ]
+  };
+}
+function encodeActionValue(payload) {
+  return JSON.stringify(payload);
+}
+function decodeActionValue(value) {
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function button(text, style, actionId, value) {
+  return {
+    type: "button",
+    text: { type: "plain_text", text },
+    action_id: actionId,
+    value: encodeActionValue(value),
+    ...style ? { style } : {}
+  };
+}
+function section(text) {
+  return { type: "section", text: { type: "mrkdwn", text: truncate(text) } };
+}
+function fields(items) {
+  return {
+    type: "section",
+    fields: items.map((text) => ({ type: "mrkdwn", text: truncate(text) }))
+  };
+}
+function formatArgs(args) {
+  if (typeof args === "string") return args;
+  try {
+    return JSON.stringify(args, null, 2);
+  } catch {
+    return String(args);
+  }
+}
+function truncate(value, max = MAX_BLOCK_TEXT) {
+  return value.length <= max ? value : `${value.slice(0, max - 3)}...`;
+}
+function truncatePlain(value, max) {
+  const normalized = value.trim() || "Input";
+  return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+function escapeMrkdwn(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/interactive/controller.ts
+var DEFAULT_NAMESPACE = "agent_slack";
+var DEFAULT_REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
+var installedActionIds = /* @__PURE__ */ new WeakMap();
+function createSlackInteractiveController(options = {}) {
+  const store = options.store ?? createInMemorySlackInteractiveRequestStore();
+  const actionIds = resolveActionIds(
+    options.namespace ?? DEFAULT_NAMESPACE,
+    options.actionIds
+  );
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const waiters = /* @__PURE__ */ new Map();
+  const pendingIds = /* @__PURE__ */ new Set();
+  async function ensurePending(kind, request) {
+    const existing = await store.get(request.id);
+    if (existing) {
+      pendingIds.add(request.id);
+      return existing;
+    }
+    const createdAt = nowIso();
+    const record = await store.upsert({
+      id: request.id,
+      kind,
+      request,
+      status: "pending",
+      createdAt,
+      updatedAt: createdAt
+    });
+    pendingIds.add(request.id);
+    return record;
+  }
+  async function waitForResolution(kind, request, waitOptions = {}) {
+    const existing = await ensurePending(kind, request);
+    if (existing.status === "resolved" && existing.resolution) {
+      return existing.resolution;
+    }
+    if (waiters.has(request.id)) {
+      throw new Error(
+        `Slack interactive request is already waiting: ${request.id}. Resolve or cancel the in-flight request before requesting again.`
+      );
+    }
+    return await new Promise((resolve, reject) => {
+      const cleanupCallbacks = [];
+      const timeoutMs = waitOptions.timeoutMs ?? requestTimeoutMs;
+      if (timeoutMs > 0) {
+        const timeoutId = setTimeout(() => {
+          void cancel(request.id, "Slack interactive request timed out.");
+        }, timeoutMs);
+        cleanupCallbacks.push(() => clearTimeout(timeoutId));
+      }
+      let abortImmediately = false;
+      if (waitOptions.signal) {
+        const onAbort = () => {
+          void cancel(request.id, "Slack interactive request aborted.");
+        };
+        if (waitOptions.signal.aborted) {
+          abortImmediately = true;
+        } else {
+          waitOptions.signal.addEventListener("abort", onAbort, {
+            once: true
+          });
+          cleanupCallbacks.push(
+            () => waitOptions.signal?.removeEventListener("abort", onAbort)
+          );
+        }
+      }
+      waiters.set(request.id, {
+        resolve,
+        reject,
+        cleanup: () => {
+          for (const cleanup of cleanupCallbacks.splice(0)) {
+            cleanup();
+          }
+        }
+      });
+      if (abortImmediately) {
+        void cancel(request.id, "Slack interactive request aborted.");
+      }
+    });
+  }
+  async function resolveRequest(requestId, resolution) {
+    const record = await store.resolve(requestId, resolution);
+    const waiter = waiters.get(requestId);
+    if (waiter) {
+      waiters.delete(requestId);
+      waiter.cleanup();
+      waiter.resolve(resolution);
+    }
+    if (record) {
+      pendingIds.delete(requestId);
+      await options.onResolve?.(requestId, resolution);
+    }
+    return record;
+  }
+  async function cancel(requestId, reason = "Cancelled") {
+    const waiter = waiters.get(requestId);
+    if (waiter) {
+      waiters.delete(requestId);
+      waiter.cleanup();
+      waiter.reject(new Error(reason));
+    }
+    const existing = await store.get(requestId);
+    if (existing?.status === "pending") {
+      await store.delete(requestId);
+      pendingIds.delete(requestId);
+      return true;
+    }
+    pendingIds.delete(requestId);
+    return Boolean(waiter);
+  }
+  async function cancelAll(reason = "Cancelled") {
+    await Promise.all(
+      [...pendingIds].map((requestId) => cancel(requestId, reason))
+    );
+  }
+  async function handleInteractiveRequest(context) {
+    const request = context.request;
+    const record = await ensurePending(context.kind, request);
+    if (record.target) {
+      return true;
+    }
+    const message = context.kind === "approval" ? buildApprovalRequestMessage(
+      request,
+      actionIds
+    ) : buildHumanInputRequestMessage(
+      request,
+      actionIds
+    );
+    const ref = await context.responder.postMessage(message);
+    await store.attachTarget(request.id, {
+      channel: ref.channel,
+      ts: ref.ts,
+      userId: context.user.userId,
+      teamId: context.user.teamId,
+      ...context.slackActivity.threadTs ? { threadTs: context.slackActivity.threadTs } : {}
+    });
+    return true;
+  }
+  function install(app) {
+    assertActionIdsCanInstall(app, actionIds);
+    app.action(actionIds.approvalAllow, async (args) => {
+      await handleAction(args, {
+        kind: "approval",
+        action: "allow"
+      });
+    });
+    app.action(actionIds.approvalDeny, async (args) => {
+      await handleAction(args, {
+        kind: "approval",
+        action: "deny"
+      });
+    });
+    app.action(actionIds.approvalRemember, async (args) => {
+      const value = firstActionValue(args);
+      const rememberScope = typeof value.rememberScope === "string" ? value.rememberScope : void 0;
+      await handleAction(args, {
+        kind: "approval",
+        action: "remember",
+        ...rememberScope ? { rememberScope } : {}
+      });
+    });
+    app.action(actionIds.humanConfirm, async (args) => {
+      await handleAction(args, {
+        kind: "human-input",
+        response: { kind: "confirm", confirmed: true, text: "Confirmed" }
+      });
+    });
+    app.action(actionIds.humanDeny, async (args) => {
+      await handleAction(args, {
+        kind: "human-input",
+        response: { kind: "confirm", confirmed: false, text: "Cancelled" }
+      });
+    });
+    app.action(actionIds.humanOpen, async (args) => {
+      await openHumanInputModal(args);
+    });
+    app.view(actionIds.humanSubmit, async (args) => {
+      await submitHumanInputModal(args);
+    });
+  }
+  async function handleAction(args, resolutionInput) {
+    const actionArgs = args;
+    await actionArgs.ack();
+    const requestId = extractRequestId(firstActionValue(args));
+    if (!requestId) return;
+    const record = await store.get(requestId);
+    if (!record || record.status === "resolved") {
+      return;
+    }
+    const actor = extractActor(actionArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      await postEphemeral(
+        actionArgs,
+        "Only the original requester can resolve this request."
+      );
+      return;
+    }
+    const resolution = resolutionInput;
+    const resolved = await resolveRequest(requestId, resolution);
+    if (resolved?.target) {
+      await updateOriginalMessage(actionArgs, resolved, resolution);
+    }
+  }
+  async function openHumanInputModal(args) {
+    const actionArgs = args;
+    await actionArgs.ack();
+    const requestId = extractRequestId(firstActionValue(args));
+    if (!requestId || !actionArgs.body.trigger_id) return;
+    const record = await store.get(requestId);
+    if (!record || record.kind !== "human-input") return;
+    const actor = extractActor(actionArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      await postEphemeral(
+        actionArgs,
+        "Only the original requester can answer this request."
+      );
+      return;
+    }
+    await actionArgs.client.views.open({
+      trigger_id: actionArgs.body.trigger_id,
+      view: buildHumanInputModal(
+        record.request,
+        actionIds
+      )
+    });
+  }
+  async function submitHumanInputModal(args) {
+    const viewArgs = args;
+    await viewArgs.ack();
+    const requestId = extractRequestIdFromView(viewArgs.view);
+    if (!requestId) return;
+    const record = await store.get(requestId);
+    if (!record || record.kind !== "human-input" || record.status === "resolved") {
+      return;
+    }
+    const actor = extractActor(viewArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      return;
+    }
+    const response = responseFromView(
+      record.request,
+      viewArgs.view
+    );
+    const resolution = {
+      kind: "human-input",
+      response
+    };
+    const resolved = await resolveRequest(requestId, resolution);
+    if (resolved?.target) {
+      await viewArgs.client.chat.update({
+        channel: resolved.target.channel,
+        ts: resolved.target.ts,
+        ...buildResolvedMessage("Slack response received.", resolution)
+      });
+    }
+  }
+  async function isAuthorized(record, actor) {
+    if (options.authorize) {
+      return await options.authorize(record, actor);
+    }
+    return record.target?.userId === actor.userId;
+  }
+  async function updateOriginalMessage(args, record, resolution) {
+    const target = record.target;
+    if (!target) return;
+    const label = resolution.kind === "approval" ? `${resolution.action} selected.` : resolution.response.text;
+    await args.client.chat.update({
+      channel: target.channel,
+      ts: target.ts,
+      ...buildResolvedMessage(label, resolution)
+    });
+  }
+  return {
+    actionIds,
+    store,
+    approval: {
+      async onRequest(request, options2) {
+        const resolution = await waitForResolution(
+          "approval",
+          request,
+          options2
+        );
+        if (resolution.kind !== "approval") {
+          throw new Error(
+            `Unexpected human-input resolution for ${request.id}.`
+          );
+        }
+        return {
+          action: resolution.action,
+          ...resolution.feedback ? { feedback: resolution.feedback } : {},
+          ...resolution.rememberScope ? { rememberScope: resolution.rememberScope } : {}
+        };
+      }
+    },
+    humanInput: {
+      async onRequest(request, options2) {
+        const resolution = await waitForResolution(
+          "human-input",
+          request,
+          options2
+        );
+        if (resolution.kind !== "human-input") {
+          throw new Error(`Unexpected approval resolution for ${request.id}.`);
+        }
+        return resolution.response;
+      }
+    },
+    cancel,
+    cancelAll,
+    handleInteractiveRequest,
+    install
+  };
+}
+function resolveActionIds(namespace, overrides) {
+  const prefix = normalizeActionIdNamespace(namespace);
+  return {
+    approvalAllow: `${prefix}_approval_allow`,
+    approvalDeny: `${prefix}_approval_deny`,
+    approvalRemember: `${prefix}_approval_remember`,
+    humanConfirm: `${prefix}_human_confirm`,
+    humanDeny: `${prefix}_human_deny`,
+    humanOpen: `${prefix}_human_open`,
+    humanSubmit: `${prefix}_human_submit`,
+    ...overrides ?? {}
+  };
+}
+function normalizeActionIdNamespace(namespace) {
+  const trimmed = namespace.trim();
+  if (!trimmed) {
+    throw new Error("Slack interactive action namespace cannot be empty.");
+  }
+  return trimmed;
+}
+function assertActionIdsCanInstall(app, actionIds) {
+  const ids = Object.values(actionIds);
+  const duplicateWithinController = ids.find(
+    (id, index) => ids.indexOf(id) !== index
+  );
+  if (duplicateWithinController) {
+    throw new Error(
+      `Duplicate Slack interactive action id configured: ${duplicateWithinController}`
+    );
+  }
+  const appKey = app;
+  const installed = installedActionIds.get(appKey) ?? /* @__PURE__ */ new Set();
+  const duplicate = ids.find((id) => installed.has(id));
+  if (duplicate) {
+    throw new Error(
+      `Slack interactive action id '${duplicate}' is already installed on this Bolt app. Provide a unique createSlackInteractiveController({ namespace }) or actionIds config.`
+    );
+  }
+  for (const id of ids) {
+    installed.add(id);
+  }
+  installedActionIds.set(appKey, installed);
+}
+function firstActionValue(args) {
+  const body = args.body;
+  return decodeActionValue(body.actions?.[0]?.value);
+}
+function extractRequestId(value) {
+  return typeof value.requestId === "string" && value.requestId.length > 0 ? value.requestId : void 0;
+}
+function extractRequestIdFromView(view) {
+  return extractRequestId(decodeActionValue(view.private_metadata));
+}
+function extractActor(body) {
+  return {
+    userId: body.user?.id ?? "unknown",
+    ...body.user?.team_id ?? body.team?.id ? { teamId: body.user?.team_id ?? body.team?.id } : {}
+  };
+}
+async function postEphemeral(args, text) {
+  const channel = args.body.channel?.id;
+  const user = args.body.user?.id;
+  if (!channel || !user || !args.client.chat.postEphemeral) return;
+  await args.client.chat.postEphemeral({ channel, user, text });
+}
+function responseFromView(request, view) {
+  const input = view.state?.values?.input?.value;
+  if (request.kind === "choice") {
+    const selected = input?.selected_options?.map((option) => option.value ?? "").filter(Boolean) ?? (input?.selected_option?.value ? [input.selected_option.value] : []);
+    return {
+      kind: "choice",
+      selected,
+      text: selected.join(", ")
+    };
+  }
+  const text = input?.value ?? "";
+  return { kind: "text", text };
+}
+
+export {
+  createInMemorySlackInteractiveRequestStore,
+  nowIso,
+  cloneRecord,
+  buildApprovalRequestMessage,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  buildHumanInputModal,
+  encodeActionValue,
+  decodeActionValue,
+  createSlackInteractiveController
+};