The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(slack): per-channel rules for the assistant (#26016)
Abdul Rahman25519b4ff33c
diff --git a/packages/twenty-apps/public/slack/README.md b/packages/twenty-apps/public/slack/README.mdindex 1e173ae21b6..408d38c847c 100644--- a/packages/twenty-apps/public/slack/README.md+++ b/packages/twenty-apps/public/slack/README.md@@ -7,6 +7,7 @@- **A CRM assistant in Slack**: `@twenty how many open opportunities do we have?` It answers as whoever tagged it- **Slack steps for your workflows**: post, update or delete messages, send ephemerals, add reactions, list channels- **Open by default, restrict when you want**: in the Settings tab, limit the assistant to Slack accounts linked to a workspace member+- **Per-channel rules**: open a channel to anyone, restrict it to linked members, or silence the assistant there## 💳 Billingdiff --git a/packages/twenty-apps/public/slack/SETUP.md b/packages/twenty-apps/public/slack/SETUP.mdindex ccc23b7a322..09a473334cd 100644--- a/packages/twenty-apps/public/slack/SETUP.md+++ b/packages/twenty-apps/public/slack/SETUP.md@@ -197,6 +197,32 @@ that member's own permissions, so it can never do more than the person asking.Accounts with no link act with the Slack Assistant role alone, so keep it scopedto what you're comfortable exposing to anyone who can message the bot.+### Channel rules++The **Channels** section of the app's **Settings** tab lets a member with the+roles permission override the workspace access mode for individual channels.+Each rule names one channel and one mode:++- **Open to anyone**: the assistant answers everyone there, even when the+ workspace access mode is restricted to linked members.+- **Linked members only**: only Slack accounts linked to a workspace member get+ an answer there. Anyone else is told, in the thread, to ask an admin to link+ them.+- **Silent**: the assistant ignores the channel. Mentions, thread follow-ups and+ empty mentions are dropped before anything visible happens in Slack, and no+ Slack Assistant Request is recorded.++A channel without a rule follows the workspace access mode. Direct messages+never carry a rule: the requester is the only person there, so the workspace+mode applies. Rules are keyed on the Slack channel id, so renaming a channel+does not affect them. Slack confirms the channel when a rule is saved, so a rule+can only target a channel or private group, never a direct message.++Rules restrict who the assistant answers, not what it can do. A linked member+who is allowed in a channel still acts with their own permissions, and an+unlinked account still acts with the Slack Assistant role. Each rule is stored+as a **Slack Channel Rule** record that only the app can write.+## Linking Slack accounts to workspace membersConnecting the Slack workspace links the installer, then sweeps the rest of thediff --git a/packages/twenty-apps/public/slack/src/constants/slack-channel-rules-route-path.constant.ts b/packages/twenty-apps/public/slack/src/constants/slack-channel-rules-route-path.constant.tsnew file mode 100644index 00000000000..60cb564ed3f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/constants/slack-channel-rules-route-path.constant.ts@@ -0,0 +1,7 @@+export const SLACK_CHANNEL_RULES_SET_ROUTE_PATH = '/slack-channel-rules/set';++export const SLACK_CHANNEL_RULES_REMOVE_ROUTE_PATH =+ '/slack-channel-rules/remove';++export const SLACK_CHANNEL_RULES_SEARCH_ROUTE_PATH =+ '/slack-channel-rules/search';diff --git a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.tsindex ffb255b29ab..753ee0834cd 100644--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts@@ -195,3 +195,33 @@ export const SLACK_ACCESS_MODE_GET_UNIVERSAL_IDENTIFIER =export const SLACK_ACCESS_MODE_SET_UNIVERSAL_IDENTIFIER ='34458aca-bf05-4dc6-a002-b1786ca42652';++export const SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER =+ '615b8cfe-5739-4dbc-8c9b-f86da840b479';++export const SLACK_CHANNEL_RULE_NAME_FIELD_UNIVERSAL_IDENTIFIER =+ 'd14f9737-b852-4969-a3f7-ece5ca5c5f53';++export const SLACK_CHANNEL_RULE_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER =+ '43c9a417-56a5-4f6e-8cc7-26e2ad77a7f3';++export const SLACK_CHANNEL_RULE_TEAM_ID_FIELD_UNIVERSAL_IDENTIFIER =+ 'c7266041-7407-4032-91b2-aa4438149e28';++export const SLACK_CHANNEL_RULE_MODE_FIELD_UNIVERSAL_IDENTIFIER =+ 'd942ff8e-377f-4080-aec4-4d18eae2ce12';++export const SLACK_CHANNEL_RULE_CHANNEL_INDEX_UNIVERSAL_IDENTIFIER =+ '36982751-500c-403d-b7ff-9e83718da07d';++export const SLACK_CHANNEL_RULE_CHANNEL_INDEX_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER =+ 'a11438fa-9bc8-4842-bd07-a89c152b9b5c';++export const SLACK_SET_CHANNEL_RULE_UNIVERSAL_IDENTIFIER =+ '3dfe4269-1766-4418-85f9-bf9e8ccc3d74';++export const SLACK_REMOVE_CHANNEL_RULE_UNIVERSAL_IDENTIFIER =+ '386fb6b7-9b3b-4b76-a014-67bf2064453e';++export const SLACK_SEARCH_CHANNELS_UNIVERSAL_IDENTIFIER =+ '41047b7d-e551-4c35-919a-5cb2bb60efbf';diff --git a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsxindex bac7178fd7b..8cf7cc2770e 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsx@@ -6,6 +6,7 @@ import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';import { themeCssVariables } from 'twenty-ui/theme-constants';import { InlineWorkspaceMemberPickerPanel } from 'src/front-components/components/InlineWorkspaceMemberPickerPanel';+import { SlackDropdownTrigger } from 'src/front-components/components/SlackDropdownTrigger';import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';@@ -15,32 +16,6 @@ const StyledContainer = styled.div`position: relative;`;-const StyledSelectTrigger = styled.button`- align-items: center;- background-color: ${() => themeCssVariables.background.transparent.lighter};- border: 1px solid ${() => themeCssVariables.border.color.medium};- border-radius: ${() => themeCssVariables.border.radius.md};- box-sizing: border-box;- cursor: pointer;- display: grid;- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.sm};- gap: ${() => themeCssVariables.spacing[1]};- grid-template-columns: 1fr auto;- height: ${() => themeCssVariables.spacing[6]};- padding: 0 ${() => themeCssVariables.spacing[2]};- text-align: left;- width: 100%;-- &:hover:enabled {- background-color: ${() => themeCssVariables.background.transparent.light};- }-- &:disabled {- cursor: not-allowed;- }-`;-const StyledSelectedValue = styled.div`align-items: center;display: flex;@@ -60,15 +35,6 @@ const StyledPlaceholder = styled.div`white-space: nowrap;`;-const StyledChevron = styled.div`- border-bottom: 1px solid ${() => themeCssVariables.font.color.tertiary};- border-right: 1px solid ${() => themeCssVariables.font.color.tertiary};- height: 5px;- margin-top: -3px;- transform: rotate(45deg);- width: 5px;-`;-type InlineWorkspaceMemberPickerProps = {selectedMember: WorkspaceMemberOption | null;onSelect: (member: WorkspaceMemberOption) => void;@@ -84,13 +50,12 @@ export const InlineWorkspaceMemberPicker = ({return (<StyledContainer>- <StyledSelectTrigger- type="button"+ <SlackDropdownTrigger+ ariaLabel="Select the workspace member"+ isOpen={isOpen}+ onOpen={() => setIsOpen(true)}disabled={disabled}- onClick={() => setIsOpen(true)}- aria-label="Select the workspace member"- aria-haspopup="listbox"- aria-expanded={isOpen}+ size="small">{isDefined(selectedMember) ? (<StyledSelectedValue>@@ -109,8 +74,7 @@ export const InlineWorkspaceMemberPicker = ({) : (<StyledPlaceholder>Select member</StyledPlaceholder>)}- <StyledChevron />- </StyledSelectTrigger>+ </SlackDropdownTrigger>{isOpen && (<InlineWorkspaceMemberPickerPanelonSelect={(member) => {diff --git a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsx b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsxindex 12ebba98294..c3addacd1e9 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsx@@ -1,34 +1,15 @@import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';import { useState } from 'react';-import { MenuItem, MenuItemAvatar } from 'twenty-ui/navigation';+import { isDefined } from 'twenty-sdk/utils';import { themeCssVariables } from 'twenty-ui/theme-constants';+import { SlackDropdownBackdrop } from 'src/front-components/components/SlackDropdownBackdrop';+import { SlackPickerDropdownPanel } from 'src/front-components/components/SlackPickerDropdownPanel';import { useWorkspaceMemberSearch } from 'src/front-components/hooks/use-workspace-member-search';import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';-const StyledBackdrop = styled.div`- inset: 0;- position: fixed;- z-index: 1;-`;--const StyledDropdownPanel = styled.div`- background: ${() => themeCssVariables.background.primary};- border: 1px solid ${() => themeCssVariables.border.color.medium};- border-radius: ${() => themeCssVariables.border.radius.md};- box-shadow: ${() => themeCssVariables.boxShadow.light};- box-sizing: border-box;- left: 0;- margin-top: ${() => themeCssVariables.spacing[1]};- min-width: 240px;- position: absolute;- top: 100%;- width: 100%;- z-index: 2;-`;-const StyledSearchInput = styled.input`background: transparent;border: none;@@ -47,30 +28,6 @@ const StyledSearchInput = styled.input`}`;-const StyledOptions = styled.div`- max-height: 240px;- overflow-y: auto;- padding: ${() => themeCssVariables.spacing[1]};-`;--const getEmptyStateText = ({- isSearching,- searchErrorMessage,-}: {- isSearching: boolean;- searchErrorMessage: string | undefined;-}): string => {- if (isSearching) {- return 'Searching…';- }-- if (isNonEmptyString(searchErrorMessage)) {- return searchErrorMessage;- }-- return 'No results';-};-type InlineWorkspaceMemberPickerPanelProps = {onSelect: (member: WorkspaceMemberOption) => void;onClose: () => void;@@ -87,55 +44,64 @@ export const InlineWorkspaceMemberPickerPanel = ({return (<>- <StyledBackdrop onClick={onClose} />- <StyledDropdownPanel>- <StyledSearchInput- value={searchTerm}- onChange={(event) => setSearchTerm(event.target.value)}- onKeyDown={(event) => {- if (event.key === 'Escape') {- event.preventDefault();- onClose();+ <SlackDropdownBackdrop onClose={onClose} />+ <SlackPickerDropdownPanel+ options={options.map((member) => {+ const displayedName = getMemberDisplayName(member);++ return {+ key: member.id,+ name: displayedName,+ meta: member.userEmail ?? undefined,+ avatar: {+ type: 'rounded' as const,+ placeholder: displayedName,+ placeholderColorSeed: member.id,+ },+ };+ })}+ isSearching={isSearching}+ emptyText={+ isNonEmptyString(searchErrorMessage)+ ? searchErrorMessage+ : 'No results'+ }+ listLabel="Workspace members"+ onSelect={(memberId) => {+ const selectedMember = options.find(+ (member) => member.id === memberId,+ );- return;- }+ if (isDefined(selectedMember)) {+ onSelect(selectedMember);+ }+ }}+ header={+ <StyledSearchInput+ value={searchTerm}+ onChange={(event) => setSearchTerm(event.target.value)}+ onKeyDown={(event) => {+ if (event.key === 'Escape') {+ event.preventDefault();+ onClose();++ return;+ }- if (event.key === 'Enter') {- event.preventDefault();+ if (event.key === 'Enter') {+ event.preventDefault();- if (options.length > 0) {- onSelect(options[0]);+ if (options.length > 0) {+ onSelect(options[0]);+ }}- }- }}- placeholder="Search members"- aria-label="Search workspace members"- autoFocus- />- <StyledOptions role="listbox" aria-label="Workspace members">- {options.map((member) => (- <div key={member.id} role="option" aria-selected={false}>- <MenuItemAvatar- avatar={{- type: 'rounded',- size: 'md',- placeholder: getMemberDisplayName(member),- placeholderColorSeed: member.id,- }}- text={getMemberDisplayName(member)}- contextualText={member.userEmail ?? undefined}- onClick={() => onSelect(member)}- />- </div>- ))}- {options.length === 0 && (- <MenuItem- disabled- text={getEmptyStateText({ isSearching, searchErrorMessage })}- />- )}- </StyledOptions>- </StyledDropdownPanel>+ }}+ placeholder="Search members"+ aria-label="Search workspace members"+ autoFocus+ />+ }+ /></>);};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsx b/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsxindex c71088801bf..dc3aa622a94 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsx@@ -21,6 +21,11 @@ export const ResolvedSlackUserField = ({}: ResolvedSlackUserFieldProps) => (<SlackPickedEntityButtonname={resolvedUser.displayName ?? resolvedUser.slackUserId}+ avatar={{+ type: 'rounded',+ placeholder: resolvedUser.displayName ?? resolvedUser.slackUserId,+ placeholderColorSeed: resolvedUser.slackUserId,+ }}meta={isNonEmptyString(resolvedUser.email)? resolvedUser.emaildiff --git a/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsxindex e92c9c95d22..04a5955fcfb 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsx@@ -1,8 +1,13 @@import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';import { useState } from 'react';-import { themeCssVariables } from 'twenty-ui/theme-constants';+import { isDefined } from 'twenty-sdk/utils';+import { SlackDropdownBackdrop } from 'src/front-components/components/SlackDropdownBackdrop';+import {+ type SlackPickerOption,+ SlackPickerDropdownPanel,+} from 'src/front-components/components/SlackPickerDropdownPanel';import { SlackUserLinkTextInput } from 'src/front-components/components/SlackUserLinkTextInput';const StyledContainer = styled.div`@@ -10,55 +15,9 @@ const StyledContainer = styled.div`width: 100%;`;-const StyledDropdown = styled.div`- background: ${() => themeCssVariables.background.primary};- border: 1px solid ${() => themeCssVariables.border.color.medium};- border-radius: ${() => themeCssVariables.border.radius.sm};- box-shadow: ${() => themeCssVariables.boxShadow.light};- box-sizing: border-box;- left: 0;- margin-top: ${() => themeCssVariables.spacing[1]};- max-height: 240px;- overflow-y: auto;- position: absolute;- right: 0;- top: 100%;- z-index: 1;-`;--const StyledOption = styled.button`- background: transparent;- border: none;- cursor: pointer;- display: flex;- flex-direction: column;- gap: ${() => themeCssVariables.spacing[1]};- padding: ${() => themeCssVariables.spacing[2]};- text-align: left;- width: 100%;-- &:hover {- background: ${() => themeCssVariables.background.secondary};- }-`;--const StyledOptionName = styled.span`- color: ${() => themeCssVariables.font.color.primary};- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.sm};-`;--const StyledOptionMeta = styled.span`- color: ${() => themeCssVariables.font.color.tertiary};- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.xs};-`;--const StyledEmptyState = styled.div`- color: ${() => themeCssVariables.font.color.tertiary};- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.sm};- padding: ${() => themeCssVariables.spacing[2]};+const StyledInputWrapper = styled.div`+ position: relative;+ z-index: 2;`;type SearchDropdownPickerProps<TOption> = {@@ -67,9 +26,7 @@ type SearchDropdownPickerProps<TOption> = {options: TOption[];isSearching: boolean;onSelect: (option: TOption) => void;- getOptionKey: (option: TOption) => string;- getOptionName: (option: TOption) => string;- getOptionMeta: (option: TOption) => string | undefined;+ getOption: (option: TOption) => SlackPickerOption;searchLabel: string;emptyText: string;disabled?: boolean;@@ -82,71 +39,76 @@ export const SearchDropdownPicker = <TOption,>({options,isSearching,onSelect,- getOptionKey,- getOptionName,- getOptionMeta,+ getOption,searchLabel,emptyText,disabled,autoFocus,}: SearchDropdownPickerProps<TOption>) => {- const [isFocused, setIsFocused] = useState(false);+ const [isOpen, setIsOpen] = useState(false);const hasSearchTerm = isNonEmptyString(searchTerm.trim());- const isDropdownOpen = isFocused && hasSearchTerm;+ const isDropdownOpen = isOpen && hasSearchTerm;const handleSelect = (option: TOption) => {+ setIsOpen(false);onSearchTermChange('');onSelect(option);};return (<StyledContainer>- <SlackUserLinkTextInput- value={searchTerm}- onChange={(event) => onSearchTermChange(event.target.value)}- onFocus={() => setIsFocused(true)}- onBlur={() => setIsFocused(false)}- onKeyDown={(event) => {- if (event.key !== 'Enter') {- return;- }-- event.preventDefault();-- if (options.length > 0) {- handleSelect(options[0]);- }- }}- placeholder={searchLabel}- disabled={disabled}- autoFocus={autoFocus}- aria-label={searchLabel}- />+ <StyledInputWrapper>+ <SlackUserLinkTextInput+ value={searchTerm}+ onChange={(event) => {+ setIsOpen(true);+ onSearchTermChange(event.target.value);+ }}+ onFocus={() => setIsOpen(true)}+ onKeyDown={(event) => {+ if (event.key === 'Escape') {+ event.preventDefault();+ setIsOpen(false);++ return;+ }++ if (event.key !== 'Enter') {+ return;+ }++ event.preventDefault();++ if (options.length > 0) {+ handleSelect(options[0]);+ }+ }}+ placeholder={searchLabel}+ disabled={disabled}+ autoFocus={autoFocus}+ aria-label={searchLabel}+ />+ </StyledInputWrapper>{isDropdownOpen && (- <StyledDropdown onMouseDown={(event) => event.preventDefault()}>- {options.map((option) => {- const meta = getOptionMeta(option);-- return (- <StyledOption- key={getOptionKey(option)}- type="button"- onMouseDown={() => handleSelect(option)}- >- <StyledOptionName>{getOptionName(option)}</StyledOptionName>- {isNonEmptyString(meta) && (- <StyledOptionMeta>{meta}</StyledOptionMeta>- )}- </StyledOption>- );- })}- {options.length === 0 && (- <StyledEmptyState>- {isSearching ? 'Searching…' : emptyText}- </StyledEmptyState>- )}- </StyledDropdown>+ <>+ <SlackDropdownBackdrop onClose={() => setIsOpen(false)} />+ <SlackPickerDropdownPanel+ options={options.map(getOption)}+ isSearching={isSearching}+ emptyText={emptyText}+ listLabel={searchLabel}+ onSelect={(optionKey) => {+ const selectedOption = options.find(+ (option) => getOption(option).key === optionKey,+ );++ if (isDefined(selectedOption)) {+ handleSelect(selectedOption);+ }+ }}+ />+ </>)}</StyledContainer>);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackAccessModeSection.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackAccessModeSection.tsxindex 376de4e377c..d45bf08692b 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackAccessModeSection.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackAccessModeSection.tsx@@ -1,7 +1,5 @@import styled from '@emotion/styled';-import { isNonEmptyString } from '@sniptt/guards';import { useId } from 'react';-import { enqueueSnackbar } from 'twenty-sdk/front-component';import { IconLock } from 'twenty-ui/icon';import { Section } from 'twenty-ui/layout';import { Card } from 'twenty-ui/surfaces';@@ -11,6 +9,7 @@ import { H2Title } from 'twenty-ui/typography';import { Toggle } from 'src/front-components/components/Toggle';import { useSlackAccessMode } from 'src/front-components/hooks/use-slack-access-mode';+import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';const StyledCardContent = styled.div<{ $disabled: boolean }>`@@ -127,10 +126,7 @@ export const SlackAccessModeSection = ({value ? SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS : SLACK_ACCESS_MODE.ANYONE,);- enqueueSnackbar({- message: isNonEmptyString(result.error) ? result.error : result.message,- variant: result.success ? 'success' : 'error',- });+ enqueueSlackToolResultSnackbar(result);};const description = getDescription({ hasAccessModeError, isRestricted });diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelPicker.tsxnew file mode 100644index 00000000000..e08884fe1f3--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelPicker.tsx@@ -0,0 +1,52 @@+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';++import { SearchDropdownPicker } from 'src/front-components/components/SearchDropdownPicker';+import { useSlackChannelSearch } from 'src/front-components/hooks/use-slack-channel-search';+import { type SlackChannelSearchOption } from 'src/logic-functions/types/slack-channel-search.type';++const getChannelMeta = (channel: SlackChannelSearchOption): string =>+ [+ channel.isPrivate ? 'Private' : 'Public',+ channel.isMember ? undefined : 'Bot is not a member yet',+ ]+ .filter(isDefined)+ .join(' · ');++type SlackChannelPickerProps = {+ onSelect: (channel: SlackChannelSearchOption) => void;+ disabled?: boolean;+ autoFocus?: boolean;+};++export const SlackChannelPicker = ({+ onSelect,+ disabled,+ autoFocus,+}: SlackChannelPickerProps) => {+ const [searchTerm, setSearchTerm] = useState('');+ const { options, isSearching, searchErrorMessage } =+ useSlackChannelSearch(searchTerm);++ return (+ <SearchDropdownPicker+ searchTerm={searchTerm}+ onSearchTermChange={setSearchTerm}+ options={options}+ isSearching={isSearching}+ onSelect={onSelect}+ getOption={(channel) => ({+ key: channel.slackChannelId,+ name: `#${channel.name}`,+ meta: getChannelMeta(channel),+ })}+ searchLabel="Search Slack channels by name"+ emptyText={+ searchErrorMessage ??+ 'No channels found. Private channels only appear once the bot has been added to them.'+ }+ disabled={disabled}+ autoFocus={autoFocus}+ />+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleForm.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleForm.tsxnew file mode 100644index 00000000000..a0db4da473c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleForm.tsx@@ -0,0 +1,140 @@+import styled from '@emotion/styled';+import { useId, useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { Button } from 'twenty-ui/input';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { SlackChannelPicker } from 'src/front-components/components/SlackChannelPicker';+import { SlackChannelRuleModeSelect } from 'src/front-components/components/SlackChannelRuleModeSelect';+import { SlackPickedEntityButton } from 'src/front-components/components/SlackPickedEntityButton';+import { SlackUserLinkFormField } from 'src/front-components/components/SlackUserLinkFormField';+import { SlackUserLinkFormHint } from 'src/front-components/components/SlackUserLinkFormHint';+import { SLACK_CHANNEL_RULE_MODE_DESCRIPTIONS } from 'src/front-components/constants/slack-channel-rule-mode-descriptions.constant';+import { useSetSlackChannelRule } from 'src/front-components/hooks/use-set-slack-channel-rule';+import { type SlackChannelRuleRecord } from 'src/front-components/types/slack-channel-rule-record.type';+import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';+import { type SlackChannelSearchOption } from 'src/logic-functions/types/slack-channel-search.type';++const StyledForm = styled.form`+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[4]};+`;++const StyledActions = styled.div`+ display: flex;+ gap: ${() => themeCssVariables.spacing[2]};+`;++type SlackChannelRuleFormProps = {+ existingRules: SlackChannelRuleRecord[];+ onRuleSaved: () => void;+ onCancel: () => void;+};++export const SlackChannelRuleForm = ({+ existingRules,+ onRuleSaved,+ onCancel,+}: SlackChannelRuleFormProps) => {+ const modeSelectId = useId();+ const [selectedChannel, setSelectedChannel] =+ useState<SlackChannelSearchOption | null>(null);+ const [mode, setMode] = useState<SlackChannelRuleMode>(+ SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY,+ );+ const { setSlackChannelRule, savingChannelId } = useSetSlackChannelRule();++ const isSubmitting = isDefined(savingChannelId);+ const canSubmit = isDefined(selectedChannel) && !isSubmitting;++ const existingRule = isDefined(selectedChannel)+ ? existingRules.find(+ (rule) => rule.slackChannelId === selectedChannel.slackChannelId,+ )+ : undefined;++ const handleSubmit = async () => {+ if (!isDefined(selectedChannel)) {+ return;+ }++ const result = await setSlackChannelRule({+ slackChannelId: selectedChannel.slackChannelId,+ name: selectedChannel.name,+ mode,+ });++ enqueueSlackToolResultSnackbar(result);++ if (result.success) {+ setSelectedChannel(null);+ onRuleSaved();+ }+ };++ return (+ <StyledForm+ onSubmit={(event) => {+ event.preventDefault();++ if (canSubmit) {+ handleSubmit();+ }+ }}+ >+ <SlackUserLinkFormField label="Channel">+ {isDefined(selectedChannel) ? (+ <SlackPickedEntityButton+ name={`#${selectedChannel.name}`}+ meta={+ selectedChannel.isPrivate ? 'Private channel' : 'Public channel'+ }+ changeLabel="Pick a different channel"+ onChangeRequest={() => setSelectedChannel(null)}+ disabled={isSubmitting}+ />+ ) : (+ <SlackChannelPicker+ onSelect={setSelectedChannel}+ disabled={isSubmitting}+ autoFocus+ />+ )}+ </SlackUserLinkFormField>+ <SlackUserLinkFormField label="Mode" htmlFor={modeSelectId}>+ <SlackChannelRuleModeSelect+ id={modeSelectId}+ value={mode}+ onChange={setMode}+ disabled={isSubmitting}+ ariaLabel="Rule mode"+ />+ </SlackUserLinkFormField>+ <SlackUserLinkFormHint>+ {isDefined(existingRule)+ ? `This channel already has a rule; saving replaces it. ${SLACK_CHANNEL_RULE_MODE_DESCRIPTIONS[mode]}`+ : SLACK_CHANNEL_RULE_MODE_DESCRIPTIONS[mode]}+ </SlackUserLinkFormHint>+ <StyledActions>+ <Button+ type="button"+ title={isSubmitting ? 'Saving…' : 'Save rule'}+ variant="primary"+ accent="blue"+ disabled={!canSubmit}+ onClick={handleSubmit}+ />+ <Button+ type="button"+ title="Cancel"+ variant="secondary"+ disabled={isSubmitting}+ onClick={onCancel}+ />+ </StyledActions>+ </StyledForm>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeCell.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeCell.tsxnew file mode 100644index 00000000000..931c431a328--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeCell.tsx@@ -0,0 +1,44 @@+import { isDefined } from 'twenty-sdk/utils';+import { Tag } from 'twenty-ui/data-display';++import { SlackChannelRuleModeSelect } from 'src/front-components/components/SlackChannelRuleModeSelect';+import { type SlackChannelRuleRecord } from 'src/front-components/types/slack-channel-rule-record.type';+import { DISCONNECTED_SLACK_WORKSPACE_LABEL } from 'src/front-components/utils/is-from-disconnected-slack-workspace.util';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';+import { isSlackChannelRuleMode } from 'src/logic-functions/utils/is-slack-channel-rule-mode';++type SlackChannelRuleModeCellProps = {+ rule: SlackChannelRuleRecord;+ displayedName: string;+ isDisconnected: boolean;+ disabled: boolean;+ onModeChange: (mode: SlackChannelRuleMode) => void;+};++export const SlackChannelRuleModeCell = ({+ rule,+ displayedName,+ isDisconnected,+ disabled,+ onModeChange,+}: SlackChannelRuleModeCellProps) => {+ if (isDisconnected) {+ return <Tag color="gray" text={DISCONNECTED_SLACK_WORKSPACE_LABEL} />;+ }++ const mode = isSlackChannelRuleMode(rule.mode) ? rule.mode : undefined;++ if (!isDefined(mode)) {+ return <Tag color="red" text="Unknown mode" />;+ }++ return (+ <SlackChannelRuleModeSelect+ value={mode}+ onChange={onModeChange}+ disabled={disabled}+ ariaLabel={`Rule mode for ${displayedName}`}+ size="small"+ />+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeSelect.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeSelect.tsxnew file mode 100644index 00000000000..84adea07c1c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRuleModeSelect.tsx@@ -0,0 +1,36 @@+import { SlackSelect } from 'src/front-components/components/SlackSelect';+import { SLACK_CHANNEL_RULE_MODE_LABELS } from 'src/front-components/constants/slack-channel-rule-mode-labels.constant';+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++const SLACK_CHANNEL_RULE_MODE_OPTIONS = Object.values(+ SLACK_CHANNEL_RULE_MODE,+).map((mode) => ({ value: mode, label: SLACK_CHANNEL_RULE_MODE_LABELS[mode] }));++type SlackChannelRuleModeSelectProps = {+ id?: string;+ value: SlackChannelRuleMode;+ onChange: (mode: SlackChannelRuleMode) => void;+ disabled?: boolean;+ ariaLabel: string;+ size?: 'small' | 'medium';+};++export const SlackChannelRuleModeSelect = ({+ id,+ value,+ onChange,+ disabled,+ ariaLabel,+ size,+}: SlackChannelRuleModeSelectProps) => (+ <SlackSelect+ id={id}+ value={value}+ options={SLACK_CHANNEL_RULE_MODE_OPTIONS}+ onChange={onChange}+ ariaLabel={ariaLabel}+ disabled={disabled}+ size={size}+ />+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesList.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesList.tsxnew file mode 100644index 00000000000..a115d9d3d84--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesList.tsx@@ -0,0 +1,175 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';+import { Button } from 'twenty-ui/input';+import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { SlackChannelRuleModeCell } from 'src/front-components/components/SlackChannelRuleModeCell';+import {+ SlackTable,+ SlackTableBody,+ SlackTableCell,+ SlackTableHeader,+ SlackTableRow,+} from 'src/front-components/components/SlackSettingsTable';+import { useArmedRemoval } from 'src/front-components/hooks/use-armed-removal';+import { type SlackChannelRuleRecord } from 'src/front-components/types/slack-channel-rule-record.type';+import { isFromDisconnectedSlackWorkspace } from 'src/front-components/utils/is-from-disconnected-slack-workspace.util';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++const RULES_GRID_TEMPLATE_COLUMNS = 'minmax(0, 2fr) 220px 156px';++const StyledDetails = styled.div`+ display: flex;+ flex-direction: column;+ min-width: 0;+ padding: ${() => themeCssVariables.spacing[1]} 0;+`;++const StyledName = styled.div`+ color: ${() => themeCssVariables.font.color.primary};+ min-width: 0;+`;++const StyledMeta = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-size: ${() => themeCssVariables.font.size.xs};+ min-width: 0;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+`;++const StyledEmptyState = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ padding: ${() => themeCssVariables.spacing[2]};+`;++const getDisplayedName = (rule: SlackChannelRuleRecord): string =>+ isNonEmptyString(rule.name)+ ? `#${rule.name}`+ : (rule.slackChannelId ?? 'Unnamed channel');++type SlackChannelRulesListProps = {+ slackChannelRules: SlackChannelRuleRecord[];+ canManage: boolean;+ installedSlackTeamId: string | undefined;+ hasMore?: boolean;+ onModeChange: (+ rule: SlackChannelRuleRecord,+ mode: SlackChannelRuleMode,+ ) => void;+ onRemove: (rule: SlackChannelRuleRecord) => void;+ savingChannelId: string | undefined;+ removingRuleId: string | undefined;+};++export const SlackChannelRulesList = ({+ slackChannelRules,+ canManage,+ installedSlackTeamId,+ hasMore = false,+ onModeChange,+ onRemove,+ savingChannelId,+ removingRuleId,+}: SlackChannelRulesListProps) => {+ const {+ armedId: removalArmedRuleId,+ arm: armRuleRemoval,+ disarm: disarmRuleRemoval,+ } = useArmedRemoval();++ const isActionInFlight =+ isDefined(savingChannelId) || isDefined(removingRuleId);++ if (slackChannelRules.length === 0) {+ return (+ <StyledEmptyState>+ No channel rules yet. Every channel follows the workspace access mode.+ </StyledEmptyState>+ );+ }++ return (+ <SlackTable>+ <SlackTableRow gridTemplateColumns={RULES_GRID_TEMPLATE_COLUMNS}>+ <SlackTableHeader>Channel</SlackTableHeader>+ <SlackTableHeader>Mode</SlackTableHeader>+ <SlackTableHeader align="right" />+ </SlackTableRow>+ <SlackTableBody>+ {slackChannelRules.map((rule) => {+ const displayedName = getDisplayedName(rule);++ return (+ <SlackTableRow+ key={rule.id}+ gridTemplateColumns={RULES_GRID_TEMPLATE_COLUMNS}+ >+ <SlackTableCell>+ <StyledDetails>+ <StyledName>+ <OverflowingTextWithTooltip text={displayedName} />+ </StyledName>+ <StyledMeta>{rule.slackChannelId ?? 'unknown'}</StyledMeta>+ </StyledDetails>+ </SlackTableCell>+ <SlackTableCell>+ <SlackChannelRuleModeCell+ rule={rule}+ displayedName={displayedName}+ isDisconnected={isFromDisconnectedSlackWorkspace({+ slackTeamId: rule.slackTeamId,+ installedSlackTeamId,+ })}+ disabled={!canManage || isActionInFlight}+ onModeChange={(nextMode) => onModeChange(rule, nextMode)}+ />+ </SlackTableCell>+ <SlackTableCell align="right">+ {canManage &&+ (removalArmedRuleId === rule.id ? (+ <Button+ type="button"+ title={+ removingRuleId === rule.id+ ? 'Removing…'+ : 'Confirm removal'+ }+ size="small"+ variant="secondary"+ accent="danger"+ disabled={isActionInFlight}+ onClick={() => {+ disarmRuleRemoval();+ onRemove(rule);+ }}+ />+ ) : (+ <Button+ type="button"+ title="Remove"+ size="small"+ variant="secondary"+ disabled={isActionInFlight}+ onClick={() => armRuleRemoval(rule.id)}+ />+ ))}+ </SlackTableCell>+ </SlackTableRow>+ );+ })}+ {hasMore && (+ <StyledEmptyState>+ Showing {slackChannelRules.length} rules; more exist than can be+ shown here.+ </StyledEmptyState>+ )}+ </SlackTableBody>+ </SlackTable>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesSection.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesSection.tsxnew file mode 100644index 00000000000..59dff96858b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackChannelRulesSection.tsx@@ -0,0 +1,136 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { Button } from 'twenty-ui/input';+import { Section } from 'twenty-ui/layout';+import { themeCssVariables } from 'twenty-ui/theme-constants';+import { H2Title } from 'twenty-ui/typography';++import { SlackChannelRuleForm } from 'src/front-components/components/SlackChannelRuleForm';+import { SlackChannelRulesList } from 'src/front-components/components/SlackChannelRulesList';+import { useRemoveSlackChannelRule } from 'src/front-components/hooks/use-remove-slack-channel-rule';+import { useSetSlackChannelRule } from 'src/front-components/hooks/use-set-slack-channel-rule';+import { useSlackChannelRules } from 'src/front-components/hooks/use-slack-channel-rules';+import { type SlackChannelRuleRecord } from 'src/front-components/types/slack-channel-rule-record.type';+import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++const StyledCenteredState = styled.div`+ align-items: center;+ box-sizing: border-box;+ color: ${() => themeCssVariables.font.color.tertiary};+ display: flex;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ height: 100%;+ justify-content: center;+ padding: ${() => themeCssVariables.spacing[4]};+ width: 100%;+`;++const StyledDisclosure = styled.div`+ align-self: flex-start;+ padding-top: ${() => themeCssVariables.spacing[2]};+`;++type SlackChannelRulesSectionProps = {+ canManage: boolean;+ installedSlackTeamId: string | undefined;+};++export const SlackChannelRulesSection = ({+ canManage,+ installedSlackTeamId,+}: SlackChannelRulesSectionProps) => {+ const [isFormOpen, setIsFormOpen] = useState(false);+ const {+ slackChannelRules,+ isSlackChannelRulesLoading,+ channelRulesErrorMessage,+ hasMoreSlackChannelRules,+ refetchSlackChannelRules,+ } = useSlackChannelRules();+ const { setSlackChannelRule, savingChannelId } = useSetSlackChannelRule();+ const { removeSlackChannelRule, removingRuleId } =+ useRemoveSlackChannelRule();++ const handleModeChange = async (+ rule: SlackChannelRuleRecord,+ mode: SlackChannelRuleMode,+ ) => {+ if (!isNonEmptyString(rule.slackChannelId)) {+ return;+ }++ const result = await setSlackChannelRule({+ slackChannelId: rule.slackChannelId,+ name: rule.name ?? undefined,+ mode,+ });++ enqueueSlackToolResultSnackbar(result);++ if (result.success) {+ await refetchSlackChannelRules();+ }+ };++ const handleRemove = async (rule: SlackChannelRuleRecord) => {+ const result = await removeSlackChannelRule(rule.id);++ enqueueSlackToolResultSnackbar(result);++ if (result.success) {+ await refetchSlackChannelRules();+ }+ };++ const handleRuleSaved = async () => {+ setIsFormOpen(false);+ await refetchSlackChannelRules();+ };++ return (+ <Section>+ <H2Title+ title="Channels"+ description="Override the workspace access mode for specific channels: open a channel to anyone, restrict it to linked members, or silence the assistant there. Channels without a rule follow the setting above."+ />+ {isSlackChannelRulesLoading && slackChannelRules.length === 0 ? (+ <StyledCenteredState>Loading channel rules…</StyledCenteredState>+ ) : isDefined(channelRulesErrorMessage) ? (+ <StyledCenteredState>{channelRulesErrorMessage}</StyledCenteredState>+ ) : (+ <SlackChannelRulesList+ slackChannelRules={slackChannelRules}+ canManage={canManage}+ installedSlackTeamId={installedSlackTeamId}+ hasMore={hasMoreSlackChannelRules}+ onModeChange={handleModeChange}+ onRemove={handleRemove}+ savingChannelId={savingChannelId}+ removingRuleId={removingRuleId}+ />+ )}+ {canManage &&+ (isFormOpen ? (+ <SlackChannelRuleForm+ existingRules={slackChannelRules}+ onRuleSaved={handleRuleSaved}+ onCancel={() => setIsFormOpen(false)}+ />+ ) : (+ <StyledDisclosure>+ <Button+ type="button"+ title="Add a channel rule"+ size="small"+ variant="secondary"+ onClick={() => setIsFormOpen(true)}+ />+ </StyledDisclosure>+ ))}+ </Section>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownBackdrop.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownBackdrop.tsxnew file mode 100644index 00000000000..9a52b7ff79d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownBackdrop.tsx@@ -0,0 +1,15 @@+import styled from '@emotion/styled';++const StyledBackdrop = styled.div`+ inset: 0;+ position: fixed;+ z-index: 1;+`;++type SlackDropdownBackdropProps = {+ onClose: () => void;+};++export const SlackDropdownBackdrop = ({+ onClose,+}: SlackDropdownBackdropProps) => <StyledBackdrop onClick={onClose} />;diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownTrigger.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownTrigger.tsxnew file mode 100644index 00000000000..3142c04e54c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackDropdownTrigger.tsx@@ -0,0 +1,75 @@+import styled from '@emotion/styled';+import { type ReactNode } from 'react';+import { themeCssVariables } from 'twenty-ui/theme-constants';++const StyledTrigger = styled.button<{ $size: 'small' | 'medium' }>`+ align-items: center;+ background-color: ${() => themeCssVariables.background.transparent.lighter};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.md};+ box-sizing: border-box;+ cursor: pointer;+ display: grid;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ gap: ${() => themeCssVariables.spacing[1]};+ grid-template-columns: 1fr auto;+ height: ${({ $size }) =>+ $size === 'small'+ ? themeCssVariables.spacing[6]+ : themeCssVariables.spacing[8]};+ padding: 0 ${() => themeCssVariables.spacing[2]};+ text-align: left;+ width: 100%;++ &:hover:enabled {+ background-color: ${() => themeCssVariables.background.transparent.light};+ }++ &:disabled {+ cursor: not-allowed;+ }+`;++const StyledChevron = styled.div`+ border-bottom: 1px solid ${() => themeCssVariables.font.color.tertiary};+ border-right: 1px solid ${() => themeCssVariables.font.color.tertiary};+ height: 5px;+ margin-top: -3px;+ transform: rotate(45deg);+ width: 5px;+`;++type SlackDropdownTriggerProps = {+ id?: string;+ children: ReactNode;+ ariaLabel: string;+ isOpen: boolean;+ onOpen: () => void;+ disabled?: boolean;+ size?: 'small' | 'medium';+};++export const SlackDropdownTrigger = ({+ id,+ children,+ ariaLabel,+ isOpen,+ onOpen,+ disabled,+ size = 'medium',+}: SlackDropdownTriggerProps) => (+ <StyledTrigger+ id={id}+ $size={size}+ type="button"+ disabled={disabled}+ onClick={onOpen}+ aria-label={ariaLabel}+ aria-haspopup="listbox"+ aria-expanded={isOpen}+ >+ {children}+ <StyledChevron />+ </StyledTrigger>+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsxindex f5cb1639dfa..5ef55abfc08 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsx@@ -1,7 +1,11 @@import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';+import { Avatar } from 'twenty-ui/data-display';import { themeCssVariables } from 'twenty-ui/theme-constants';+import { type SlackPickerOptionAvatar } from 'src/front-components/components/SlackPickerDropdownPanel';+const StyledPickedEntity = styled.button`align-items: center;background: ${() => themeCssVariables.background.secondary};@@ -46,6 +50,7 @@ const StyledMeta = styled.span`type SlackPickedEntityButtonProps = {name: string;meta?: string;+ avatar?: SlackPickerOptionAvatar;changeLabel: string;onChangeRequest: () => void;disabled?: boolean;@@ -54,6 +59,7 @@ type SlackPickedEntityButtonProps = {export const SlackPickedEntityButton = ({name,meta,+ avatar,changeLabel,onChangeRequest,disabled,@@ -64,6 +70,14 @@ export const SlackPickedEntityButton = ({disabled={disabled}aria-label={changeLabel}>+ {isDefined(avatar) && (+ <Avatar+ placeholder={avatar.placeholder}+ placeholderColorSeed={avatar.placeholderColorSeed}+ type={avatar.type}+ size="md"+ />+ )}<StyledDetails><StyledName>{name}</StyledName>{isNonEmptyString(meta) && <StyledMeta>{meta}</StyledMeta>}diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackPickerDropdownPanel.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickerDropdownPanel.tsxnew file mode 100644index 00000000000..0e34bc4c7ec--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickerDropdownPanel.tsx@@ -0,0 +1,99 @@+import styled from '@emotion/styled';+import { isDefined } from 'twenty-sdk/utils';+import { type ReactNode } from 'react';+import { MenuItem, MenuItemAvatar } from 'twenty-ui/navigation';+import { themeCssVariables } from 'twenty-ui/theme-constants';++export type SlackPickerOptionAvatar = {+ placeholder: string;+ placeholderColorSeed: string;+ type: 'rounded' | 'squared';+};++export type SlackPickerOption = {+ key: string;+ name: string;+ meta?: string;+ avatar?: SlackPickerOptionAvatar;+ isSelected?: boolean;+};++const StyledDropdownPanel = styled.div`+ background: ${() => themeCssVariables.background.primary};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.md};+ box-shadow: ${() => themeCssVariables.boxShadow.light};+ box-sizing: border-box;+ left: 0;+ margin-top: ${() => themeCssVariables.spacing[1]};+ min-width: 240px;+ position: absolute;+ top: 100%;+ width: 100%;+ z-index: 2;+`;++const StyledOptions = styled.div`+ max-height: 240px;+ overflow-y: auto;+ padding: ${() => themeCssVariables.spacing[1]};+`;++type SlackPickerDropdownPanelProps = {+ options: SlackPickerOption[];+ isSearching: boolean;+ emptyText: string;+ listLabel: string;+ onSelect: (optionKey: string) => void;+ header?: ReactNode;+};++export const SlackPickerDropdownPanel = ({+ options,+ isSearching,+ emptyText,+ listLabel,+ onSelect,+ header,+}: SlackPickerDropdownPanelProps) => (+ <StyledDropdownPanel>+ {header}+ <StyledOptions+ role="listbox"+ aria-label={listLabel}+ onMouseDown={(event) => event.preventDefault()}+ >+ {options.map((option) => (+ <div+ key={option.key}+ role="option"+ aria-selected={option.isSelected === true}+ >+ {isDefined(option.avatar) ? (+ <MenuItemAvatar+ avatar={{+ type: option.avatar.type,+ size: 'md',+ placeholder: option.avatar.placeholder,+ placeholderColorSeed: option.avatar.placeholderColorSeed,+ }}+ text={option.name}+ contextualText={option.meta}+ onClick={() => onSelect(option.key)}+ />+ ) : (+ <MenuItem+ text={option.name}+ contextualText={option.meta}+ selected={option.isSelected}+ onClick={() => onSelect(option.key)}+ />+ )}+ </div>+ ))}+ {options.length === 0 && (+ <MenuItem disabled text={isSearching ? 'Searching…' : emptyText} />+ )}+ </StyledOptions>+ </StyledDropdownPanel>+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackSelect.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackSelect.tsxnew file mode 100644index 00000000000..aed2dd25e4c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackSelect.tsx@@ -0,0 +1,91 @@+import styled from '@emotion/styled';+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { SlackDropdownBackdrop } from 'src/front-components/components/SlackDropdownBackdrop';+import { SlackDropdownTrigger } from 'src/front-components/components/SlackDropdownTrigger';+import { SlackPickerDropdownPanel } from 'src/front-components/components/SlackPickerDropdownPanel';++const StyledContainer = styled.div`+ min-width: 0;+ position: relative;+ width: 100%;+`;++const StyledValue = styled.div`+ color: ${() => themeCssVariables.font.color.primary};+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+`;++type SlackSelectOption<TValue extends string> = {+ value: TValue;+ label: string;+};++type SlackSelectProps<TValue extends string> = {+ id?: string;+ value: TValue;+ options: SlackSelectOption<TValue>[];+ onChange: (value: TValue) => void;+ ariaLabel: string;+ disabled?: boolean;+ size?: 'small' | 'medium';+};++export const SlackSelect = <TValue extends string>({+ id,+ value,+ options,+ onChange,+ ariaLabel,+ disabled,+ size = 'medium',+}: SlackSelectProps<TValue>) => {+ const [isOpen, setIsOpen] = useState(false);++ const selectedOption = options.find((option) => option.value === value);++ return (+ <StyledContainer>+ <SlackDropdownTrigger+ id={id}+ ariaLabel={ariaLabel}+ isOpen={isOpen}+ onOpen={() => setIsOpen(true)}+ disabled={disabled}+ size={size}+ >+ <StyledValue>{selectedOption?.label ?? value}</StyledValue>+ </SlackDropdownTrigger>+ {isOpen && (+ <>+ <SlackDropdownBackdrop onClose={() => setIsOpen(false)} />+ <SlackPickerDropdownPanel+ options={options.map((option) => ({+ key: option.value,+ name: option.label,+ isSelected: option.value === value,+ }))}+ isSearching={false}+ emptyText="No options"+ listLabel={ariaLabel}+ onSelect={(optionKey) => {+ setIsOpen(false);++ const nextOption = options.find(+ (option) => option.value === optionKey,+ );++ if (isDefined(nextOption)) {+ onChange(nextOption.value);+ }+ }}+ />+ </>+ )}+ </StyledContainer>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsxindex 56ff63860ea..cb96c969c03 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx@@ -2,7 +2,6 @@ import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';import { useState } from 'react';import { isDefined } from 'twenty-sdk/utils';-import { enqueueSnackbar } from 'twenty-sdk/front-component';import { Button } from 'twenty-ui/input';import { Section } from 'twenty-ui/layout';import { themeCssVariables } from 'twenty-ui/theme-constants';@@ -20,6 +19,7 @@ import { useSetSlackUserLink } from 'src/front-components/hooks/use-set-slack-usimport { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';import { buildSlackUserLinkSaveNote } from 'src/front-components/utils/build-slack-user-link-save-note.util';+import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';const StyledForm = styled.form`display: flex;@@ -109,10 +109,7 @@ export const SlackUserLinkForm = ({: resolvedUser.displayName,});- enqueueSnackbar({- message: isNonEmptyString(result.error) ? result.error : result.message,- variant: result.success ? 'success' : 'error',- });+ enqueueSlackToolResultSnackbar(result);if (result.success) {resetForm();diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsxindex df54f437328..94ea7e4d0b4 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx@@ -1,6 +1,5 @@import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';-import { useEffect, useState } from 'react';import { isDefined } from 'twenty-sdk/utils';import { Avatar, Tag } from 'twenty-ui/data-display';import { Button } from 'twenty-ui/input';@@ -18,10 +17,14 @@ import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slaimport { SLACK_USER_LINK_SOURCE } from 'src/logic-functions/constants/slack-user-link-source';import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';import { isSlackUserLinkConsentState } from 'src/logic-functions/utils/is-slack-user-link-consent-state';+import { useArmedRemoval } from 'src/front-components/hooks/use-armed-removal';import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+import {+ DISCONNECTED_SLACK_WORKSPACE_LABEL,+ isFromDisconnectedSlackWorkspace,+} from 'src/front-components/utils/is-from-disconnected-slack-workspace.util';const LINKS_GRID_TEMPLATE_COLUMNS = 'minmax(0, 2fr) minmax(0, 2fr) 320px 156px';-const REMOVAL_CONFIRM_TIMEOUT_MS = 4000;const StyledIdentity = styled.div`align-items: center;@@ -94,19 +97,6 @@ const CONSENT_COLORS: Record<SlackUserLinkConsentState, TagColor> = {[SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET]: 'gray',};-const DISCONNECTED_WORKSPACE_LABEL = 'Slack workspace disconnected';--const isFromDisconnectedSlackWorkspace = ({- slackUserLink,- installedSlackTeamId,-}: {- slackUserLink: SlackUserLinkRecord;- installedSlackTeamId: string | undefined;-}): boolean =>- isNonEmptyString(installedSlackTeamId) &&- isNonEmptyString(slackUserLink.slackTeamId) &&- slackUserLink.slackTeamId !== installedSlackTeamId;-type SlackUserLinksListProps = {slackUserLinks: SlackUserLinkRecord[];canManage: boolean;@@ -128,22 +118,11 @@ export const SlackUserLinksList = ({removingLinkId,resendingLinkId,}: SlackUserLinksListProps) => {- const [removalArmedLinkId, setRemovalArmedLinkId] = useState<string | null>(- null,- );-- useEffect(() => {- if (removalArmedLinkId === null) {- return undefined;- }-- const disarmTimer = setTimeout(- () => setRemovalArmedLinkId(null),- REMOVAL_CONFIRM_TIMEOUT_MS,- );-- return () => clearTimeout(disarmTimer);- }, [removalArmedLinkId]);+ const {+ armedId: removalArmedLinkId,+ arm: armLinkRemoval,+ disarm: disarmLinkRemoval,+ } = useArmedRemoval();const isActionInFlight =isDefined(removingLinkId) || isDefined(resendingLinkId);@@ -163,7 +142,7 @@ export const SlackUserLinksList = ({<SlackTableBody>{slackUserLinks.map((slackUserLink) => {const isDisconnected = isFromDisconnectedSlackWorkspace({- slackUserLink,+ slackTeamId: slackUserLink.slackTeamId,installedSlackTeamId,});const consentState = toDisplayedConsentState(@@ -208,7 +187,7 @@ export const SlackUserLinksList = ({</SlackTableCell><SlackTableCell>{isDisconnected ? (- <Tag color="gray" text={DISCONNECTED_WORKSPACE_LABEL} />+ <Tag color="gray" text={DISCONNECTED_SLACK_WORKSPACE_LABEL} />) : (isDefined(consentState) && (<Tag@@ -252,7 +231,7 @@ export const SlackUserLinksList = ({accent="danger"disabled={isActionInFlight}onClick={() => {- setRemovalArmedLinkId(null);+ disarmLinkRemoval();onRemove(slackUserLink);}}/>@@ -263,7 +242,7 @@ export const SlackUserLinksList = ({size="small"variant="secondary"disabled={isActionInFlight}- onClick={() => setRemovalArmedLinkId(slackUserLink.id)}+ onClick={() => armLinkRemoval(slackUserLink.id)}/>)}</>diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsxindex a2855560134..696a324c32f 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx@@ -14,6 +14,7 @@ import { ThemeProvider, themeCssVariables } from 'twenty-ui/theme-constants';import { H2Title } from 'twenty-ui/typography';import { SlackAccessModeSection } from 'src/front-components/components/SlackAccessModeSection';+import { SlackChannelRulesSection } from 'src/front-components/components/SlackChannelRulesSection';import { SlackUserLinkForm } from 'src/front-components/components/SlackUserLinkForm';import { SlackUserLinksList } from 'src/front-components/components/SlackUserLinksList';import { UnlinkedSlackUsersList } from 'src/front-components/components/UnlinkedSlackUsersList';@@ -26,6 +27,7 @@ import { useResendSlackUserLinkConsent } from 'src/front-components/hooks/use-reimport { useSlackUserLinks } from 'src/front-components/hooks/use-slack-user-links';import { useUnlinkedSlackUsers } from 'src/front-components/hooks/use-unlinked-slack-users';import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';const StyledContainer = styled.div`box-sizing: border-box;@@ -131,10 +133,7 @@ const SlackUserLinksSettingsContent = () => {const handleRemove = async (slackUserLink: SlackUserLinkRecord) => {const result = await removeSlackUserLink(slackUserLink.id);- enqueueSnackbar({- message: isNonEmptyString(result.error) ? result.error : result.message,- variant: result.success ? 'success' : 'error',- });+ enqueueSlackToolResultSnackbar(result);if (result.success) {await handleLinkSaved();@@ -161,10 +160,7 @@ const SlackUserLinksSettingsContent = () => {slackUserId: slackUserLink.slackUserId,});- enqueueSnackbar({- message: isNonEmptyString(result.error) ? result.error : result.message,- variant: result.success ? 'success' : 'error',- });+ enqueueSlackToolResultSnackbar(result);if (result.success) {await refetchSlackUserLinks();@@ -215,6 +211,10 @@ const SlackUserLinksSettingsContent = () => {/>)}<SlackAccessModeSection canManage={canManage} />+ <SlackChannelRulesSection+ canManage={canManage}+ installedSlackTeamId={installedSlackTeamId}+ />{canManage && (<Section><H2Titlediff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsxindex efed8089e46..b6bf1ae0d13 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsx@@ -26,11 +26,20 @@ export const SlackUserPicker = ({options={options}isSearching={isSearching}onSelect={onSelect}- getOptionKey={(slackUser) => slackUser.slackUserId}- getOptionName={(slackUser) =>- slackUser.displayName ?? slackUser.slackUserId- }- getOptionMeta={(slackUser) => slackUser.email}+ getOption={(slackUser) => {+ const displayedName = slackUser.displayName ?? slackUser.slackUserId;++ return {+ key: slackUser.slackUserId,+ name: displayedName,+ meta: slackUser.email,+ avatar: {+ type: 'rounded',+ placeholder: displayedName,+ placeholderColorSeed: slackUser.slackUserId,+ },+ };+ }}searchLabel="Search Slack by name or email"emptyText={searchErrorMessage ??diff --git a/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsxindex 4783f2a6c50..6153e4115a8 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx@@ -1,4 +1,3 @@-import { isNonEmptyString } from '@sniptt/guards';import { isDefined } from 'twenty-sdk/utils';import { useState } from 'react';@@ -31,6 +30,12 @@ export const WorkspaceMemberPicker = ({return (<SlackPickedEntityButtonname={getMemberDisplayName(selectedMember)}+ meta={selectedMember.userEmail ?? undefined}+ avatar={{+ type: 'rounded',+ placeholder: getMemberDisplayName(selectedMember),+ placeholderColorSeed: selectedMember.id,+ }}changeLabel="Change the workspace member"onChangeRequest={() => {setIsReopening(true);@@ -51,11 +56,20 @@ export const WorkspaceMemberPicker = ({setIsReopening(false);onSelect(member);}}- getOptionKey={(member) => member.id}- getOptionName={(member) =>- isNonEmptyString(member.name) ? member.name : member.id- }- getOptionMeta={(member) => member.userEmail ?? undefined}+ getOption={(member) => {+ const displayedName = getMemberDisplayName(member);++ return {+ key: member.id,+ name: displayedName,+ meta: member.userEmail ?? undefined,+ avatar: {+ type: 'rounded',+ placeholder: displayedName,+ placeholderColorSeed: member.id,+ },+ };+ }}searchLabel="Search a workspace member by name"emptyText={searchErrorMessage ?? 'No members found'}disabled={disabled}diff --git a/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-descriptions.constant.ts b/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-descriptions.constant.tsnew file mode 100644index 00000000000..f46c404d1c1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-descriptions.constant.ts@@ -0,0 +1,14 @@+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export const SLACK_CHANNEL_RULE_MODE_DESCRIPTIONS: Record<+ SlackChannelRuleMode,+ string+> = {+ [SLACK_CHANNEL_RULE_MODE.OPEN]:+ 'Anyone in the channel can use the assistant, even when the workspace is restricted.',+ [SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY]:+ 'Only Slack accounts linked to a workspace member get an answer. Others are asked to have an admin link them.',+ [SLACK_CHANNEL_RULE_MODE.SILENT]:+ 'The assistant ignores the channel: no thinking status, nothing recorded. Whoever mentions it gets a private note that it is silenced there.',+};diff --git a/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-labels.constant.ts b/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-labels.constant.tsnew file mode 100644index 00000000000..13d51f139a2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/constants/slack-channel-rule-mode-labels.constant.ts@@ -0,0 +1,11 @@+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export const SLACK_CHANNEL_RULE_MODE_LABELS: Record<+ SlackChannelRuleMode,+ string+> = {+ [SLACK_CHANNEL_RULE_MODE.OPEN]: 'Open to anyone',+ [SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY]: 'Linked members only',+ [SLACK_CHANNEL_RULE_MODE.SILENT]: 'Silent',+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-armed-removal.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-armed-removal.tsnew file mode 100644index 00000000000..3a88febff00--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-armed-removal.ts@@ -0,0 +1,32 @@+import { useEffect, useState } from 'react';++type ArmedRemovalState = {+ armedId: string | null;+ arm: (id: string) => void;+ disarm: () => void;+};++const REMOVAL_CONFIRM_TIMEOUT_MS = 4000;++export const useArmedRemoval = (): ArmedRemovalState => {+ const [armedId, setArmedId] = useState<string | null>(null);++ useEffect(() => {+ if (armedId === null) {+ return undefined;+ }++ const disarmTimer = setTimeout(+ () => setArmedId(null),+ REMOVAL_CONFIRM_TIMEOUT_MS,+ );++ return () => clearTimeout(disarmTimer);+ }, [armedId]);++ return {+ armedId,+ arm: setArmedId,+ disarm: () => setArmedId(null),+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-channel-rule.tsnew file mode 100644index 00000000000..ac01a42ff55--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-channel-rule.ts@@ -0,0 +1,22 @@+import { SLACK_CHANNEL_RULES_REMOVE_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { useSlackToolPost } from 'src/front-components/hooks/use-slack-tool-post';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++type RemoveSlackChannelRuleState = {+ removeSlackChannelRule: (id: string) => Promise<SlackToolResult>;+ removingRuleId: string | undefined;+};++export const useRemoveSlackChannelRule = (): RemoveSlackChannelRuleState => {+ const { postSlackTool, inFlightLinkId } = useSlackToolPost({+ routePath: SLACK_CHANNEL_RULES_REMOVE_ROUTE_PATH,+ fallbackMessage: 'Could not remove the channel rule',+ busyError: 'Another removal is still in progress. Please wait.',+ });++ return {+ removeSlackChannelRule: (id) =>+ postSlackTool({ linkId: id, payload: { id } }),+ removingRuleId: inFlightLinkId,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-channel-rule.tsnew file mode 100644index 00000000000..140d1b727ef--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-channel-rule.ts@@ -0,0 +1,25 @@+import { SLACK_CHANNEL_RULES_SET_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { useSlackToolPost } from 'src/front-components/hooks/use-slack-tool-post';+import { type SlackSetChannelRuleInput } from 'src/logic-functions/types/slack-set-channel-rule-input.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++type SetSlackChannelRuleState = {+ setSlackChannelRule: (+ input: SlackSetChannelRuleInput,+ ) => Promise<SlackToolResult>;+ savingChannelId: string | undefined;+};++export const useSetSlackChannelRule = (): SetSlackChannelRuleState => {+ const { postSlackTool, inFlightLinkId } = useSlackToolPost({+ routePath: SLACK_CHANNEL_RULES_SET_ROUTE_PATH,+ fallbackMessage: 'Could not save the channel rule',+ busyError: 'Another save is still in progress. Please wait.',+ });++ return {+ setSlackChannelRule: (input) =>+ postSlackTool({ linkId: input.slackChannelId, payload: input }),+ savingChannelId: inFlightLinkId,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-rules.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-rules.tsnew file mode 100644index 00000000000..be0993c027d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-rules.ts@@ -0,0 +1,154 @@+import { isNonEmptyString, isNumber } from '@sniptt/guards';+import { useCallback, useEffect, useRef, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { type SlackChannelRuleRecord } from 'src/front-components/types/slack-channel-rule-record.type';++const SLACK_CHANNEL_RULES_PAGE_SIZE = 200;+const SLACK_CHANNEL_RULES_MAX_PAGES = 10;++const SLACK_CHANNEL_RULES_ERROR_MESSAGE =+ 'Could not load Slack channel rules. Please try again later.';++type SlackChannelRuleRestRecord = {+ id?: string | null;+ name?: string | null;+ slackChannelId?: string | null;+ slackTeamId?: string | null;+ mode?: string | null;+};++type SlackChannelRulesResponse = {+ data?: { slackChannelRules?: SlackChannelRuleRestRecord[] | null } | null;+ totalCount?: number | null;+ pageInfo?: {+ hasNextPage?: boolean | null;+ endCursor?: string | null;+ } | null;+};++const fetchAllSlackChannelRulePages = async (): Promise<{+ records: SlackChannelRuleRestRecord[];+ totalCount: number | undefined;+}> => {+ const client = new RestApiClient();+ const records: SlackChannelRuleRestRecord[] = [];+ let startingAfter: string | undefined;+ let totalCount: number | undefined;++ for (let page = 0; page < SLACK_CHANNEL_RULES_MAX_PAGES; page += 1) {+ const response = await client.get<SlackChannelRulesResponse>(+ '/rest/slackChannelRules',+ {+ query: {+ limit: String(SLACK_CHANNEL_RULES_PAGE_SIZE),+ starting_after: startingAfter,+ },+ },+ );++ records.push(...(response.data?.slackChannelRules ?? []));+ totalCount = isNumber(response.totalCount)+ ? response.totalCount+ : totalCount;++ const endCursor = response.pageInfo?.endCursor;++ if (+ response.pageInfo?.hasNextPage !== true ||+ !isNonEmptyString(endCursor)+ ) {+ break;+ }++ startingAfter = endCursor;+ }++ return { records, totalCount };+};++type SlackChannelRulesState = {+ slackChannelRules: SlackChannelRuleRecord[];+ isSlackChannelRulesLoading: boolean;+ channelRulesErrorMessage: string | undefined;+ hasMoreSlackChannelRules: boolean;+ refetchSlackChannelRules: () => Promise<void>;+};++export const useSlackChannelRules = (): SlackChannelRulesState => {+ const [slackChannelRules, setSlackChannelRules] = useState<+ SlackChannelRuleRecord[]+ >([]);+ const [isSlackChannelRulesLoading, setIsSlackChannelRulesLoading] =+ useState(true);+ const [channelRulesErrorMessage, setChannelRulesErrorMessage] = useState<+ string | undefined+ >(undefined);+ const [hasMoreSlackChannelRules, setHasMoreSlackChannelRules] =+ useState(false);+ const fetchIdRef = useRef(0);++ const fetchSlackChannelRules = useCallback(async () => {+ fetchIdRef.current += 1;+ const fetchId = fetchIdRef.current;++ setIsSlackChannelRulesLoading(true);+ setChannelRulesErrorMessage(undefined);++ try {+ const { records: restRecords, totalCount } =+ await fetchAllSlackChannelRulePages();++ const records: SlackChannelRuleRecord[] = [];++ for (const record of restRecords) {+ if (!isNonEmptyString(record.id)) {+ continue;+ }++ records.push({+ id: record.id,+ name: record.name ?? null,+ slackChannelId: record.slackChannelId ?? null,+ slackTeamId: record.slackTeamId ?? null,+ mode: record.mode ?? null,+ });+ }++ records.sort((left, right) =>+ (left.name ?? left.slackChannelId ?? '').localeCompare(+ right.name ?? right.slackChannelId ?? '',+ ),+ );++ if (fetchId !== fetchIdRef.current) {+ return;+ }++ setHasMoreSlackChannelRules(+ isNumber(totalCount) && totalCount > records.length,+ );+ setSlackChannelRules(records);+ } catch {+ if (fetchId === fetchIdRef.current) {+ setChannelRulesErrorMessage(SLACK_CHANNEL_RULES_ERROR_MESSAGE);+ }+ } finally {+ if (fetchId === fetchIdRef.current) {+ setIsSlackChannelRulesLoading(false);+ }+ }+ }, []);++ useEffect(() => {+ fetchSlackChannelRules();+ }, [fetchSlackChannelRules]);++ return {+ slackChannelRules,+ isSlackChannelRulesLoading,+ channelRulesErrorMessage,+ hasMoreSlackChannelRules,+ refetchSlackChannelRules: fetchSlackChannelRules,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-search.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-search.tsnew file mode 100644index 00000000000..113c1cfc53a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-channel-search.ts@@ -0,0 +1,14 @@+import { SLACK_CHANNEL_RULES_SEARCH_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { useSlackRouteSearch } from 'src/front-components/hooks/use-slack-route-search';+import {+ FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ parseSlackChannelSearchResponse,+} from 'src/front-components/utils/parse-slack-channel-search-response.util';++export const useSlackChannelSearch = (searchTerm: string) =>+ useSlackRouteSearch({+ routePath: SLACK_CHANNEL_RULES_SEARCH_ROUTE_PATH,+ searchTerm,+ parseResponse: parseSlackChannelSearchResponse,+ fallbackErrorMessage: FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ });diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-route-search.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-route-search.tsnew file mode 100644index 00000000000..3a8d4266538--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-route-search.ts@@ -0,0 +1,82 @@+import { isNonEmptyString } from '@sniptt/guards';+import { useEffect, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++const SLACK_SEARCH_DEBOUNCE_MS = 400;++type SlackRouteSearchState<TOption> = {+ options: TOption[];+ isSearching: boolean;+ searchErrorMessage: string | undefined;+};++export const useSlackRouteSearch = <TOption>({+ routePath,+ searchTerm,+ parseResponse,+ fallbackErrorMessage,+}: {+ routePath: string;+ searchTerm: string;+ parseResponse: (value: unknown) => {+ options: TOption[];+ errorMessage: string | undefined;+ };+ fallbackErrorMessage: string;+}): SlackRouteSearchState<TOption> => {+ const [options, setOptions] = useState<TOption[]>([]);+ const [isSearching, setIsSearching] = useState(false);+ const [searchErrorMessage, setSearchErrorMessage] = useState<+ string | undefined+ >(undefined);++ useEffect(() => {+ const trimmedSearchTerm = searchTerm.trim();++ if (!isNonEmptyString(trimmedSearchTerm)) {+ setOptions([]);+ setSearchErrorMessage(undefined);+ setIsSearching(false);++ return;+ }++ let cancelled = false;++ setOptions([]);+ setSearchErrorMessage(undefined);+ setIsSearching(true);++ const timeoutId = setTimeout(async () => {+ try {+ const result = await new RestApiClient().post(`/s${routePath}`, {+ query: trimmedSearchTerm,+ });++ if (!cancelled) {+ const { options: parsedOptions, errorMessage } =+ parseResponse(result);++ setOptions(parsedOptions);+ setSearchErrorMessage(errorMessage);+ }+ } catch {+ if (!cancelled) {+ setOptions([]);+ setSearchErrorMessage(fallbackErrorMessage);+ }+ } finally {+ if (!cancelled) {+ setIsSearching(false);+ }+ }+ }, SLACK_SEARCH_DEBOUNCE_MS);++ return () => {+ cancelled = true;+ clearTimeout(timeoutId);+ };+ }, [routePath, searchTerm, parseResponse, fallbackErrorMessage]);++ return { options, isSearching, searchErrorMessage };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.tsindex adf080eb0f6..f2129c44b2e 100644--- a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.ts+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.ts@@ -1,79 +1,14 @@-import { isNonEmptyString } from '@sniptt/guards';-import { useEffect, useState } from 'react';-import { RestApiClient } from 'twenty-client-sdk/rest';-import { SLACK_USER_LINKS_SEARCH_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { useSlackRouteSearch } from 'src/front-components/hooks/use-slack-route-search';import {FALLBACK_SEARCH_ERROR_MESSAGE,parseSlackUserSearchResponse,} from 'src/front-components/utils/parse-slack-user-search-response.util';-import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';--const SLACK_USER_SEARCH_DEBOUNCE_MS = 400;--type SlackUserSearchState = {- options: SlackResolvedUser[];- isSearching: boolean;- searchErrorMessage: string | undefined;-};--export const useSlackUserSearch = (- searchTerm: string,-): SlackUserSearchState => {- const [options, setOptions] = useState<SlackResolvedUser[]>([]);- const [isSearching, setIsSearching] = useState(false);- const [searchErrorMessage, setSearchErrorMessage] = useState<- string | undefined- >(undefined);-- useEffect(() => {- const trimmedSearchTerm = searchTerm.trim();-- if (!isNonEmptyString(trimmedSearchTerm)) {- setOptions([]);- setSearchErrorMessage(undefined);- setIsSearching(false);-- return;- }-- let cancelled = false;-- setOptions([]);- setSearchErrorMessage(undefined);- setIsSearching(true);-- const timeoutId = setTimeout(async () => {- try {- const result = await new RestApiClient().post(- `/s${SLACK_USER_LINKS_SEARCH_ROUTE_PATH}`,- { query: trimmedSearchTerm },- );-- if (!cancelled) {- const { options: parsedOptions, errorMessage } =- parseSlackUserSearchResponse(result);-- setOptions(parsedOptions);- setSearchErrorMessage(errorMessage);- }- } catch {- if (!cancelled) {- setOptions([]);- setSearchErrorMessage(FALLBACK_SEARCH_ERROR_MESSAGE);- }- } finally {- if (!cancelled) {- setIsSearching(false);- }- }- }, SLACK_USER_SEARCH_DEBOUNCE_MS);-- return () => {- cancelled = true;- clearTimeout(timeoutId);- };- }, [searchTerm]);- return { options, isSearching, searchErrorMessage };-};+export const useSlackUserSearch = (searchTerm: string) =>+ useSlackRouteSearch({+ routePath: SLACK_USER_LINKS_SEARCH_ROUTE_PATH,+ searchTerm,+ parseResponse: parseSlackUserSearchResponse,+ fallbackErrorMessage: FALLBACK_SEARCH_ERROR_MESSAGE,+ });diff --git a/packages/twenty-apps/public/slack/src/front-components/types/slack-channel-rule-record.type.ts b/packages/twenty-apps/public/slack/src/front-components/types/slack-channel-rule-record.type.tsnew file mode 100644index 00000000000..c1e3b2f14c2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/types/slack-channel-rule-record.type.ts@@ -0,0 +1,7 @@+export type SlackChannelRuleRecord = {+ id: string;+ name: string | null;+ slackChannelId: string | null;+ slackTeamId: string | null;+ mode: string | null;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/enqueue-slack-tool-result-snackbar.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/enqueue-slack-tool-result-snackbar.util.test.tsnew file mode 100644index 00000000000..8329befc221--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/enqueue-slack-tool-result-snackbar.util.test.ts@@ -0,0 +1,55 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { enqueueSlackToolResultSnackbar } from 'src/front-components/utils/enqueue-slack-tool-result-snackbar.util';++const { enqueueSnackbarMock } = vi.hoisted(() => ({+ enqueueSnackbarMock: vi.fn(),+}));++vi.mock('twenty-sdk/front-component', () => ({+ enqueueSnackbar: enqueueSnackbarMock,+}));++describe('enqueueSlackToolResultSnackbar', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ });++ it('should show the message as a success', () => {+ enqueueSlackToolResultSnackbar({+ success: true,+ message: 'Saved the rule',+ });++ expect(enqueueSnackbarMock).toHaveBeenCalledWith({+ message: 'Saved the rule',+ variant: 'success',+ });+ });++ it('should prefer the error over the message on a failure', () => {+ enqueueSlackToolResultSnackbar({+ success: false,+ message: 'Could not save the rule',+ error: 'Slack rejected the channel',+ });++ expect(enqueueSnackbarMock).toHaveBeenCalledWith({+ message: 'Slack rejected the channel',+ variant: 'error',+ });+ });++ it('should fall back to the message when the error is empty', () => {+ enqueueSlackToolResultSnackbar({+ success: false,+ message: 'Could not save the rule',+ error: '',+ });++ expect(enqueueSnackbarMock).toHaveBeenCalledWith({+ message: 'Could not save the rule',+ variant: 'error',+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-from-disconnected-slack-workspace.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-from-disconnected-slack-workspace.util.test.tsnew file mode 100644index 00000000000..dc857263459--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-from-disconnected-slack-workspace.util.test.ts@@ -0,0 +1,35 @@+import { describe, expect, it } from 'vitest';++import { isFromDisconnectedSlackWorkspace } from 'src/front-components/utils/is-from-disconnected-slack-workspace.util';++describe('isFromDisconnectedSlackWorkspace', () => {+ it('should be true only when both team ids are known and differ', () => {+ expect(+ isFromDisconnectedSlackWorkspace({+ slackTeamId: 'T0OLD',+ installedSlackTeamId: 'T0NEW',+ }),+ ).toBe(true);+ expect(+ isFromDisconnectedSlackWorkspace({+ slackTeamId: 'T0NEW',+ installedSlackTeamId: 'T0NEW',+ }),+ ).toBe(false);+ });++ it('should not flag a record or workspace whose team id is unknown', () => {+ expect(+ isFromDisconnectedSlackWorkspace({+ slackTeamId: null,+ installedSlackTeamId: 'T0NEW',+ }),+ ).toBe(false);+ expect(+ isFromDisconnectedSlackWorkspace({+ slackTeamId: 'T0OLD',+ installedSlackTeamId: undefined,+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-channel-search-response.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-channel-search-response.util.test.tsnew file mode 100644index 00000000000..465d501151d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-channel-search-response.util.test.ts@@ -0,0 +1,50 @@+import { describe, expect, it } from 'vitest';++import {+ FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ parseSlackChannelSearchResponse,+} from 'src/front-components/utils/parse-slack-channel-search-response.util';++describe('parseSlackChannelSearchResponse', () => {+ it('should fall back to the generic error when the value is not a record', () => {+ expect(parseSlackChannelSearchResponse('nope')).toEqual({+ options: [],+ errorMessage: FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ });+ });++ it('should surface the server error on failure, falling back when missing', () => {+ expect(+ parseSlackChannelSearchResponse({ success: false, error: 'Not allowed' }),+ ).toEqual({ options: [], errorMessage: 'Not allowed' });+ expect(parseSlackChannelSearchResponse({ success: false })).toEqual({+ options: [],+ errorMessage: FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ });+ });++ it('should return no options and no error when slackChannels is not an array', () => {+ expect(+ parseSlackChannelSearchResponse({ success: true, slackChannels: 'nope' }),+ ).toEqual({ options: [], errorMessage: undefined });+ });++ it('should map valid entries and skip malformed ones', () => {+ expect(+ parseSlackChannelSearchResponse({+ success: true,+ slackChannels: [+ 'not-a-record',+ { name: 'no-id' },+ { slackChannelId: 'C2', name: '' },+ { slackChannelId: 'C1', name: 'eng', isPrivate: true },+ ],+ }),+ ).toEqual({+ options: [+ { slackChannelId: 'C1', name: 'eng', isPrivate: true, isMember: false },+ ],+ errorMessage: undefined,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/enqueue-slack-tool-result-snackbar.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/enqueue-slack-tool-result-snackbar.util.tsnew file mode 100644index 00000000000..eeb50d6b8e3--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/enqueue-slack-tool-result-snackbar.util.ts@@ -0,0 +1,11 @@+import { isNonEmptyString } from '@sniptt/guards';+import { enqueueSnackbar } from 'twenty-sdk/front-component';++import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++export const enqueueSlackToolResultSnackbar = (result: SlackToolResult) => {+ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: result.success ? 'success' : 'error',+ });+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/is-from-disconnected-slack-workspace.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/is-from-disconnected-slack-workspace.util.tsnew file mode 100644index 00000000000..958bda84878--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/is-from-disconnected-slack-workspace.util.ts@@ -0,0 +1,15 @@+import { isNonEmptyString } from '@sniptt/guards';++export const DISCONNECTED_SLACK_WORKSPACE_LABEL =+ 'Slack workspace disconnected';++export const isFromDisconnectedSlackWorkspace = ({+ slackTeamId,+ installedSlackTeamId,+}: {+ slackTeamId: string | null;+ installedSlackTeamId: string | undefined;+}): boolean =>+ isNonEmptyString(installedSlackTeamId) &&+ isNonEmptyString(slackTeamId) &&+ slackTeamId !== installedSlackTeamId;diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-channel-search-response.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-channel-search-response.util.tsnew file mode 100644index 00000000000..0e2905979f2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-channel-search-response.util.ts@@ -0,0 +1,57 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { type SlackChannelSearchOption } from 'src/logic-functions/types/slack-channel-search.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';++export type SlackChannelSearchResponse = {+ options: SlackChannelSearchOption[];+ errorMessage: string | undefined;+};++export const FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE =+ 'Slack channel search failed. Try again.';++export const parseSlackChannelSearchResponse = (+ value: unknown,+): SlackChannelSearchResponse => {+ const record = asRecord(value);++ if (!isDefined(record) || record.success !== true) {+ const error = record?.error;++ return {+ options: [],+ errorMessage: isNonEmptyString(error)+ ? error+ : FALLBACK_CHANNEL_SEARCH_ERROR_MESSAGE,+ };+ }++ const slackChannels = Array.isArray(record.slackChannels)+ ? record.slackChannels+ : [];++ const options: SlackChannelSearchOption[] = [];++ for (const entry of slackChannels) {+ const channelRecord = asRecord(entry);++ if (+ !isDefined(channelRecord) ||+ !isNonEmptyString(channelRecord.slackChannelId) ||+ !isNonEmptyString(channelRecord.name)+ ) {+ continue;+ }++ options.push({+ slackChannelId: channelRecord.slackChannelId,+ name: channelRecord.name,+ isPrivate: channelRecord.isPrivate === true,+ isMember: channelRecord.isMember === true,+ });+ }++ return { options, errorMessage: undefined };+};diff --git a/packages/twenty-apps/public/slack/src/indexes/slack-channel-rule-channel.index.ts b/packages/twenty-apps/public/slack/src/indexes/slack-channel-rule-channel.index.tsnew file mode 100644index 00000000000..2071c2b4f6d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/indexes/slack-channel-rule-channel.index.ts@@ -0,0 +1,22 @@+import { defineIndex } from 'twenty-sdk/define';++import {+ SLACK_CHANNEL_RULE_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_CHANNEL_INDEX_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_CHANNEL_INDEX_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,+} from 'src/constants/universal-identifiers';++export default defineIndex({+ universalIdentifier: SLACK_CHANNEL_RULE_CHANNEL_INDEX_UNIVERSAL_IDENTIFIER,+ objectUniversalIdentifier: SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,+ isUnique: true,+ fields: [+ {+ universalIdentifier:+ SLACK_CHANNEL_RULE_CHANNEL_INDEX_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ fieldUniversalIdentifier:+ SLACK_CHANNEL_RULE_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ },+ ],+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-access-denied-text.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-access-denied-text.tsnew file mode 100644index 00000000000..751812f4d05--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-access-denied-text.ts@@ -0,0 +1,2 @@+export const SLACK_CHANNEL_ACCESS_DENIED_TEXT =+ "In this channel I can only help Slack accounts linked to a workspace member. Ask a workspace admin to link your Slack account from the Twenty Slack app's Settings tab, then mention me again.";diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-mode.tsnew file mode 100644index 00000000000..3be08ec8c70--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-mode.ts@@ -0,0 +1,5 @@+export const SLACK_CHANNEL_RULE_MODE = {+ OPEN: 'OPEN',+ LINKED_MEMBERS_ONLY: 'LINKED_MEMBERS_ONLY',+ SILENT: 'SILENT',+} as const;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-unreadable-error.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-unreadable-error.tsnew file mode 100644index 00000000000..dfefb168aa6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-rule-unreadable-error.ts@@ -0,0 +1,2 @@+export const SLACK_CHANNEL_RULE_UNREADABLE_ERROR =+ 'The rule for this Slack channel could not be read';diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-silenced-text.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-silenced-text.tsnew file mode 100644index 00000000000..d79df9443e1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-channel-silenced-text.ts@@ -0,0 +1,2 @@+export const SLACK_CHANNEL_SILENCED_TEXT =+ "I have been silenced in this channel, so I won't answer here. A workspace admin can change that from the Twenty Slack app's Settings tab.";diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-channel-rule.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-channel-rule.test.tsnew file mode 100644index 00000000000..6e3c409e2a8--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-channel-rule.test.ts@@ -0,0 +1,67 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { findSlackChannelRule } from 'src/logic-functions/data/find-slack-channel-rule';++const SLACK_CHANNEL_ID = 'C0ENG';++const queryMock = vi.fn();++const client = { query: queryMock };++const buildQueryResult = (node: Record<string, unknown> | undefined) => ({+ slackChannelRules: { edges: node === undefined ? [] : [{ node }] },+});++const buildNode = (overrides: Record<string, unknown> = {}) => ({+ id: 'rule-1',+ name: 'eng',+ slackChannelId: SLACK_CHANNEL_ID,+ slackTeamId: 'T0INSTALLED',+ mode: 'SILENT',+ ...overrides,+});++const find = () =>+ findSlackChannelRule(client, { slackChannelId: SLACK_CHANNEL_ID });++describe('findSlackChannelRule', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ queryMock.mockResolvedValue(buildQueryResult(buildNode()));+ });++ it('should return the stored rule', async () => {+ expect(await find()).toEqual({+ id: 'rule-1',+ name: 'eng',+ slackChannelId: SLACK_CHANNEL_ID,+ slackTeamId: 'T0INSTALLED',+ mode: 'SILENT',+ });+ expect(queryMock).toHaveBeenCalledWith(+ expect.objectContaining({+ slackChannelRules: expect.objectContaining({+ __args: expect.objectContaining({+ filter: { slackChannelId: { eq: SLACK_CHANNEL_ID } },+ }),+ }),+ }),+ );+ });++ it('should return undefined when the channel has no rule', async () => {+ queryMock.mockResolvedValue(buildQueryResult(undefined));++ expect(await find()).toBeUndefined();+ });++ it('should refuse a mode it cannot interpret rather than reading it as open', async () => {+ queryMock.mockResolvedValue(+ buildQueryResult(buildNode({ mode: 'READ_ONLY' })),+ );++ await expect(find()).rejects.toThrow(+ 'Slack channel rule rule-1 has an unsupported mode "READ_ONLY"',+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-channel-rule.tsnew file mode 100644index 00000000000..a971145d1c2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-channel-rule.ts@@ -0,0 +1,24 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { type SlackChannelRuleDraft } from 'src/logic-functions/types/slack-channel-rule-draft.type';++export const createSlackChannelRule = async (+ client: Pick<CoreApiClient, 'mutation'>,+ draft: SlackChannelRuleDraft,+): Promise<string> => {+ const result = await client.mutation({+ createSlackChannelRule: {+ __args: { data: draft },+ id: true,+ },+ });++ const createdId = result.createSlackChannelRule?.id;++ if (!isNonEmptyString(createdId)) {+ throw new Error('Slack channel rule creation returned no id');+ }++ return createdId;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-channel-rule.tsnew file mode 100644index 00000000000..27d9cffd520--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-channel-rule.ts@@ -0,0 +1,13 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++export const destroySlackChannelRule = async (+ client: Pick<CoreApiClient, 'mutation'>,+ { id }: { id: string },+): Promise<void> => {+ await client.mutation({+ destroySlackChannelRule: {+ __args: { id },+ id: true,+ },+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-channel-rule.tsnew file mode 100644index 00000000000..15b4995c6f8--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-channel-rule.ts@@ -0,0 +1,48 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { type SlackChannelRule } from 'src/logic-functions/types/slack-channel-rule.type';+import { isSlackChannelRuleMode } from 'src/logic-functions/utils/is-slack-channel-rule-mode';++export const findSlackChannelRule = async (+ client: Pick<CoreApiClient, 'query'>,+ { slackChannelId }: { slackChannelId: string },+): Promise<SlackChannelRule | undefined> => {+ const queryResult = await client.query({+ slackChannelRules: {+ __args: {+ filter: { slackChannelId: { eq: slackChannelId } },+ first: 1,+ },+ edges: {+ node: {+ id: true,+ name: true,+ slackChannelId: true,+ slackTeamId: true,+ mode: true,+ },+ },+ },+ });++ const node = queryResult.slackChannelRules?.edges?.[0]?.node;++ if (!isNonEmptyString(node?.id)) {+ return undefined;+ }++ if (!isSlackChannelRuleMode(node.mode)) {+ throw new Error(+ `Slack channel rule ${node.id} has an unsupported mode "${node.mode}"`,+ );+ }++ return {+ id: node.id,+ name: node.name ?? undefined,+ slackChannelId: node.slackChannelId ?? slackChannelId,+ slackTeamId: node.slackTeamId ?? undefined,+ mode: node.mode,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-channel-rule.tsnew file mode 100644index 00000000000..ff033024fcc--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-channel-rule.ts@@ -0,0 +1,33 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export const updateSlackChannelRule = async (+ client: Pick<CoreApiClient, 'mutation'>,+ {+ id,+ name,+ slackTeamId,+ mode,+ }: {+ id: string;+ name: string | undefined;+ slackTeamId: string;+ mode: SlackChannelRuleMode;+ },+): Promise<void> => {+ await client.mutation({+ updateSlackChannelRule: {+ __args: {+ id,+ data: {+ ...(isNonEmptyString(name) ? { name } : {}),+ slackTeamId,+ mode,+ },+ },+ id: true,+ },+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.tsindex ee6070aa770..0b25b21bbb5 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-assistant-worker-handler.test.ts@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';import { SLACK_ACCESS_DENIED_TEXT } from 'src/logic-functions/constants/slack-access-denied-text';import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';+import { SLACK_CHANNEL_ACCESS_DENIED_TEXT } from 'src/logic-functions/constants/slack-channel-access-denied-text';+import { SLACK_CHANNEL_RULE_UNREADABLE_ERROR } from 'src/logic-functions/constants/slack-channel-rule-unreadable-error';import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';import { SLACK_ASSISTANT_REQUEST_TIMEOUT_SECONDS } from 'src/logic-functions/constants/slack-assistant-request-timeout-seconds';import { slackAssistantWorkerHandler } from 'src/logic-functions/handlers/slack-assistant-worker-handler';@@ -22,8 +24,9 @@ const {finishSlackAssistantRequestWithFailureMock,setSlackAssistantThreadTitleMock,subscribeSlackThreadMock,- getSlackAccessModeMock,+ resolveSlackChannelAccessPolicyMock,resolveSlackAccessDecisionMock,+ notifySilencedSlackChannelMock,} = vi.hoisted(() => ({callLog: [] as string[],coreApiClientMock: vi.fn(),@@ -39,18 +42,26 @@ const {finishSlackAssistantRequestWithFailureMock: vi.fn(),setSlackAssistantThreadTitleMock: vi.fn(),subscribeSlackThreadMock: vi.fn(),- getSlackAccessModeMock: vi.fn(),+ resolveSlackChannelAccessPolicyMock: vi.fn(),resolveSlackAccessDecisionMock: vi.fn(),+ notifySilencedSlackChannelMock: vi.fn(),}));vi.mock('src/logic-functions/utils/resolve-slack-access-decision', () => ({resolveSlackAccessDecision: resolveSlackAccessDecisionMock,}));-vi.mock('src/logic-functions/utils/get-slack-access-mode', () => ({- getSlackAccessMode: getSlackAccessModeMock,+vi.mock('src/logic-functions/utils/notify-silenced-slack-channel', () => ({+ notifySilencedSlackChannel: notifySilencedSlackChannelMock,}));+vi.mock(+ 'src/logic-functions/utils/resolve-slack-channel-access-policy',+ () => ({+ resolveSlackChannelAccessPolicy: resolveSlackChannelAccessPolicyMock,+ }),+);+vi.mock('twenty-client-sdk/core', () => ({CoreApiClient: coreApiClientMock,}));@@ -149,10 +160,15 @@ describe('slackAssistantWorkerHandler', () => {return {};});claimSlackAssistantRequestMock.mockResolvedValue(true);+ notifySilencedSlackChannelMock.mockResolvedValue(undefined);updateSlackAssistantRequestMock.mockResolvedValue(undefined);fetchWorkspaceBaseUrlsMock.mockResolvedValue(['https://acme.twenty.com']);resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);- getSlackAccessModeMock.mockResolvedValue(SLACK_ACCESS_MODE.ANYONE);+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ANYONE,+ isChannelRule: false,+ });resolveSlackAccessDecisionMock.mockResolvedValue({ status: 'ALLOWED' });setSlackAssistantThreadTitleMock.mockResolvedValue(undefined);subscribeSlackThreadMock.mockResolvedValue(undefined);@@ -250,10 +266,12 @@ describe('slackAssistantWorkerHandler', () => {);});- it('should ask for the access decision with the stored mode and the resolved requester', async () => {- getSlackAccessModeMock.mockResolvedValue(- SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,- );+ it('should ask for the access decision with the channel policy mode and the resolved requester', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,+ isChannelRule: false,+ });resolveSlackRunAsForRequestMock.mockResolvedValue('workspace-member-1');fetchSlackAssistantContextMock.mockImplementation(async () => {callLog.push('context:fetch');@@ -267,6 +285,12 @@ describe('slackAssistantWorkerHandler', () => {await slackAssistantWorkerHandler(REQUEST_RECORD);+ expect(resolveSlackChannelAccessPolicyMock).toHaveBeenCalledWith(+ expect.objectContaining({+ slackChannelId: REQUEST_RECORD.slackChannelId,+ isDirectMessage: true,+ }),+ );expect(resolveSlackAccessDecisionMock).toHaveBeenCalledWith(expect.objectContaining({accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,@@ -276,10 +300,90 @@ describe('slackAssistantWorkerHandler', () => {);});- it('should answer a request access allowed', async () => {- getSlackAccessModeMock.mockResolvedValue(- SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,+ it('should word the denial for the channel when a channel rule restricts it', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,+ isChannelRule: true,+ });+ resolveSlackAccessDecisionMock.mockResolvedValue({ status: 'DENIED' });++ await expect(slackAssistantWorkerHandler(REQUEST_RECORD)).resolves.toEqual({+ done: true,+ declined: true,+ });++ expect(sendSlackMessageMock).toHaveBeenCalledWith(+ expect.objectContaining({+ messageText: SLACK_CHANNEL_ACCESS_DENIED_TEXT,+ }),);+ expect(updateSlackAssistantRequestMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,+ responseText: SLACK_CHANNEL_ACCESS_DENIED_TEXT,+ }),+ );+ });++ it('should close a request from a silenced channel without answering or running the agent', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({ status: 'SILENT' });++ await expect(slackAssistantWorkerHandler(REQUEST_RECORD)).resolves.toEqual({+ done: true,+ silenced: true,+ });++ expect(callLog).toEqual(['status:start', 'context:fetch', 'status:stop']);+ expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();+ expect(sendSlackMessageMock).not.toHaveBeenCalled();+ expect(resolveSlackAccessDecisionMock).not.toHaveBeenCalled();+ expect(updateSlackAssistantRequestMock).toHaveBeenCalledWith(+ expect.anything(),+ { id: REQUEST_RECORD.id, status: SLACK_ASSISTANT_REQUEST_STATUS.DONE },+ );+ });++ it('should tell the requester privately when the channel was silenced after the request was enqueued', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({ status: 'SILENT' });++ await slackAssistantWorkerHandler({+ ...REQUEST_RECORD,+ slackChannelId: 'C0FIN',+ slackChannelType: 'channel',+ slackThreadTimestamp: '1700000000.000001',+ });++ expect(notifySilencedSlackChannelMock).toHaveBeenCalledWith({+ slackChannelId: 'C0FIN',+ slackUserId: 'U123',+ parentMessageTimestamp: '1700000000.000001',+ });+ });++ it('should fail rather than answer when the channel rule cannot be read', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({+ status: 'UNREADABLE',+ });++ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);++ expect(result).toEqual({+ failed: true,+ reason: SLACK_CHANNEL_RULE_UNREADABLE_ERROR,+ });+ expect(stopStatusUpdatesMock).toHaveBeenCalledTimes(1);+ expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();+ expect(resolveSlackAccessDecisionMock).not.toHaveBeenCalled();+ });++ it('should answer a request access allowed', async () => {+ resolveSlackChannelAccessPolicyMock.mockResolvedValue({+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,+ isChannelRule: false,+ });resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);await expect(slackAssistantWorkerHandler(REQUEST_RECORD)).resolves.toEqual({diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-channel-rule-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-channel-rule-handler.test.tsnew file mode 100644index 00000000000..4feb31c4455--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-channel-rule-handler.test.ts@@ -0,0 +1,85 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackRemoveChannelRuleHandler } from 'src/logic-functions/handlers/slack-remove-channel-rule-handler';++const {+ coreApiClientMock,+ currentUserHasRolesPermissionMock,+ destroySlackChannelRuleMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ currentUserHasRolesPermissionMock: vi.fn(),+ destroySlackChannelRuleMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('src/logic-functions/data/destroy-slack-channel-rule', () => ({+ destroySlackChannelRule: destroySlackChannelRuleMock,+}));++const buildPayload = (body: unknown) => ({ body });++describe('slackRemoveChannelRuleHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ destroySlackChannelRuleMock.mockResolvedValue(undefined);+ });++ it('should require an id', async () => {+ const result = await slackRemoveChannelRuleHandler(buildPayload({}));++ expect(result.success).toBe(false);+ expect(result.error).toBe('id is required.');+ expect(destroySlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackRemoveChannelRuleHandler(+ buildPayload({ id: 'rule-1' }),+ );++ expect(result.success).toBe(false);+ expect(result.message).toBe('Not allowed');+ expect(destroySlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should destroy the rule as the application', async () => {+ const result = await slackRemoveChannelRuleHandler(+ buildPayload({ id: 'rule-1' }),+ );++ expect(result.success).toBe(true);+ expect(coreApiClientMock).toHaveBeenCalledWith({ runAs: 'application' });+ expect(destroySlackChannelRuleMock).toHaveBeenCalledWith(+ expect.anything(),+ { id: 'rule-1' },+ );+ });++ it('should fail with a structured result when the destroy errors', async () => {+ destroySlackChannelRuleMock.mockRejectedValue(new Error('not found'));++ const result = await slackRemoveChannelRuleHandler(+ buildPayload({ id: 'rule-1' }),+ );++ expect(result).toEqual({+ success: false,+ message: 'Could not remove the rule',+ error: 'not found',+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-channels-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-channels-handler.test.tsnew file mode 100644index 00000000000..0a7fa8f4aa1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-channels-handler.test.ts@@ -0,0 +1,201 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackSearchChannelsHandler } from 'src/logic-functions/handlers/slack-search-channels-handler';++const {+ currentUserHasRolesPermissionMock,+ getSlackClientMock,+ conversationsListMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ conversationsListMock: vi.fn(),+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('src/logic-functions/utils/get-slack-client', () => ({+ getSlackClient: getSlackClientMock,+}));++const ENG = { id: 'C0ENG', name: 'eng', is_private: false, is_member: true };+const FINANCE = {+ id: 'C0FIN',+ name: 'finance',+ is_private: true,+ is_member: false,+};+const ENGINEERING_LEADS = {+ id: 'C0LEAD',+ name: 'engineering-leads',+ is_private: true,+ is_member: true,+};++const buildPayload = (query: unknown) => ({ body: { query } });++describe('slackSearchChannelsHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ getSlackClientMock.mockResolvedValue({+ success: true,+ client: { conversations: { list: conversationsListMock } },+ });+ conversationsListMock.mockResolvedValue({+ channels: [ENG, FINANCE, ENGINEERING_LEADS],+ response_metadata: { next_cursor: '' },+ });+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackSearchChannelsHandler(buildPayload('eng'));++ expect(result.success).toBe(false);+ expect(conversationsListMock).not.toHaveBeenCalled();+ });++ it('should return no channels for an empty query without calling Slack', async () => {+ const result = await slackSearchChannelsHandler(buildPayload(' '));++ expect(result).toEqual({ success: true, slackChannels: [] });+ expect(conversationsListMock).not.toHaveBeenCalled();+ });++ it('should fail when Slack is not connected', async () => {+ getSlackClientMock.mockResolvedValue({+ success: false,+ error: 'No Slack connection',+ });++ const result = await slackSearchChannelsHandler(buildPayload('eng'));++ expect(result).toEqual({+ success: false,+ message: 'Slack is not connected',+ error: 'No Slack connection',+ });+ });++ it('should match channel names case-insensitively and ignore a leading hash', async () => {+ const result = await slackSearchChannelsHandler(buildPayload('#ENG'));++ expect(result).toEqual({+ success: true,+ slackChannels: [+ {+ slackChannelId: 'C0ENG',+ name: 'eng',+ isPrivate: false,+ isMember: true,+ },+ {+ slackChannelId: 'C0LEAD',+ name: 'engineering-leads',+ isPrivate: true,+ isMember: true,+ },+ ],+ });+ expect(conversationsListMock).toHaveBeenCalledWith(+ expect.objectContaining({+ types: 'public_channel,private_channel',+ exclude_archived: true,+ }),+ );+ });++ it('should follow the cursor to later pages until it runs out', async () => {+ conversationsListMock+ .mockResolvedValueOnce({+ channels: [ENG],+ response_metadata: { next_cursor: 'page-2' },+ })+ .mockResolvedValueOnce({+ channels: [FINANCE],+ response_metadata: { next_cursor: '' },+ });++ const result = await slackSearchChannelsHandler(buildPayload('fin'));++ expect(result).toEqual({+ success: true,+ slackChannels: [+ {+ slackChannelId: 'C0FIN',+ name: 'finance',+ isPrivate: true,+ isMember: false,+ },+ ],+ });+ expect(conversationsListMock).toHaveBeenCalledTimes(2);+ expect(conversationsListMock).toHaveBeenLastCalledWith(+ expect.objectContaining({ cursor: 'page-2' }),+ );+ });++ it('should keep following the cursor past the first pages until Slack exhausts the list', async () => {+ const pages = Array.from({ length: 6 }, (_, index) => ({+ channels: [ENG],+ response_metadata: { next_cursor: index < 5 ? `page-${index + 2}` : '' },+ }));++ for (const page of pages) {+ conversationsListMock.mockResolvedValueOnce(page);+ }++ const result = await slackSearchChannelsHandler(+ buildPayload('nothing-matches'),+ );++ expect(result).toEqual({ success: true, slackChannels: [] });+ expect(conversationsListMock).toHaveBeenCalledTimes(6);+ expect(conversationsListMock).toHaveBeenCalledWith(+ expect.objectContaining({ limit: 1000 }),+ );+ });++ it('should stop once it has enough matches without reading further pages', async () => {+ conversationsListMock.mockResolvedValue({+ channels: Array.from({ length: 12 }, (_, index) => ({+ id: `C${index}`,+ name: `eng-${index}`,+ })),+ response_metadata: { next_cursor: 'more' },+ });++ const result = await slackSearchChannelsHandler(buildPayload('eng'));++ expect(result.success).toBe(true);+ expect(result.success && result.slackChannels).toHaveLength(10);+ expect(conversationsListMock).toHaveBeenCalledTimes(1);+ });++ it('should stop reading pages after the page bound even if Slack keeps returning a cursor', async () => {+ conversationsListMock.mockResolvedValue({+ channels: [ENG],+ response_metadata: { next_cursor: 'more' },+ });++ await slackSearchChannelsHandler(buildPayload('nothing-matches'));++ expect(conversationsListMock).toHaveBeenCalledTimes(20);+ });++ it('should fail with a structured result when Slack errors', async () => {+ conversationsListMock.mockRejectedValue(new Error('ratelimited'));++ const result = await slackSearchChannelsHandler(buildPayload('eng'));++ expect(result).toEqual({+ success: false,+ message: 'Could not search Slack channels',+ error: 'ratelimited',+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-channel-rule-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-channel-rule-handler.test.tsnew file mode 100644index 00000000000..ece0aef46a9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-channel-rule-handler.test.ts@@ -0,0 +1,239 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackSetChannelRuleHandler } from 'src/logic-functions/handlers/slack-set-channel-rule-handler';++const {+ coreApiClientMock,+ currentUserHasRolesPermissionMock,+ getSlackClientMock,+ conversationsInfoMock,+ authTestMock,+ findSlackChannelRuleMock,+ createSlackChannelRuleMock,+ updateSlackChannelRuleMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ currentUserHasRolesPermissionMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ conversationsInfoMock: vi.fn(),+ authTestMock: vi.fn(),+ findSlackChannelRuleMock: vi.fn(),+ createSlackChannelRuleMock: vi.fn(),+ updateSlackChannelRuleMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('src/logic-functions/utils/get-slack-client', () => ({+ getSlackClient: getSlackClientMock,+}));++vi.mock('src/logic-functions/data/find-slack-channel-rule', () => ({+ findSlackChannelRule: findSlackChannelRuleMock,+}));++vi.mock('src/logic-functions/data/create-slack-channel-rule', () => ({+ createSlackChannelRule: createSlackChannelRuleMock,+}));++vi.mock('src/logic-functions/data/update-slack-channel-rule', () => ({+ updateSlackChannelRule: updateSlackChannelRuleMock,+}));++const INSTALLED_TEAM_ID = 'T0INSTALLED';++const buildPayload = (body: unknown) => ({ body });++const VALID_BODY = { slackChannelId: 'C0FIN', mode: 'SILENT' };++describe('slackSetChannelRuleHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ getSlackClientMock.mockResolvedValue({+ success: true,+ client: {+ auth: { test: authTestMock },+ conversations: { info: conversationsInfoMock },+ },+ });+ authTestMock.mockResolvedValue({ team_id: INSTALLED_TEAM_ID });+ conversationsInfoMock.mockResolvedValue({+ channel: {+ id: 'C0FIN',+ name: 'finance',+ is_private: true,+ context_team_id: INSTALLED_TEAM_ID,+ },+ });+ findSlackChannelRuleMock.mockResolvedValue(undefined);+ createSlackChannelRuleMock.mockResolvedValue('rule-1');+ updateSlackChannelRuleMock.mockResolvedValue(undefined);+ });++ it('should require a channel id', async () => {+ const result = await slackSetChannelRuleHandler(+ buildPayload({ mode: 'SILENT' }),+ );++ expect(result.success).toBe(false);+ expect(result.error).toBe('slackChannelId is required.');+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ });++ it('should reject a mode it does not know', async () => {+ const result = await slackSetChannelRuleHandler(+ buildPayload({ slackChannelId: 'C0FIN', mode: 'READ_ONLY' }),+ );++ expect(result.success).toBe(false);+ expect(result.message).toBe('Invalid mode');+ expect(createSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result.success).toBe(false);+ expect(result.message).toBe('Not allowed');+ expect(conversationsInfoMock).not.toHaveBeenCalled();+ });++ it('should fail when Slack is not connected', async () => {+ getSlackClientMock.mockResolvedValue({+ success: false,+ error: 'No Slack connection',+ });++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result).toEqual({+ success: false,+ message: 'Slack is not connected',+ error: 'No Slack connection',+ });+ });++ it('should surface the Slack error when the channel lookup fails', async () => {+ conversationsInfoMock.mockRejectedValue(new Error('channel_not_found'));++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result).toEqual({+ success: false,+ message: 'Could not confirm the channel with Slack',+ error: 'channel_not_found',+ });+ expect(createSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should refuse a channel Slack does not return', async () => {+ conversationsInfoMock.mockResolvedValue({ ok: true });++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result.success).toBe(false);+ expect(result.message).toBe('Slack channel not found');+ expect(createSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should refuse a direct message conversation', async () => {+ conversationsInfoMock.mockResolvedValue({+ channel: { id: 'D123', is_im: true },+ });++ const result = await slackSetChannelRuleHandler(+ buildPayload({ slackChannelId: 'D123', mode: 'OPEN' }),+ );++ expect(result.success).toBe(false);+ expect(result.message).toBe('Not a channel');+ expect(createSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should create a rule with the channel name and team confirmed by Slack', async () => {+ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result.success).toBe(true);+ expect(result.message).toContain('#finance');+ expect(coreApiClientMock).toHaveBeenCalledWith({ runAs: 'application' });+ expect(createSlackChannelRuleMock).toHaveBeenCalledWith(expect.anything(), {+ name: 'finance',+ slackChannelId: 'C0FIN',+ slackTeamId: INSTALLED_TEAM_ID,+ mode: 'SILENT',+ });+ expect(updateSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should fall back to the installed team when the channel carries no team id', async () => {+ conversationsInfoMock.mockResolvedValue({+ channel: { id: 'C0FIN', name: 'finance' },+ });++ await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(createSlackChannelRuleMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ slackTeamId: INSTALLED_TEAM_ID }),+ );+ });++ it('should update the existing rule for the channel instead of creating a second one', async () => {+ findSlackChannelRuleMock.mockResolvedValue({+ id: 'rule-1',+ name: 'finance',+ slackChannelId: 'C0FIN',+ slackTeamId: INSTALLED_TEAM_ID,+ mode: 'OPEN',+ });++ const result = await slackSetChannelRuleHandler(+ buildPayload({ slackChannelId: 'C0FIN', mode: 'LINKED_MEMBERS_ONLY' }),+ );++ expect(result.success).toBe(true);+ expect(updateSlackChannelRuleMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'rule-1',+ name: 'finance',+ slackTeamId: INSTALLED_TEAM_ID,+ mode: 'LINKED_MEMBERS_ONLY',+ });+ expect(createSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should fail with a structured result when the existing rule cannot be read', async () => {+ findSlackChannelRuleMock.mockRejectedValue(new Error('db down'));++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result).toEqual({+ success: false,+ message: 'Could not look up the existing rule',+ error: 'db down',+ });+ });++ it('should fail with a structured result when the write errors', async () => {+ createSlackChannelRuleMock.mockRejectedValue(new Error('write failed'));++ const result = await slackSetChannelRuleHandler(buildPayload(VALID_BODY));++ expect(result).toEqual({+ success: false,+ message: 'Could not save the rule',+ error: 'write failed',+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.tsindex c5af2cdfd10..8469f652538 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-assistant-worker-handler.ts@@ -5,6 +5,8 @@ import { isDefined } from 'twenty-sdk/utils';import { SLACK_ASSISTANT_AGENT_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';import { SLACK_ACCESS_DENIED_TEXT } from 'src/logic-functions/constants/slack-access-denied-text';import { SLACK_ACCESS_UNVERIFIABLE_ERROR } from 'src/logic-functions/constants/slack-access-unverifiable-error';+import { SLACK_CHANNEL_ACCESS_DENIED_TEXT } from 'src/logic-functions/constants/slack-channel-access-denied-text';+import { SLACK_CHANNEL_RULE_UNREADABLE_ERROR } from 'src/logic-functions/constants/slack-channel-rule-unreadable-error';import { SLACK_ASSISTANT_AGENT_BUDGET_SECONDS } from 'src/logic-functions/constants/slack-assistant-agent-budget-seconds';import { SLACK_ASSISTANT_EMPTY_RESPONSE_ERROR } from 'src/logic-functions/constants/slack-assistant-empty-response-error';import { SLACK_ASSISTANT_REQUEST_STATUS } from 'src/logic-functions/constants/slack-assistant-request-status';@@ -22,10 +24,11 @@ import { fetchSlackAssistantContext } from 'src/logic-functions/utils/fetch-slacimport { fetchWorkspaceBaseUrls } from 'src/logic-functions/utils/fetch-workspace-base-urls';import { isSlackAssistantRequestResumable } from 'src/logic-functions/utils/is-slack-assistant-request-resumable';import { finishSlackAssistantRequestWithFailure } from 'src/logic-functions/utils/finish-slack-assistant-request-with-failure';-import { getSlackAccessMode } from 'src/logic-functions/utils/get-slack-access-mode';import { getSlackAssistantParentMessageTimestamp } from 'src/logic-functions/utils/get-slack-assistant-parent-message-timestamp';+import { notifySilencedSlackChannel } from 'src/logic-functions/utils/notify-silenced-slack-channel';import { resolveSlackAccessDecision } from 'src/logic-functions/utils/resolve-slack-access-decision';import { resolveSlackAssistantAttachments } from 'src/logic-functions/utils/resolve-slack-assistant-attachments';+import { resolveSlackChannelAccessPolicy } from 'src/logic-functions/utils/resolve-slack-channel-access-policy';import { resolveSlackAssistantMentions } from 'src/logic-functions/utils/resolve-slack-assistant-mentions';import { resolveSlackRunAsForRequest } from 'src/logic-functions/utils/resolve-slack-run-as-for-request';import { runSlackAssistantAgentWithDeadline } from 'src/logic-functions/utils/run-slack-assistant-agent-with-deadline';@@ -127,8 +130,42 @@ export const slackAssistantWorkerHandler = async (}).catch(() => undefined);}+ const channelAccessPolicy = await resolveSlackChannelAccessPolicy({+ client,+ slackChannelId,+ isDirectMessage,+ });++ if (channelAccessPolicy.status === 'UNREADABLE') {+ await stopStatusUpdates();++ return await finishSlackAssistantRequestWithFailure({+ ...failureContext,+ errorMessage: SLACK_CHANNEL_RULE_UNREADABLE_ERROR,+ });+ }++ if (channelAccessPolicy.status === 'SILENT') {+ await stopStatusUpdates();++ if (isNonEmptyString(record.slackUserId)) {+ await notifySilencedSlackChannel({+ slackChannelId,+ slackUserId: record.slackUserId,+ parentMessageTimestamp,+ });+ }++ await updateSlackAssistantRequest(client, {+ id: record.id,+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,+ });++ return { done: true, silenced: true };+ }+const accessDecision = await resolveSlackAccessDecision({- accessMode: await getSlackAccessMode(),+ accessMode: channelAccessPolicy.accessMode,client,slackClient,identity: requesterIdentity,@@ -147,9 +184,13 @@ export const slackAssistantWorkerHandler = async (if (accessDecision.status === 'DENIED') {await stopStatusUpdates();+ const accessDeniedText = channelAccessPolicy.isChannelRule+ ? SLACK_CHANNEL_ACCESS_DENIED_TEXT+ : SLACK_ACCESS_DENIED_TEXT;+const denialDelivery = await sendSlackMessage({slackChannelId,- messageText: SLACK_ACCESS_DENIED_TEXT,+ messageText: accessDeniedText,parentMessageTimestamp,messageFormat: 'markdown',unfurlLinks: false,@@ -166,7 +207,7 @@ export const slackAssistantWorkerHandler = async (await updateSlackAssistantRequest(client, {id: record.id,status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,- responseText: SLACK_ACCESS_DENIED_TEXT,+ responseText: accessDeniedText,});return { done: true, declined: true };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-channel-rule-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-channel-rule-handler.tsnew file mode 100644index 00000000000..867a455a824--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-channel-rule-handler.ts@@ -0,0 +1,52 @@+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';++import { destroySlackChannelRule } from 'src/logic-functions/data/destroy-slack-channel-rule';+import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++export const slackRemoveChannelRuleHandler = async (+ payload: SlackRouteBody,+): Promise<SlackToolResult> => {+ const id = readOptionalString(asRecord(payload.body)?.id);++ if (!isNonEmptyString(id)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'id is required.',+ };+ }++ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error: 'Only members with the roles permission can remove channel rules.',+ };+ }++ try {+ await destroySlackChannelRule(new CoreApiClient({ runAs: 'application' }), {+ id,+ });+ } catch (error) {+ return {+ success: false,+ message: 'Could not remove the rule',+ error: toErrorMessage(error),+ };+ }++ return {+ success: true,+ message:+ 'Removed the channel rule. The channel now follows the workspace access mode.',+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-channels-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-channels-handler.tsnew file mode 100644index 00000000000..59ea9854176--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-channels-handler.ts@@ -0,0 +1,60 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackChannelSearchResult } from 'src/logic-functions/types/slack-channel-search.type';+import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { searchSlackChannelsByName } from 'src/logic-functions/utils/search-slack-channels-by-name';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const MAX_RESULTS = 10;++export const slackSearchChannelsHandler = async (+ payload: SlackRouteBody,+): Promise<SlackChannelSearchResult> => {+ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error:+ 'Only members with the roles permission can search Slack channels.',+ };+ }++ const body = asRecord(payload.body) ?? {};+ const query = readOptionalString(body.query)?.trim().replace(/^#/, '');++ if (!isNonEmptyString(query)) {+ return { success: true, slackChannels: [] };+ }++ const slackClientResult = await getSlackClient();++ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }++ try {+ const slackChannels = await searchSlackChannelsByName({+ slackClient: slackClientResult.client,+ query,+ maxResults: MAX_RESULTS,+ });++ return { success: true, slackChannels };+ } catch (error) {+ return {+ success: false,+ message: 'Could not search Slack channels',+ error: toErrorMessage(error),+ };+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-channel-rule-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-channel-rule-handler.tsnew file mode 100644index 00000000000..e4dfbcb80c4--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-channel-rule-handler.ts@@ -0,0 +1,174 @@+import { type ConversationsInfoResponse } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { createSlackChannelRule } from 'src/logic-functions/data/create-slack-channel-rule';+import { findSlackChannelRule } from 'src/logic-functions/data/find-slack-channel-rule';+import { updateSlackChannelRule } from 'src/logic-functions/data/update-slack-channel-rule';+import { type SlackChannelRule } from 'src/logic-functions/types/slack-channel-rule.type';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';+import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { isSlackChannelRuleMode } from 'src/logic-functions/utils/is-slack-channel-rule-mode';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const MODE_SAVED_NOTES: Record<SlackChannelRuleMode, string> = {+ [SLACK_CHANNEL_RULE_MODE.OPEN]:+ 'The assistant answers anyone there, whatever the workspace access mode.',+ [SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY]:+ 'The assistant only answers Slack accounts linked to a workspace member there.',+ [SLACK_CHANNEL_RULE_MODE.SILENT]:+ 'The assistant ignores that channel entirely.',+};++const describeChannel = ({+ name,+ slackChannelId,+}: {+ name: string | undefined;+ slackChannelId: string;+}): string => (isNonEmptyString(name) ? `#${name}` : slackChannelId);++export const slackSetChannelRuleHandler = async (+ payload: SlackRouteBody,+): Promise<SlackToolResult> => {+ const body = asRecord(payload.body) ?? {};+ const slackChannelId = readOptionalString(body.slackChannelId)?.trim();+ const requestedName = readOptionalString(body.name)?.trim();++ if (!isNonEmptyString(slackChannelId)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'slackChannelId is required.',+ };+ }++ if (!isSlackChannelRuleMode(body.mode)) {+ return {+ success: false,+ message: 'Invalid mode',+ error: 'mode must be OPEN, LINKED_MEMBERS_ONLY or SILENT.',+ };+ }++ const mode = body.mode;++ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error: 'Only members with the roles permission can set channel rules.',+ };+ }++ const slackClientResult = await getSlackClient();++ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }++ const slackClient = slackClientResult.client;++ let channelInfo: ConversationsInfoResponse;++ try {+ channelInfo = await slackClient.conversations.info({+ channel: slackChannelId,+ });+ } catch (error) {+ return {+ success: false,+ message: 'Could not confirm the channel with Slack',+ error: toErrorMessage(error),+ };+ }++ const channel = channelInfo.channel;++ if (!isDefined(channel)) {+ return {+ success: false,+ message: 'Slack channel not found',+ error: `Slack did not return a channel with id ${slackChannelId}. Check that the app can see it and try again.`,+ };+ }++ if (channel.is_im === true || channel.is_mpim === true) {+ return {+ success: false,+ message: 'Not a channel',+ error: 'Rules apply to channels only, not to direct messages.',+ };+ }++ const installedTeamId = await getInstalledSlackTeamId(slackClient);+ const slackTeamId =+ readOptionalString(channel.context_team_id) ?? installedTeamId;++ if (!isNonEmptyString(slackTeamId)) {+ return {+ success: false,+ message: 'Could not verify the installed Slack workspace',+ error: 'Slack did not confirm the installed workspace. Please try again.',+ };+ }++ const name = readOptionalString(channel.name) ?? requestedName;++ const client = new CoreApiClient({ runAs: 'application' });++ let existingRule: SlackChannelRule | undefined;++ try {+ existingRule = await findSlackChannelRule(client, { slackChannelId });+ } catch (error) {+ return {+ success: false,+ message: 'Could not look up the existing rule',+ error: toErrorMessage(error),+ };+ }++ try {+ if (isDefined(existingRule)) {+ await updateSlackChannelRule(client, {+ id: existingRule.id,+ name,+ slackTeamId,+ mode,+ });+ } else {+ await createSlackChannelRule(client, {+ name: name ?? slackChannelId,+ slackChannelId,+ slackTeamId,+ mode,+ });+ }+ } catch (error) {+ return {+ success: false,+ message: 'Could not save the rule',+ error: toErrorMessage(error),+ };+ }++ return {+ success: true,+ message: `Saved the rule for ${describeChannel({ name, slackChannelId })}. ${MODE_SAVED_NOTES[mode]}`,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-channel-rule.tsnew file mode 100644index 00000000000..6429a84fb12--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-channel-rule.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_CHANNEL_RULES_REMOVE_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { SLACK_REMOVE_CHANNEL_RULE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackRemoveChannelRuleHandler } from 'src/logic-functions/handlers/slack-remove-channel-rule-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_REMOVE_CHANNEL_RULE_UNIVERSAL_IDENTIFIER,+ name: 'slack-remove-channel-rule',+ description:+ 'Removes a Slack channel rule so the channel follows the workspace access mode again. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_CHANNEL_RULES_REMOVE_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackRemoveChannelRuleHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-search-channels.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-search-channels.tsnew file mode 100644index 00000000000..bb942392d46--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-search-channels.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_CHANNEL_RULES_SEARCH_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { SLACK_SEARCH_CHANNELS_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackSearchChannelsHandler } from 'src/logic-functions/handlers/slack-search-channels-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_SEARCH_CHANNELS_UNIVERSAL_IDENTIFIER,+ name: 'slack-search-channels',+ description:+ 'Searches the Slack channels visible to the bot by name so an admin can pick one for a channel rule. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_CHANNEL_RULES_SEARCH_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackSearchChannelsHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-set-channel-rule.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-set-channel-rule.tsnew file mode 100644index 00000000000..622eb574c25--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-set-channel-rule.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_CHANNEL_RULES_SET_ROUTE_PATH } from 'src/constants/slack-channel-rules-route-path.constant';+import { SLACK_SET_CHANNEL_RULE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackSetChannelRuleHandler } from 'src/logic-functions/handlers/slack-set-channel-rule-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_SET_CHANNEL_RULE_UNIVERSAL_IDENTIFIER,+ name: 'slack-set-channel-rule',+ description:+ 'Creates or updates the rule for one Slack channel: open to anyone, linked members only, or silent. Confirms the channel with Slack first. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_CHANNEL_RULES_SET_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackSetChannelRuleHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-access-policy.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-access-policy.type.tsnew file mode 100644index 00000000000..d85ce3060e1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-access-policy.type.ts@@ -0,0 +1,6 @@+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';++export type SlackChannelAccessPolicy =+ | { status: 'SILENT' }+ | { status: 'ANSWER'; accessMode: SlackAccessMode; isChannelRule: boolean }+ | { status: 'UNREADABLE' };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-draft.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-draft.type.tsnew file mode 100644index 00000000000..57f2d5265e6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-draft.type.ts@@ -0,0 +1,8 @@+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export type SlackChannelRuleDraft = {+ name: string;+ slackChannelId: string;+ slackTeamId: string;+ mode: SlackChannelRuleMode;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-mode.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-mode.type.tsnew file mode 100644index 00000000000..f484eb8a974--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule-mode.type.ts@@ -0,0 +1,4 @@+import { type SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';++export type SlackChannelRuleMode =+ (typeof SLACK_CHANNEL_RULE_MODE)[keyof typeof SLACK_CHANNEL_RULE_MODE];diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule.type.tsnew file mode 100644index 00000000000..54893ca58ef--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-rule.type.ts@@ -0,0 +1,9 @@+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export type SlackChannelRule = {+ id: string;+ name: string | undefined;+ slackChannelId: string;+ slackTeamId: string | undefined;+ mode: SlackChannelRuleMode;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-search.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-search.type.tsnew file mode 100644index 00000000000..7e751e6e59f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-channel-search.type.ts@@ -0,0 +1,10 @@+export type SlackChannelSearchOption = {+ slackChannelId: string;+ name: string;+ isPrivate: boolean;+ isMember: boolean;+};++export type SlackChannelSearchResult =+ | { success: true; slackChannels: SlackChannelSearchOption[] }+ | { success: false; message: string; error?: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-channel-rule-input.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-channel-rule-input.type.tsnew file mode 100644index 00000000000..5a7eb598886--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-channel-rule-input.type.ts@@ -0,0 +1,7 @@+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export type SlackSetChannelRuleInput = {+ slackChannelId: string;+ mode: SlackChannelRuleMode;+ name?: string;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request.test.tsnew file mode 100644index 00000000000..b2122ea10e4--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/enqueue-slack-assistant-request.test.ts@@ -0,0 +1,216 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { enqueueSlackAssistantRequest } from 'src/logic-functions/utils/enqueue-slack-assistant-request';++const {+ coreApiClientMock,+ isSlackChannelSilencedMock,+ notifySilencedSlackChannelMock,+ gateSlackThreadFollowUpMock,+ enqueueSlackAssistantRequestRecordMock,+ replyToEmptySlackAssistantRequestMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ isSlackChannelSilencedMock: vi.fn(),+ notifySilencedSlackChannelMock: vi.fn(),+ gateSlackThreadFollowUpMock: vi.fn(),+ enqueueSlackAssistantRequestRecordMock: vi.fn(),+ replyToEmptySlackAssistantRequestMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/utils/is-slack-channel-silenced', () => ({+ isSlackChannelSilenced: isSlackChannelSilencedMock,+}));++vi.mock('src/logic-functions/utils/notify-silenced-slack-channel', () => ({+ notifySilencedSlackChannel: notifySilencedSlackChannelMock,+}));++vi.mock('src/logic-functions/utils/gate-slack-thread-follow-up', () => ({+ gateSlackThreadFollowUp: gateSlackThreadFollowUpMock,+}));++vi.mock(+ 'src/logic-functions/utils/enqueue-slack-assistant-request-record',+ () => ({+ enqueueSlackAssistantRequestRecord: enqueueSlackAssistantRequestRecordMock,+ }),+);++vi.mock(+ 'src/logic-functions/utils/reply-to-empty-slack-assistant-request',+ () => ({+ replyToEmptySlackAssistantRequest: replyToEmptySlackAssistantRequestMock,+ }),+);++const BOT_USER_ID = 'U0BOT';++const buildBody = (event: Record<string, unknown>) => ({+ type: 'event_callback' as const,+ event_id: 'Ev123',+ team_id: 'T0INSTALLED',+ authorizations: [{ user_id: BOT_USER_ID }],+ event: {+ ts: '1700000000.000100',+ user: 'U123',+ ...event,+ },+});++const MENTION_BODY = buildBody({+ type: 'app_mention',+ channel: 'C0FIN',+ text: `<@${BOT_USER_ID}> how many open deals?`,+});++const EMPTY_MENTION_BODY = buildBody({+ type: 'app_mention',+ channel: 'C0FIN',+ text: `<@${BOT_USER_ID}>`,+});++const MENTION_IN_THREAD_BODY = buildBody({+ type: 'app_mention',+ channel: 'C0FIN',+ thread_ts: '1700000000.000001',+ text: `<@${BOT_USER_ID}> how many open deals?`,+});++const DIRECT_MESSAGE_BODY = buildBody({+ type: 'message',+ channel: 'D123',+ channel_type: 'im',+ text: 'how many open deals?',+});++const THREAD_FOLLOW_UP_BODY = buildBody({+ type: 'message',+ channel: 'C0FIN',+ channel_type: 'channel',+ thread_ts: '1700000000.000001',+ text: 'and last quarter?',+});++describe('enqueueSlackAssistantRequest', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ isSlackChannelSilencedMock.mockResolvedValue(false);+ notifySilencedSlackChannelMock.mockResolvedValue(undefined);+ gateSlackThreadFollowUpMock.mockResolvedValue(undefined);+ enqueueSlackAssistantRequestRecordMock.mockResolvedValue({+ ok: true,+ request: { id: 'request-1' },+ });+ replyToEmptySlackAssistantRequestMock.mockResolvedValue({ ok: true });+ });++ it('should record a mention in a channel with no silencing rule', async () => {+ const result = await enqueueSlackAssistantRequest(MENTION_BODY);++ expect(result).toEqual({ ok: true, request: { id: 'request-1' } });+ expect(isSlackChannelSilencedMock).toHaveBeenCalledWith(+ expect.objectContaining({ slackChannelId: 'C0FIN' }),+ );+ });++ it('should drop a mention in a silenced channel before recording anything', async () => {+ isSlackChannelSilencedMock.mockResolvedValue(true);++ const result = await enqueueSlackAssistantRequest(MENTION_BODY);++ expect(result).toEqual({+ ok: true,+ skipped: 'Channel is silenced by a channel rule',+ });+ expect(enqueueSlackAssistantRequestRecordMock).not.toHaveBeenCalled();+ expect(notifySilencedSlackChannelMock).toHaveBeenCalledWith({+ slackChannelId: 'C0FIN',+ slackUserId: 'U123',+ parentMessageTimestamp: undefined,+ });+ });++ it('should tell the requester in the thread they mentioned the assistant in', async () => {+ isSlackChannelSilencedMock.mockResolvedValue(true);++ await enqueueSlackAssistantRequest(MENTION_IN_THREAD_BODY);++ expect(notifySilencedSlackChannelMock).toHaveBeenCalledWith({+ slackChannelId: 'C0FIN',+ slackUserId: 'U123',+ parentMessageTimestamp: '1700000000.000001',+ });+ });++ it('should drop an empty mention in a silenced channel without replying', async () => {+ isSlackChannelSilencedMock.mockResolvedValue(true);++ const result = await enqueueSlackAssistantRequest(EMPTY_MENTION_BODY);++ expect(result).toEqual({+ ok: true,+ skipped: 'Channel is silenced by a channel rule',+ });+ expect(replyToEmptySlackAssistantRequestMock).not.toHaveBeenCalled();+ expect(notifySilencedSlackChannelMock).toHaveBeenCalledTimes(1);+ });++ it('should still answer an empty mention in a channel that is not silenced', async () => {+ await enqueueSlackAssistantRequest(EMPTY_MENTION_BODY);++ expect(replyToEmptySlackAssistantRequestMock).toHaveBeenCalledTimes(1);+ });++ it('should never read channel rules for a direct message', async () => {+ const result = await enqueueSlackAssistantRequest(DIRECT_MESSAGE_BODY);++ expect(result).toEqual({ ok: true, request: { id: 'request-1' } });+ expect(isSlackChannelSilencedMock).not.toHaveBeenCalled();+ expect(notifySilencedSlackChannelMock).not.toHaveBeenCalled();+ });++ it('should drop a thread follow-up in a silenced channel before the thread gate can nudge it', async () => {+ isSlackChannelSilencedMock.mockResolvedValue(true);++ const result = await enqueueSlackAssistantRequest(THREAD_FOLLOW_UP_BODY);++ expect(result).toEqual({+ ok: true,+ skipped: 'Channel is silenced by a channel rule',+ });+ expect(gateSlackThreadFollowUpMock).not.toHaveBeenCalled();+ expect(notifySilencedSlackChannelMock).not.toHaveBeenCalled();+ });++ it('should keep gating thread follow-ups by subscription when the channel is not silenced', async () => {+ gateSlackThreadFollowUpMock.mockResolvedValue({+ ok: true,+ skipped: 'Thread is not subscribed for unmentioned follow-ups',+ });++ const result = await enqueueSlackAssistantRequest(THREAD_FOLLOW_UP_BODY);++ expect(result).toEqual({+ ok: true,+ skipped: 'Thread is not subscribed for unmentioned follow-ups',+ });+ expect(enqueueSlackAssistantRequestRecordMock).not.toHaveBeenCalled();+ });++ it('should let a failed rule read propagate so Slack retries the event', async () => {+ isSlackChannelSilencedMock.mockRejectedValue(new Error('db down'));++ await expect(enqueueSlackAssistantRequest(MENTION_BODY)).rejects.toThrow(+ 'db down',+ );+ expect(enqueueSlackAssistantRequestRecordMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-channel-access-policy.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-channel-access-policy.test.tsnew file mode 100644index 00000000000..d04e08ac957--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-channel-access-policy.test.ts@@ -0,0 +1,96 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { resolveSlackChannelAccessPolicy } from 'src/logic-functions/utils/resolve-slack-channel-access-policy';++const { findSlackChannelRuleMock, getSlackAccessModeMock } = vi.hoisted(() => ({+ findSlackChannelRuleMock: vi.fn(),+ getSlackAccessModeMock: vi.fn(),+}));++vi.mock('src/logic-functions/data/find-slack-channel-rule', () => ({+ findSlackChannelRule: findSlackChannelRuleMock,+}));++vi.mock('src/logic-functions/utils/get-slack-access-mode', () => ({+ getSlackAccessMode: getSlackAccessModeMock,+}));++const client = { query: vi.fn() };++const buildRule = (mode: string) => ({+ id: 'rule-1',+ name: 'finance',+ slackChannelId: 'C0FIN',+ slackTeamId: 'T0INSTALLED',+ mode,+});++const resolve = (isDirectMessage = false) =>+ resolveSlackChannelAccessPolicy({+ client,+ slackChannelId: 'C0FIN',+ isDirectMessage,+ });++describe('resolveSlackChannelAccessPolicy', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ findSlackChannelRuleMock.mockResolvedValue(undefined);+ getSlackAccessModeMock.mockResolvedValue('ONLY_LINKED_MEMBERS');+ });++ it('should follow the workspace access mode in a direct message without reading rules', async () => {+ expect(await resolve(true)).toEqual({+ status: 'ANSWER',+ accessMode: 'ONLY_LINKED_MEMBERS',+ isChannelRule: false,+ });+ expect(findSlackChannelRuleMock).not.toHaveBeenCalled();+ });++ it('should follow the workspace access mode when the channel has no rule', async () => {+ expect(await resolve()).toEqual({+ status: 'ANSWER',+ accessMode: 'ONLY_LINKED_MEMBERS',+ isChannelRule: false,+ });+ });++ it('should silence the channel for a SILENT rule', async () => {+ findSlackChannelRuleMock.mockResolvedValue(buildRule('SILENT'));++ expect(await resolve()).toEqual({ status: 'SILENT' });+ expect(getSlackAccessModeMock).not.toHaveBeenCalled();+ });++ it('should restrict the channel to linked members for a LINKED_MEMBERS_ONLY rule', async () => {+ getSlackAccessModeMock.mockResolvedValue('ANYONE');+ findSlackChannelRuleMock.mockResolvedValue(+ buildRule('LINKED_MEMBERS_ONLY'),+ );++ expect(await resolve()).toEqual({+ status: 'ANSWER',+ accessMode: 'ONLY_LINKED_MEMBERS',+ isChannelRule: true,+ });+ });++ it('should open the channel for an OPEN rule even when the workspace is restricted', async () => {+ findSlackChannelRuleMock.mockResolvedValue(buildRule('OPEN'));++ expect(await resolve()).toEqual({+ status: 'ANSWER',+ accessMode: 'ANYONE',+ isChannelRule: true,+ });+ expect(getSlackAccessModeMock).not.toHaveBeenCalled();+ });++ it('should report an unreadable rule rather than falling back to the workspace mode', async () => {+ findSlackChannelRuleMock.mockRejectedValue(new Error('db down'));++ expect(await resolve()).toEqual({ status: 'UNREADABLE' });+ expect(getSlackAccessModeMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request.tsindex c46d7528a05..f4f2e9f82b3 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/enqueue-slack-assistant-request.ts@@ -1,23 +1,86 @@+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';import { isDefined } from 'twenty-sdk/utils';import { type SlackEventsEnqueueResult } from 'src/logic-functions/types/slack-events-enqueue-result.type';import { type SlackEventsRequestBody } from 'src/logic-functions/types/slack-events-request-body.type';import { enqueueSlackAssistantRequestRecord } from 'src/logic-functions/utils/enqueue-slack-assistant-request-record';import { gateSlackThreadFollowUp } from 'src/logic-functions/utils/gate-slack-thread-follow-up';+import { isSlackChannelSilenced } from 'src/logic-functions/utils/is-slack-channel-silenced';+import { notifySilencedSlackChannel } from 'src/logic-functions/utils/notify-silenced-slack-channel';import { parseSlackAssistantRequest } from 'src/logic-functions/utils/parse-slack-assistant-request';import { replyToEmptySlackAssistantRequest } from 'src/logic-functions/utils/reply-to-empty-slack-assistant-request';+const SILENCED_CHANNEL_SKIP_REASON = 'Channel is silenced by a channel rule';++const DIRECT_MESSAGE_CHANNEL_TYPE = 'im';++const gateSilencedChannelEvent = async ({+ body,+ slackChannelId,+ shouldNotifyRequester,+}: {+ body: SlackEventsRequestBody;+ slackChannelId: string;+ shouldNotifyRequester: boolean;+}): Promise<SlackEventsEnqueueResult | undefined> => {+ if (body.event?.channel_type === DIRECT_MESSAGE_CHANNEL_TYPE) {+ return undefined;+ }++ const isSilenced = await isSlackChannelSilenced({+ client: new CoreApiClient(),+ slackChannelId,+ });++ if (!isSilenced) {+ return undefined;+ }++ const slackUserId = body.event?.user;++ if (shouldNotifyRequester && isNonEmptyString(slackUserId)) {+ await notifySilencedSlackChannel({+ slackChannelId,+ slackUserId,+ parentMessageTimestamp: body.event?.thread_ts,+ });+ }++ return { ok: true, skipped: SILENCED_CHANNEL_SKIP_REASON };+};+export const enqueueSlackAssistantRequest = async (body: SlackEventsRequestBody,): Promise<SlackEventsEnqueueResult> => {const parsed = parseSlackAssistantRequest(body);if (parsed.request === null) {- if (isDefined(parsed.emptyRequest)) {- return await replyToEmptySlackAssistantRequest(parsed.emptyRequest);+ if (!isDefined(parsed.emptyRequest)) {+ return { ok: true, skipped: parsed.skipReason };}- return { ok: true, skipped: parsed.skipReason };+ const silencedEmptyRequestResult = await gateSilencedChannelEvent({+ body,+ slackChannelId: parsed.emptyRequest.slackChannelId,+ shouldNotifyRequester: true,+ });++ if (isDefined(silencedEmptyRequestResult)) {+ return silencedEmptyRequestResult;+ }++ return await replyToEmptySlackAssistantRequest(parsed.emptyRequest);+ }++ const silencedRequestResult = await gateSilencedChannelEvent({+ body,+ slackChannelId: parsed.request.slackChannelId,+ shouldNotifyRequester: !parsed.requiresActiveThreadSubscription,+ });++ if (isDefined(silencedRequestResult)) {+ return silencedRequestResult;}if (parsed.requiresActiveThreadSubscription) {diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-rule-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-rule-mode.tsnew file mode 100644index 00000000000..685a42b5c4e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-rule-mode.ts@@ -0,0 +1,7 @@+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { type SlackChannelRuleMode } from 'src/logic-functions/types/slack-channel-rule-mode.type';++export const isSlackChannelRuleMode = (+ value: unknown,+): value is SlackChannelRuleMode =>+ Object.values(SLACK_CHANNEL_RULE_MODE).some((mode) => mode === value);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-silenced.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-silenced.tsnew file mode 100644index 00000000000..6ba8031f77b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-channel-silenced.ts@@ -0,0 +1,16 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { findSlackChannelRule } from 'src/logic-functions/data/find-slack-channel-rule';++export const isSlackChannelSilenced = async ({+ client,+ slackChannelId,+}: {+ client: Pick<CoreApiClient, 'query'>;+ slackChannelId: string;+}): Promise<boolean> => {+ const rule = await findSlackChannelRule(client, { slackChannelId });++ return rule?.mode === SLACK_CHANNEL_RULE_MODE.SILENT;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/notify-silenced-slack-channel.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/notify-silenced-slack-channel.tsnew file mode 100644index 00000000000..d1ba17653a1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/notify-silenced-slack-channel.ts@@ -0,0 +1,19 @@+import { SLACK_CHANNEL_SILENCED_TEXT } from 'src/logic-functions/constants/slack-channel-silenced-text';+import { slackPostEphemeralMessageHandler } from 'src/logic-functions/handlers/slack-post-ephemeral-message-handler';++export const notifySilencedSlackChannel = async ({+ slackChannelId,+ slackUserId,+ parentMessageTimestamp,+}: {+ slackChannelId: string;+ slackUserId: string;+ parentMessageTimestamp: string | undefined;+}): Promise<void> => {+ await slackPostEphemeralMessageHandler({+ slackChannelId,+ recipientSlackUserId: slackUserId,+ messageText: SLACK_CHANNEL_SILENCED_TEXT,+ parentMessageTimestamp,+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-channel-access-policy.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-channel-access-policy.tsnew file mode 100644index 00000000000..a402f852d5c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-channel-access-policy.ts@@ -0,0 +1,64 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';+import { findSlackChannelRule } from 'src/logic-functions/data/find-slack-channel-rule';+import { type SlackChannelAccessPolicy } from 'src/logic-functions/types/slack-channel-access-policy.type';+import { type SlackChannelRule } from 'src/logic-functions/types/slack-channel-rule.type';+import { getSlackAccessMode } from 'src/logic-functions/utils/get-slack-access-mode';++const resolveWorkspacePolicy = async (): Promise<SlackChannelAccessPolicy> => ({+ status: 'ANSWER',+ accessMode: await getSlackAccessMode(),+ isChannelRule: false,+});++const toChannelRulePolicy = (+ rule: SlackChannelRule,+): SlackChannelAccessPolicy => {+ switch (rule.mode) {+ case SLACK_CHANNEL_RULE_MODE.SILENT:+ return { status: 'SILENT' };+ case SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY:+ return {+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,+ isChannelRule: true,+ };+ case SLACK_CHANNEL_RULE_MODE.OPEN:+ return {+ status: 'ANSWER',+ accessMode: SLACK_ACCESS_MODE.ANYONE,+ isChannelRule: true,+ };+ }+};++export const resolveSlackChannelAccessPolicy = async ({+ client,+ slackChannelId,+ isDirectMessage,+}: {+ client: Pick<CoreApiClient, 'query'>;+ slackChannelId: string;+ isDirectMessage: boolean;+}): Promise<SlackChannelAccessPolicy> => {+ if (isDirectMessage) {+ return await resolveWorkspacePolicy();+ }++ let rule: SlackChannelRule | undefined;++ try {+ rule = await findSlackChannelRule(client, { slackChannelId });+ } catch {+ return { status: 'UNREADABLE' };+ }++ if (!isDefined(rule)) {+ return await resolveWorkspacePolicy();+ }++ return toChannelRulePolicy(rule);+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/search-slack-channels-by-name.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/search-slack-channels-by-name.tsnew file mode 100644index 00000000000..10d9666ef23--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/search-slack-channels-by-name.ts@@ -0,0 +1,71 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';++import { SLACK_RATE_LIMIT_RETRY_BUDGET_MS } from 'src/logic-functions/constants/slack-rate-limit-retry-budget-ms';+import { type SlackChannelSearchOption } from 'src/logic-functions/types/slack-channel-search.type';+import { retrySlackCallWhenRateLimited } from 'src/logic-functions/utils/retry-slack-call-when-rate-limited';++const CHANNELS_PER_PAGE = 1000;+const DEFAULT_MAX_PAGES = 20;+const CHANNEL_TYPES = 'public_channel,private_channel';++export const searchSlackChannelsByName = async ({+ slackClient,+ query,+ maxResults,+ maxPages = DEFAULT_MAX_PAGES,+ rateLimitRetryBudgetMs = SLACK_RATE_LIMIT_RETRY_BUDGET_MS,+}: {+ slackClient: WebClient;+ query: string;+ maxResults: number;+ maxPages?: number;+ rateLimitRetryBudgetMs?: number;+}): Promise<SlackChannelSearchOption[]> => {+ const normalizedQuery = query.toLowerCase();+ const slackChannels: SlackChannelSearchOption[] = [];+ const rateLimitDeadlineAtMs = Date.now() + rateLimitRetryBudgetMs;+ let cursor: string | undefined;++ for (let page = 0; page < maxPages; page += 1) {+ const response = await retrySlackCallWhenRateLimited({+ call: async () =>+ slackClient.conversations.list({+ types: CHANNEL_TYPES,+ exclude_archived: true,+ limit: CHANNELS_PER_PAGE,+ cursor,+ }),+ budgetMs: Math.max(rateLimitDeadlineAtMs - Date.now(), 0),+ });++ for (const channel of response.channels ?? []) {+ if (slackChannels.length >= maxResults) {+ break;+ }++ if (+ !isNonEmptyString(channel.id) ||+ !isNonEmptyString(channel.name) ||+ !channel.name.toLowerCase().includes(normalizedQuery)+ ) {+ continue;+ }++ slackChannels.push({+ slackChannelId: channel.id,+ name: channel.name,+ isPrivate: channel.is_private === true,+ isMember: channel.is_member === true,+ });+ }++ cursor = response.response_metadata?.next_cursor;++ if (slackChannels.length >= maxResults || !isNonEmptyString(cursor)) {+ break;+ }+ }++ return slackChannels;+};diff --git a/packages/twenty-apps/public/slack/src/objects/slack-channel-rule.object.ts b/packages/twenty-apps/public/slack/src/objects/slack-channel-rule.object.tsnew file mode 100644index 00000000000..c367ce0f0d9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/objects/slack-channel-rule.object.ts@@ -0,0 +1,88 @@+import {+ defineObject,+ FieldType,+ MetadataWritability,+} from 'twenty-sdk/define';++import {+ SLACK_CHANNEL_RULE_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_MODE_FIELD_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_NAME_FIELD_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_TEAM_ID_FIELD_UNIVERSAL_IDENTIFIER,+} from 'src/constants/universal-identifiers';+import { SLACK_CHANNEL_RULE_MODE } from 'src/logic-functions/constants/slack-channel-rule-mode';++export default defineObject({+ universalIdentifier: SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,+ nameSingular: 'slackChannelRule',+ namePlural: 'slackChannelRules',+ labelSingular: 'Slack Channel Rule',+ labelPlural: 'Slack Channel Rules',+ description:+ 'Decides who the assistant answers in one Slack channel. A channel without a rule follows the workspace access mode.',+ icon: 'IconBrandSlack',+ writability: MetadataWritability.APPLICATION,+ labelIdentifierFieldMetadataUniversalIdentifier:+ SLACK_CHANNEL_RULE_NAME_FIELD_UNIVERSAL_IDENTIFIER,+ fields: [+ {+ universalIdentifier: SLACK_CHANNEL_RULE_NAME_FIELD_UNIVERSAL_IDENTIFIER,+ type: FieldType.TEXT,+ label: 'Name',+ description: 'Slack channel name captured when the rule was saved',+ icon: 'IconAbc',+ name: 'name',+ },+ {+ universalIdentifier:+ SLACK_CHANNEL_RULE_CHANNEL_ID_FIELD_UNIVERSAL_IDENTIFIER,+ type: FieldType.TEXT,+ label: 'Slack channel ID',+ description: 'Channel the rule applies to',+ icon: 'IconHash',+ name: 'slackChannelId',+ },+ {+ universalIdentifier:+ SLACK_CHANNEL_RULE_TEAM_ID_FIELD_UNIVERSAL_IDENTIFIER,+ type: FieldType.TEXT,+ label: 'Slack team ID',+ description: 'Slack workspace the channel belongs to',+ icon: 'IconHash',+ name: 'slackTeamId',+ },+ {+ universalIdentifier: SLACK_CHANNEL_RULE_MODE_FIELD_UNIVERSAL_IDENTIFIER,+ type: FieldType.SELECT,+ label: 'Mode',+ description: 'Who the assistant answers in this channel',+ icon: 'IconLock',+ defaultValue: `'${SLACK_CHANNEL_RULE_MODE.OPEN}'`,+ options: [+ {+ id: '2f5e761b-fd23-41be-8491-c86ab7596fcc',+ value: SLACK_CHANNEL_RULE_MODE.OPEN,+ label: 'Open to anyone',+ position: 0,+ color: 'green',+ },+ {+ id: '028db981-4d77-49e1-bf2c-a5a0240cb180',+ value: SLACK_CHANNEL_RULE_MODE.LINKED_MEMBERS_ONLY,+ label: 'Linked members only',+ position: 1,+ color: 'orange',+ },+ {+ id: '91ef2997-5ff9-4593-913e-d48a0c81e398',+ value: SLACK_CHANNEL_RULE_MODE.SILENT,+ label: 'Silent',+ position: 2,+ color: 'gray',+ },+ ],+ name: 'mode',+ },+ ],+});diff --git a/packages/twenty-apps/public/slack/src/roles/default-function.role.ts b/packages/twenty-apps/public/slack/src/roles/default-function.role.tsindex 11604d13d50..4169264f68a 100644--- a/packages/twenty-apps/public/slack/src/roles/default-function.role.ts+++ b/packages/twenty-apps/public/slack/src/roles/default-function.role.ts@@ -7,6 +7,7 @@ import {import {DEFAULT_ROLE_UNIVERSAL_IDENTIFIER,SLACK_ASSISTANT_REQUEST_OBJECT_UNIVERSAL_IDENTIFIER,+ SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,SLACK_USER_LINK_OBJECT_UNIVERSAL_IDENTIFIER,} from 'src/constants/universal-identifiers';@@ -14,7 +15,7 @@ export default defineApplicationRole({universalIdentifier: DEFAULT_ROLE_UNIVERSAL_IDENTIFIER,label: 'Twenty Slack tools role',description:- 'Tools only forward requests to Slack using the configured connected account. Tracks assistant requests, links Slack accounts to workspace members (which needs read access on workspace members for the email match), reads CRM records to render record link previews in Slack, and runs the assistant agent; write access to the CRM is granted separately through the role assigned to the agent.',+ 'Tools only forward requests to Slack using the configured connected account. Tracks assistant requests, links Slack accounts to workspace members (which needs read access on workspace members for the email match), keeps per-channel rules for the assistant, reads CRM records to render record link previews in Slack, and runs the assistant agent; write access to the CRM is granted separately through the role assigned to the agent.',canReadAllObjectRecords: false,canUpdateAllObjectRecords: false,canSoftDeleteAllObjectRecords: false,@@ -39,6 +40,13 @@ export default defineApplicationRole({canSoftDeleteObjectRecords: false,canDestroyObjectRecords: true,},+ {+ objectUniversalIdentifier: SLACK_CHANNEL_RULE_OBJECT_UNIVERSAL_IDENTIFIER,+ canReadObjectRecords: true,+ canUpdateObjectRecords: true,+ canSoftDeleteObjectRecords: false,+ canDestroyObjectRecords: true,+ },{objectUniversalIdentifier:STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.workspaceMember