Merge branch 'main' into ENG-2685

frontend/src/hooks/api/admin/index.ts

@@ -4,13 +4,12 @@ export {
   useAdminRemoveIdentitySuperAdminAccess,
   useCreateAdminUser,
   useRemoveUserServerAdminAccess,
-  useUpdateAdminSlackConfig,
   useUpdateServerConfig,
   useUpdateServerEncryptionStrategy
 } from "./mutation";
 export {
   useAdminGetUsers,
-  useGetAdminSlackConfig,
+  useGetAdminIntegrationsConfig,
   useGetServerConfig,
   useGetServerRootKmsEncryptionDetails
 } from "./queries";

frontend/src/hooks/api/admin/mutation.ts

@@ -6,11 +6,10 @@ import { organizationKeys } from "../organization/queries";
 import { User } from "../users/types";
 import { adminQueryKeys, adminStandaloneKeys } from "./queries";
 import {
-  AdminSlackConfig,
   RootKeyEncryptionStrategy,
   TCreateAdminUserDTO,
   TServerConfig,
-  TUpdateAdminSlackConfigDTO
+  TUpdateServerConfigDTO
 } from "./types";
 
 export const useCreateAdminUser = () => {
@@ -34,11 +33,7 @@ export const useCreateAdminUser = () => {
 export const useUpdateServerConfig = () => {
   const queryClient = useQueryClient();
 
-  return useMutation<
-    TServerConfig,
-    object,
-    Partial<TServerConfig & { slackClientId: string; slackClientSecret: string }>
-  >({
+  return useMutation<TServerConfig, object, TUpdateServerConfigDTO>({
     mutationFn: async (opt) => {
       const { data } = await apiRequest.patch<{ config: TServerConfig }>(
         "/api/v1/admin/config",
@@ -48,6 +43,7 @@ export const useUpdateServerConfig = () => {
     },
     onSuccess: (data) => {
       queryClient.setQueryData(adminQueryKeys.serverConfig(), data);
+      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getAdminIntegrationsConfig() });
       queryClient.invalidateQueries({ queryKey: adminQueryKeys.serverConfig() });
       queryClient.invalidateQueries({ queryKey: organizationKeys.getUserOrganizations });
     }
@@ -119,23 +115,6 @@ export const useAdminGrantServerAdminAccess = () => {
   });
 };
 
-export const useUpdateAdminSlackConfig = () => {
-  const queryClient = useQueryClient();
-  return useMutation<AdminSlackConfig, object, TUpdateAdminSlackConfigDTO>({
-    mutationFn: async (dto) => {
-      const { data } = await apiRequest.put<AdminSlackConfig>(
-        "/api/v1/admin/integrations/slack/config",
-        dto
-      );
-
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getAdminSlackConfig() });
-    }
-  });
-};
-
 export const useUpdateServerEncryptionStrategy = () => {
   const queryClient = useQueryClient();
   return useMutation({

frontend/src/hooks/api/admin/queries.ts

@@ -7,7 +7,7 @@ import { User } from "../types";
 import {
   AdminGetIdentitiesFilters,
   AdminGetUsersFilters,
-  AdminSlackConfig,
+  AdminIntegrationsConfig,
   TGetServerRootKmsEncryptionDetails,
   TServerConfig
 } from "./types";
@@ -22,7 +22,7 @@ export const adminQueryKeys = {
   getUsers: (filters: AdminGetUsersFilters) => [adminStandaloneKeys.getUsers, { filters }] as const,
   getIdentities: (filters: AdminGetIdentitiesFilters) =>
     [adminStandaloneKeys.getIdentities, { filters }] as const,
-  getAdminSlackConfig: () => ["admin-slack-config"] as const,
+  getAdminIntegrationsConfig: () => ["admin-integrations-config"] as const,
   getServerEncryptionStrategies: () => ["server-encryption-strategies"] as const
 };
 
@@ -95,13 +95,11 @@ export const useAdminGetIdentities = (filters: AdminGetIdentitiesFilters) => {
   });
 };
 
-export const useGetAdminSlackConfig = () => {
+export const useGetAdminIntegrationsConfig = () => {
   return useQuery({
-    queryKey: adminQueryKeys.getAdminSlackConfig(),
+    queryKey: adminQueryKeys.getAdminIntegrationsConfig(),
     queryFn: async () => {
-      const { data } = await apiRequest.get<AdminSlackConfig>(
-        "/api/v1/admin/integrations/slack/config"
-      );
+      const { data } = await apiRequest.get<AdminIntegrationsConfig>("/api/v1/admin/integrations");
 
       return data;
     }

frontend/src/hooks/api/admin/types.ts

@@ -26,6 +26,14 @@ export type TServerConfig = {
   pageFrameContent?: string;
 };
 
+export type TUpdateServerConfigDTO = {
+  slackClientId?: string;
+  slackClientSecret?: string;
+  microsoftTeamsAppId?: string;
+  microsoftTeamsClientSecret?: string;
+  microsoftTeamsBotId?: string;
+} & Partial<TServerConfig>;
+
 export type TCreateAdminUserDTO = {
   email: string;
   password: string;
@@ -42,11 +50,6 @@ export type TCreateAdminUserDTO = {
   salt: string;
 };
 
-export type TUpdateAdminSlackConfigDTO = {
-  clientId: string;
-  clientSecret: string;
-};
-
 export type AdminGetUsersFilters = {
   limit: number;
   searchTerm: string;
@@ -58,9 +61,16 @@ export type AdminGetIdentitiesFilters = {
   searchTerm: string;
 };
 
-export type AdminSlackConfig = {
-  clientId: string;
-  clientSecret: string;
+export type AdminIntegrationsConfig = {
+  slack: {
+    clientId: string;
+    clientSecret: string;
+  };
+  microsoftTeams: {
+    appId: string;
+    clientSecret: string;
+    botId: string;
+  };
 };
 
 export type TGetServerRootKmsEncryptionDetails = {

frontend/src/hooks/api/appConnections/azure/index.ts

@@ -0,0 +1 @@
+export * from "./queries";

frontend/src/hooks/api/appConnections/azure/queries.tsx

@@ -0,0 +1,37 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { appConnectionKeys } from "../queries";
+import { TAzureClient } from "./types";
+
+const azureConnectionKeys = {
+  all: [...appConnectionKeys.all, "azure"] as const,
+  listClients: (connectionId: string) =>
+    [...azureConnectionKeys.all, "clients", connectionId] as const
+};
+
+export const useAzureConnectionListClients = (
+  connectionId: string,
+  options?: Omit<
+    UseQueryOptions<
+      TAzureClient[],
+      unknown,
+      TAzureClient[],
+      ReturnType<typeof azureConnectionKeys.listClients>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: azureConnectionKeys.listClients(connectionId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{ clients: TAzureClient[] }>(
+        `/api/v1/app-connections/azure-client-secrets/${connectionId}/clients`
+      );
+
+      return data.clients;
+    },
+    ...options
+  });
+};

frontend/src/hooks/api/appConnections/azure/types.ts

@@ -0,0 +1,5 @@
+export type TAzureClient = {
+  name: string;
+  appId: string;
+  id: string;
+};

frontend/src/hooks/api/appConnections/enums.ts

@@ -4,6 +4,7 @@ export enum AppConnection {
   GCP = "gcp",
   AzureKeyVault = "azure-key-vault",
   AzureAppConfiguration = "azure-app-configuration",
+  AzureClientSecrets = "azure-client-secrets",
   Databricks = "databricks",
   Humanitec = "humanitec",
   TerraformCloud = "terraform-cloud",
@@ -13,6 +14,7 @@ export enum AppConnection {
   Camunda = "camunda",
   Windmill = "windmill",
   Auth0 = "auth0",
+  HCVault = "hashicorp-vault",
   LDAP = "ldap",
   TeamCity = "teamcity"
 }

frontend/src/hooks/api/appConnections/hc-vault/index.ts

@@ -0,0 +1 @@
+export * from "./queries";

frontend/src/hooks/api/appConnections/hc-vault/queries.tsx

@@ -0,0 +1,36 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { appConnectionKeys } from "../queries";
+
+const hcVaultConnectionKeys = {
+  all: [...appConnectionKeys.all, "hcvault"] as const,
+  listMounts: (connectionId: string) =>
+    [...hcVaultConnectionKeys.all, "mounts", connectionId] as const
+};
+
+export const useHCVaultConnectionListMounts = (
+  connectionId: string,
+  options?: Omit<
+    UseQueryOptions<
+      string[],
+      unknown,
+      string[],
+      ReturnType<typeof hcVaultConnectionKeys.listMounts>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: hcVaultConnectionKeys.listMounts(connectionId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<string[]>(
+        `/api/v1/app-connections/hashicorp-vault/${connectionId}/mounts`
+      );
+
+      return data;
+    },
+    ...options
+  });
+};

frontend/src/hooks/api/appConnections/types/app-options.ts

@@ -31,6 +31,11 @@ export type TAzureAppConfigurationConnectionOption = TAppConnectionOptionBase &
   oauthClientId?: string;
 };
 
+export type TAzureClientSecretsConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.AzureClientSecrets;
+  oauthClientId?: string;
+};
+
 export type TDatabricksConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.Databricks;
 };
@@ -67,6 +72,10 @@ export type TAuth0ConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.Auth0;
 };
 
+export type THCVaultConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.HCVault;
+};
+
 export type TLdapConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.LDAP;
 };
@@ -81,6 +90,7 @@ export type TAppConnectionOption =
   | TGcpConnectionOption
   | TAzureAppConfigurationConnectionOption
   | TAzureKeyVaultConnectionOption
+  | TAzureClientSecretsConnectionOption
   | TDatabricksConnectionOption
   | THumanitecConnectionOption
   | TTerraformCloudConnectionOption
@@ -90,6 +100,7 @@ export type TAppConnectionOption =
   | TCamundaConnectionOption
   | TWindmillConnectionOption
   | TAuth0ConnectionOption
+  | THCVaultConnectionOption
   | TTeamCityConnectionOption;
 
 export type TAppConnectionOptionMap = {
@@ -98,6 +109,7 @@ export type TAppConnectionOptionMap = {
   [AppConnection.GCP]: TGcpConnectionOption;
   [AppConnection.AzureKeyVault]: TAzureKeyVaultConnectionOption;
   [AppConnection.AzureAppConfiguration]: TAzureAppConfigurationConnectionOption;
+  [AppConnection.AzureClientSecrets]: TAzureClientSecretsConnectionOption;
   [AppConnection.Databricks]: TDatabricksConnectionOption;
   [AppConnection.Humanitec]: THumanitecConnectionOption;
   [AppConnection.TerraformCloud]: TTerraformCloudConnectionOption;
@@ -107,6 +119,7 @@ export type TAppConnectionOptionMap = {
   [AppConnection.Camunda]: TCamundaConnectionOption;
   [AppConnection.Windmill]: TWindmillConnectionOption;
   [AppConnection.Auth0]: TAuth0ConnectionOption;
+  [AppConnection.HCVault]: THCVaultConnectionOption;
   [AppConnection.LDAP]: TLdapConnectionOption;
   [AppConnection.TeamCity]: TTeamCityConnectionOption;
 };

frontend/src/hooks/api/appConnections/types/azure-client-secrets-connection.ts

@@ -0,0 +1,16 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum AzureClientSecretsConnectionMethod {
+  OAuth = "oauth"
+}
+
+export type TAzureClientSecretsConnection = TRootAppConnection & {
+  app: AppConnection.AzureClientSecrets;
+} & {
+  method: AzureClientSecretsConnectionMethod.OAuth;
+  credentials: {
+    code: string;
+    tenantId: string;
+  };
+};

frontend/src/hooks/api/appConnections/types/hc-vault-connection.ts

@@ -0,0 +1,27 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum HCVaultConnectionMethod {
+  AccessToken = "access-token",
+  AppRole = "app-role"
+}
+
+export type THCVaultConnection = TRootAppConnection & { app: AppConnection.HCVault } & (
+    | {
+        method: HCVaultConnectionMethod.AccessToken;
+        credentials: {
+          instanceUrl: string;
+          namespace?: string;
+          accessToken: string;
+        };
+      }
+    | {
+        method: HCVaultConnectionMethod.AppRole;
+        credentials: {
+          instanceUrl: string;
+          namespace?: string;
+          roleId: string;
+          secretId: string;
+        };
+      }
+  );

frontend/src/hooks/api/appConnections/types/index.ts

@@ -3,11 +3,13 @@ import { TAppConnectionOption } from "./app-options";
 import { TAuth0Connection } from "./auth0-connection";
 import { TAwsConnection } from "./aws-connection";
 import { TAzureAppConfigurationConnection } from "./azure-app-configuration-connection";
+import { TAzureClientSecretsConnection } from "./azure-client-secrets-connection";
 import { TAzureKeyVaultConnection } from "./azure-key-vault-connection";
 import { TCamundaConnection } from "./camunda-connection";
 import { TDatabricksConnection } from "./databricks-connection";
 import { TGcpConnection } from "./gcp-connection";
 import { TGitHubConnection } from "./github-connection";
+import { THCVaultConnection } from "./hc-vault-connection";
 import { THumanitecConnection } from "./humanitec-connection";
 import { TLdapConnection } from "./ldap-connection";
 import { TMsSqlConnection } from "./mssql-connection";
@@ -20,11 +22,13 @@ import { TWindmillConnection } from "./windmill-connection";
 export * from "./auth0-connection";
 export * from "./aws-connection";
 export * from "./azure-app-configuration-connection";
+export * from "./azure-client-secrets-connection";
 export * from "./azure-key-vault-connection";
 export * from "./camunda-connection";
 export * from "./databricks-connection";
 export * from "./gcp-connection";
 export * from "./github-connection";
+export * from "./hc-vault-connection";
 export * from "./humanitec-connection";
 export * from "./ldap-connection";
 export * from "./mssql-connection";
@@ -40,6 +44,7 @@ export type TAppConnection =
   | TGcpConnection
   | TAzureKeyVaultConnection
   | TAzureAppConfigurationConnection
+  | TAzureClientSecretsConnection
   | TDatabricksConnection
   | THumanitecConnection
   | TTerraformCloudConnection
@@ -49,6 +54,7 @@ export type TAppConnection =
   | TCamundaConnection
   | TWindmillConnection
   | TAuth0Connection
+  | THCVaultConnection
   | TLdapConnection
   | TTeamCityConnection;
 
@@ -83,6 +89,7 @@ export type TAppConnectionMap = {
   [AppConnection.GCP]: TGcpConnection;
   [AppConnection.AzureKeyVault]: TAzureKeyVaultConnection;
   [AppConnection.AzureAppConfiguration]: TAzureAppConfigurationConnection;
+  [AppConnection.AzureClientSecrets]: TAzureClientSecretsConnection;
   [AppConnection.Databricks]: TDatabricksConnection;
   [AppConnection.Humanitec]: THumanitecConnection;
   [AppConnection.TerraformCloud]: TTerraformCloudConnection;
@@ -92,6 +99,7 @@ export type TAppConnectionMap = {
   [AppConnection.Camunda]: TCamundaConnection;
   [AppConnection.Windmill]: TWindmillConnection;
   [AppConnection.Auth0]: TAuth0Connection;
+  [AppConnection.HCVault]: THCVaultConnection;
   [AppConnection.LDAP]: TLdapConnection;
   [AppConnection.TeamCity]: TTeamCityConnection;
 };

frontend/src/hooks/api/auditLogs/constants.tsx

@@ -96,8 +96,10 @@ export const eventToNameMap: { [K in EventType]: string } = {
     "Create certificate template EST configuration",
   [EventType.UPDATE_CERTIFICATE_TEMPLATE_EST_CONFIG]:
     "Update certificate template EST configuration",
-  [EventType.UPDATE_PROJECT_SLACK_CONFIG]: "Update project slack configuration",
-  [EventType.GET_PROJECT_SLACK_CONFIG]: "Get project slack configuration",
+  [EventType.UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG]:
+    "Update project workflow integration configuration",
+  [EventType.GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG]:
+    "Get project workflow integration configuration",
   [EventType.INTEGRATION_SYNCED]: "Integration sync",
   [EventType.CREATE_SHARED_SECRET]: "Create shared secret",
   [EventType.DELETE_SHARED_SECRET]: "Delete shared secret",
@@ -165,7 +167,22 @@ export const eventToNameMap: { [K in EventType]: string } = {
   [EventType.CREATE_SECRET_ROTATION]: "Create Secret Rotation",
   [EventType.UPDATE_SECRET_ROTATION]: "Update Secret Rotation",
   [EventType.DELETE_SECRET_ROTATION]: "Delete Secret Rotation",
-  [EventType.SECRET_ROTATION_ROTATE_SECRETS]: "Secret Rotation secrets rotated"
+  [EventType.SECRET_ROTATION_ROTATE_SECRETS]: "Secret Rotation secrets rotated",
+
+  [EventType.GET_PROJECT_SLACK_CONFIG]: "Get Project Slack Config",
+  [EventType.UPDATE_PROJECT_SLACK_CONFIG]: "Update Project Slack Config",
+
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CREATE]:
+    "Create Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_DELETE]:
+    "Delete Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_UPDATE]:
+    "Update Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CHECK_INSTALLATION_STATUS]:
+    "Microsoft Teams Workflow Integration Check Installation Status",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET_TEAMS]: "Get Microsoft Teams tenant teams",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET]: "Get Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_LIST]: "List Microsoft Teams Workflow Integration"
 };
 
 export const userAgentTTypeoNameMap: { [K in UserAgentType]: string } = {

frontend/src/hooks/api/auditLogs/enums.tsx

@@ -100,8 +100,8 @@ export enum EventType {
   CREATE_CERTIFICATE_TEMPLATE_EST_CONFIG = "create-certificate-template-est-config",
   UPDATE_CERTIFICATE_TEMPLATE_EST_CONFIG = "update-certificate-template-est-config",
   GET_CERTIFICATE_TEMPLATE_EST_CONFIG = "get-certificate-template-est-config",
-  UPDATE_PROJECT_SLACK_CONFIG = "update-project-slack-config",
-  GET_PROJECT_SLACK_CONFIG = "get-project-slack-config",
+  UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG = "update-project-workflow-integration-config",
+  GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG = "get-project-workflow-integration-config",
   INTEGRATION_SYNCED = "integration-synced",
   CREATE_SHARED_SECRET = "create-shared-secret",
   DELETE_SHARED_SECRET = "delete-shared-secret",
@@ -165,5 +165,16 @@ export enum EventType {
   CREATE_SECRET_ROTATION = "create-secret-rotation",
   UPDATE_SECRET_ROTATION = "update-secret-rotation",
   DELETE_SECRET_ROTATION = "delete-secret-rotation",
-  SECRET_ROTATION_ROTATE_SECRETS = "secret-rotation-rotate-secrets"
+  SECRET_ROTATION_ROTATE_SECRETS = "secret-rotation-rotate-secrets",
+
+  GET_PROJECT_SLACK_CONFIG = "get-project-slack-config",
+  UPDATE_PROJECT_SLACK_CONFIG = "update-project-slack-config",
+
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CREATE = "microsoft-teams-workflow-integration-create",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_DELETE = "microsoft-teams-workflow-integration-delete",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_UPDATE = "microsoft-teams-workflow-integration-update",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CHECK_INSTALLATION_STATUS = "microsoft-teams-workflow-integration-check-installation-status",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET_TEAMS = "microsoft-teams-workflow-integration-get-teams",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET = "microsoft-teams-workflow-integration-get",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_LIST = "microsoft-teams-workflow-integration-list"
 }

frontend/src/hooks/api/auditLogs/types.tsx

@@ -1,6 +1,7 @@
 import { CaStatus } from "../ca";
 import { IdentityTrustedIp } from "../identities/types";
 import { PkiItemType } from "../pkiCollections/constants";
+import { WorkflowIntegration } from "../workflowIntegrations/types";
 import { ActorType, EventType, UserAgentType } from "./enums";
 
 export type TGetAuditLogsFilter = {
@@ -804,11 +805,12 @@ interface GetCertificateTemplateEstConfig {
   };
 }
 
-interface UpdateProjectSlackConfig {
-  type: EventType.UPDATE_PROJECT_SLACK_CONFIG;
+interface UpdateProjectWorkflowIntegrationConfig {
+  type: EventType.UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG;
   metadata: {
     id: string;
-    slackIntegrationId: string;
+    integrationId: string;
+    integration: WorkflowIntegration;
     isAccessRequestNotificationEnabled: boolean;
     accessRequestChannels: string;
     isSecretRequestNotificationEnabled: boolean;
@@ -816,10 +818,11 @@ interface UpdateProjectSlackConfig {
   };
 }
 
-interface GetProjectSlackConfig {
-  type: EventType.GET_PROJECT_SLACK_CONFIG;
+interface GetProjectWorkflowIntegrationConfig {
+  type: EventType.GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG;
   metadata: {
     id: string;
+    integration: WorkflowIntegration;
   };
 }
 
@@ -918,8 +921,8 @@ export type Event =
   | UpdateCertificateTemplateEstConfig
   | CreateCertificateTemplateEstConfig
   | GetCertificateTemplateEstConfig
-  | UpdateProjectSlackConfig
-  | GetProjectSlackConfig
+  | UpdateProjectWorkflowIntegrationConfig
+  | GetProjectWorkflowIntegrationConfig
   | IntegrationSyncedEvent;
 
 export type AuditLog = {

frontend/src/hooks/api/auth/types.ts

@@ -107,6 +107,7 @@ export type CompleteAccountSignupDTO = CompleteAccountDTO & {
   providerAuthToken?: string;
   attributionSource?: string;
   organizationName: string;
+  useDefaultOrg?: boolean;
 };
 
 export type VerifySignupInviteDTO = {

frontend/src/hooks/api/index.tsx

@@ -44,6 +44,7 @@ export * from "./serviceTokens";
 export * from "./sshCa";
 export * from "./sshCertificateTemplates";
 export * from "./sshHost";
+export * from "./sshHostGroup";
 export * from "./ssoConfig";
 export * from "./subscriptions";
 export * from "./tags";

frontend/src/hooks/api/organization/queries.tsx

@@ -111,7 +111,8 @@ export const useUpdateOrg = () => {
       enforceMfa,
       selectedMfaMethod,
       allowSecretSharingOutsideOrganization,
-      bypassOrgAuthEnabled
+      bypassOrgAuthEnabled,
+      userTokenExpiration
     }) => {
       return apiRequest.patch(`/api/v1/organization/${orgId}`, {
         name,
@@ -122,7 +123,8 @@ export const useUpdateOrg = () => {
         enforceMfa,
         selectedMfaMethod,
         allowSecretSharingOutsideOrganization,
-        bypassOrgAuthEnabled
+        bypassOrgAuthEnabled,
+        userTokenExpiration
       });
     },
     onSuccess: () => {

frontend/src/hooks/api/organization/types.ts

@@ -18,6 +18,7 @@ export type Organization = {
   selectedMfaMethod?: MfaMethod;
   shouldUseNewPrivilegeSystem: boolean;
   allowSecretSharingOutsideOrganization?: boolean;
+  userTokenExpiration?: string;
   userRole: string;
 };
 
@@ -32,6 +33,7 @@ export type UpdateOrgDTO = {
   selectedMfaMethod?: MfaMethod;
   allowSecretSharingOutsideOrganization?: boolean;
   bypassOrgAuthEnabled?: boolean;
+  userTokenExpiration?: string;
 };
 
 export type BillingDetails = {

frontend/src/hooks/api/secretRotationsV2/enums.ts

@@ -2,6 +2,7 @@ export enum SecretRotation {
   PostgresCredentials = "postgres-credentials",
   MsSqlCredentials = "mssql-credentials",
   Auth0ClientSecret = "auth0-client-secret",
+  AzureClientSecret = "azure-client-secret",
   LdapPassword = "ldap-password",
   AwsIamUserSecret = "aws-iam-user-secret"
 }

frontend/src/hooks/api/secretRotationsV2/types/azure-client-secret-rotation.ts

@@ -0,0 +1,38 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { SecretRotation } from "@app/hooks/api/secretRotationsV2";
+import {
+  TSecretRotationV2Base,
+  TSecretRotationV2GeneratedCredentialsResponseBase
+} from "@app/hooks/api/secretRotationsV2/types/shared";
+
+export type TAzureClientSecretRotation = TSecretRotationV2Base & {
+  type: SecretRotation.AzureClientSecret;
+  parameters: {
+    objectId: string;
+    appName: string;
+  };
+  secretsMapping: {
+    clientId: string;
+    clientSecret: string;
+  };
+};
+
+export type TAzureClientSecretRotationGeneratedCredentials = {
+  clientId: string;
+  clientSecret: string;
+};
+
+export type TAzureClientSecretRotationGeneratedCredentialsResponse =
+  TSecretRotationV2GeneratedCredentialsResponseBase<
+    SecretRotation.AzureClientSecret,
+    TAzureClientSecretRotationGeneratedCredentials
+  >;
+
+export type TAzureClientSecretRotationOption = {
+  name: string;
+  type: SecretRotation.AzureClientSecret;
+  connection: AppConnection.AzureClientSecrets;
+  template: {
+    secretsMapping: TAzureClientSecretRotation["secretsMapping"];
+  };
+};

frontend/src/hooks/api/secretRotationsV2/types/index.ts

@@ -9,6 +9,11 @@ import {
   TAwsIamUserSecretRotationGeneratedCredentialsResponse,
   TAwsIamUserSecretRotationOption
 } from "@app/hooks/api/secretRotationsV2/types/aws-iam-user-secret-rotation";
+import {
+  TAzureClientSecretRotation,
+  TAzureClientSecretRotationGeneratedCredentialsResponse,
+  TAzureClientSecretRotationOption
+} from "@app/hooks/api/secretRotationsV2/types/azure-client-secret-rotation";
 import {
   TLdapPasswordRotation,
   TLdapPasswordRotationGeneratedCredentialsResponse,
@@ -30,6 +35,7 @@ export type TSecretRotationV2 = (
   | TPostgresCredentialsRotation
   | TMsSqlCredentialsRotation
   | TAuth0ClientSecretRotation
+  | TAzureClientSecretRotation
   | TLdapPasswordRotation
   | TAwsIamUserSecretRotation
 ) & {
@@ -39,6 +45,7 @@ export type TSecretRotationV2 = (
 export type TSecretRotationV2Option =
   | TSqlCredentialsRotationOption
   | TAuth0ClientSecretRotationOption
+  | TAzureClientSecretRotationOption
   | TLdapPasswordRotationOption
   | TAwsIamUserSecretRotationOption;
 
@@ -50,6 +57,7 @@ export type TViewSecretRotationGeneratedCredentialsResponse =
   | TPostgresCredentialsRotationGeneratedCredentialsResponse
   | TMsSqlCredentialsRotationGeneratedCredentialsResponse
   | TAuth0ClientSecretRotationGeneratedCredentialsResponse
+  | TAzureClientSecretRotationGeneratedCredentialsResponse
   | TLdapPasswordRotationGeneratedCredentialsResponse
   | TAwsIamUserSecretRotationGeneratedCredentialsResponse;
 
@@ -98,6 +106,7 @@ export type TSecretRotationOptionMap = {
   [SecretRotation.PostgresCredentials]: TSqlCredentialsRotationOption;
   [SecretRotation.MsSqlCredentials]: TSqlCredentialsRotationOption;
   [SecretRotation.Auth0ClientSecret]: TAuth0ClientSecretRotationOption;
+  [SecretRotation.AzureClientSecret]: TAzureClientSecretRotationOption;
   [SecretRotation.LdapPassword]: TLdapPasswordRotationOption;
   [SecretRotation.AwsIamUserSecret]: TAwsIamUserSecretRotationOption;
 };
@@ -106,6 +115,7 @@ export type TSecretRotationGeneratedCredentialsResponseMap = {
   [SecretRotation.PostgresCredentials]: TPostgresCredentialsRotationGeneratedCredentialsResponse;
   [SecretRotation.MsSqlCredentials]: TMsSqlCredentialsRotationGeneratedCredentialsResponse;
   [SecretRotation.Auth0ClientSecret]: TAuth0ClientSecretRotationGeneratedCredentialsResponse;
+  [SecretRotation.AzureClientSecret]: TAzureClientSecretRotationGeneratedCredentialsResponse;
   [SecretRotation.LdapPassword]: TLdapPasswordRotationGeneratedCredentialsResponse;
   [SecretRotation.AwsIamUserSecret]: TAwsIamUserSecretRotationGeneratedCredentialsResponse;
 };

frontend/src/hooks/api/secretSyncs/enums.ts

@@ -11,6 +11,7 @@ export enum SecretSync {
   Camunda = "camunda",
   Vercel = "vercel",
   Windmill = "windmill",
+  HCVault = "hashicorp-vault",
   TeamCity = "teamcity"
 }
 

frontend/src/hooks/api/secretSyncs/types/hc-vault-sync.ts

@@ -0,0 +1,16 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { SecretSync } from "@app/hooks/api/secretSyncs";
+import { TRootSecretSync } from "@app/hooks/api/secretSyncs/types/root-sync";
+
+export type THCVaultSync = TRootSecretSync & {
+  destination: SecretSync.HCVault;
+  destinationConfig: {
+    mount: string;
+    path: string;
+  };
+  connection: {
+    app: AppConnection.HCVault;
+    name: string;
+    id: string;
+  };
+};

frontend/src/hooks/api/secretSyncs/types/index.ts

@@ -9,6 +9,7 @@ import { TCamundaSync } from "./camunda-sync";
 import { TDatabricksSync } from "./databricks-sync";
 import { TGcpSync } from "./gcp-sync";
 import { TGitHubSync } from "./github-sync";
+import { THCVaultSync } from "./hc-vault-sync";
 import { THumanitecSync } from "./humanitec-sync";
 import { TTeamCitySync } from "./teamcity-sync";
 import { TTerraformCloudSync } from "./terraform-cloud-sync";
@@ -34,6 +35,7 @@ export type TSecretSync =
   | TCamundaSync
   | TVercelSync
   | TWindmillSync
+  | THCVaultSync
   | TTeamCitySync;
 
 export type TListSecretSyncs = { secretSyncs: TSecretSync[] };

frontend/src/hooks/api/sshHost/types.ts

@@ -1,3 +1,16 @@
+export enum LoginMappingSource {
+  HOST = "host",
+  HOST_GROUP = "hostGroup"
+}
+
+export type TLoginMapping = {
+  loginUser: string;
+  allowedPrincipals: {
+    usernames: string[];
+  };
+  source: LoginMappingSource;
+};
+
 export type TSshHost = {
   id: string;
   projectId: string;
@@ -5,26 +18,15 @@ export type TSshHost = {
   alias: string | null;
   userCertTtl: string;
   hostCertTtl: string;
-  loginMappings: {
-    loginUser: string;
-    allowedPrincipals: {
-      usernames: string[];
-    };
-  }[];
+  loginMappings: TLoginMapping[];
 };
-
 export type TCreateSshHostDTO = {
   projectId: string;
   hostname: string;
   alias?: string;
   userCertTtl?: string;
   hostCertTtl?: string;
-  loginMappings: {
-    loginUser: string;
-    allowedPrincipals: {
-      usernames: string[];
-    };
-  }[];
+  loginMappings: Omit<TLoginMapping, "source">[];
 };
 
 export type TUpdateSshHostDTO = {
@@ -33,12 +35,7 @@ export type TUpdateSshHostDTO = {
   alias?: string;
   userCertTtl?: string;
   hostCertTtl?: string;
-  loginMappings?: {
-    loginUser: string;
-    allowedPrincipals: {
-      usernames: string[];
-    };
-  }[];
+  loginMappings?: Omit<TLoginMapping, "source">[];
 };
 
 export type TDeleteSshHostDTO = {

frontend/src/hooks/api/sshHostGroup/index.tsx

@@ -0,0 +1,8 @@
+export {
+  useAddHostToSshHostGroup,
+  useCreateSshHostGroup,
+  useDeleteSshHostGroup,
+  useRemoveHostFromSshHostGroup,
+  useUpdateSshHostGroup
+} from "./mutations";
+export { useGetSshHostGroupById, useListSshHostGroupHosts } from "./queries";

frontend/src/hooks/api/sshHostGroup/mutations.tsx

@@ -0,0 +1,105 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { workspaceKeys } from "../workspace/query-keys";
+import { sshHostGroupKeys } from "./queries";
+import {
+  TCreateSshHostGroupDTO,
+  TDeleteSshHostGroupDTO,
+  TSshHostGroup,
+  TUpdateSshHostGroupDTO
+} from "./types";
+
+export const useCreateSshHostGroup = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHostGroup, object, TCreateSshHostGroupDTO>({
+    mutationFn: async (body) => {
+      const { data: hostGroup } = await apiRequest.post("/api/v1/ssh/host-groups", body);
+      return hostGroup;
+    },
+    onSuccess: ({ projectId, id }) => {
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceSshHostGroups(projectId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: sshHostGroupKeys.getSshHostGroupById(id)
+      });
+    }
+  });
+};
+
+export const useUpdateSshHostGroup = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHostGroup, object, TUpdateSshHostGroupDTO>({
+    mutationFn: async ({ sshHostGroupId, ...body }) => {
+      const { data: hostGroup } = await apiRequest.patch(
+        `/api/v1/ssh/host-groups/${sshHostGroupId}`,
+        body
+      );
+      return hostGroup;
+    },
+    onSuccess: ({ projectId }, { sshHostGroupId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceSshHostGroups(projectId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceSshHosts(projectId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: sshHostGroupKeys.getSshHostGroupById(sshHostGroupId)
+      });
+    }
+  });
+};
+
+export const useDeleteSshHostGroup = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHostGroup, object, TDeleteSshHostGroupDTO>({
+    mutationFn: async ({ sshHostGroupId }) => {
+      const { data: hostGroup } = await apiRequest.delete(
+        `/api/v1/ssh/host-groups/${sshHostGroupId}`
+      );
+      return hostGroup;
+    },
+    onSuccess: ({ projectId }, { sshHostGroupId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceSshHostGroups(projectId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceSshHosts(projectId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: sshHostGroupKeys.getSshHostGroupById(sshHostGroupId)
+      });
+    }
+  });
+};
+
+export const useAddHostToSshHostGroup = () => {
+  const queryClient = useQueryClient();
+  return useMutation<void, object, { sshHostGroupId: string; sshHostId: string }>({
+    mutationFn: async ({ sshHostGroupId, sshHostId }) => {
+      await apiRequest.post(`/api/v1/ssh/host-groups/${sshHostGroupId}/hosts/${sshHostId}`);
+    },
+    onSuccess: (_, { sshHostGroupId }) => {
+      queryClient.invalidateQueries({
+        queryKey: sshHostGroupKeys.forSshHostGroupHosts(sshHostGroupId)
+      });
+    }
+  });
+};
+
+export const useRemoveHostFromSshHostGroup = () => {
+  const queryClient = useQueryClient();
+  return useMutation<void, object, { sshHostGroupId: string; sshHostId: string }>({
+    mutationFn: async ({ sshHostGroupId, sshHostId }) => {
+      await apiRequest.delete(`/api/v1/ssh/host-groups/${sshHostGroupId}/hosts/${sshHostId}`);
+    },
+    onSuccess: (_, { sshHostGroupId }) => {
+      queryClient.invalidateQueries({
+        queryKey: sshHostGroupKeys.forSshHostGroupHosts(sshHostGroupId)
+      });
+    }
+  });
+};

frontend/src/hooks/api/sshHostGroup/queries.tsx

@@ -0,0 +1,60 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { EHostGroupMembershipFilter, TListSshHostGroupHostsResponse, TSshHostGroup } from "./types";
+
+export const sshHostGroupKeys = {
+  getSshHostGroupById: (sshHostGroupId: string) => [{ sshHostGroupId }, "ssh-host-group"],
+  allSshHostGroupHosts: () => ["ssh-host-group-hosts"] as const,
+  forSshHostGroupHosts: (sshHostGroupId: string) =>
+    [...sshHostGroupKeys.allSshHostGroupHosts(), sshHostGroupId] as const,
+  specificSshHostGroupHosts: ({
+    sshHostGroupId,
+    filter
+  }: {
+    sshHostGroupId: string;
+    filter?: EHostGroupMembershipFilter;
+  }) => [...sshHostGroupKeys.forSshHostGroupHosts(sshHostGroupId), { filter }] as const
+};
+
+export const useGetSshHostGroupById = (sshHostGroupId: string) => {
+  return useQuery({
+    queryKey: sshHostGroupKeys.getSshHostGroupById(sshHostGroupId),
+    queryFn: async () => {
+      const { data: sshHostGroup } = await apiRequest.get<TSshHostGroup>(
+        `/api/v1/ssh/host-groups/${sshHostGroupId}`
+      );
+      return sshHostGroup;
+    },
+    enabled: Boolean(sshHostGroupId)
+  });
+};
+
+export const useListSshHostGroupHosts = ({
+  sshHostGroupId,
+  filter
+}: {
+  sshHostGroupId: string;
+  filter?: EHostGroupMembershipFilter;
+}) => {
+  return useQuery({
+    queryKey: sshHostGroupKeys.specificSshHostGroupHosts({ sshHostGroupId, filter }),
+    queryFn: async () => {
+      const params = new URLSearchParams({
+        ...(filter ? { filter } : {})
+      });
+
+      const { data } = await apiRequest.get<TListSshHostGroupHostsResponse>(
+        `/api/v1/ssh/host-groups/${sshHostGroupId}/hosts`,
+        {
+          params
+        }
+      );
+      return data;
+    },
+    enabled: Boolean(sshHostGroupId),
+    staleTime: 0,
+    gcTime: 0
+  });
+};

frontend/src/hooks/api/sshHostGroup/types.ts

@@ -0,0 +1,34 @@
+import { TLoginMapping, TSshHost } from "../sshHost/types";
+
+export type TSshHostGroup = {
+  id: string;
+  projectId: string;
+  name: string;
+  loginMappings: Omit<TLoginMapping, "source">[];
+};
+
+export type TCreateSshHostGroupDTO = {
+  projectId: string;
+  name: string;
+  loginMappings: Omit<TLoginMapping, "source">[];
+};
+
+export type TUpdateSshHostGroupDTO = {
+  sshHostGroupId: string;
+  name?: string;
+  loginMappings?: Omit<TLoginMapping, "source">[];
+};
+
+export type TDeleteSshHostGroupDTO = {
+  sshHostGroupId: string;
+};
+
+export type TListSshHostGroupHostsResponse = {
+  hosts: (TSshHost & { joinedGroupAt: string; isPartOfGroup: boolean })[];
+  totalCount: number;
+};
+
+export enum EHostGroupMembershipFilter {
+  GROUP_MEMBERS = "group-members",
+  NON_GROUP_MEMBERS = "non-group-members"
+}

frontend/src/hooks/api/subscriptions/types.ts

@@ -24,6 +24,7 @@ export type SubscriptionPlan = {
   workspacesUsed: number;
   environmentLimit: number;
   samlSSO: boolean;
+  sshHostGroups: boolean;
   secretAccessInsights: boolean;
   hsm: boolean;
   oidcSSO: boolean;

frontend/src/hooks/api/workflowIntegrations/index.ts

@@ -1,13 +1,2 @@
-export {
-  useDeleteSlackIntegration,
-  useUpdateProjectSlackConfig,
-  useUpdateSlackIntegration
-} from "./mutation";
-export {
-  fetchSlackInstallUrl,
-  fetchSlackReinstallUrl,
-  useGetSlackIntegrationById,
-  useGetSlackIntegrationChannels,
-  useGetSlackIntegrations,
-  useGetWorkflowIntegrations
-} from "./queries";
+export * from "./mutation";
+export * from "./queries";

frontend/src/hooks/api/workflowIntegrations/mutation.tsx

@@ -5,8 +5,13 @@ import { apiRequest } from "@app/config/request";
 import { workspaceKeys } from "../workspace/query-keys";
 import { workflowIntegrationKeys } from "./queries";
 import {
+  TCheckMicrosoftTeamsIntegrationInstallationStatusDTO,
+  TCreateMicrosoftTeamsIntegrationDTO,
+  TDeleteMicrosoftTeamsIntegrationDTO,
+  TDeleteProjectWorkflowIntegrationDTO,
   TDeleteSlackIntegrationDTO,
-  TUpdateProjectSlackConfigDTO,
+  TUpdateMicrosoftTeamsIntegrationDTO,
+  TUpdateProjectWorkflowIntegrationConfigDTO,
   TUpdateSlackIntegrationDTO
 } from "./types";
 
@@ -28,6 +33,47 @@ export const useUpdateSlackIntegration = () => {
   });
 };
 
+export const useUpdateMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TUpdateMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.patch(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.id}`,
+        dto
+      );
+
+      return data;
+    },
+    onSuccess: (_, { orgId, id }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+export const useCreateMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TCreateMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.post("/api/v1/workflow-integrations/microsoft-teams", dto);
+
+      return data;
+    },
+    onSuccess: (_, { orgId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+
 export const useDeleteSlackIntegration = () => {
   const queryClient = useQueryClient();
 
@@ -44,21 +90,86 @@ export const useDeleteSlackIntegration = () => {
   });
 };
 
-export const useUpdateProjectSlackConfig = () => {
+export const useDeleteMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TDeleteMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.delete(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.id}`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { orgId, id }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+
+export const useUpdateProjectWorkflowIntegrationConfig = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (dto: TUpdateProjectSlackConfigDTO) => {
+    mutationFn: async (dto: TUpdateProjectWorkflowIntegrationConfigDTO) => {
       const { data } = await apiRequest.put(
-        `/api/v1/workspace/${dto.workspaceId}/slack-config`,
+        `/api/v1/workspace/${dto.workspaceId}/workflow-integration`,
         dto
       );
 
       return data;
     },
-    onSuccess: (_, { workspaceId }) => {
+    onSuccess: (_, { workspaceId, integration }) => {
       queryClient.invalidateQueries({
-        queryKey: workspaceKeys.getWorkspaceSlackConfig(workspaceId)
+        queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(workspaceId, integration)
       });
     }
   });
 };
+
+export const useDeleteProjectWorkflowIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: TDeleteProjectWorkflowIntegrationDTO) => {
+      const { data } = await apiRequest.delete(
+        `/api/v1/workspace/${dto.projectId}/workflow-integration/${dto.integration}/${dto.integrationId}`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { projectId, integration }) => {
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(projectId, integration)
+      });
+    }
+  });
+};
+
+export const useCheckMicrosoftTeamsIntegrationInstallationStatus = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: TCheckMicrosoftTeamsIntegrationInstallationStatusDTO) => {
+      const { data } = await apiRequest.post(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.workflowIntegrationId}/installation-status`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { workflowIntegrationId, orgId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(workflowIntegrationId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};

frontend/src/hooks/api/workflowIntegrations/queries.tsx

@@ -2,13 +2,29 @@ import { useQuery } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
-import { SlackIntegration, SlackIntegrationChannel, WorkflowIntegration } from "./types";
+import {
+  MicrosoftTeamsIntegration,
+  MicrosoftTeamsIntegrationTeam,
+  SlackIntegration,
+  SlackIntegrationChannel,
+  WorkflowIntegration
+} from "./types";
 
 export const workflowIntegrationKeys = {
   getIntegrations: (orgId?: string) => [{ orgId }, "workflow-integrations"],
   getSlackIntegrations: (orgId?: string) => [{ orgId }, "slack-workflow-integrations"],
   getSlackIntegration: (id?: string) => [{ id }, "slack-workflow-integration"],
-  getSlackIntegrationChannels: (id?: string) => [{ id }, "slack-workflow-integration-channels"]
+  getMicrosoftTeamsIntegrations: (orgId?: string) => [
+    { orgId },
+    "microsoft-teams-workflow-integrations"
+  ],
+  getMicrosoftTeamsIntegration: (id?: string) => [{ id }, "microsoft-teams-workflow-integration"],
+  getMicrosoftTeamsIntegrationTeams: (id?: string) => [
+    { id },
+    "microsoft-teams-workflow-integration-teams"
+  ],
+  getSlackIntegrationChannels: (id?: string) => [{ id }, "slack-workflow-integration-channels"],
+  getMicrosoftTeamsClientId: () => ["microsoft-teams-client-id"]
 };
 
 export const fetchSlackInstallUrl = async ({
@@ -66,13 +82,58 @@ export const fetchWorkflowIntegrations = async () => {
   return data;
 };
 
-export const useGetSlackIntegrations = (orgId?: string) =>
+export const fetchMicrosoftTeamsIntegrations = async () => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegration[]>(
+    "/api/v1/workflow-integrations/microsoft-teams"
+  );
+
+  return data;
+};
+
+export const fetchMicrosoftTeamsIntegrationById = async (id?: string) => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegration>(
+    `/api/v1/workflow-integrations/microsoft-teams/${id}`
+  );
+
+  return data;
+};
+export const fetchMicrosoftTeamsIntegrationTeams = async (id?: string) => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegrationTeam[]>(
+    `/api/v1/workflow-integrations/microsoft-teams/${id}/teams`
+  );
+
+  return data;
+};
+
+export const fetchMicrosoftTeamsClientId = async () => {
+  const { data } = await apiRequest.get<{ clientId: string }>(
+    "/api/v1/workflow-integrations/microsoft-teams/client-id"
+  );
+
+  return data;
+};
+
+export const useGetMicrosoftTeamsIntegrations = (orgId?: string) =>
   useQuery({
-    queryKey: workflowIntegrationKeys.getSlackIntegrations(orgId),
-    queryFn: () => fetchSlackIntegrations(),
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId),
+    queryFn: () => fetchMicrosoftTeamsIntegrations(),
     enabled: Boolean(orgId)
   });
 
+export const useGetMicrosoftTeamsIntegrationById = (id?: string) =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id),
+    queryFn: () => fetchMicrosoftTeamsIntegrationById(id),
+    enabled: Boolean(id)
+  });
+
+export const useGetMicrosoftTeamsIntegrationTeams = (id?: string) =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrationTeams(id),
+    queryFn: () => fetchMicrosoftTeamsIntegrationTeams(id),
+    enabled: Boolean(id)
+  });
+
 export const useGetSlackIntegrationById = (id?: string) =>
   useQuery({
     queryKey: workflowIntegrationKeys.getSlackIntegration(id),
@@ -93,3 +154,10 @@ export const useGetWorkflowIntegrations = (id?: string) =>
     queryFn: () => fetchWorkflowIntegrations(),
     enabled: Boolean(id)
   });
+
+export const useGetMicrosoftTeamsClientId = () =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsClientId(),
+    queryFn: () => fetchMicrosoftTeamsClientId(),
+    enabled: true
+  });

frontend/src/hooks/api/workflowIntegrations/types.ts

@@ -1,14 +1,25 @@
 export enum WorkflowIntegrationPlatform {
-  SLACK = "slack"
+  SLACK = "slack",
+  MICROSOFT_TEAMS = "microsoft-teams"
 }
 
 export type WorkflowIntegration = {
   id: string;
   slug: string;
   description: string;
+  status: WorkflowIntegrationStatus;
   integration: WorkflowIntegrationPlatform;
 };
 
+export type MicrosoftTeamsIntegrationTeam = {
+  teamId: string;
+  teamName: string;
+  channels: {
+    channelId: string;
+    channelName: string;
+  }[];
+};
+
 export type SlackIntegration = {
   id: string;
   slug: string;
@@ -16,6 +27,18 @@ export type SlackIntegration = {
   teamName: string;
 };
 
+export enum WorkflowIntegrationStatus {
+  Pending = "pending",
+  Installed = "installed"
+}
+
+export type MicrosoftTeamsIntegration = {
+  id: string;
+  slug: string;
+  description: string;
+  tenantId: string;
+};
+
 export type SlackIntegrationChannel = {
   id: string;
   name: string;
@@ -28,25 +51,90 @@ export type TUpdateSlackIntegrationDTO = {
   description?: string;
 };
 
+export type TUpdateMicrosoftTeamsIntegrationDTO = {
+  id: string;
+  orgId: string;
+  slug?: string;
+  description?: string;
+};
+
+export type TCreateMicrosoftTeamsIntegrationDTO = {
+  code: string;
+  tenantId: string;
+  slug: string;
+  description?: string;
+  redirectUri: string;
+  orgId: string;
+};
+
 export type TDeleteSlackIntegrationDTO = {
   id: string;
   orgId: string;
 };
 
-export type ProjectSlackConfig = {
+export type TDeleteMicrosoftTeamsIntegrationDTO = {
   id: string;
-  slackIntegrationId: string;
-  isAccessRequestNotificationEnabled: boolean;
-  accessRequestChannels: string;
-  isSecretRequestNotificationEnabled: boolean;
-  secretRequestChannels: string;
+  orgId: string;
 };
 
-export type TUpdateProjectSlackConfigDTO = {
-  workspaceId: string;
-  slackIntegrationId: string;
-  isAccessRequestNotificationEnabled: boolean;
-  accessRequestChannels: string;
-  isSecretRequestNotificationEnabled: boolean;
-  secretRequestChannels: string;
+export type ProjectWorkflowIntegrationConfig =
+  | {
+      id: string;
+      integration: WorkflowIntegrationPlatform.SLACK;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      accessRequestChannels: string;
+      isSecretRequestNotificationEnabled: boolean;
+      secretRequestChannels: string;
+    }
+  | {
+      id: string;
+      integration: WorkflowIntegrationPlatform.MICROSOFT_TEAMS;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      isSecretRequestNotificationEnabled: boolean;
+      accessRequestChannels: {
+        teamId: string;
+        channelIds: string[];
+      };
+      secretRequestChannels: {
+        teamId: string;
+        channelIds: string[];
+      };
+    };
+
+export type TUpdateProjectWorkflowIntegrationConfigDTO =
+  | {
+      integration: WorkflowIntegrationPlatform.SLACK;
+      workspaceId: string;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      accessRequestChannels: string;
+      isSecretRequestNotificationEnabled: boolean;
+      secretRequestChannels: string;
+    }
+  | {
+      integration: WorkflowIntegrationPlatform.MICROSOFT_TEAMS;
+      workspaceId: string;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      isSecretRequestNotificationEnabled: boolean;
+      accessRequestChannels?: {
+        teamId: string;
+        channelIds: string[];
+      };
+      secretRequestChannels?: {
+        teamId: string;
+        channelIds: string[];
+      };
+    };
+export type TDeleteProjectWorkflowIntegrationDTO = {
+  projectId: string;
+  integration: WorkflowIntegrationPlatform;
+  integrationId: string;
+};
+
+export type TCheckMicrosoftTeamsIntegrationInstallationStatusDTO = {
+  workflowIntegrationId: string;
+  orgId: string;
 };

frontend/src/hooks/api/workspace/index.tsx

@@ -26,9 +26,9 @@ export {
   useGetWorkspaceIndexStatus,
   useGetWorkspaceIntegrations,
   useGetWorkspaceSecrets,
-  useGetWorkspaceSlackConfig,
   useGetWorkspaceUserDetails,
   useGetWorkspaceUsers,
+  useGetWorkspaceWorkflowIntegrationConfig,
   useListWorkspaceCas,
   useListWorkspaceCertificates,
   useListWorkspaceCertificateTemplates,
@@ -38,6 +38,7 @@ export {
   useListWorkspaceSshCas,
   useListWorkspaceSshCertificates,
   useListWorkspaceSshCertificateTemplates,
+  useListWorkspaceSshHostGroups,
   useListWorkspaceSshHosts,
   useNameWorkspaceSecrets,
   useSearchProjects,

frontend/src/hooks/api/workspace/queries.tsx

@@ -18,9 +18,13 @@ import { EncryptedSecret } from "../secrets/types";
 import { TSshCertificate, TSshCertificateAuthority } from "../sshCa/types";
 import { TSshCertificateTemplate } from "../sshCertificateTemplates/types";
 import { TSshHost } from "../sshHost/types";
+import { TSshHostGroup } from "../sshHostGroup/types";
 import { userKeys } from "../users/query-keys";
 import { TWorkspaceUser } from "../users/types";
-import { ProjectSlackConfig } from "../workflowIntegrations/types";
+import {
+  ProjectWorkflowIntegrationConfig,
+  WorkflowIntegrationPlatform
+} from "../workflowIntegrations/types";
 import { workspaceKeys } from "./query-keys";
 import {
   CreateEnvironmentDTO,
@@ -870,6 +874,21 @@ export const useListWorkspaceSshHosts = (projectId: string) => {
   });
 };
 
+export const useListWorkspaceSshHostGroups = (projectId: string) => {
+  return useQuery({
+    queryKey: workspaceKeys.getWorkspaceSshHostGroups(projectId),
+    queryFn: async () => {
+      const {
+        data: { groups }
+      } = await apiRequest.get<{ groups: (TSshHostGroup & { hostCount: number })[] }>(
+        `/api/v2/workspace/${projectId}/ssh-host-groups`
+      );
+      return groups;
+    },
+    enabled: Boolean(projectId)
+  });
+};
+
 export const useListWorkspaceSshCertificateTemplates = (projectId: string) => {
   return useQuery({
     queryKey: workspaceKeys.getWorkspaceSshCertificateTemplates(projectId),
@@ -883,13 +902,27 @@ export const useListWorkspaceSshCertificateTemplates = (projectId: string) => {
   });
 };
 
-export const useGetWorkspaceSlackConfig = ({ workspaceId }: { workspaceId: string }) => {
+export const useGetWorkspaceWorkflowIntegrationConfig = ({
+  workspaceId,
+  integration
+}: {
+  workspaceId: string;
+  integration: WorkflowIntegrationPlatform;
+}) => {
   return useQuery({
-    queryKey: workspaceKeys.getWorkspaceSlackConfig(workspaceId),
+    queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(workspaceId, integration),
     queryFn: async () => {
-      const { data } = await apiRequest.get<ProjectSlackConfig>(
-        `/api/v1/workspace/${workspaceId}/slack-config`
-      );
+      const { data } = await apiRequest
+        .get<ProjectWorkflowIntegrationConfig>(
+          `/api/v1/workspace/${workspaceId}/workflow-integration-config/${integration}`
+        )
+        .catch((err) => {
+          if (err.response.status === 404) {
+            return { data: null };
+          }
+
+          throw err;
+        });
 
       return data;
     },

frontend/src/hooks/api/workspace/query-keys.tsx

@@ -1,6 +1,7 @@
 import { TListProjectIdentitiesDTO, TSearchProjectsDTO } from "@app/hooks/api/workspace/types";
 
 import type { CaStatus } from "../ca";
+import { WorkflowIntegrationPlatform } from "../workflowIntegrations/types";
 
 export const workspaceKeys = {
   getWorkspaceById: (workspaceId: string) => ["workspaces", { workspaceId }] as const,
@@ -54,12 +55,16 @@ export const workspaceKeys = {
     [{ workspaceId }, "workspace-pki-collections"] as const,
   getWorkspaceCertificateTemplates: (workspaceId: string) =>
     [{ workspaceId }, "workspace-certificate-templates"] as const,
-  getWorkspaceSlackConfig: (workspaceId: string) =>
-    [{ workspaceId }, "workspace-slack-config"] as const,
+  getWorkspaceWorkflowIntegrationConfig: (
+    workspaceId: string,
+    integration: WorkflowIntegrationPlatform
+  ) => [{ workspaceId, integration }, "workspace-workflow-integration-config"] as const,
   getWorkspaceSshCas: (projectId: string) => [{ projectId }, "workspace-ssh-cas"] as const,
   allWorkspaceSshCertificates: (projectId: string) =>
     [{ projectId }, "workspace-ssh-certificates"] as const,
   getWorkspaceSshHosts: (projectId: string) => [{ projectId }, "workspace-ssh-hosts"] as const,
+  getWorkspaceSshHostGroups: (projectId: string) =>
+    [{ projectId }, "workspace-ssh-host-groups"] as const,
   specificWorkspaceSshCertificates: ({
     offset,
     limit,