Skip to content

The open alternative to Salesforce, designed for AI.

feat(slack): access mode to restrict the assistant to linked members (#25834)

Abdul Rahman6a52d1416b17
diff --git a/packages/twenty-apps/public/slack/README.md b/packages/twenty-apps/public/slack/README.md
index a7167f09328..1e173ae21b6 100644
--- a/packages/twenty-apps/public/slack/README.md
+++ b/packages/twenty-apps/public/slack/README.md
@@ -6,6 +6,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
## 💳 Billing
diff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.json
index c48337a5968..d0d7175684a 100644
--- a/packages/twenty-apps/public/slack/package.json
+++ b/packages/twenty-apps/public/slack/package.json
@@ -1,6 +1,6 @@
{
"name": "@twentyhq/slack",
- "version": "1.2.0",
+ "version": "1.3.0",
"description": "Slack assistant and workflow steps for Twenty",
"license": "MIT",
"engines": {
diff --git a/packages/twenty-apps/public/slack/src/constants/slack-access-mode-route-path.constant.ts b/packages/twenty-apps/public/slack/src/constants/slack-access-mode-route-path.constant.ts
new file mode 100644
index 00000000000..b5af58c2e74
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/constants/slack-access-mode-route-path.constant.ts
@@ -0,0 +1,3 @@
+export const SLACK_ACCESS_MODE_GET_ROUTE_PATH = '/slack-access-mode';
+
+export const SLACK_ACCESS_MODE_SET_ROUTE_PATH = '/slack-access-mode/set';
diff --git a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts
index 4cbc82a0ab1..ffb255b29ab 100644
--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts
+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts
@@ -189,3 +189,9 @@ export const SLACK_CONNECTION_STATUS_UNIVERSAL_IDENTIFIER =
export const SLACK_DELIVER_MESSAGE_UNIVERSAL_IDENTIFIER =
'cc43a728-7b9f-43c6-a9a2-bd1196204822';
+
+export const SLACK_ACCESS_MODE_GET_UNIVERSAL_IDENTIFIER =
+ 'bc06872e-4978-4476-b655-fc234ce64592';
+
+export const SLACK_ACCESS_MODE_SET_UNIVERSAL_IDENTIFIER =
+ '34458aca-bf05-4dc6-a002-b1786ca42652';
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.tsx
new file mode 100644
index 00000000000..376de4e377c
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackAccessModeSection.tsx
@@ -0,0 +1,171 @@
+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';
+import { THEME_COMMON } from 'twenty-ui/theme';
+import { themeCssVariables } from 'twenty-ui/theme-constants';
+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 { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+
+const StyledCardContent = styled.div<{ $disabled: boolean }>`
+ align-items: center;
+ background-color: ${() => themeCssVariables.background.secondary};
+ cursor: ${({ $disabled }) => ($disabled ? 'default' : 'pointer')};
+ display: flex;
+ gap: ${() => themeCssVariables.spacing[3]};
+ padding: ${() => themeCssVariables.spacing[4]};
+ pointer-events: ${({ $disabled }) => ($disabled ? 'none' : 'auto')};
+ position: relative;
+
+ &:hover {
+ background: ${() => themeCssVariables.background.transparent.lighter};
+ }
+`;
+
+const StyledIcon = styled.div`
+ align-items: center;
+ background-color: ${() => themeCssVariables.background.primary};
+ border: 2px solid ${() => themeCssVariables.border.color.light};
+ border-radius: ${() => themeCssVariables.border.radius.sm};
+ box-sizing: border-box;
+ color: ${() => themeCssVariables.font.color.secondary};
+ display: flex;
+ height: ${() => themeCssVariables.spacing[8]};
+ justify-content: center;
+ min-width: ${() => themeCssVariables.spacing[8]};
+ width: ${() => themeCssVariables.spacing[8]};
+`;
+
+const StyledTextContainer = styled.div`
+ flex: 1;
+ min-width: 0;
+`;
+
+const StyledTitle = styled.div`
+ color: ${() => themeCssVariables.font.color.primary};
+ font-family: ${() => themeCssVariables.font.family};
+ font-weight: ${() => themeCssVariables.font.weight.medium};
+ margin-bottom: ${() => themeCssVariables.spacing[1]};
+`;
+
+const StyledDescription = styled.div`
+ color: ${() => themeCssVariables.font.color.secondary};
+ font-family: ${() => themeCssVariables.font.family};
+ font-size: ${() => themeCssVariables.font.size.sm};
+ line-height: ${() => themeCssVariables.text.lineHeight.lg};
+ overflow-wrap: break-word;
+`;
+
+const StyledCover = styled.span`
+ cursor: pointer;
+ inset: 0;
+ position: absolute;
+`;
+
+const StyledToggleContainer = styled.span`
+ align-items: center;
+ display: flex;
+ flex-shrink: 0;
+ margin-left: auto;
+`;
+
+const RESTRICTED_DESCRIPTION =
+ 'Only Slack accounts linked to a workspace member can use it.';
+
+const OPEN_DESCRIPTION =
+ 'Anyone who can mention the assistant in Slack can use it.';
+
+const UNREADABLE_DESCRIPTION =
+ 'The current setting could not be loaded. Reload to try again.';
+
+const getDescription = ({
+ hasAccessModeError,
+ isRestricted,
+}: {
+ hasAccessModeError: boolean;
+ isRestricted: boolean;
+}): string => {
+ if (hasAccessModeError) {
+ return UNREADABLE_DESCRIPTION;
+ }
+
+ return isRestricted ? RESTRICTED_DESCRIPTION : OPEN_DESCRIPTION;
+};
+
+type SlackAccessModeSectionProps = {
+ canManage: boolean;
+};
+
+export const SlackAccessModeSection = ({
+ canManage,
+}: SlackAccessModeSectionProps) => {
+ const toggleId = useId();
+ const {
+ accessMode,
+ hasAccessModeError,
+ isAccessModeLoading,
+ isSavingAccessMode,
+ saveAccessMode,
+ } = useSlackAccessMode();
+
+ const isRestricted = accessMode === SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS;
+
+ const isDisabled =
+ !canManage ||
+ hasAccessModeError ||
+ isAccessModeLoading ||
+ isSavingAccessMode;
+
+ const handleToggle = async (value: boolean) => {
+ const result = await saveAccessMode(
+ 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',
+ });
+ };
+
+ const description = getDescription({ hasAccessModeError, isRestricted });
+
+ return (
+ <Section>
+ <H2Title
+ title="Access"
+ description="Choose who the assistant answers in Slack."
+ />
+ <Card rounded>
+ <StyledCardContent $disabled={isDisabled}>
+ <StyledIcon>
+ <IconLock size={THEME_COMMON.icon.size.md} />
+ </StyledIcon>
+ <StyledTextContainer>
+ <StyledTitle>
+ <label htmlFor={toggleId}>
+ Restrict to linked members
+ <StyledCover />
+ </label>
+ </StyledTitle>
+ <StyledDescription>{description}</StyledDescription>
+ </StyledTextContainer>
+ <StyledToggleContainer>
+ <Toggle
+ id={toggleId}
+ checked={isRestricted}
+ onChange={handleToggle}
+ disabled={isDisabled}
+ ariaLabel="Restrict the assistant to linked members"
+ />
+ </StyledToggleContainer>
+ </StyledCardContent>
+ </Card>
+ </Section>
+ );
+};
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.tsx
index 8370b3e1518..a2855560134 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
@@ -1,16 +1,19 @@
import 'twenty-ui/style.css';
+import 'twenty-ui/theme-dark.css';
+import 'twenty-ui/theme-light.css';
import styled from '@emotion/styled';
import { isNonEmptyString } from '@sniptt/guards';
import { useState } from 'react';
-import { enqueueSnackbar } from 'twenty-sdk/front-component';
+import { enqueueSnackbar, useColorScheme } from 'twenty-sdk/front-component';
import { isDefined } from 'twenty-sdk/utils';
import { Callout } from 'twenty-ui/feedback';
import { Button } from 'twenty-ui/input';
import { Section } from 'twenty-ui/layout';
-import { themeCssVariables } from 'twenty-ui/theme-constants';
+import { ThemeProvider, themeCssVariables } from 'twenty-ui/theme-constants';
import { H2Title } from 'twenty-ui/typography';
+import { SlackAccessModeSection } from 'src/front-components/components/SlackAccessModeSection';
import { SlackUserLinkForm } from 'src/front-components/components/SlackUserLinkForm';
import { SlackUserLinksList } from 'src/front-components/components/SlackUserLinksList';
import { UnlinkedSlackUsersList } from 'src/front-components/components/UnlinkedSlackUsersList';
@@ -63,7 +66,7 @@ const StyledCenteredState = styled.div`
width: 100%;
`;
-export const SlackUserLinksSettings = () => {
+const SlackUserLinksSettingsContent = () => {
const { canManage, isPermissionLoading } = useCanManageSlackUserLinks();
const {
isSlackConnected,
@@ -211,6 +214,7 @@ export const SlackUserLinksSettings = () => {
description="The last automatic email match failed before linking everyone. Press Auto-link by email below to run it again."
/>
)}
+ <SlackAccessModeSection canManage={canManage} />
{canManage && (
<Section>
<H2Title
@@ -287,3 +291,17 @@ export const SlackUserLinksSettings = () => {
</StyledContainer>
);
};
+
+// twenty-ui components and this app's styled rules read every token off
+// ThemeContext as a var() reference. The sandbox document does not inherit the
+// host stylesheet, so the theme variable sheets are imported here for the
+// provider to resolve them against.
+export const SlackUserLinksSettings = () => {
+ const colorScheme = useColorScheme();
+
+ return (
+ <ThemeProvider colorScheme={colorScheme}>
+ <SlackUserLinksSettingsContent />
+ </ThemeProvider>
+ );
+};
diff --git a/packages/twenty-apps/public/slack/src/front-components/components/Toggle.tsx b/packages/twenty-apps/public/slack/src/front-components/components/Toggle.tsx
new file mode 100644
index 00000000000..9e9b16d0733
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/front-components/components/Toggle.tsx
@@ -0,0 +1,89 @@
+import styled from '@emotion/styled';
+import { themeCssVariables } from 'twenty-ui/theme-constants';
+
+// twenty-ui's Toggle is a base-ui Switch whose click handler constructs a
+// PointerEvent, which the front component sandbox does not provide. This is
+// the same control as a plain button, styled after twenty-ui's Toggle. The
+// host theme squircles every corner, so the capsule and thumb opt out.
+const TOGGLE_WIDTH_PIXELS = 32;
+const TOGGLE_HEIGHT_PIXELS = 20;
+const THUMB_SIZE_PIXELS = 16;
+const THUMB_INSET_PIXELS = 2;
+
+const CHECKED_THUMB_OFFSET_PIXELS =
+ TOGGLE_WIDTH_PIXELS - THUMB_SIZE_PIXELS - THUMB_INSET_PIXELS;
+
+const StyledToggle = styled.button`
+ align-items: center;
+ appearance: none;
+ background-color: ${() => themeCssVariables.background.transparent.medium};
+ border: none;
+ border-radius: ${() => themeCssVariables.border.radius.pill};
+ corner-shape: round;
+ cursor: pointer;
+ display: flex;
+ flex-shrink: 0;
+ height: ${TOGGLE_HEIGHT_PIXELS}px;
+ padding: 0;
+ position: relative;
+ transition: background-color
+ calc(${() => themeCssVariables.animation.duration.normal} * 1s) ease;
+ width: ${TOGGLE_WIDTH_PIXELS}px;
+
+ &[data-checked='true'] {
+ background-color: ${() => themeCssVariables.color.blue};
+ }
+
+ &:disabled {
+ cursor: default;
+ opacity: 0.5;
+ }
+`;
+
+const StyledThumb = styled.span`
+ background-color: ${() => themeCssVariables.background.primary};
+ border-radius: 50%;
+ corner-shape: round;
+ display: block;
+ height: ${THUMB_SIZE_PIXELS}px;
+ left: 0;
+ position: absolute;
+ top: 50%;
+ transform: translate(${THUMB_INSET_PIXELS}px, -50%);
+ transition: transform
+ calc(${() => themeCssVariables.animation.duration.normal} * 1s) ease;
+ width: ${THUMB_SIZE_PIXELS}px;
+
+ &[data-checked='true'] {
+ transform: translate(${CHECKED_THUMB_OFFSET_PIXELS}px, -50%);
+ }
+`;
+
+type ToggleProps = {
+ id?: string;
+ checked: boolean;
+ disabled?: boolean;
+ ariaLabel: string;
+ onChange: (checked: boolean) => void;
+};
+
+export const Toggle = ({
+ id,
+ checked,
+ disabled = false,
+ ariaLabel,
+ onChange,
+}: ToggleProps) => (
+ <StyledToggle
+ type="button"
+ role="switch"
+ id={id}
+ aria-checked={checked ? 'true' : 'false'}
+ aria-label={ariaLabel}
+ data-checked={checked ? 'true' : 'false'}
+ disabled={disabled}
+ onClick={() => onChange(!checked)}
+ >
+ <StyledThumb data-checked={checked ? 'true' : 'false'} />
+ </StyledToggle>
+);
diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-access-mode.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-access-mode.ts
new file mode 100644
index 00000000000..1de7eed5868
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-access-mode.ts
@@ -0,0 +1,127 @@
+import { isBoolean, isString } from '@sniptt/guards';
+import { useEffect, useState } from 'react';
+import { RestApiClient } from 'twenty-client-sdk/rest';
+import { isDefined } from 'twenty-sdk/utils';
+
+import {
+ SLACK_ACCESS_MODE_GET_ROUTE_PATH,
+ SLACK_ACCESS_MODE_SET_ROUTE_PATH,
+} from 'src/constants/slack-access-mode-route-path.constant';
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+import { asRecord } from 'src/logic-functions/utils/as-record.util';
+import { isSlackAccessMode } from 'src/logic-functions/utils/is-slack-access-mode';
+
+type SaveAccessModeResult = {
+ success: boolean;
+ message: string;
+ error?: string;
+};
+
+type SlackAccessModeState = {
+ accessMode: SlackAccessMode;
+ hasAccessModeError: boolean;
+ isAccessModeLoading: boolean;
+ isSavingAccessMode: boolean;
+ saveAccessMode: (
+ accessMode: SlackAccessMode,
+ ) => Promise<SaveAccessModeResult>;
+};
+
+const GENERIC_ERROR_RESULT: SaveAccessModeResult = {
+ success: false,
+ message: 'Could not save the access mode',
+ error: 'The request failed. Please try again.',
+};
+
+export const useSlackAccessMode = (): SlackAccessModeState => {
+ const [accessMode, setAccessMode] = useState<SlackAccessMode>(
+ SLACK_ACCESS_MODE.ANYONE,
+ );
+ const [hasAccessModeError, setHasAccessModeError] = useState(false);
+ const [isAccessModeLoading, setIsAccessModeLoading] = useState(true);
+ const [isSavingAccessMode, setIsSavingAccessMode] = useState(false);
+
+ useEffect(() => {
+ let cancelled = false;
+
+ const fetchAccessMode = async () => {
+ try {
+ const result = await new RestApiClient().get(
+ `/s${SLACK_ACCESS_MODE_GET_ROUTE_PATH}`,
+ );
+
+ if (!cancelled) {
+ const record = asRecord(result);
+
+ const readAccessMode = record?.accessMode;
+
+ if (isSlackAccessMode(readAccessMode)) {
+ setAccessMode(readAccessMode);
+ }
+
+ setHasAccessModeError(
+ record?.isAccessModeReadable === false ||
+ !isSlackAccessMode(readAccessMode),
+ );
+ }
+ } catch {
+ if (!cancelled) {
+ setHasAccessModeError(true);
+ }
+ } finally {
+ if (!cancelled) {
+ setIsAccessModeLoading(false);
+ }
+ }
+ };
+
+ fetchAccessMode();
+
+ return () => {
+ cancelled = true;
+ };
+ }, []);
+
+ const saveAccessMode = async (
+ nextAccessMode: SlackAccessMode,
+ ): Promise<SaveAccessModeResult> => {
+ setIsSavingAccessMode(true);
+
+ try {
+ const result = await new RestApiClient().post(
+ `/s${SLACK_ACCESS_MODE_SET_ROUTE_PATH}`,
+ { accessMode: nextAccessMode },
+ );
+
+ const record = asRecord(result);
+
+ if (!isDefined(record) || !isBoolean(record.success)) {
+ return GENERIC_ERROR_RESULT;
+ }
+
+ if (record.success) {
+ setAccessMode(nextAccessMode);
+ setHasAccessModeError(false);
+ }
+
+ return {
+ success: record.success,
+ message: isString(record.message) ? record.message : '',
+ error: isString(record.error) ? record.error : undefined,
+ };
+ } catch {
+ return GENERIC_ERROR_RESULT;
+ } finally {
+ setIsSavingAccessMode(false);
+ }
+ };
+
+ return {
+ accessMode,
+ hasAccessModeError,
+ isAccessModeLoading,
+ isSavingAccessMode,
+ saveAccessMode,
+ };
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-denied-text.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-denied-text.ts
new file mode 100644
index 00000000000..85f3d8ce41a
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-denied-text.ts
@@ -0,0 +1,2 @@
+export const SLACK_ACCESS_DENIED_TEXT =
+ "I can only help Slack accounts linked to a workspace member right now. 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-access-mode-kv-key.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-mode-kv-key.ts
new file mode 100644
index 00000000000..42793dbd62b
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-mode-kv-key.ts
@@ -0,0 +1 @@
+export const SLACK_ACCESS_MODE_KV_KEY = 'slack-access-mode';
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-mode.ts
new file mode 100644
index 00000000000..ae2b2760371
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-mode.ts
@@ -0,0 +1,4 @@
+export const SLACK_ACCESS_MODE = {
+ ANYONE: 'ANYONE',
+ ONLY_LINKED_MEMBERS: 'ONLY_LINKED_MEMBERS',
+} as const;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-unverifiable-error.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-unverifiable-error.ts
new file mode 100644
index 00000000000..6ca94254d7e
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-access-unverifiable-error.ts
@@ -0,0 +1,2 @@
+export const SLACK_ACCESS_UNVERIFIABLE_ERROR =
+ 'Could not check whether this Slack account is linked to a workspace member.';
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-get-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-get-handler.test.ts
new file mode 100644
index 00000000000..afa49096911
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-get-handler.test.ts
@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { slackAccessModeGetHandler } from 'src/logic-functions/handlers/slack-access-mode-get-handler';
+
+const { readSlackAccessModeMock } = vi.hoisted(() => ({
+ readSlackAccessModeMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/read-slack-access-mode', () => ({
+ readSlackAccessMode: readSlackAccessModeMock,
+}));
+
+describe('slackAccessModeGetHandler', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should return the stored access mode as readable', async () => {
+ readSlackAccessModeMock.mockResolvedValue({
+ status: 'READ',
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ });
+
+ expect(await slackAccessModeGetHandler()).toEqual({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ isAccessModeReadable: true,
+ });
+ });
+
+ it('should report an unreadable store rather than passing the fallback off as stored', async () => {
+ readSlackAccessModeMock.mockResolvedValue({ status: 'UNREADABLE' });
+
+ expect(await slackAccessModeGetHandler()).toEqual({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ isAccessModeReadable: false,
+ });
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-set-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-set-handler.test.ts
new file mode 100644
index 00000000000..2809da8fa53
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-access-mode-set-handler.test.ts
@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { slackAccessModeSetHandler } from 'src/logic-functions/handlers/slack-access-mode-set-handler';
+
+const { currentUserHasRolesPermissionMock, kvSetMock } = vi.hoisted(() => ({
+ currentUserHasRolesPermissionMock: vi.fn(),
+ kvSetMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({
+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,
+}));
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ kv: { set: kvSetMock },
+}));
+
+const buildPayload = (body: unknown) => ({ body });
+
+describe('slackAccessModeSetHandler', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ currentUserHasRolesPermissionMock.mockResolvedValue(true);
+ });
+
+ it('should refuse when the user lacks the roles permission', async () => {
+ currentUserHasRolesPermissionMock.mockResolvedValue(false);
+
+ const result = await slackAccessModeSetHandler(
+ buildPayload({ accessMode: 'ONLY_LINKED_MEMBERS' }),
+ );
+
+ expect(result.success).toBe(false);
+ expect(kvSetMock).not.toHaveBeenCalled();
+ });
+
+ it('should reject an invalid access mode', async () => {
+ const result = await slackAccessModeSetHandler(
+ buildPayload({ accessMode: 'NONSENSE' }),
+ );
+
+ expect(result.success).toBe(false);
+ expect(kvSetMock).not.toHaveBeenCalled();
+ });
+
+ it('should store a valid access mode in the workspace key value store', async () => {
+ const result = await slackAccessModeSetHandler(
+ buildPayload({ accessMode: 'ONLY_LINKED_MEMBERS' }),
+ );
+
+ expect(result.success).toBe(true);
+ expect(kvSetMock).toHaveBeenCalledWith(
+ 'slack-access-mode',
+ 'ONLY_LINKED_MEMBERS',
+ { scope: 'WORKSPACE' },
+ );
+ });
+
+ it('should fail with a structured result when the write errors', async () => {
+ kvSetMock.mockRejectedValueOnce(new Error('kv down'));
+
+ const result = await slackAccessModeSetHandler(
+ buildPayload({ accessMode: 'ANYONE' }),
+ );
+
+ expect(result.success).toBe(false);
+ expect(result.error).toBe('kv down');
+ });
+});
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.ts
index 93d8a9a6a14..91984b8444b 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
@@ -1,5 +1,7 @@
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_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';
@@ -20,6 +22,8 @@ const {
finishSlackAssistantRequestWithFailureMock,
setSlackAssistantThreadTitleMock,
subscribeSlackThreadMock,
+ getSlackAccessModeMock,
+ resolveSlackAccessDecisionMock,
} = vi.hoisted(() => ({
callLog: [] as string[],
coreApiClientMock: vi.fn(),
@@ -35,6 +39,16 @@ const {
finishSlackAssistantRequestWithFailureMock: vi.fn(),
setSlackAssistantThreadTitleMock: vi.fn(),
subscribeSlackThreadMock: vi.fn(),
+ getSlackAccessModeMock: vi.fn(),
+ resolveSlackAccessDecisionMock: 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('twenty-client-sdk/core', () => ({
@@ -106,6 +120,14 @@ const REQUEST_RECORD: SlackAssistantRequestRecord = {
requestText: 'how many open deals does Acme have?',
};
+const REQUESTER_IDENTITY = {
+ slackUserId: 'U123',
+ slackTeamId: 'T0INSTALLED',
+ displayName: 'Ada',
+ email: '[email protected]',
+ isRegularUserAccount: true,
+};
+
const SLACK_CONTEXT = {
conversationMessages: [],
requesterName: 'Ada',
@@ -129,6 +151,8 @@ describe('slackAssistantWorkerHandler', () => {
updateSlackAssistantRequestMock.mockResolvedValue(undefined);
fetchWorkspaceBaseUrlsMock.mockResolvedValue(['https://acme.twenty.com']);
resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);
+ getSlackAccessModeMock.mockResolvedValue(SLACK_ACCESS_MODE.ANYONE);
+ resolveSlackAccessDecisionMock.mockResolvedValue({ status: 'ALLOWED' });
setSlackAssistantThreadTitleMock.mockResolvedValue(undefined);
subscribeSlackThreadMock.mockResolvedValue(undefined);
@@ -164,6 +188,106 @@ describe('slackAssistantWorkerHandler', () => {
);
});
+ it('should decline an unlinked Slack user when access is restricted to linked members', async () => {
+ resolveSlackAccessDecisionMock.mockResolvedValue({ status: 'DENIED' });
+
+ await expect(slackAssistantWorkerHandler(REQUEST_RECORD)).resolves.toEqual({
+ done: true,
+ declined: true,
+ });
+
+ expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();
+ expect(sendSlackMessageMock).toHaveBeenCalledTimes(1);
+ expect(sendSlackMessageMock).toHaveBeenCalledWith(
+ expect.objectContaining({ messageText: SLACK_ACCESS_DENIED_TEXT }),
+ );
+ expect(updateSlackAssistantRequestMock).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({
+ id: REQUEST_RECORD.id,
+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,
+ responseText: SLACK_ACCESS_DENIED_TEXT,
+ }),
+ );
+ });
+
+ it('should fail the request when the denial message cannot be delivered', async () => {
+ resolveSlackAccessDecisionMock.mockResolvedValue({ status: 'DENIED' });
+ sendSlackMessageMock.mockImplementation(async () => {
+ callLog.push('reply:denied');
+
+ return { success: false, message: 'channel_not_found' };
+ });
+
+ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);
+
+ expect(result).toEqual(expect.objectContaining({ failed: true }));
+ expect(finishSlackAssistantRequestWithFailureMock).toHaveBeenCalledTimes(1);
+ expect(updateSlackAssistantRequestMock).not.toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({
+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,
+ responseText: SLACK_ACCESS_DENIED_TEXT,
+ }),
+ );
+ });
+
+ it('should fail rather than deny when access could not be established', async () => {
+ resolveSlackAccessDecisionMock.mockResolvedValue({
+ status: 'UNVERIFIABLE',
+ });
+
+ const result = await slackAssistantWorkerHandler(REQUEST_RECORD);
+
+ expect(result).toEqual(expect.objectContaining({ failed: true }));
+ expect(finishSlackAssistantRequestWithFailureMock).toHaveBeenCalledTimes(1);
+ expect(runSlackAssistantAgentWithDeadlineMock).not.toHaveBeenCalled();
+ expect(sendSlackMessageMock).not.toHaveBeenCalled();
+ expect(updateSlackAssistantRequestMock).not.toHaveBeenCalledWith(
+ expect.anything(),
+ expect.objectContaining({ responseText: SLACK_ACCESS_DENIED_TEXT }),
+ );
+ });
+
+ it('should ask for the access decision with the stored mode and the resolved requester', async () => {
+ getSlackAccessModeMock.mockResolvedValue(
+ SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,
+ );
+ resolveSlackRunAsForRequestMock.mockResolvedValue('workspace-member-1');
+ fetchSlackAssistantContextMock.mockImplementation(async () => {
+ callLog.push('context:fetch');
+
+ return {
+ ...SLACK_CONTEXT,
+ slackClient: {},
+ requesterIdentity: REQUESTER_IDENTITY,
+ };
+ });
+
+ await slackAssistantWorkerHandler(REQUEST_RECORD);
+
+ expect(resolveSlackAccessDecisionMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,
+ identity: REQUESTER_IDENTITY,
+ runAsWorkspaceMemberId: 'workspace-member-1',
+ }),
+ );
+ });
+
+ it('should answer a request access allowed', async () => {
+ getSlackAccessModeMock.mockResolvedValue(
+ SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,
+ );
+ resolveSlackRunAsForRequestMock.mockResolvedValue(undefined);
+
+ await expect(slackAssistantWorkerHandler(REQUEST_RECORD)).resolves.toEqual({
+ done: true,
+ });
+
+ expect(runSlackAssistantAgentWithDeadlineMock).toHaveBeenCalledTimes(1);
+ });
+
it('should show the thinking status before fetching the Slack context', async () => {
await slackAssistantWorkerHandler(REQUEST_RECORD);
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-get-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-get-handler.ts
new file mode 100644
index 00000000000..71b472aa61a
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-get-handler.ts
@@ -0,0 +1,17 @@
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+import { readSlackAccessMode } from 'src/logic-functions/utils/read-slack-access-mode';
+
+export const slackAccessModeGetHandler = async (): Promise<{
+ accessMode: SlackAccessMode;
+ isAccessModeReadable: boolean;
+}> => {
+ const result = await readSlackAccessMode();
+
+ return result.status === 'READ'
+ ? { accessMode: result.accessMode, isAccessModeReadable: true }
+ : {
+ accessMode: SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS,
+ isAccessModeReadable: false,
+ };
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-set-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-set-handler.ts
new file mode 100644
index 00000000000..e4ecf231c81
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-access-mode-set-handler.ts
@@ -0,0 +1,54 @@
+import { kv } from 'twenty-sdk/logic-function';
+
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { SLACK_ACCESS_MODE_KV_KEY } from 'src/logic-functions/constants/slack-access-mode-kv-key';
+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 { isSlackAccessMode } from 'src/logic-functions/utils/is-slack-access-mode';
+
+export const slackAccessModeSetHandler = async (
+ payload: SlackRouteBody,
+): Promise<SlackToolResult> => {
+ const isAllowed = await currentUserHasRolesPermission();
+
+ if (!isAllowed) {
+ return {
+ success: false,
+ message: 'Not allowed',
+ error:
+ 'Only members with the roles permission can change the access mode.',
+ };
+ }
+
+ const body = asRecord(payload.body) ?? {};
+
+ if (!isSlackAccessMode(body.accessMode)) {
+ return {
+ success: false,
+ message: 'Invalid access mode',
+ error: 'accessMode must be ANYONE or ONLY_LINKED_MEMBERS.',
+ };
+ }
+
+ const accessMode = body.accessMode;
+
+ try {
+ await kv.set(SLACK_ACCESS_MODE_KV_KEY, accessMode, { scope: 'WORKSPACE' });
+ } catch (error) {
+ return {
+ success: false,
+ message: 'Could not save the access mode',
+ error: error instanceof Error ? error.message : String(error),
+ };
+ }
+
+ return {
+ success: true,
+ message:
+ accessMode === SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS
+ ? 'The assistant is now restricted to linked members.'
+ : 'The assistant is now open to anyone.',
+ };
+};
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.ts
index eb40df37fd8..1ac67b1170e 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
@@ -3,6 +3,8 @@ import { CoreApiClient } from 'twenty-client-sdk/core';
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_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';
@@ -20,7 +22,9 @@ import { fetchSlackAssistantContext } from 'src/logic-functions/utils/fetch-slac
import { 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 { resolveSlackAccessDecision } from 'src/logic-functions/utils/resolve-slack-access-decision';
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';
@@ -122,6 +126,51 @@ export const slackAssistantWorkerHandler = async (
}).catch(() => undefined);
}
+ const accessDecision = await resolveSlackAccessDecision({
+ accessMode: await getSlackAccessMode(),
+ client,
+ slackClient,
+ identity: requesterIdentity,
+ runAsWorkspaceMemberId,
+ });
+
+ if (accessDecision.status === 'UNVERIFIABLE') {
+ await stopStatusUpdates();
+
+ return await finishSlackAssistantRequestWithFailure({
+ ...failureContext,
+ errorMessage: SLACK_ACCESS_UNVERIFIABLE_ERROR,
+ });
+ }
+
+ if (accessDecision.status === 'DENIED') {
+ await stopStatusUpdates();
+
+ const denialDelivery = await sendSlackMessage({
+ slackChannelId,
+ messageText: SLACK_ACCESS_DENIED_TEXT,
+ parentMessageTimestamp,
+ messageFormat: 'markdown',
+ unfurlLinks: false,
+ unfurlMedia: false,
+ });
+
+ if (!denialDelivery.success) {
+ return await finishSlackAssistantRequestWithFailure({
+ ...failureContext,
+ errorMessage: buildSlackAnswerDeliveryFailureMessage(denialDelivery),
+ });
+ }
+
+ await updateSlackAssistantRequest(client, {
+ id: record.id,
+ status: SLACK_ASSISTANT_REQUEST_STATUS.DONE,
+ responseText: SLACK_ACCESS_DENIED_TEXT,
+ });
+
+ return { done: true, declined: true };
+ }
+
const resolvedMentions = await resolveSlackAssistantMentions({
requestText,
conversationMessages,
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-get.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-get.ts
new file mode 100644
index 00000000000..ab94cc460eb
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-get.ts
@@ -0,0 +1,19 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { SLACK_ACCESS_MODE_GET_ROUTE_PATH } from 'src/constants/slack-access-mode-route-path.constant';
+import { SLACK_ACCESS_MODE_GET_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { slackAccessModeGetHandler } from 'src/logic-functions/handlers/slack-access-mode-get-handler';
+
+export default defineLogicFunction({
+ universalIdentifier: SLACK_ACCESS_MODE_GET_UNIVERSAL_IDENTIFIER,
+ name: 'slack-access-mode-get',
+ description:
+ 'Return whether the Slack assistant is open to anyone or restricted to workspace members with a Slack user link.',
+ timeoutSeconds: 15,
+ httpRouteTriggerSettings: {
+ path: SLACK_ACCESS_MODE_GET_ROUTE_PATH,
+ httpMethod: 'GET',
+ isAuthRequired: true,
+ },
+ handler: slackAccessModeGetHandler,
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-set.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-set.ts
new file mode 100644
index 00000000000..42af137ff78
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-access-mode-set.ts
@@ -0,0 +1,19 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { SLACK_ACCESS_MODE_SET_ROUTE_PATH } from 'src/constants/slack-access-mode-route-path.constant';
+import { SLACK_ACCESS_MODE_SET_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { slackAccessModeSetHandler } from 'src/logic-functions/handlers/slack-access-mode-set-handler';
+
+export default defineLogicFunction({
+ universalIdentifier: SLACK_ACCESS_MODE_SET_UNIVERSAL_IDENTIFIER,
+ name: 'slack-access-mode-set',
+ description:
+ 'Set whether the Slack assistant is open to anyone or restricted to workspace members with a Slack user link. Restricted to members with the workspace members permission.',
+ timeoutSeconds: 15,
+ httpRouteTriggerSettings: {
+ path: SLACK_ACCESS_MODE_SET_ROUTE_PATH,
+ httpMethod: 'POST',
+ isAuthRequired: true,
+ },
+ handler: slackAccessModeSetHandler,
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-decision.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-decision.type.ts
new file mode 100644
index 00000000000..abce32c5be2
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-decision.type.ts
@@ -0,0 +1,4 @@
+export type SlackAccessDecision =
+ | { status: 'ALLOWED' }
+ | { status: 'DENIED' }
+ | { status: 'UNVERIFIABLE' };
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode-read.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode-read.type.ts
new file mode 100644
index 00000000000..3ac62624d3c
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode-read.type.ts
@@ -0,0 +1,5 @@
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+
+export type SlackAccessModeRead =
+ | { status: 'READ'; accessMode: SlackAccessMode }
+ | { status: 'UNREADABLE' };
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode.type.ts
new file mode 100644
index 00000000000..95af0133ce5
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-access-mode.type.ts
@@ -0,0 +1,4 @@
+import { type SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+
+export type SlackAccessMode =
+ (typeof SLACK_ACCESS_MODE)[keyof typeof SLACK_ACCESS_MODE];
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-identity-resolution.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-identity-resolution.type.ts
index 9a544c579af..25042ffd28a 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-identity-resolution.type.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-identity-resolution.type.ts
@@ -16,5 +16,6 @@ export type SlackIdentityResolution = SlackIdentityResolutionBase &
memberProvenance: SlackMemberProvenance;
}
| { outcome: 'membershipNotConfirmed' }
+ | { outcome: 'membershipUnverifiable' }
| { outcome: 'unidentified' }
);
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/read-slack-access-mode.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/read-slack-access-mode.test.ts
new file mode 100644
index 00000000000..cedafd3bed0
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/read-slack-access-mode.test.ts
@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getSlackAccessMode } from 'src/logic-functions/utils/get-slack-access-mode';
+import { readSlackAccessMode } from 'src/logic-functions/utils/read-slack-access-mode';
+
+const { kvGetMock } = vi.hoisted(() => ({
+ kvGetMock: vi.fn(),
+}));
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ kv: { get: kvGetMock },
+}));
+
+describe('readSlackAccessMode', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should read as ANYONE when nothing is stored', async () => {
+ kvGetMock.mockResolvedValue(null);
+
+ expect(await readSlackAccessMode()).toEqual({
+ status: 'READ',
+ accessMode: 'ANYONE',
+ });
+ });
+
+ it('should report the read outcome alongside a stored value', async () => {
+ kvGetMock.mockResolvedValue('ONLY_LINKED_MEMBERS');
+
+ expect(await readSlackAccessMode()).toEqual({
+ status: 'READ',
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ });
+ });
+
+ it('should report an unreadable store distinctly from a stored value', async () => {
+ kvGetMock.mockRejectedValue(new Error('kv unavailable'));
+
+ expect(await readSlackAccessMode()).toEqual({ status: 'UNREADABLE' });
+ });
+
+ it('should report a stored value it cannot interpret as unreadable', async () => {
+ kvGetMock.mockResolvedValue('SOMETHING_ELSE');
+
+ expect(await readSlackAccessMode()).toEqual({ status: 'UNREADABLE' });
+ });
+});
+
+describe('getSlackAccessMode', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should default to ANYONE when nothing is stored', async () => {
+ kvGetMock.mockResolvedValue(null);
+
+ expect(await getSlackAccessMode()).toBe('ANYONE');
+ });
+
+ it('should return ONLY_LINKED_MEMBERS when stored', async () => {
+ kvGetMock.mockResolvedValue('ONLY_LINKED_MEMBERS');
+
+ expect(await getSlackAccessMode()).toBe('ONLY_LINKED_MEMBERS');
+ });
+
+ it('should keep the restriction on when the read throws', async () => {
+ kvGetMock.mockRejectedValue(new Error('kv unavailable'));
+
+ expect(await getSlackAccessMode()).toBe('ONLY_LINKED_MEMBERS');
+ });
+
+ it('should keep the restriction on for a stored value it cannot interpret', async () => {
+ kvGetMock.mockResolvedValue('SOMETHING_ELSE');
+
+ expect(await getSlackAccessMode()).toBe('ONLY_LINKED_MEMBERS');
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-access-decision.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-access-decision.test.ts
new file mode 100644
index 00000000000..a33fafa7b59
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-access-decision.test.ts
@@ -0,0 +1,193 @@
+import { type WebClient } from '@slack/web-api';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { type SlackIdentityResolution } from 'src/logic-functions/types/slack-identity-resolution.type';
+import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';
+import { resolveSlackAccessDecision } from 'src/logic-functions/utils/resolve-slack-access-decision';
+
+const { resolveSlackIdentitiesMock } = vi.hoisted(() => ({
+ resolveSlackIdentitiesMock: vi.fn(),
+}));
+
+vi.mock('src/logic-functions/utils/resolve-slack-identities', () => ({
+ resolveSlackIdentities: resolveSlackIdentitiesMock,
+}));
+
+const SLACK_USER_ID = 'U1';
+
+const identity: SlackUserIdentity = {
+ slackUserId: SLACK_USER_ID,
+ slackTeamId: 'T1',
+ email: '[email protected]',
+ displayName: 'Member',
+ isRegularUserAccount: true,
+};
+
+const client = {} as CoreApiClient;
+const slackClient = {} as WebClient;
+
+const RESOLUTION_BASE = {
+ slackUserId: SLACK_USER_ID,
+ identity,
+ link: undefined,
+};
+
+const mockResolution = (resolution: SlackIdentityResolution) => {
+ resolveSlackIdentitiesMock.mockResolvedValue(
+ new Map([[SLACK_USER_ID, resolution]]),
+ );
+};
+
+describe('resolveSlackAccessDecision', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should allow everyone when the workspace is open', async () => {
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ANYONE',
+ client,
+ slackClient,
+ identity: undefined,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'ALLOWED' });
+
+ expect(resolveSlackIdentitiesMock).not.toHaveBeenCalled();
+ });
+
+ it('should allow a request already running as a workspace member without resolving again', async () => {
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: 'member-id',
+ }),
+ ).toEqual({ status: 'ALLOWED' });
+
+ expect(resolveSlackIdentitiesMock).not.toHaveBeenCalled();
+ });
+
+ it('should allow a linked member whose request is not eligible for impersonation', async () => {
+ mockResolution({
+ ...RESOLUTION_BASE,
+ outcome: 'confirmedMember',
+ workspaceMemberId: 'member-id',
+ memberProvenance: 'verifiedEmail',
+ });
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'ALLOWED' });
+ });
+
+ it('should deny an account every lookup agreed is not a member', async () => {
+ mockResolution({ ...RESOLUTION_BASE, outcome: 'membershipNotConfirmed' });
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'DENIED' });
+ });
+
+ it('should not deny when membership could not be established', async () => {
+ mockResolution({ ...RESOLUTION_BASE, outcome: 'membershipUnverifiable' });
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+ });
+
+ it('should not deny when the requester could not be identified', async () => {
+ mockResolution({
+ ...RESOLUTION_BASE,
+ identity: undefined,
+ outcome: 'unidentified',
+ });
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+ });
+
+ it('should not deny when resolution throws', async () => {
+ resolveSlackIdentitiesMock.mockRejectedValue(
+ new Error('slack unreachable'),
+ );
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+ });
+
+ it('should not deny when resolution returns nothing for the requester', async () => {
+ resolveSlackIdentitiesMock.mockResolvedValue(new Map());
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+ });
+
+ it('should not deny without a Slack client or an identity to look up', async () => {
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient: undefined,
+ identity,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+
+ expect(
+ await resolveSlackAccessDecision({
+ accessMode: 'ONLY_LINKED_MEMBERS',
+ client,
+ slackClient,
+ identity: undefined,
+ runAsWorkspaceMemberId: undefined,
+ }),
+ ).toEqual({ status: 'UNVERIFIABLE' });
+
+ expect(resolveSlackIdentitiesMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-identities.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-identities.test.ts
index 7ce2a961c44..b6c9afc534e 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-identities.test.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-identities.test.ts
@@ -168,6 +168,26 @@ describe('resolveSlackIdentities', () => {
expect(resolution?.outcome).toBe('membershipNotConfirmed');
});
+ it('should report membership as unverifiable when the installing team is unreadable', async () => {
+ authTestMock.mockRejectedValue(new Error('slack unreachable'));
+ findWorkspaceMemberIdsByEmailsMock.mockResolvedValue({
+ workspaceMemberIdByEmail: new Map([['[email protected]', 'member-1']]),
+ ambiguousEmailCount: 0,
+ });
+
+ const resolution = (await resolve([identity()])).get('U04ABC');
+
+ expect(resolution?.outcome).toBe('membershipUnverifiable');
+ });
+
+ it('should report membership as unverifiable when the account names no team', async () => {
+ const resolution = (
+ await resolve([identity({ slackTeamId: undefined })])
+ ).get('U04ABC');
+
+ expect(resolution?.outcome).toBe('membershipUnverifiable');
+ });
+
it('should keep the stored link of a member linked under an external team', async () => {
findSlackUserLinksBySlackUserIdsMock.mockResolvedValue(
new Map([['U04ABC', link({ slackTeamId: EXTERNAL_TEAM_ID })]]),
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-access-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-access-mode.ts
new file mode 100644
index 00000000000..6d95405e4d2
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-access-mode.ts
@@ -0,0 +1,13 @@
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+import { readSlackAccessMode } from 'src/logic-functions/utils/read-slack-access-mode';
+
+export const getSlackAccessMode = async (): Promise<SlackAccessMode> => {
+ const result = await readSlackAccessMode();
+
+ // An unreadable store is not an open workspace: only a store that answers
+ // can say the restriction is off, so a failed read keeps it on.
+ return result.status === 'READ'
+ ? result.accessMode
+ : SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS;
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-access-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-access-mode.ts
new file mode 100644
index 00000000000..b5ffa8a0722
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-access-mode.ts
@@ -0,0 +1,6 @@
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+
+export const isSlackAccessMode = (value: unknown): value is SlackAccessMode =>
+ value === SLACK_ACCESS_MODE.ANYONE ||
+ value === SLACK_ACCESS_MODE.ONLY_LINKED_MEMBERS;
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/read-slack-access-mode.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/read-slack-access-mode.ts
new file mode 100644
index 00000000000..1ac99062f68
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/read-slack-access-mode.ts
@@ -0,0 +1,29 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { kv } from 'twenty-sdk/logic-function';
+
+import { SLACK_ACCESS_MODE } from 'src/logic-functions/constants/slack-access-mode';
+import { SLACK_ACCESS_MODE_KV_KEY } from 'src/logic-functions/constants/slack-access-mode-kv-key';
+import { type SlackAccessModeRead } from 'src/logic-functions/types/slack-access-mode-read.type';
+import { isSlackAccessMode } from 'src/logic-functions/utils/is-slack-access-mode';
+
+export const readSlackAccessMode = async (): Promise<SlackAccessModeRead> => {
+ try {
+ const stored = await kv.get<string>(SLACK_ACCESS_MODE_KV_KEY, {
+ scope: 'WORKSPACE',
+ });
+
+ if (!isNonEmptyString(stored)) {
+ return { status: 'READ', accessMode: SLACK_ACCESS_MODE.ANYONE };
+ }
+
+ // A stored value this version cannot interpret is not a deliberate choice
+ // to open the workspace, so it reads as unreadable rather than as ANYONE.
+ if (!isSlackAccessMode(stored)) {
+ return { status: 'UNREADABLE' };
+ }
+
+ return { status: 'READ', accessMode: stored };
+ } catch {
+ return { status: 'UNREADABLE' };
+ }
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-access-decision.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-access-decision.ts
new file mode 100644
index 00000000000..380eab4d628
--- /dev/null
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-access-decision.ts
@@ -0,0 +1,61 @@
+import { type WebClient } from '@slack/web-api';
+import { isNonEmptyString } from '@sniptt/guards';
+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 { type SlackAccessDecision } from 'src/logic-functions/types/slack-access-decision.type';
+import { type SlackAccessMode } from 'src/logic-functions/types/slack-access-mode.type';
+import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';
+import { resolveSlackIdentities } from 'src/logic-functions/utils/resolve-slack-identities';
+
+export const resolveSlackAccessDecision = async ({
+ accessMode,
+ client,
+ slackClient,
+ identity,
+ runAsWorkspaceMemberId,
+}: {
+ accessMode: SlackAccessMode;
+ client: CoreApiClient;
+ slackClient: WebClient | undefined;
+ identity: SlackUserIdentity | undefined;
+ runAsWorkspaceMemberId: string | undefined;
+}): Promise<SlackAccessDecision> => {
+ if (accessMode === SLACK_ACCESS_MODE.ANYONE) {
+ return { status: 'ALLOWED' };
+ }
+
+ if (isNonEmptyString(runAsWorkspaceMemberId)) {
+ return { status: 'ALLOWED' };
+ }
+
+ if (!isDefined(slackClient) || !isDefined(identity)) {
+ return { status: 'UNVERIFIABLE' };
+ }
+
+ const { slackUserId } = identity;
+
+ const resolutionBySlackUserId = await resolveSlackIdentities({
+ slackUserIds: [slackUserId],
+ knownIdentities: [identity],
+ client,
+ slackClient,
+ }).catch(() => undefined);
+
+ const resolution = resolutionBySlackUserId?.get(slackUserId);
+
+ if (!isDefined(resolution)) {
+ return { status: 'UNVERIFIABLE' };
+ }
+
+ switch (resolution.outcome) {
+ case 'confirmedMember':
+ return { status: 'ALLOWED' };
+ case 'membershipNotConfirmed':
+ return { status: 'DENIED' };
+ case 'membershipUnverifiable':
+ case 'unidentified':
+ return { status: 'UNVERIFIABLE' };
+ }
+};
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-identities.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-identities.ts
index 742937c3a14..cacc3f719a0 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-identities.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-identities.ts
@@ -105,6 +105,16 @@ const buildResolution = ({
: { slackUserId, identity, link, outcome: 'membershipNotConfirmed' };
}
+ // The link lookup is keyed on team plus user and the email rule compares
+ // against the installing team, so with either team id missing nothing ran
+ // that could establish this account is not a member.
+ if (
+ !isNonEmptyString(installedSlackTeamId) ||
+ !isNonEmptyString(identity.slackTeamId)
+ ) {
+ return { slackUserId, identity, link, outcome: 'membershipUnverifiable' };
+ }
+
if (!isLinkableSlackIdentity({ identity, installedSlackTeamId })) {
return { slackUserId, identity, link, outcome: 'membershipNotConfirmed' };
}