fix: resolve TypeScript and ESLint errors in extension and server

- Add AUTH/AUTH_SUCCESS to MessageType for WebSocket authentication
- Implement missing TreeDataProvider methods in FriendsProvider
- Fix exactOptionalPropertyTypes compatibility in buildActivityInfo
- Install minimatch dependency, fix ESLint config extension
- Remove async from sync handleHeartbeat function

Author: senutpal

apps/extension/eslint.config.cjs apps/extension/eslint.config.mjsapps/extension/eslint.config.cjs renamed to apps/extension/eslint.config.mjs

@@ -223,7 +223,8 @@
     "clean": "rimraf dist out"
   },
   "dependencies": {
-    "@devradar/shared": "workspace:*"
+    "@devradar/shared": "workspace:*",
+    "minimatch": "^10.1.1"
   },
   "devDependencies": {
     "@devradar/eslint-config": "workspace:*",

apps/extension/package.json

@@ -42,7 +42,7 @@ class DevRadarExtension implements vscode.Disposable {
     this.activityTracker = new ActivityTracker(this.wsClient, this.configManager, this.logger);
 
     // Initialize views
-    this.friendsProvider = new FriendsProvider(this.authService, this.configManager, this.logger);
+    this.friendsProvider = new FriendsProvider(this.logger);
     this.activityProvider = new ActivityProvider(this.wsClient, this.logger);
     this.statusBar = new StatusBarManager(this.wsClient, this.authService, this.logger);
 
@@ -330,9 +330,11 @@ class DevRadarExtension implements vscode.Disposable {
 
     const trimmedMessage = message.trim();
     // Sanitize: strip control characters (except simple whitespace) and HTML-like tags
+    /* eslint-disable no-control-regex */
     const sanitizedMessage = trimmedMessage
       .replace(/[\u0000-\u001f\u007f-\u009f]/g, '') // Remove control chars
       .replace(/<[^>]*>/g, ''); // Remove HTML tags
+    /* eslint-enable no-control-regex */
 
     this.wsClient.sendPoke(userId, sanitizedMessage);
     void vscode.window.showInformationMessage('DevRadar: Poke sent! 👋');

apps/extension/src/extension.ts

@@ -59,7 +59,11 @@ export class AuthService implements vscode.Disposable {
       },
       5 * 60 * 1000
     );
-    this.disposables.push({ dispose: () => clearInterval(validationInterval) });
+    this.disposables.push({
+      dispose: () => {
+        clearInterval(validationInterval);
+      },
+    });
   }
 
   /**

apps/extension/src/services/authService.ts

@@ -4,8 +4,8 @@
  * Provides type-safe access to extension configuration with caching.
  */
 
-import * as vscode from 'vscode';
 import { minimatch } from 'minimatch';
+import * as vscode from 'vscode';
 
 /**
  * Extension configuration schema.

apps/extension/src/utils/configManager.ts

@@ -6,11 +6,8 @@
 
 import * as vscode from 'vscode';
 
-import type { AuthService } from '../services/authService';
-import type { ConfigManager } from '../utils/configManager';
-import type { WebSocketClient } from '../services/wsClient';
 import type { Logger } from '../utils/logger';
-import type { UserDTO, UserStatus, UserStatusType } from '@devradar/shared';
+import type { ActivityPayload, UserDTO, UserStatus, UserStatusType } from '@devradar/shared';
 
 /**
  * Friend item with status information.
@@ -221,19 +218,80 @@ export class FriendsProvider
     FriendTreeItem | GroupTreeItem | undefined
   >();
   private friends = new Map<string, FriendInfo>();
-  private isAuthenticated = false;
 
   readonly onDidChangeTreeData = this.onDidChangeTreeDataEmitter.event;
 
-  constructor(
-    private readonly authService: AuthService,
-    private readonly configManager: ConfigManager,
-    private readonly logger: Logger
-  ) {
+  constructor(private readonly logger: Logger) {
     this.disposables.push(this.onDidChangeTreeDataEmitter);
   }
 
-  // ... (keeping method order)
+  /**
+   * Returns a tree item for the given element.
+   */
+  getTreeItem(element: FriendTreeItem | GroupTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  /**
+   * Returns children for the given element or root elements if no element is provided.
+   */
+  getChildren(element?: FriendTreeItem | GroupTreeItem): (FriendTreeItem | GroupTreeItem)[] {
+    if (element instanceof GroupTreeItem) {
+      // Return friends filtered by the group's status
+      const statusGroup = element.statusGroup;
+      const friendsList = Array.from(this.friends.values());
+
+      if (statusGroup === 'all') {
+        return friendsList.map((friend) => new FriendTreeItem(friend));
+      }
+
+      return friendsList
+        .filter((friend) => friend.status === statusGroup)
+        .map((friend) => new FriendTreeItem(friend));
+    }
+
+    // Root level: return groups with counts
+    const friendsList = Array.from(this.friends.values());
+    const groups: GroupTreeItem[] = [];
+
+    const onlineCount = friendsList.filter((f) => f.status === 'online').length;
+    const idleCount = friendsList.filter((f) => f.status === 'idle').length;
+    const dndCount = friendsList.filter((f) => f.status === 'dnd').length;
+    const offlineCount = friendsList.filter((f) => f.status === 'offline').length;
+
+    if (onlineCount > 0) groups.push(new GroupTreeItem('online', onlineCount));
+    if (idleCount > 0) groups.push(new GroupTreeItem('idle', idleCount));
+    if (dndCount > 0) groups.push(new GroupTreeItem('dnd', dndCount));
+    if (offlineCount > 0) groups.push(new GroupTreeItem('offline', offlineCount));
+
+    return groups;
+  }
+
+  /**
+   * Refreshes the friends tree view.
+   */
+  refresh(): void {
+    this.onDidChangeTreeDataEmitter.fire(undefined);
+  }
+
+  /**
+   * Builds activity info from ActivityPayload.
+   */
+  private buildActivityInfo(activity: ActivityPayload): FriendInfo['activity'] {
+    const result: FriendInfo['activity'] = {
+      sessionDuration: activity.sessionDuration,
+    };
+    if (activity.fileName !== undefined) {
+      result.fileName = activity.fileName;
+    }
+    if (activity.language !== undefined) {
+      result.language = activity.language;
+    }
+    if (activity.project !== undefined) {
+      result.project = activity.project;
+    }
+    return result;
+  }
 
   /**
    * Handles friend status update from WebSocket.
@@ -284,55 +342,6 @@ export class FriendsProvider
     );
   }
 
-  /**
-   * Fetches friends list from server.
-   */
-  private async fetchFriends(): Promise<void> {
-    try {
-      const token = this.authService.getToken();
-      if (!token) {
-        return;
-      }
-
-      this.logger.debug('Fetching friends list from server...');
-      const serverUrl = this.configManager.get('serverUrl');
-
-      const response = await fetch(`${serverUrl}/api/v1/friends?limit=100`, {
-        headers: {
-          Authorization: `Bearer ${token}`,
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error(`Failed to fetch friends: ${String(response.status)}`);
-      }
-
-      const json = (await response.json()) as { data: any[] };
-      const friendsList = json.data;
-
-      this.friends.clear();
-
-      for (const friendData of friendsList) {
-        const friend: FriendInfo = {
-          id: friendData.id,
-          username: friendData.username,
-          displayName: friendData.displayName,
-          avatarUrl: friendData.avatarUrl,
-          status: friendData.status,
-          activity: friendData.activity,
-          lastUpdated: Date.now(),
-        };
-        this.friends.set(friend.id, friend);
-      }
-
-      this.onDidChangeTreeDataEmitter.fire(undefined);
-      this.logger.info(`Fetched ${String(this.friends.size)} friends`);
-    } catch (error) {
-      this.logger.error('Failed to fetch friends', error);
-      void vscode.window.showErrorMessage('DevRadar: Failed to load friends list');
-    }
-  }
-
   /**
    * Adds a friend to the list (called when receiving initial state).
    */

apps/extension/src/views/friendsProvider.ts

@@ -206,11 +206,11 @@ async function unsubscribeFromFriends(ws: AuthenticatedWebSocket): Promise<void>
 /**
  * Handle heartbeat message.
  */
-async function handleHeartbeat(
+function handleHeartbeat(
   ws: AuthenticatedWebSocket,
   payload: unknown,
   correlationId?: string
-): Promise<void> {
+): void {
   const result = HeartbeatMessageSchema.safeParse(payload);
 
   if (!result.success) {
@@ -311,7 +311,7 @@ async function handleMessage(ws: AuthenticatedWebSocket, data: string): Promise<
 
     switch (type) {
       case 'HEARTBEAT':
-        await handleHeartbeat(ws, payload, correlationId);
+        handleHeartbeat(ws, payload, correlationId);
         break;
 
       case 'STATUS_UPDATE':

apps/server/src/ws/handler.ts

@@ -17,6 +17,8 @@ export type RoleType = 'OWNER' | 'ADMIN' | 'MEMBER';
  * WebSocket message types.
  */
 export type MessageType =
+  | 'AUTH'
+  | 'AUTH_SUCCESS'
   | 'STATUS_UPDATE'
   | 'FRIEND_STATUS'
   | 'POKE'