android/app/src/main/res/drawable/ic_quickaction_contact.xml (1)

1-5: Consider standardizing viewport dimensions.

The vector drawable is correctly formatted. However, note that ic_quickaction_contact.xml uses a 24x24 viewport while ic_quickaction_recent.xml uses 512x512. While both will render correctly, standardizing viewports across related icon resources can improve maintainability.

♻️ Optional: standardize to 512x512 viewport

If you want consistency with the recent icon, you could rescale the path data to a 512x512 viewport. However, this is purely cosmetic and not required for functionality.

app/actions/actionsTypes.ts (1)

15-15: New action namespaces look consistent; consider tightening createRequestTypes typing.

Lines 15 and 63-65 align with the new quick-actions/UI flows. Small TS maintainability improvement: createRequestTypes(base = {}, ...) should likely take base: string (default '') to avoid accidental ${base} becoming [object Object].

Also applies to: 63-65

app/actions/quickActions.ts (1)

5-15: Make params optional (and avoid params.action ambiguity).
Right now IQuickAction.params is required (Line 9) and quickActionHandle requires an argument (Line 11), which makes “no-param” dispatch awkward, and params.action is easy to confuse with Redux “action”.

Proposed diff

 interface IQuickActionParams {
-	action: string;
+	action: string;
 }
 interface IQuickAction extends Action {
-	params: Partial<IQuickActionParams>;
+	params?: Partial<IQuickActionParams>;
 }
