@cuylabs/channel-slack 0.7.0 → 0.9.0

package/dist/interactive/index.js

@@ -0,0 +1,650 @@
+// 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/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);
+}
+export {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createPostgresSlackInteractiveRequestStore,
+  decodeActionValue,
+  encodeActionValue,
+  initializePostgresSlackInteractiveRequestStore,
+  nowIso,
+  prunePostgresSlackInteractiveRequestStore
+};

package/dist/interactive-CbKYkkc_.d.ts

@@ -0,0 +1,46 @@
+import { S as SlackActivityInfo, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
+
+/**
+ * Transport-neutral interactive request contracts.
+ *
+ * These types let callers delegate approval and human-input requests to a
+ * Slack-specific renderer without importing Bolt or Web API types into
+ * `shared/`.
+ */
+
+type SlackInteractiveRequestKind = "approval" | "human-input";
+interface SlackApprovalRequest {
+    id: string;
+}
+interface SlackHumanInputRequest {
+    id: string;
+}
+type SlackInteractiveRequest = SlackApprovalRequest | SlackHumanInputRequest;
+interface SlackInteractiveMessageRef {
+    channel: string;
+    ts: string;
+}
+interface SlackInteractiveMessage {
+    text: string;
+    blocks?: unknown[];
+}
+interface SlackInteractiveResponder {
+    postMessage(message: SlackInteractiveMessage): Promise<SlackInteractiveMessageRef>;
+    updateMessage(ref: SlackInteractiveMessageRef, message: SlackInteractiveMessage): Promise<void>;
+}
+interface SlackInteractiveRequestBaseContext {
+    kind: SlackInteractiveRequestKind;
+    request: SlackInteractiveRequest;
+    fallbackText: string;
+}
+interface SlackInteractiveRequestContext extends SlackInteractiveRequestBaseContext {
+    slackActivity: SlackActivityInfo;
+    user: SlackUserIdentity;
+    sessionId: string;
+    message: string;
+    responder: SlackInteractiveResponder;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+type SlackEventInteractiveRequestHandler = (context: SlackInteractiveRequestBaseContext) => boolean | void | Promise<boolean | void>;
+
+export type { SlackApprovalRequest as S, SlackEventInteractiveRequestHandler as a, SlackHumanInputRequest as b, SlackInteractiveMessage as c, SlackInteractiveMessageRef as d, SlackInteractiveRequest as e, SlackInteractiveRequestBaseContext as f, SlackInteractiveRequestContext as g, SlackInteractiveRequestHandler as h, SlackInteractiveRequestKind as i, SlackInteractiveResponder as j };