@cuylabs/channel-slack-agent-core 0.7.0 → 0.9.0

package/dist/chunk-X7ILLZZP.js

@@ -1,1046 +0,0 @@
-// 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/postgres-store.ts
-var DEFAULT_TABLE = "channel_slack_interactive_requests";
-var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
-var DEFAULT_PRUNE_BATCH_SIZE = 1e3;
-var DEFAULT_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
-function createPostgresSlackInteractiveRequestStore({
-  client,
-  connectionString,
-  ensureSchema = true,
-  onPruneError,
-  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
-  pruneIntervalMs = DEFAULT_PRUNE_INTERVAL_MS,
-  retentionMs = DEFAULT_RETENTION_MS,
-  schema,
-  tableName = DEFAULT_TABLE
-}) {
-  let activeClient = client;
-  let ownsClient = false;
-  let initialized;
-  let pruneTimer;
-  async function getClient() {
-    if (activeClient) {
-      return activeClient;
-    }
-    if (!connectionString) {
-      throw new Error(
-        "connectionString is required when a Postgres Slack interactive request client is not provided"
-      );
-    }
-    const Pool = await importPostgresPoolConstructor();
-    activeClient = new Pool({ connectionString });
-    ownsClient = true;
-    return activeClient;
-  }
-  async function ensureInitialized() {
-    const currentClient = await getClient();
-    initialized ??= initializePostgresSlackInteractiveRequestStore({
-      client: currentClient,
-      ensureSchema,
-      schema,
-      tableName
-    });
-    await initialized;
-    startPruneTimer();
-    return currentClient;
-  }
-  function startPruneTimer() {
-    if (pruneTimer || pruneIntervalMs <= 0) {
-      return;
-    }
-    pruneTimer = setInterval(() => {
-      void prune().catch((error) => {
-        onPruneError?.(error);
-      });
-    }, pruneIntervalMs);
-    pruneTimer.unref?.();
-  }
-  async function prune() {
-    const currentClient = await ensureInitialized();
-    return prunePostgresSlackInteractiveRequestStore({
-      client: currentClient,
-      pruneBatchSize,
-      retentionMs,
-      schema,
-      tableName
-    });
-  }
-  return {
-    async get(requestId) {
-      const currentClient = await ensureInitialized();
-      const result = await currentClient.query(
-        `SELECT * FROM ${qualifiedTableName({
-          schema,
-          tableName
-        })} WHERE id = $1::text LIMIT 1`,
-        [requestId]
-      );
-      return rowToRecord(result.rows[0]);
-    },
-    async upsert(record) {
-      const currentClient = await ensureInitialized();
-      const result = await currentClient.query(
-        `INSERT INTO ${qualifiedTableName({
-          schema,
-          tableName
-        })} (
-          id,
-          kind,
-          request,
-          status,
-          created_at,
-          updated_at,
-          target,
-          resolution
-        )
-        VALUES (
-          $1::text,
-          $2::text,
-          $3::jsonb,
-          $4::text,
-          $5::timestamptz,
-          $6::timestamptz,
-          $7::jsonb,
-          $8::jsonb
-        )
-        ON CONFLICT (id) DO UPDATE SET
-          kind = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.kind
-            ELSE EXCLUDED.kind
-          END,
-          request = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.request
-            ELSE EXCLUDED.request
-          END,
-          status = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.status
-            ELSE EXCLUDED.status
-          END,
-          target = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.target
-            ELSE COALESCE(EXCLUDED.target, ${qualifiedTableName({
-          schema,
-          tableName
-        })}.target)
-          END,
-          resolution = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.resolution
-            ELSE COALESCE(EXCLUDED.resolution, ${qualifiedTableName({
-          schema,
-          tableName
-        })}.resolution)
-          END,
-          updated_at = CASE
-            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
-              THEN ${qualifiedTableName({ schema, tableName })}.updated_at
-            ELSE now()
-          END
-        RETURNING *`,
-        [
-          record.id,
-          record.kind,
-          JSON.stringify(record.request),
-          record.status,
-          record.createdAt,
-          record.updatedAt,
-          record.target ? JSON.stringify(record.target) : null,
-          record.resolution ? JSON.stringify(record.resolution) : null
-        ]
-      );
-      return requireReturnedRecord(result.rows[0], record.id);
-    },
-    async attachTarget(requestId, target) {
-      const currentClient = await ensureInitialized();
-      const result = await currentClient.query(
-        `UPDATE ${qualifiedTableName({ schema, tableName })}
-        SET target = $2::jsonb, updated_at = now()
-        WHERE id = $1::text
-        RETURNING *`,
-        [requestId, JSON.stringify(target)]
-      );
-      return rowToRecord(result.rows[0]);
-    },
-    async resolve(requestId, resolution) {
-      const currentClient = await ensureInitialized();
-      const result = await currentClient.query(
-        `UPDATE ${qualifiedTableName({ schema, tableName })}
-        SET status = 'resolved',
-          resolution = $2::jsonb,
-          updated_at = now()
-        WHERE id = $1::text AND status <> 'resolved'
-        RETURNING *`,
-        [requestId, JSON.stringify(resolution)]
-      );
-      const resolved = rowToRecord(result.rows[0]);
-      if (resolved) {
-        return resolved;
-      }
-      const existing = await currentClient.query(
-        `SELECT * FROM ${qualifiedTableName({
-          schema,
-          tableName
-        })} WHERE id = $1::text LIMIT 1`,
-        [requestId]
-      );
-      return rowToRecord(existing.rows[0]);
-    },
-    async delete(requestId) {
-      const currentClient = await ensureInitialized();
-      await currentClient.query(
-        `DELETE FROM ${qualifiedTableName({
-          schema,
-          tableName
-        })} WHERE id = $1::text`,
-        [requestId]
-      );
-    },
-    prune,
-    async close() {
-      if (pruneTimer) {
-        clearInterval(pruneTimer);
-        pruneTimer = void 0;
-      }
-      if (ownsClient) {
-        await activeClient?.end?.();
-      }
-    }
-  };
-}
-async function initializePostgresSlackInteractiveRequestStore({
-  client,
-  ensureSchema = true,
-  schema,
-  tableName = DEFAULT_TABLE
-}) {
-  if (schema && ensureSchema) {
-    await client.query(
-      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schema)}`
-    );
-  }
-  const table = qualifiedTableName({ schema, tableName });
-  await client.query(`
-    CREATE TABLE IF NOT EXISTS ${table} (
-      id text PRIMARY KEY,
-      kind text NOT NULL CHECK (kind IN ('approval', 'human-input')),
-      request jsonb NOT NULL,
-      status text NOT NULL CHECK (status IN ('pending', 'resolved')),
-      target jsonb,
-      resolution jsonb,
-      created_at timestamptz NOT NULL DEFAULT now(),
-      updated_at timestamptz NOT NULL DEFAULT now()
-    )
-  `);
-  const indexPrefix = interactiveIndexPrefix({ schema, tableName });
-  await client.query(
-    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
-      `${indexPrefix}_status_updated_idx`
-    )} ON ${table} (status, updated_at DESC)`
-  );
-  await client.query(
-    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
-      `${indexPrefix}_updated_idx`
-    )} ON ${table} (updated_at DESC)`
-  );
-}
-async function prunePostgresSlackInteractiveRequestStore({
-  client,
-  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
-  retentionMs = DEFAULT_RETENTION_MS,
-  schema,
-  tableName = DEFAULT_TABLE
-}) {
-  if (retentionMs <= 0) {
-    return { deleted: 0 };
-  }
-  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
-  const result = await client.query(
-    `WITH expired AS (
-      SELECT id
-      FROM ${qualifiedTableName({ schema, tableName })}
-      WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')
-      ORDER BY updated_at ASC
-      LIMIT $2::integer
-    )
-    DELETE FROM ${qualifiedTableName({ schema, tableName })} target
-    USING expired
-    WHERE target.id = expired.id`,
-    [Math.max(1, Math.floor(retentionMs)), batchSize]
-  );
-  return { deleted: result.rowCount ?? 0 };
-}
-function rowToRecord(row) {
-  if (!row) return void 0;
-  return cloneRecord({
-    id: row.id,
-    kind: row.kind,
-    request: readJsonValue(
-      row.request
-    ),
-    status: row.status,
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at),
-    ...row.target ? {
-      target: readJsonValue(
-        row.target
-      )
-    } : {},
-    ...row.resolution ? {
-      resolution: readJsonValue(
-        row.resolution
-      )
-    } : {}
-  });
-}
-function requireReturnedRecord(row, requestId) {
-  const record = rowToRecord(row);
-  if (!record) {
-    throw new Error(
-      `Postgres Slack interactive request store did not return request ${requestId}.`
-    );
-  }
-  return record;
-}
-function readJsonValue(value) {
-  if (typeof value === "string") {
-    return JSON.parse(value);
-  }
-  return value;
-}
-function toIsoString(value) {
-  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
-}
-function qualifiedTableName({
-  schema,
-  tableName
-}) {
-  return schema ? `${quoteIdentifier(schema)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
-}
-function quoteIdentifier(value) {
-  return `"${value.replace(/"/g, '""')}"`;
-}
-function interactiveIndexPrefix({
-  schema,
-  tableName
-}) {
-  const raw = [schema, tableName].filter(Boolean).join("_");
-  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_interactive";
-}
-async function importPostgresPoolConstructor() {
-  const dynamicImport = new Function(
-    "specifier",
-    "return import(specifier)"
-  );
-  try {
-    const pg = await dynamicImport("pg");
-    return pg.Pool;
-  } catch (error) {
-    throw new Error(
-      `The "pg" package is required when using connectionString with createPostgresSlackInteractiveRequestStore. Install pg or pass a client. ${formatImportError(
-        error
-      )}`
-    );
-  }
-}
-function formatImportError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// 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
-import { openSlackModal } from "@cuylabs/channel-slack/views";
-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 openSlackModal({
-      client: actionArgs.client,
-      triggerId: 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,
-  createPostgresSlackInteractiveRequestStore,
-  initializePostgresSlackInteractiveRequestStore,
-  prunePostgresSlackInteractiveRequestStore,
-  buildApprovalRequestMessage,
-  buildHumanInputRequestMessage,
-  buildResolvedMessage,
-  buildHumanInputModal,
-  encodeActionValue,
-  decodeActionValue,
-  createSlackInteractiveController
-};