-export function quickActionHandle(params: Partial<IQuickActionParams>): IQuickAction {
+export function quickActionHandle(params: Partial<IQuickActionParams> = {}): IQuickAction {
 	return {
 		type: QUICK_ACTIONS.QUICK_ACTION_HANDLE,
 		params
 	};
 }

app/views/RoomsListView/hooks/useSearch.ts (1)

65-104: Type your Redux dispatch and avoid clearing triggers with untyped objects.
Since AppDispatch now exists, prefer useDispatch<AppDispatch>() so these dispatches are type-checked (Line 66, Line 96).

Proposed diff

-import { useDispatch } from 'react-redux';
+import { useDispatch } from 'react-redux';
+import type { AppDispatch } from '../../../lib/store';

 ...
-	const storeDispatch = useDispatch();
+	const storeDispatch = useDispatch<AppDispatch>();

app/lib/store/index.ts (1)

29-33: Good addition; watch out for store name collisions with auxStore.ts.
AppDispatch is a solid typing hook for useDispatch, but it’s easy to accidentally import the wrong store given app/lib/store/auxStore.ts also exports store.

app/reducers/rooms.ts (1)

9-10: Inconsistent naming: mix of abbreviation and full word.

The state fields use inconsistent naming styles:

• lastVisitedRid — abbreviation ("Rid" for room ID)
• lastVisitedName — full word ("Name")

The action payload uses full words (lastVisitedRoomId, lastVisitedRoomName), which is clearer. Consider renaming the state fields to match for consistency:

-	lastVisitedRid: string;
-	lastVisitedName: string;
+	lastVisitedRoomId: string;
+	lastVisitedRoomName: string;

You'll also need to update the initial state (lines 18-19) and the reducer case (lines 54-55) accordingly.

app/AppContainer.tsx (1)

4-25: Consider avoiding connect(...) + hooks in the same component.
Not a blocker, but it makes the data-flow harder to follow (props from HOC + hooks from store). Either approach alone would be simpler.

app/i18n/locales/en.json (1)

331-331: Same i18n key hygiene note (Something_Wrong?) + optional copy polish.
If you keep the \n in Error_finding_room, consider sentence punctuation for UI consistency (non-blocking).

Also applies to: 457-457, 698-699, 846-846, 984-984

app/index.tsx (1)

166-184: Replace non-null assertion and add quick-action ID validation.

The deepLinking! non-null assertion is unsafe since Linking.getInitialURL() can return null or undefined. Additionally, validation here prevents accidental dispatches of unknown quick-action IDs. The handler gracefully ignores them today, but explicit validation at the entry point is clearer and prevents unnecessary Redux actions.

Replace the non-null assertion:

const parsedDeepLinkingURL = deepLinking ? parseDeepLinking(deepLinking) : null;

And add ID validation before dispatch in the quick-action handler to match the known cases defined in app/lib/quickActions/index.ts ('search', 'add-server', 'recent', 'contact').

app/lib/quickActions/getRecentQuickAction.ts (1)

14-19: Consider simplifying the error handling return.

The try-catch appropriately returns null on any error. The ?? null on line 16 is defensive but potentially redundant, since getInitialQuickAction should return a string or null/undefined. If the native contract guarantees this, you can simplify to return action || null.

♻️ Optional simplification

 	try {
 		const action = await QuickActionsConnector.getInitialQuickAction();
-		return action ?? null;
+		return action || null;
 	} catch {
 		return null;
 	}

app/reducers/ui.ts (1)

13-28: Strengthen type safety with a discriminated union for UI actions.

The reducer uses a generic Action type, preventing TypeScript from verifying that UI.TRIGGER_SEARCH and UI.CLEAR_TRIGGERED_SEARCH are valid action types. Define a union of specific UI action types for better compile-time safety.

♻️ Proposed type-safe action union

+type UIAction = 
+	| { type: typeof UI.TRIGGER_SEARCH }
+	| { type: typeof UI.CLEAR_TRIGGERED_SEARCH };
+
-export default function ui(state = initialState, action: Action): IUIState {
+export default function ui(state = initialState, action: UIAction | Action): IUIState {
 	switch (action.type) {
 		case UI.TRIGGER_SEARCH:
 			return {
 				...state,
 				triggerSearch: true
 			};
 		case UI.CLEAR_TRIGGERED_SEARCH:
 			return {
 				...state,
 				triggerSearch: false
 			};
 		default:
 			return state;
 	}
 }

This approach allows UI actions to be type-checked while still accepting generic actions for Redux compatibility.

app/sagas/roomVisited.ts (1)

21-31: Add error handling for UserPreferences persistence.

The UserPreferences.setString calls (lines 28-29) lack error handling. If persistence fails, the saga will crash and stop processing future room visitation events. Consider wrapping these calls in a try-catch to ensure the saga remains resilient.

♻️ Proposed error handling

 function* watchRoomVisited(): SagaIterator {
 	const channel = yield call(createRoomVisitedChannel);
 
 	while (true) {
 		const { rid, name } = yield take(channel);
 		yield put(roomsStoreLastVisited(rid, name));
 
-		UserPreferences.setString(LAST_VISITED_ROOM_ID_KEY, rid);
-		UserPreferences.setString(LAST_VISITED_ROOM_Name_KEY, name);
+		try {
+			UserPreferences.setString(LAST_VISITED_ROOM_ID_KEY, rid);
+			UserPreferences.setString(LAST_VISITED_ROOM_Name_KEY, name);
+		} catch (error) {
+			// Log but don't crash the saga
+			console.warn('Failed to persist last visited room:', error);
+		}
 	}
 }

app/lib/methods/helpers/goRoom.ts (2)

115-116: Silent catch block may hide unexpected errors.

The empty catch block with "do nothing" comment intentionally swallows all errors from the room visitation tracking. While this prevents blocking navigation, it also hides potential bugs (e.g., emitter failures, getRoom issues). Consider logging the error for debugging.

📋 Optional logging addition

 				} catch {
-					// do nothing
+					// Ignore errors in room visit tracking to avoid blocking navigation
 				}

Or add minimal logging:

-				} catch {
-					// do nothing
+				} catch (error) {
+					// Log but don't block navigation
+					console.debug('Failed to track room visit:', error);
 				}

---

141-149: Sequential database queries may impact performance.

Lines 141 and 149 make two separate database calls (getRoom and getSubscriptionByRoomId) for the same item.rid. If these queries are frequently executed, consider optimizing by fetching both in parallel or combining into a single query.

Example parallel fetch:

const [room, sub] = await Promise.all([
  getRoom(item.rid).catch(() => null),
  getSubscriptionByRoomId(item.rid)
]);

if (room) {
  emitter.emit('roomVisited', {
    rid: room.rid,
    name: room.name
  });
}

if (sub) {
  _item = sub;
}

This reduces the total latency when both queries are independent.

app/reducers/quickActions.ts (1)

25-33: Consider refining the type narrowing.

The type guard on line 26 correctly checks for the payload, but line 31 still uses a type assertion. Since QuickActionsAction is a union including the bare Action type, TypeScript cannot automatically narrow the type after the guard. While the current implementation is functionally correct, you could improve type safety by using a more explicit type predicate or restructuring the action types to avoid the manual cast.

♻️ Alternative approach using type predicate

