@cuylabs/channel-slack 0.6.0 → 0.8.0

package/dist/app-home.js

@@ -1,3 +1,7 @@
+import {
+  publishSlackHomeView
+} from "./chunk-IRFKUPJN.js";
+
 // src/app-home.ts
 function installSlackAppHome({
   boltApp,
@@ -7,8 +11,9 @@ function installSlackAppHome({
   boltApp.event("app_home_opened", async ({ event, client }) => {
     const homeEvent = event;
     try {
-      await client.views.publish({
-        user_id: homeEvent.user,
+      await publishSlackHomeView({
+        client,
+        userId: homeEvent.user,
         view: await buildView({ event: homeEvent })
       });
       logger?.debug?.("Slack App Home published", {

package/dist/chunk-3KP3CBCC.js

@@ -0,0 +1,175 @@
+// src/turn-controls/block.ts
+var SLACK_TURN_CANCEL_ACTION_ID = "agent_turn_cancel";
+function createSlackTurnCancelMessage(options) {
+  const actionId = resolveSlackTurnCancelActionId(options.actionId);
+  const controlId = options.controlId.trim();
+  if (!controlId) {
+    throw new Error(
+      "createSlackTurnCancelMessage: controlId must be a non-empty string"
+    );
+  }
+  const text = (options.messageText ?? "Request controls").trim();
+  if (!text) {
+    throw new Error(
+      "createSlackTurnCancelMessage: messageText must be a non-empty string"
+    );
+  }
+  const buttonText = (options.buttonText ?? "Cancel").trim();
+  if (!buttonText) {
+    throw new Error(
+      "createSlackTurnCancelMessage: buttonText must be a non-empty string"
+    );
+  }
+  const value = encodeSlackTurnCancelButtonValue({
+    action: "cancel",
+    controlId,
+    ...options.sessionId ? { sessionId: options.sessionId } : {},
+    ...options.turnId ? { turnId: options.turnId } : {}
+  });
+  return {
+    text,
+    blocks: [
+      {
+        type: "section",
+        text: { type: "mrkdwn", text }
+      },
+      {
+        type: "actions",
+        elements: [
+          {
+            type: "button",
+            action_id: actionId,
+            text: { type: "plain_text", text: buttonText },
+            accessibility_label: buttonText,
+            style: "danger",
+            value
+          }
+        ]
+      }
+    ]
+  };
+}
+function encodeSlackTurnCancelButtonValue(value) {
+  return JSON.stringify(value);
+}
+function decodeSlackTurnCancelButtonValue(rawValue) {
+  if (typeof rawValue !== "string" || !rawValue.trim()) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(rawValue);
+    const controlId = parseOptionalString(parsed.controlId);
+    if (parsed.action !== "cancel" || !controlId) {
+      return void 0;
+    }
+    const sessionId = parseOptionalString(parsed.sessionId);
+    const turnId = parseOptionalString(parsed.turnId);
+    return {
+      action: "cancel",
+      controlId,
+      ...sessionId ? { sessionId } : {},
+      ...turnId ? { turnId } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parseOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function resolveSlackTurnCancelActionId(actionId) {
+  const resolved = (actionId ?? SLACK_TURN_CANCEL_ACTION_ID).trim();
+  if (!resolved) {
+    throw new Error("Slack turn cancel action id cannot be empty.");
+  }
+  return resolved;
+}
+
+// src/turn-controls/action.ts
+function registerSlackTurnCancelAction(app, options) {
+  const actionId = resolveSlackTurnCancelActionId(options.actionId);
+  app.action(
+    actionId,
+    // Bolt's action args are structurally stable, but not exported as one
+    // concise public type across all action element variants.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async ({ ack, body, client, logger }) => {
+      try {
+        const ackFn = ack;
+        await ackFn();
+        if (body?.type !== "block_actions" || !Array.isArray(body.actions) || body.actions.length === 0) {
+          return;
+        }
+        const action = body.actions[0];
+        if (action?.type !== "button") {
+          return;
+        }
+        const value = decodeSlackTurnCancelButtonValue(action.value);
+        if (!value) {
+          return;
+        }
+        const channelId = body.channel?.id ?? body.container?.channel_id;
+        const userId = body.user?.id;
+        const messageTs = body.message?.ts ?? body.container?.message_ts;
+        const threadTs = body.message?.thread_ts ?? body.container?.thread_ts;
+        const teamId = body.team?.id;
+        const triggerId = typeof body.trigger_id === "string" ? body.trigger_id : void 0;
+        if (!channelId || !userId || !messageTs) {
+          return;
+        }
+        const acknowledgeEphemeral = async (text) => {
+          await client.chat.postEphemeral({
+            channel: channelId,
+            user: userId,
+            ...threadTs ? { thread_ts: threadTs } : { thread_ts: messageTs },
+            text
+          });
+        };
+        const deleteMessage = async () => {
+          await client.chat.delete({
+            channel: channelId,
+            ts: messageTs
+          });
+        };
+        const updateMessage = async (message) => {
+          await client.chat.update({
+            channel: channelId,
+            ts: messageTs,
+            text: message.text,
+            ...message.blocks ? { blocks: message.blocks } : {}
+          });
+        };
+        await options.onCancel({
+          ...value,
+          channelId,
+          userId,
+          messageTs,
+          ...threadTs ? { threadTs } : {},
+          ...teamId ? { teamId } : {},
+          ...triggerId ? { triggerId } : {},
+          acknowledgeEphemeral,
+          deleteMessage,
+          updateMessage
+        });
+      } catch (error) {
+        logger?.error?.(
+          `[channel-slack] turn cancel action failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  return { actionId };
+}
+
+export {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  encodeSlackTurnCancelButtonValue,
+  decodeSlackTurnCancelButtonValue,
+  resolveSlackTurnCancelActionId,
+  registerSlackTurnCancelAction
+};

package/dist/chunk-IRFKUPJN.js

@@ -0,0 +1,235 @@
+// src/views/client.ts
+async function openSlackModal({
+  client,
+  triggerId,
+  view,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "open"
+  )({
+    ...tokenArgs(token),
+    trigger_id: requireTrimmed(triggerId, "triggerId"),
+    view
+  });
+}
+async function pushSlackModal({
+  client,
+  triggerId,
+  view,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "push"
+  )({
+    ...tokenArgs(token),
+    trigger_id: requireTrimmed(triggerId, "triggerId"),
+    view
+  });
+}
+async function updateSlackView({
+  client,
+  view,
+  viewId,
+  externalId,
+  hash,
+  token
+}) {
+  const normalizedViewId = trimOptional(viewId);
+  const normalizedExternalId = trimOptional(externalId);
+  if (!normalizedViewId && !normalizedExternalId) {
+    throw new Error("updateSlackView requires viewId or externalId.");
+  }
+  return await requireViewsMethod(
+    client,
+    "update"
+  )({
+    ...tokenArgs(token),
+    ...normalizedViewId ? { view_id: normalizedViewId } : {},
+    ...normalizedExternalId ? { external_id: normalizedExternalId } : {},
+    ...trimOptional(hash) ? { hash: hash?.trim() } : {},
+    view
+  });
+}
+async function publishSlackHomeView({
+  client,
+  userId,
+  view,
+  hash,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "publish"
+  )({
+    ...tokenArgs(token),
+    user_id: requireTrimmed(userId, "userId"),
+    ...trimOptional(hash) ? { hash: hash?.trim() } : {},
+    view
+  });
+}
+function requireViewsMethod(client, methodName) {
+  const method = client.views?.[methodName];
+  if (typeof method !== "function") {
+    throw new Error(`Slack client does not expose views.${methodName}.`);
+  }
+  return method.bind(client.views);
+}
+function requireTrimmed(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} is required.`);
+  }
+  return trimmed;
+}
+function trimOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function tokenArgs(token) {
+  const trimmed = token?.trim();
+  return trimmed ? { token: trimmed } : {};
+}
+
+// src/views/metadata.ts
+var SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS = 3e3;
+function encodeSlackViewPrivateMetadata(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  const encoded = typeof value === "string" ? value : JSON.stringify(value);
+  if (encoded.length > SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS) {
+    throw new Error(
+      `Slack view private_metadata exceeds ${SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS} characters.`
+    );
+  }
+  return encoded;
+}
+function decodeSlackViewPrivateMetadata(privateMetadata) {
+  const normalized = privateMetadata?.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function readSlackViewPrivateMetadata(view) {
+  return decodeSlackViewPrivateMetadata(view.private_metadata);
+}
+
+// src/views/workflow.ts
+function registerSlackViewWorkflow({
+  boltApp,
+  callbackId,
+  decodePrivateMetadata,
+  onSubmission,
+  onClose,
+  onError
+}) {
+  if (onSubmission) {
+    boltApp.view(
+      { callback_id: callbackId, type: "view_submission" },
+      // Bolt's listener args are structurally stable, but the exact generic
+      // narrows differ between view_submission and view_closed.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async ({ ack, body, client, view }) => {
+        const baseContext = createWorkflowContext({
+          body,
+          client,
+          view
+        });
+        try {
+          const metadata = resolveMetadata(
+            decodePrivateMetadata,
+            view,
+            baseContext
+          );
+          const response = await onSubmission({
+            ...baseContext,
+            metadata
+          });
+          await ack(response);
+        } catch (error) {
+          try {
+            await ack();
+          } catch {
+          }
+          await onError?.(error, baseContext);
+        }
+      }
+    );
+  }
+  if (onClose) {
+    boltApp.view(
+      { callback_id: callbackId, type: "view_closed" },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async ({ ack, body, client, view }) => {
+        const baseContext = createWorkflowContext({
+          body,
+          client,
+          view
+        });
+        await ack();
+        try {
+          const metadata = resolveMetadata(
+            decodePrivateMetadata,
+            view,
+            baseContext
+          );
+          await onClose({
+            ...baseContext,
+            metadata
+          });
+        } catch (error) {
+          await onError?.(error, baseContext);
+        }
+      }
+    );
+  }
+  return { callbackId };
+}
+function createWorkflowContext({
+  body,
+  client,
+  view
+}) {
+  const bodyRecord = isRecord(body) ? body : {};
+  const user = isRecord(bodyRecord.user) ? bodyRecord.user : {};
+  const team = isRecord(bodyRecord.team) ? bodyRecord.team : {};
+  const enterprise = isRecord(bodyRecord.enterprise) ? bodyRecord.enterprise : {};
+  return {
+    body,
+    client,
+    view,
+    ...typeof view.callback_id === "string" ? { callbackId: view.callback_id } : {},
+    ...typeof bodyRecord.trigger_id === "string" ? { triggerId: bodyRecord.trigger_id } : {},
+    actor: {
+      ...typeof user.id === "string" ? { userId: user.id } : {},
+      ...typeof team.id === "string" ? { teamId: team.id } : {},
+      ...typeof enterprise.id === "string" ? { enterpriseId: enterprise.id } : {}
+    }
+  };
+}
+function resolveMetadata(decodePrivateMetadata, view, context) {
+  return decodePrivateMetadata ? decodePrivateMetadata(view.private_metadata, context) : decodeSlackViewPrivateMetadata(view.private_metadata);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  openSlackModal,
+  pushSlackModal,
+  updateSlackView,
+  publishSlackHomeView,
+  SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS,
+  encodeSlackViewPrivateMetadata,
+  decodeSlackViewPrivateMetadata,
+  readSlackViewPrivateMetadata,
+  registerSlackViewWorkflow
+};

package/dist/core.d.ts

@@ -1,4 +1,7 @@
 import { S as SlackActivityInfo, b as SlackUserIdentity, a as SlackChannelType } from './activity-ByrD9Ftr.js';
+export { RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, SlackTurnCancelActionContext, SlackTurnCancelActionHandler, SlackTurnCancelButtonValue, SlackTurnCancelMessage, SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId } from './turn-controls/index.js';
+import '@slack/types';
+import '@slack/bolt';
 
 /**
  * Slack auth context — credentials and identifiers resolved from the inbound

package/dist/core.js

@@ -3,7 +3,15 @@ import {
   formatSlackAttributedFollowUp,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-X4WBBBYM.js";
+} from "./chunk-ISOMBQXE.js";
+import {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "./chunk-3KP3CBCC.js";
 import {
   markdownToSlackMrkdwn,
   resolveSlackMessageFormatter
@@ -24,7 +32,11 @@ import {
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
 export {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
   currentSlackTurnContext,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
   extractSlackActionToken,
   extractSlackAttachmentsText,
   extractSlackAuthContext,
@@ -36,8 +48,10 @@ export {
   markdownToSlackMrkdwn,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
+  registerSlackTurnCancelAction,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
+  resolveSlackTurnCancelActionId,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   stripLeadingMentions

package/dist/feedback/index.js

@@ -1,3 +1,7 @@
+import {
+  openSlackModal
+} from "../chunk-IRFKUPJN.js";
+
 // src/feedback/block.ts
 var SLACK_FEEDBACK_ACTION_ID = "agent_feedback";
 function createSlackFeedbackBlock(options = {}) {
@@ -76,13 +80,7 @@ function registerSlackFeedbackAction(app, options) {
               "Slack feedback payload did not include trigger_id."
             );
           }
-          if (typeof client.views?.open !== "function") {
-            throw new Error("Slack client does not expose views.open.");
-          }
-          await client.views.open({
-            trigger_id: triggerId,
-            view
-          });
+          await openSlackModal({ client, triggerId, view });
         };
         const acknowledgeEphemeral = async (text) => {
           await client.chat.postEphemeral({

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { S as SlackActivityInfo, a as SlackChannelType, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
 export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackApprovalRequest, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackEventInteractiveRequestHandler, SlackHumanInputRequest, SlackInteractiveMessage, SlackInteractiveMessageRef, SlackInteractiveRequest, SlackInteractiveRequestBaseContext, SlackInteractiveRequestContext, SlackInteractiveRequestHandler, SlackInteractiveRequestKind, SlackInteractiveResponder, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
+export { RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, SlackTurnCancelActionContext, SlackTurnCancelActionHandler, SlackTurnCancelButtonValue, SlackTurnCancelMessage, SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId } from './turn-controls/index.js';
 export { InMemorySlackThreadParticipationStateStoreOptions, PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, PostgresSlackThreadParticipationStateStore, PostgresSlackThreadParticipationStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackQuietThreadRejectedDecision, SlackSyncMessagePolicyStateStore, SlackThreadAwareMessagePolicyConfig, SlackThreadAwareMessagePolicyDecision, SlackThreadAwareMessagePolicyResolver, SlackThreadParticipationEligibility, SlackThreadParticipationEligibilityOptions, SlackThreadParticipationMode, SlackThreadParticipationPostgresClient, SlackThreadParticipationPruneResult, SlackThreadParticipationReactivation, SlackThreadParticipationState, SlackThreadParticipationStateContext, SlackThreadParticipationStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages } from './policy/index.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';
+import '@slack/types';
+import '@slack/bolt';

package/dist/index.js

@@ -20,7 +20,15 @@ import {
   formatSlackAttributedFollowUp,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-X4WBBBYM.js";
+} from "./chunk-ISOMBQXE.js";
+import {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "./chunk-3KP3CBCC.js";
 import {
   markdownToSlackMrkdwn,
   resolveSlackMessageFormatter
@@ -41,6 +49,7 @@ import {
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
 export {
+  SLACK_TURN_CANCEL_ACTION_ID,
   createAsyncSlackMessagePolicyResolver,
   createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
@@ -50,7 +59,10 @@ export {
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
+  createSlackTurnCancelMessage,
   currentSlackTurnContext,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
   extractSlackActionToken,
   extractSlackAttachmentsText,
   extractSlackAuthContext,
@@ -66,9 +78,11 @@ export {
   parseSlackMessageActivity,
   prunePostgresSlackMessagePolicyState,
   prunePostgresSlackThreadParticipationState,
+  registerSlackTurnCancelAction,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
   resolveSlackThreadParticipationEligibility,
+  resolveSlackTurnCancelActionId,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   shouldRegisterSlackPassiveChannelMessages,

package/dist/setup/index.d.ts

@@ -1,6 +1,6 @@
 import { I as InspectSlackConnectionOptions, f as SlackDiagnosticsClient, c as SlackConnectionInspection } from '../inspect-BpY5JA0K.js';
 
-type SlackSetupFeature = "assistant" | "app-mentions" | "direct-messages" | "channel-messages" | "slash-commands" | "shortcuts" | "artifacts" | "canvas-artifacts" | "history" | "interactivity" | "feedback" | "user-profiles" | "user-emails" | "workspace-search";
+type SlackSetupFeature = "assistant" | "app-mentions" | "direct-messages" | "channel-messages" | "slash-commands" | "shortcuts" | "artifacts" | "canvas-artifacts" | "history" | "interactivity" | "views" | "feedback" | "user-profiles" | "user-emails" | "workspace-search";
 type SlackSetupFeaturePreset = "assistant" | "channel-adapter" | "agent-app";
 type SlackSetupTransport = "http" | "socket";
 interface SlackSetupEnvironmentVariable {

package/dist/setup/index.js

@@ -53,6 +53,9 @@ var FEATURE_REQUIREMENTS = {
     botScopes: ["chat:write"],
     interactivity: true
   },
+  views: {
+    interactivity: true
+  },
   feedback: {
     botScopes: ["chat:write"],
     interactivity: true

package/dist/transports/index.js

@@ -1,3 +1,6 @@
+import {
+  createSlackBoltApp
+} from "../chunk-QJYCHWN6.js";
 import {
   acquireSlackSocketModePostgresLock,
   acquireSlackSocketModeProcessLock,
@@ -7,9 +10,6 @@ import {
   createSlackSocketModeRuntime,
   redactSlackSocketModeLogValue
 } from "../chunk-73QXT7MA.js";
-import {
-  createSlackBoltApp
-} from "../chunk-QJYCHWN6.js";
 import "../chunk-S3SWPYXJ.js";
 export {
   acquireSlackSocketModePostgresLock,

package/dist/turn-controls/index.d.ts

@@ -0,0 +1,51 @@
+import { SectionBlock, ActionsBlock, KnownBlock } from '@slack/types';
+import { App } from '@slack/bolt';
+
+declare const SLACK_TURN_CANCEL_ACTION_ID = "agent_turn_cancel";
+interface SlackTurnCancelButtonValue {
+    action: "cancel";
+    controlId: string;
+    sessionId?: string;
+    turnId?: string;
+}
+interface SlackTurnCancelMessageOptions {
+    controlId: string;
+    actionId?: string;
+    buttonText?: string;
+    messageText?: string;
+    sessionId?: string;
+    turnId?: string;
+}
+interface SlackTurnCancelMessage {
+    text: string;
+    blocks: [SectionBlock, ActionsBlock];
+}
+declare function createSlackTurnCancelMessage(options: SlackTurnCancelMessageOptions): SlackTurnCancelMessage;
+declare function encodeSlackTurnCancelButtonValue(value: SlackTurnCancelButtonValue): string;
+declare function decodeSlackTurnCancelButtonValue(rawValue: unknown): SlackTurnCancelButtonValue | undefined;
+declare function resolveSlackTurnCancelActionId(actionId?: string): string;
+
+interface SlackTurnCancelActionContext extends SlackTurnCancelButtonValue {
+    channelId: string;
+    userId: string;
+    messageTs: string;
+    threadTs?: string;
+    teamId?: string;
+    triggerId?: string;
+    acknowledgeEphemeral: (text: string) => Promise<void>;
+    deleteMessage: () => Promise<void>;
+    updateMessage: (message: {
+        text: string;
+        blocks?: KnownBlock[];
+    }) => Promise<void>;
+}
+type SlackTurnCancelActionHandler = (context: SlackTurnCancelActionContext) => void | Promise<void>;
+interface RegisterSlackTurnCancelActionOptions {
+    actionId?: string;
+    onCancel: SlackTurnCancelActionHandler;
+}
+declare function registerSlackTurnCancelAction(app: App, options: RegisterSlackTurnCancelActionOptions): {
+    actionId: string;
+};
+
+export { type RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, type SlackTurnCancelActionContext, type SlackTurnCancelActionHandler, type SlackTurnCancelButtonValue, type SlackTurnCancelMessage, type SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId };

package/dist/turn-controls/index.js

@@ -0,0 +1,16 @@
+import {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "../chunk-3KP3CBCC.js";
+export {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+};

package/dist/views/index.d.ts

@@ -0,0 +1,98 @@
+import { App } from '@slack/bolt';
+import { View, HomeView } from '@slack/types';
+
+type SlackViewCallbackId = string | RegExp;
+interface SlackViewApiResponse {
+    ok?: boolean;
+    view?: unknown;
+    [key: string]: unknown;
+}
+interface SlackViewsClient {
+    views?: {
+        open?: unknown;
+        push?: unknown;
+        update?: unknown;
+        publish?: unknown;
+    };
+}
+interface OpenSlackModalOptions {
+    client: SlackViewsClient;
+    triggerId: string;
+    view: View;
+    token?: string;
+}
+interface PushSlackModalOptions {
+    client: SlackViewsClient;
+    triggerId: string;
+    view: View;
+    token?: string;
+}
+interface UpdateSlackViewOptions {
+    client: SlackViewsClient;
+    view: View;
+    viewId?: string;
+    externalId?: string;
+    hash?: string;
+    token?: string;
+}
+interface PublishSlackHomeViewOptions {
+    client: SlackViewsClient;
+    userId: string;
+    view: HomeView;
+    hash?: string;
+    token?: string;
+}
+interface SlackViewPayload {
+    id?: string;
+    callback_id?: string;
+    private_metadata?: string;
+    state?: unknown;
+    hash?: string;
+    [key: string]: unknown;
+}
+interface SlackViewActor {
+    userId?: string;
+    teamId?: string;
+    enterpriseId?: string;
+}
+interface SlackViewSubmissionAckResponse {
+    response_action: "clear" | "errors" | "push" | "update";
+    errors?: Record<string, string>;
+    view?: View;
+}
+interface SlackViewWorkflowContext<TMetadata = unknown> {
+    body: unknown;
+    client: SlackViewsClient;
+    view: SlackViewPayload;
+    callbackId?: string;
+    triggerId?: string;
+    actor: SlackViewActor;
+    metadata: TMetadata | undefined;
+}
+interface RegisterSlackViewWorkflowOptions<TMetadata = unknown> {
+    boltApp: App;
+    callbackId: SlackViewCallbackId;
+    decodePrivateMetadata?: (privateMetadata: string | undefined, context: Omit<SlackViewWorkflowContext<TMetadata>, "metadata">) => TMetadata | undefined;
+    onSubmission?: (context: SlackViewWorkflowContext<TMetadata>) => SlackViewSubmissionAckResponse | void | Promise<SlackViewSubmissionAckResponse | void>;
+    onClose?: (context: SlackViewWorkflowContext<TMetadata>) => void | Promise<void>;
+    onError?: (error: unknown, context: Omit<SlackViewWorkflowContext<TMetadata>, "metadata"> & {
+        metadata?: TMetadata | undefined;
+    }) => void | Promise<void>;
+}
+interface SlackViewWorkflowRegistration {
+    callbackId: SlackViewCallbackId;
+}
+
+declare function openSlackModal({ client, triggerId, view, token, }: OpenSlackModalOptions): Promise<SlackViewApiResponse>;
+declare function pushSlackModal({ client, triggerId, view, token, }: PushSlackModalOptions): Promise<SlackViewApiResponse>;
+declare function updateSlackView({ client, view, viewId, externalId, hash, token, }: UpdateSlackViewOptions): Promise<SlackViewApiResponse>;
+declare function publishSlackHomeView({ client, userId, view, hash, token, }: PublishSlackHomeViewOptions): Promise<SlackViewApiResponse>;
+
+declare const SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS = 3000;
+declare function encodeSlackViewPrivateMetadata(value: unknown): string;
+declare function decodeSlackViewPrivateMetadata<T = unknown>(privateMetadata: string | undefined): T | undefined;
+declare function readSlackViewPrivateMetadata<T = unknown>(view: Pick<SlackViewPayload, "private_metadata">): T | undefined;
+
+declare function registerSlackViewWorkflow<TMetadata = unknown>({ boltApp, callbackId, decodePrivateMetadata, onSubmission, onClose, onError, }: RegisterSlackViewWorkflowOptions<TMetadata>): SlackViewWorkflowRegistration;
+
+export { type OpenSlackModalOptions, type PublishSlackHomeViewOptions, type PushSlackModalOptions, type RegisterSlackViewWorkflowOptions, SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS, type SlackViewActor, type SlackViewApiResponse, type SlackViewCallbackId, type SlackViewPayload, type SlackViewSubmissionAckResponse, type SlackViewWorkflowContext, type SlackViewWorkflowRegistration, type SlackViewsClient, type UpdateSlackViewOptions, decodeSlackViewPrivateMetadata, encodeSlackViewPrivateMetadata, openSlackModal, publishSlackHomeView, pushSlackModal, readSlackViewPrivateMetadata, registerSlackViewWorkflow, updateSlackView };

package/dist/views/index.js

@@ -0,0 +1,22 @@
+import {
+  SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS,
+  decodeSlackViewPrivateMetadata,
+  encodeSlackViewPrivateMetadata,
+  openSlackModal,
+  publishSlackHomeView,
+  pushSlackModal,
+  readSlackViewPrivateMetadata,
+  registerSlackViewWorkflow,
+  updateSlackView
+} from "../chunk-IRFKUPJN.js";
+export {
+  SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS,
+  decodeSlackViewPrivateMetadata,
+  encodeSlackViewPrivateMetadata,
+  openSlackModal,
+  publishSlackHomeView,
+  pushSlackModal,
+  readSlackViewPrivateMetadata,
+  registerSlackViewWorkflow,
+  updateSlackView
+};

package/docs/README.md

@@ -19,6 +19,7 @@ your adapter or application needs.
 - [Setup requirements](concepts/setup-requirements.md)
 - [Supplemental history](concepts/supplemental-history.md)
 - [Transport runtime](concepts/transport-runtime.md)
+- [Views](concepts/views.md)
 
 ## Recipes
 

package/docs/concepts/views.md

@@ -0,0 +1,46 @@
+# Slack Views
+
+`@cuylabs/channel-slack/views` provides Slack-runtime primitives for modal and
+Home view workflows. It keeps Slack Web API and Bolt details in
+`channel-slack` while product packages decide what a workflow means.
+
+```typescript
+import {
+  encodeSlackViewPrivateMetadata,
+  openSlackModal,
+  registerSlackViewWorkflow,
+} from "@cuylabs/channel-slack/views";
+
+await openSlackModal({
+  client,
+  triggerId,
+  view: {
+    type: "modal",
+    callback_id: "incident_triage",
+    private_metadata: encodeSlackViewPrivateMetadata({
+      workflowId: "triage-123",
+    }),
+    title: { type: "plain_text", text: "Triage incident" },
+    submit: { type: "plain_text", text: "Continue" },
+    close: { type: "plain_text", text: "Cancel" },
+    blocks: [],
+  },
+});
+
+registerSlackViewWorkflow({
+  boltApp,
+  callbackId: "incident_triage",
+  onSubmission: async ({ metadata, view, actor }) => {
+    // Load product-owned workflow state by metadata.workflowId, validate
+    // view.state, then continue the workflow or return field errors.
+    return { response_action: "clear" };
+  },
+});
+```
+
+Use `private_metadata` for compact routing data such as a workflow id, request
+id, or session id. Store durable workflow state outside the view, for example in
+the application database or the existing interactive-request store.
+
+The `views` setup feature does not require a special bot scope, but it does
+require Slack interactivity to be enabled for the app.

package/docs/reference/exports.md

@@ -3,23 +3,24 @@
 Use feature subpaths for new code. They make dependency expectations clearer and
 keep application code close to the package boundary it uses.
 
-| Export                               | Depends on                                                                      | Notes                                                                    |
-| ------------------------------------ | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
-| `@cuylabs/channel-slack/core`        | no Slack SDK runtime imports                                                    | Transport-neutral parsing, formatting, types, sessions, turn context     |
-| `@cuylabs/channel-slack/policy`      | `pg` only when using connection-string Postgres state                           | Message admission and in-memory/Postgres policy state                    |
-| `@cuylabs/channel-slack/history`     | `@slack/web-api` types                                                          | History reader accepts a Slack WebClient or minimal conversations client |
-| `@cuylabs/channel-slack/app-home`    | `@slack/bolt`, `@slack/types`                                                   | Slack App Home registration helper                                       |
-| `@cuylabs/channel-slack/artifacts`   | no Slack SDK runtime imports; requires a Web API-like client at call time       | Text, file, image, link, and Canvas artifact publishing                  |
-| `@cuylabs/channel-slack/auth`        | no Slack SDK runtime imports; `pg` is not required                              | Auth option types, auth resolution, OAuth installation stores            |
-| `@cuylabs/channel-slack/transports`  | `@slack/bolt`, `express`; `pg` only when using connection-string Postgres locks | HTTP and Socket Mode transport helpers                                   |
-| `@cuylabs/channel-slack/transports/http` | `@slack/bolt`, `express`                                                    | HTTP Events API Bolt app factory                                         |
-| `@cuylabs/channel-slack/transports/socket` | `@slack/bolt`; `pg` only when using connection-string Postgres locks      | Socket Mode app factory, runtime guard, process/Postgres locks           |
-| `@cuylabs/channel-slack/setup`       | diagnostics only when inspecting live tokens                                    | Setup requirements and app manifest helpers                              |
-| `@cuylabs/channel-slack/diagnostics` | `@slack/web-api`                                                                | Token, auth, and scope inspection                                        |
-| `@cuylabs/channel-slack/entrypoints` | no Slack SDK runtime imports                                                    | Slash command and shortcut payload normalization                         |
-| `@cuylabs/channel-slack/users`       | `@slack/web-api` when using default client                                      | User profile lookup and mention enrichment                               |
-| `@cuylabs/channel-slack/targets`     | no Slack SDK runtime imports unless resolving names through a client            | Parse and resolve channel/user targets                                   |
-| `@cuylabs/channel-slack/feedback`    | `@slack/types` types                                                            | Feedback block and action helpers                                        |
+| Export                                     | Depends on                                                                      | Notes                                                                    |
+| ------------------------------------------ | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+| `@cuylabs/channel-slack/core`              | no Slack SDK runtime imports                                                    | Transport-neutral parsing, formatting, types, sessions, turn context     |
+| `@cuylabs/channel-slack/policy`            | `pg` only when using connection-string Postgres state                           | Message admission and in-memory/Postgres policy state                    |
+| `@cuylabs/channel-slack/history`           | `@slack/web-api` types                                                          | History reader accepts a Slack WebClient or minimal conversations client |
+| `@cuylabs/channel-slack/app-home`          | `@slack/bolt`, `@slack/types`                                                   | Slack App Home registration helper                                       |
+| `@cuylabs/channel-slack/artifacts`         | no Slack SDK runtime imports; requires a Web API-like client at call time       | Text, file, image, link, and Canvas artifact publishing                  |
+| `@cuylabs/channel-slack/auth`              | no Slack SDK runtime imports; `pg` is not required                              | Auth option types, auth resolution, OAuth installation stores            |
+| `@cuylabs/channel-slack/transports`        | `@slack/bolt`, `express`; `pg` only when using connection-string Postgres locks | HTTP and Socket Mode transport helpers                                   |
+| `@cuylabs/channel-slack/transports/http`   | `@slack/bolt`, `express`                                                        | HTTP Events API Bolt app factory                                         |
+| `@cuylabs/channel-slack/transports/socket` | `@slack/bolt`; `pg` only when using connection-string Postgres locks            | Socket Mode app factory, runtime guard, process/Postgres locks           |
+| `@cuylabs/channel-slack/setup`             | diagnostics only when inspecting live tokens                                    | Setup requirements and app manifest helpers                              |
+| `@cuylabs/channel-slack/diagnostics`       | `@slack/web-api`                                                                | Token, auth, and scope inspection                                        |
+| `@cuylabs/channel-slack/entrypoints`       | no Slack SDK runtime imports                                                    | Slash command and shortcut payload normalization                         |
+| `@cuylabs/channel-slack/users`             | `@slack/web-api` when using default client                                      | User profile lookup and mention enrichment                               |
+| `@cuylabs/channel-slack/targets`           | no Slack SDK runtime imports unless resolving names through a client            | Parse and resolve channel/user targets                                   |
+| `@cuylabs/channel-slack/feedback`          | `@slack/types` types                                                            | Feedback block and action helpers                                        |
+| `@cuylabs/channel-slack/views`             | `@slack/bolt`, `@slack/types`                                                   | Modal/Home view operations and workflow registration                     |
 
 The root export remains available for lightweight core and policy helpers:
 

package/docs/reference/source-layout.md

@@ -29,6 +29,7 @@ src/
     socket/               Socket Mode Bolt app factory, runtime, locks
   targets/                channel/user target parsing and resolution
   users/                  profile lookup and mention enrichment
+  views/                  modal/Home view operations and workflow registration
 ```
 
 For public export details and peer dependency expectations, see

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Agent-runtime-agnostic Slack channel primitives for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,6 +71,11 @@
       "import": "./dist/targets/index.js",
       "default": "./dist/targets/index.js"
     },
+    "./turn-controls": {
+      "types": "./dist/turn-controls/index.d.ts",
+      "import": "./dist/turn-controls/index.js",
+      "default": "./dist/turn-controls/index.js"
+    },
     "./transports": {
       "types": "./dist/transports/index.d.ts",
       "import": "./dist/transports/index.js",
@@ -90,6 +95,11 @@
       "types": "./dist/users/index.d.ts",
       "import": "./dist/users/index.js",
       "default": "./dist/users/index.js"
+    },
+    "./views": {
+      "types": "./dist/views/index.d.ts",
+      "import": "./dist/views/index.js",
+      "default": "./dist/views/index.js"
     }
   },
   "files": [
@@ -143,9 +153,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
     "clean": "rm -rf dist",
-    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts --format esm --dts --watch",
+    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
     "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\" --max-warnings=0",
     "test": "vitest run",
     "test:watch": "vitest",