diff --git a/sway/commands.c b/sway/commands.c
index 2e048203..9968ca1c 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -96,6 +96,7 @@ static const struct cmd_handler handlers[] = {
 	{ "no_focus", cmd_no_focus },
 	{ "output", cmd_output },
 	{ "popup_during_fullscreen", cmd_popup_during_fullscreen },
+	{ "primary_selection", cmd_primary_selection },
 	{ "seat", cmd_seat },
 	{ "set", cmd_set },
 	{ "shadow_blur_radius", cmd_shadow_blur_radius },
diff --git a/sway/server.c b/sway/server.c
index c4b98d22..cd3dc14d 100644
--- a/sway/server.c
+++ b/sway/server.c
@@ -63,54 +63,61 @@
 #define SWAY_LAYER_SHELL_VERSION 4
 
 #if WLR_HAS_DRM_BACKEND
-static void handle_drm_lease_request(struct wl_listener *listener, void *data) {
+static void handle_drm_lease_request(struct wl_listener *listener, void *data)
+{
 	/* We only offer non-desktop outputs, but in the future we might want to do
 	 * more logic here. */
 
 	struct wlr_drm_lease_request_v1 *req = data;
 	struct wlr_drm_lease_v1 *lease = wlr_drm_lease_request_v1_grant(req);
-	if (!lease) {
+	if (!lease)
+	{
 		sway_log(SWAY_ERROR, "Failed to grant lease request");
 		wlr_drm_lease_request_v1_reject(req);
 	}
 }
 #endif
 
-static bool is_privileged(const struct wl_global *global) {
+static bool is_privileged(const struct wl_global *global)
+{
 #if WLR_HAS_DRM_BACKEND
-	if (server.drm_lease_manager != NULL) {
+	if (server.drm_lease_manager != NULL)
+	{
 		struct wlr_drm_lease_device_v1 *drm_lease_dev;
-		wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link) {
-			if (drm_lease_dev->global == global) {
+		wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link)
+		{
+			if (drm_lease_dev->global == global)
+			{
 				return true;
 			}
 		}
 	}
 #endif
 
-	return
-		global == server.output_manager_v1->global ||
-		global == server.output_power_manager_v1->global ||
-		global == server.input_method->global ||
-		global == server.foreign_toplevel_manager->global ||
-		global == server.data_control_manager_v1->global ||
-		global == server.screencopy_manager_v1->global ||
-		global == server.export_dmabuf_manager_v1->global ||
-		global == server.security_context_manager_v1->global ||
-		global == server.gamma_control_manager_v1->global ||
-		global == server.layer_shell->global ||
-		global == server.session_lock.manager->global ||
-		global == server.input->inhibit->global ||
-		global == server.input->keyboard_shortcuts_inhibit->global ||
-		global == server.input->virtual_keyboard->global ||
-		global == server.input->virtual_pointer->global;
+	return global == server.output_manager_v1->global ||
+		   global == server.output_power_manager_v1->global ||
+		   global == server.input_method->global ||
+		   global == server.foreign_toplevel_manager->global ||
+		   global == server.data_control_manager_v1->global ||
+		   global == server.screencopy_manager_v1->global ||
+		   global == server.export_dmabuf_manager_v1->global ||
+		   global == server.security_context_manager_v1->global ||
+		   global == server.gamma_control_manager_v1->global ||
+		   global == server.layer_shell->global ||
+		   global == server.session_lock.manager->global ||
+		   global == server.input->inhibit->global ||
+		   global == server.input->keyboard_shortcuts_inhibit->global ||
+		   global == server.input->virtual_keyboard->global ||
+		   global == server.input->virtual_pointer->global;
 }
 
 static bool filter_global(const struct wl_client *client,
-		const struct wl_global *global, void *data) {
+						  const struct wl_global *global, void *data)
+{
 #if HAVE_XWAYLAND
 	struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
-	if (xwayland && global == xwayland->shell_v1->global) {
+	if (xwayland && global == xwayland->shell_v1->global)
+	{
 		return xwayland->server != NULL && client == xwayland->server->client;
 	}
 #endif
@@ -119,15 +126,17 @@ static bool filter_global(const struct wl_client *client,
 	// TODO: add a way for users to configure an allow-list
 	const struct wlr_security_context_v1_state *security_context =
 		wlr_security_context_manager_v1_lookup_client(
-		server.security_context_manager_v1, (struct wl_client *)client);
-	if (is_privileged(global)) {
+			server.security_context_manager_v1, (struct wl_client *)client);
+	if (is_privileged(global))
+	{
 		return security_context == NULL;
 	}
 
 	return true;
 }
 
-bool server_init(struct sway_server *server) {
+bool server_init(struct sway_server *server)
+{
 	sway_log(SWAY_DEBUG, "Initializing Wayland server");
 	server->wl_display = wl_display_create();
 	server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
@@ -135,37 +144,41 @@ bool server_init(struct sway_server *server) {
 	wl_display_set_global_filter(server->wl_display, filter_global, NULL);
 
 	server->backend = wlr_backend_autocreate(server->wl_display, &server->session);
-	if (!server->backend) {
+	if (!server->backend)
+	{
 		sway_log(SWAY_ERROR, "Unable to create backend");
 		return false;
 	}
 
 	server->renderer = fx_renderer_create(server->backend);
-	if (!server->renderer) {
+	if (!server->renderer)
+	{
 		sway_log(SWAY_ERROR, "Failed to create fx_renderer");
 		return false;
 	}
 
 	wlr_renderer_init_wl_shm(server->renderer, server->wl_display);
 
-	if (wlr_renderer_get_dmabuf_texture_formats(server->renderer) != NULL) {
+	if (wlr_renderer_get_dmabuf_texture_formats(server->renderer) != NULL)
+	{
 		wlr_drm_create(server->wl_display, server->renderer);
 		server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer(
 			server->wl_display, 4, server->renderer);
 	}
 
 	server->allocator = wlr_allocator_autocreate(server->backend,
-		server->renderer);
-	if (!server->allocator) {
+												 server->renderer);
+	if (!server->allocator)
+	{
 		sway_log(SWAY_ERROR, "Failed to create allocator");
 		return false;
 	}
 
 	server->compositor = wlr_compositor_create(server->wl_display, 6,
-		server->renderer);
+											   server->renderer);
 	server->compositor_new_surface.notify = handle_compositor_new_surface;
 	wl_signal_add(&server->compositor->events.new_surface,
-		&server->compositor_new_surface);
+				  &server->compositor_new_surface);
 
 	wlr_subcompositor_create(server->wl_display);
 
@@ -176,13 +189,13 @@ bool server_init(struct sway_server *server) {
 		wlr_gamma_control_manager_v1_create(server->wl_display);
 	server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
 	wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma,
-		&server->gamma_control_set_gamma);
+				  &server->gamma_control_set_gamma);
 
 	server->new_output.notify = handle_new_output;
 	wl_signal_add(&server->backend->events.new_output, &server->new_output);
 	server->output_layout_change.notify = handle_output_layout_change;
 	wl_signal_add(&root->output_layout->events.change,
-		&server->output_layout_change);
+				  &server->output_layout_change);
 
 	wlr_xdg_output_manager_v1_create(server->wl_display, root->output_layout);
 
@@ -190,15 +203,15 @@ bool server_init(struct sway_server *server) {
 	sway_idle_inhibit_manager_v1_init();
 
 	server->layer_shell = wlr_layer_shell_v1_create(server->wl_display,
-		SWAY_LAYER_SHELL_VERSION);
+													SWAY_LAYER_SHELL_VERSION);
 	wl_signal_add(&server->layer_shell->events.new_surface,
-		&server->layer_shell_surface);
+				  &server->layer_shell_surface);
 	server->layer_shell_surface.notify = handle_layer_shell_surface;
 
 	server->xdg_shell = wlr_xdg_shell_create(server->wl_display,
-		SWAY_XDG_SHELL_VERSION);
+											 SWAY_XDG_SHELL_VERSION);
 	wl_signal_add(&server->xdg_shell->events.new_surface,
-		&server->xdg_shell_surface);
+				  &server->xdg_shell_surface);
 	server->xdg_shell_surface.notify = handle_xdg_shell_surface;
 
 	server->tablet_v2 = wlr_tablet_v2_create(server->wl_display);
@@ -209,15 +222,15 @@ bool server_init(struct sway_server *server) {
 		server->server_decoration_manager,
 		WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
 	wl_signal_add(&server->server_decoration_manager->events.new_decoration,
-		&server->server_decoration);
+				  &server->server_decoration);
 	server->server_decoration.notify = handle_server_decoration;
 	wl_list_init(&server->decorations);
 
 	server->xdg_decoration_manager =
 		wlr_xdg_decoration_manager_v1_create(server->wl_display);
 	wl_signal_add(
-			&server->xdg_decoration_manager->events.new_toplevel_decoration,
-			&server->xdg_decoration);
+		&server->xdg_decoration_manager->events.new_toplevel_decoration,
+		&server->xdg_decoration);
 	server->xdg_decoration.notify = handle_xdg_decoration;
 	wl_list_init(&server->xdg_decorations);
 
@@ -228,7 +241,7 @@ bool server_init(struct sway_server *server) {
 		wlr_pointer_constraints_v1_create(server->wl_display);
 	server->pointer_constraint.notify = handle_pointer_constraint;
 	wl_signal_add(&server->pointer_constraints->events.new_constraint,
-		&server->pointer_constraint);
+				  &server->pointer_constraint);
 
 	server->presentation =
 		wlr_presentation_create(server->wl_display, server->backend);
@@ -237,17 +250,17 @@ bool server_init(struct sway_server *server) {
 		wlr_output_manager_v1_create(server->wl_display);
 	server->output_manager_apply.notify = handle_output_manager_apply;
 	wl_signal_add(&server->output_manager_v1->events.apply,
-		&server->output_manager_apply);
+				  &server->output_manager_apply);
 	server->output_manager_test.notify = handle_output_manager_test;
 	wl_signal_add(&server->output_manager_v1->events.test,
-		&server->output_manager_test);
+				  &server->output_manager_test);
 
 	server->output_power_manager_v1 =
 		wlr_output_power_manager_v1_create(server->wl_display);
 	server->output_power_manager_set_mode.notify =
 		handle_output_power_manager_set_mode;
 	wl_signal_add(&server->output_power_manager_v1->events.set_mode,
-		&server->output_power_manager_set_mode);
+				  &server->output_power_manager_set_mode);
 	server->input_method = wlr_input_method_manager_v2_create(server->wl_display);
 	server->text_input = wlr_text_input_manager_v3_create(server->wl_display);
 	server->foreign_toplevel_manager =
@@ -256,13 +269,16 @@ bool server_init(struct sway_server *server) {
 	sway_session_lock_init();
 
 #if WLR_HAS_DRM_BACKEND
-	server->drm_lease_manager=
+	server->drm_lease_manager =
 		wlr_drm_lease_v1_manager_create(server->wl_display, server->backend);
-	if (server->drm_lease_manager) {
+	if (server->drm_lease_manager)
+	{
 		server->drm_lease_request.notify = handle_drm_lease_request;
 		wl_signal_add(&server->drm_lease_manager->events.request,
-				&server->drm_lease_request);
-	} else {
+					  &server->drm_lease_request);
+	}
+	else
+	{
 		sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1");
 		sway_log(SWAY_INFO, "VR will not be available");
 	}
@@ -287,11 +303,11 @@ bool server_init(struct sway_server *server) {
 	server->xdg_activation_v1_request_activate.notify =
 		xdg_activation_v1_handle_request_activate;
 	wl_signal_add(&server->xdg_activation_v1->events.request_activate,
-		&server->xdg_activation_v1_request_activate);
+				  &server->xdg_activation_v1_request_activate);
 	server->xdg_activation_v1_new_token.notify =
 		xdg_activation_v1_handle_new_token;
 	wl_signal_add(&server->xdg_activation_v1->events.new_token,
-		&server->xdg_activation_v1_new_token);
+				  &server->xdg_activation_v1_new_token);
 
 	struct wlr_cursor_shape_manager_v1 *cursor_shape_manager =
 		wlr_cursor_shape_manager_v1_create(server->wl_display, 1);
@@ -302,36 +318,43 @@ bool server_init(struct sway_server *server) {
 
 	// Avoid using "wayland-0" as display socket
 	char name_candidate[16];
-	for (unsigned int i = 1; i <= 32; ++i) {
+	for (unsigned int i = 1; i <= 32; ++i)
+	{
 		snprintf(name_candidate, sizeof(name_candidate), "wayland-%u", i);
-		if (wl_display_add_socket(server->wl_display, name_candidate) >= 0) {
+		if (wl_display_add_socket(server->wl_display, name_candidate) >= 0)
+		{
 			server->socket = strdup(name_candidate);
 			break;
 		}
 	}
 
-	if (!server->socket) {
+	if (!server->socket)
+	{
 		sway_log(SWAY_ERROR, "Unable to open wayland socket");
 		wlr_backend_destroy(server->backend);
 		return false;
 	}
 
 	server->headless_backend = wlr_headless_backend_create(server->wl_display);
-	if (!server->headless_backend) {
+	if (!server->headless_backend)
+	{
 		sway_log(SWAY_ERROR, "Failed to create secondary headless backend");
 		wlr_backend_destroy(server->backend);
 		return false;
-	} else {
+	}
+	else
+	{
 		wlr_multi_backend_add(server->backend, server->headless_backend);
 	}
 
 	struct wlr_output *wlr_output =
-			wlr_headless_add_output(server->headless_backend, 800, 600);
+		wlr_headless_add_output(server->headless_backend, 800, 600);
 	wlr_output_set_name(wlr_output, "FALLBACK");
 	root->fallback_output = output_create(wlr_output);
 
 	// This may have been set already via -Dtxn-timeout
-	if (!server->txn_timeout_ms) {
+	if (!server->txn_timeout_ms)
+	{
 		server->txn_timeout_ms = 200;
 	}
 
@@ -343,7 +366,8 @@ bool server_init(struct sway_server *server) {
 	return true;
 }
 
-void server_fini(struct sway_server *server) {
+void server_fini(struct sway_server *server)
+{
 	// TODO: free sway-specific resources
 #if HAVE_XWAYLAND
 	wlr_xwayland_destroy(server->xwayland.wlr_xwayland);
@@ -353,23 +377,28 @@ void server_fini(struct sway_server *server) {
 	list_free(server->dirty_nodes);
 }
 
-bool server_start(struct sway_server *server) {
+bool server_start(struct sway_server *server)
+{
 #if HAVE_XWAYLAND
-	if (config->xwayland != XWAYLAND_MODE_DISABLED) {
+	if (config->xwayland != XWAYLAND_MODE_DISABLED)
+	{
 		sway_log(SWAY_DEBUG, "Initializing Xwayland (lazy=%d)",
-				config->xwayland == XWAYLAND_MODE_LAZY);
+				 config->xwayland == XWAYLAND_MODE_LAZY);
 		server->xwayland.wlr_xwayland =
 			wlr_xwayland_create(server->wl_display, server->compositor,
-					config->xwayland == XWAYLAND_MODE_LAZY);
-		if (!server->xwayland.wlr_xwayland) {
+								config->xwayland == XWAYLAND_MODE_LAZY);
+		if (!server->xwayland.wlr_xwayland)
+		{
 			sway_log(SWAY_ERROR, "Failed to start Xwayland");
 			unsetenv("DISPLAY");
-		} else {
+		}
+		else
+		{
 			wl_signal_add(&server->xwayland.wlr_xwayland->events.new_surface,
-				&server->xwayland_surface);
+						  &server->xwayland_surface);
 			server->xwayland_surface.notify = handle_xwayland_surface;
 			wl_signal_add(&server->xwayland.wlr_xwayland->events.ready,
-				&server->xwayland_ready);
+						  &server->xwayland_ready);
 			server->xwayland_ready.notify = handle_xwayland_ready;
 
 			setenv("DISPLAY", server->xwayland.wlr_xwayland->display_name, true);
@@ -379,13 +408,15 @@ bool server_start(struct sway_server *server) {
 	}
 #endif
 
-	if (config->primary_selection) {
+	if (config->primary_selection)
+	{
 		wlr_primary_selection_v1_device_manager_create(server->wl_display);
 	}
 
 	sway_log(SWAY_INFO, "Starting backend on wayland display '%s'",
-			server->socket);
-	if (!wlr_backend_start(server->backend)) {
+			 server->socket);
+	if (!wlr_backend_start(server->backend))
+	{
 		sway_log(SWAY_ERROR, "Failed to start backend");
 		wlr_backend_destroy(server->backend);
 		return false;
@@ -394,8 +425,9 @@ bool server_start(struct sway_server *server) {
 	return true;
 }
 
-void server_run(struct sway_server *server) {
+void server_run(struct sway_server *server)
+{
 	sway_log(SWAY_INFO, "Running compositor on wayland display '%s'",
-			server->socket);
+			 server->socket);
 	wl_display_run(server->wl_display);
 }