The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.mdindex 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## 💳 Billingdiff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.jsonindex 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.tsnew file mode 100644index 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.tsindex 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.tsxnew file mode 100644index 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.tsxindex 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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-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 { 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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' };}