+function isQuickActionPayload(action: QuickActionsAction): action is IQuickActionPayloadAction {
+	return 'payload' in action && !!action.payload?.action;
+}
+
 export default function quickActions(state = initialState, action: QuickActionsAction): IQuickActionsState {
 	switch (action.type) {
 		case QUICK_ACTIONS.QUICK_ACTION_HANDLE:
-			if (!('payload' in action) || !action.payload?.action) {
+			if (!isQuickActionPayload(action)) {
 				return state;
 			}
 			return {
 				...state,
-				lastAction: (action as IQuickActionPayloadAction).payload.action,
+				lastAction: action.payload.action,
 				handled: false
 			};

ios/AppDelegate.swift (1)

7-7: Optional: Remove redundant Foundation import.

The Foundation import is typically unnecessary in iOS applications as it's already available through UIKit and other frameworks imported in this file. While not harmful, removing it can reduce clutter.

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Jira integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

app/reducers/rooms.ts (1)

61-89: Wrap STORE_LAST_VISITED case in a block for better scoping practice.
While the no-case-declarations rule is currently disabled in the project's ESLint config, wrapping lexical declarations in a block scope prevents potential variable hoisting issues and follows best practices for switch statements.

🛠️ Suggested fix

-		case ROOMS.STORE_LAST_VISITED:
+		case ROOMS.STORE_LAST_VISITED: {
 			const server = UserPreferences.getString(CURRENT_SERVER);
 			const newRoom = { rid: action.lastVisitedRoomId, name: action.lastVisitedRoomName, server };
@@
 			return {
 				...state,
 				lastVisitedRid: action.lastVisitedRoomId,
 				lastVisitedName: action.lastVisitedRoomName,
 				recentRooms: updatedRecentRooms
 			};
+		}
 		case ROOMS.STORE_RECENT_ROOMS:

app/lib/quickActions/index.ts (1)

80-85: appStateSubscription is not reset to null in unregisterQuickActions.

The cleanup function resets quickActionSubscription to null but not appStateSubscription, which could lead to inconsistent state if someone checks the subscription variables.

Proposed fix

 export function unregisterQuickActions() {
 	quickActionSubscription?.remove();
 	appStateSubscription?.remove();
 	quickActionSubscription = null;
+	appStateSubscription = null;
 	registered = false;
 }

app/AppContainer.tsx (2)

43-49: Async function called without error handling in effect.

registerQuickActions() is async but its promise is not handled. If it throws, the error will be silently swallowed. Consider adding error handling or logging.

Proposed fix

 	useEffect(() => {
-		registerQuickActions();
+		registerQuickActions().catch(e => {
+			// Log or handle registration failure
+			console.warn('Failed to register quick actions:', e);
+		});

 		return () => {
 			unregisterQuickActions();
 		};
 	}, []);

---

60-62: Same unhandled promise concern for updateQuickActions.

If updateQuickActions fails (e.g., getServersList() throws), the error is silently ignored.

Proposed fix

 	useEffect(() => {
-		updateQuickActions({ recentRooms });
+		updateQuickActions({ recentRooms }).catch(e => {
+			console.warn('Failed to update quick actions:', e);
+		});
 	}, [recentRooms]);

app/AppContainer.tsx (1)

61-68: Consider handling async updateQuickActions errors.
If the async call rejects, it can surface as an unhandled promise rejection. A small try/catch wrapper keeps this resilient.

🧯 Suggested pattern

-	useEffect(() => {
-		if (!currentServer) {
-			updateQuickActions({ recentRooms: [] });
-			return;
-		}
-
-		updateQuickActions({ recentRooms });
-	}, [recentRooms, currentServer]); // currentserver for updating after logging out
+	useEffect(() => {
+		const run = async () => {
+			if (!currentServer) {
+				await updateQuickActions({ recentRooms: [] });
+				return;
+			}
+			await updateQuickActions({ recentRooms });
+		};
+
+		run().catch(err => {
+			// TODO: log via existing logger if desired
+			console.warn('updateQuickActions failed', err);
+		});
+	}, [recentRooms, currentServer]); // currentserver for updating after logging out

app/actions/rooms.ts (1)

4-5: Use a union for IRoomsAction, not an intersection.

An intersection forces every action to carry all fields, which defeats discriminated unions in reducers. A union is the idiomatic and safer shape that allows TypeScript to narrow types in the reducer's switch statement based on the type field.

♻️ Suggested type change

-export type IRoomsAction = IRoomsRequest & ISetSearch & IRoomsFailure & IRoomsLastVisited & IRecentRooms;
+export type IRoomsAction =
+	| IRoomsRequest
+	| ISetSearch
+	| IRoomsFailure
+	| IRoomsLastVisited
+	| IRecentRooms;