fix: disabled message persistance until after release

src/components/PageComponents/Messages/MessageItem.tsx

@@ -5,100 +5,89 @@ import {
   TooltipProvider,
   TooltipTrigger,
 } from "@components/UI/Tooltip.tsx";
-import { useDevice, useDeviceStore } from "@core/stores/deviceStore.ts";
+import { useDevice } from "@core/stores/deviceStore.ts";
 import { cn } from "@core/utils/cn.ts";
 import { Avatar } from "@components/UI/Avatar.tsx";
 import { AlertCircle, CheckCircle2, CircleEllipsis } from "lucide-react";
 import type { LucideIcon } from "lucide-react";
 import { ReactNode, useMemo } from "react";
-import { Message, MessageState } from "../../../core/stores/messageStore/index.ts";
-import { Protobuf } from "@meshtastic/js";
-import { MessageActionsMenu } from "@components/PageComponents/Messages/MessageActionsMenu.tsx";
+import { MessageState, useMessageStore } from "@core/stores/messageStore/index.ts";
+import { Protobuf, Types } from "@meshtastic/js";
+import { Message } from "@core/stores/messageStore/types.ts";
+// import { MessageActionsMenu } from "@components/PageComponents/Messages/MessageActionsMenu.tsx"; // Uncomment if needed later
 
-interface MessageProps {
-  message: Message;
-  // locale?: string; // locale
-}
-
-interface MessageStatus {
-  state: MessageState;
+interface MessageStatusInfo {
   displayText: string;
   icon: LucideIcon;
   ariaLabel: string;
   iconClassName?: string;
 }
 
-const MESSAGE_STATUS: Record<MessageState, MessageStatus> = {
-  [MessageState.Ack]: { state: MessageState.Ack, displayText: "Message delivered", icon: CheckCircle2, ariaLabel: "Message delivered", iconClassName: "text-green-500 dark:text-green-500" },
-  [MessageState.Waiting]: { state: MessageState.Waiting, displayText: "Waiting for delivery", icon: CircleEllipsis, ariaLabel: "Sending message", iconClassName: "text-slate-400 dark:text-slate-400" },
-  [MessageState.Failed]: { state: MessageState.Failed, displayText: "Delivery failed", icon: AlertCircle, ariaLabel: "Message delivery failed", iconClassName: "text-red-500 dark:text-red-400" },
+const MESSAGE_STATUS_MAP: Record<MessageState, MessageStatusInfo> = {
+  [MessageState.Ack]: { displayText: "Message delivered", icon: CheckCircle2, ariaLabel: "Message delivered", iconClassName: "text-green-500" },
+  [MessageState.Waiting]: { displayText: "Waiting for delivery", icon: CircleEllipsis, ariaLabel: "Sending message", iconClassName: "text-slate-400" },
+  [MessageState.Failed]: { displayText: "Delivery failed", icon: AlertCircle, ariaLabel: "Message delivery failed", iconClassName: "text-red-500 dark:text-red-400" },
 };
 
-const getMessageStatus = (state: MessageState): MessageStatus =>
-  MESSAGE_STATUS[state] ?? { state: MessageState.Failed, displayText: "Unknown state", icon: AlertCircle, ariaLabel: "Message status unknown" };
+const UNKNOWN_STATUS: MessageStatusInfo = { displayText: "Unknown state", icon: AlertCircle, ariaLabel: "Message status unknown", iconClassName: "text-red-500 dark:text-red-400" };
 
-const StatusTooltip = ({ status, children }: { status: MessageStatus; children: ReactNode }) => (
+const getMessageStatusInfo = (state: MessageState): MessageStatusInfo =>
+  MESSAGE_STATUS_MAP[state] ?? UNKNOWN_STATUS;
+
+const StatusTooltip = ({ statusInfo, children }: { statusInfo: MessageStatusInfo; children: ReactNode }) => (
   <TooltipProvider delayDuration={300}>
     <Tooltip>
       <TooltipTrigger asChild>{children}</TooltipTrigger>
       <TooltipContent className="bg-slate-800 dark:bg-slate-600 text-white px-4 py-1 rounded text-xs">
-        {status.displayText}
+        {statusInfo.displayText}
         <TooltipArrow className="fill-slate-800" />
       </TooltipContent>
     </Tooltip>
   </TooltipProvider>
 );
 
-const StatusIcon = ({ status }: { status: MessageStatus }) => {
-  const Icon = status.icon;
-  const iconClass = cn("size-4 shrink-0", status.iconClassName);
-  return (
-    <StatusTooltip status={status}>
-      <span aria-label={status.ariaLabel} role="img">
-        <Icon className={iconClass} aria-hidden="true" />
-      </span>
-    </StatusTooltip>
-  );
-};
+interface MessageItemProps {
+  message: Message;
+}
 
-const TimeDisplay = ({ date, className }: { date: number; className?: string }) => {
-  const _date = useMemo(() => new Date(date), [date]);
-  const locale = 'en-US'; // TODO: Make dynamic
-  const formattedTime = useMemo(() => _date.toLocaleTimeString(locale, { hour: 'numeric', minute: '2-digit', hour12: true }), [_date, locale]);
-  const fullDate = useMemo(() => _date.toLocaleString(locale, { dateStyle: 'medium', timeStyle: 'short' }), [_date, locale]);
+export const MessageItem = ({ message }: MessageItemProps) => {
+  const { getNode } = useDevice();
+  const { getMyNodeNum } = useMessageStore()
+
+  const messageUser: Protobuf.Mesh.NodeInfo | null | undefined = useMemo(() => {
+    return message.from != null ? getNode(message.from) : null;
+  }, [getNode, message.from]);
 
-  return (
-    <time dateTime={_date.toISOString()} className={cn("text-xs", className)}>
-      <span aria-hidden="true">{formattedTime}</span>
-      <span className="sr-only">{fullDate}</span>
-    </time>
-  );
-};
 
-export const MessageItem = ({ message }: MessageProps) => {
-  const { getDevices } = useDeviceStore();
-  const { getNode } = useDevice()
-
-  const messageUser: Protobuf.Mesh.NodeInfo | null = useMemo(() => {
-    if (message?.from === null || message?.from === undefined) return null;
-    const fromNode = getNode(message.from);
-    if (fromNode) {
-      return fromNode ?? null;
-    }
-    return null;
-  }, [getDevices, message.from]);
-
-  const { shortName, displayName, } = useMemo(() => {
-    const fallbackName = message.from
+  const myNodeNum = useMemo(() => getMyNodeNum(), [getMyNodeNum]);
+  const { displayName, shortName } = useMemo(() => {
+    const userIdHex = message.from.toString(16).toUpperCase().padStart(2, '0');
+    const last4 = userIdHex.slice(-4);
+    const fallbackName = `Meshtastic ${last4}`
     const longName = messageUser?.user?.longName;
-    const shortName = messageUser?.user?.shortName ?? fallbackName;
-    const displayName = longName || fallbackName;
-    return { shortName, displayName, from: message.from };
+    const derivedShortName = messageUser?.user?.shortName || fallbackName;
+    const derivedDisplayName = longName || derivedShortName;
+    return { displayName: derivedDisplayName, shortName: derivedShortName };
   }, [messageUser, message.from]);
 
-  const messageStatus = getMessageStatus(message.state);
-  const messageText = message?.message ?? "";
-  const messageDate = message?.date;
+  const messageStatusInfo = getMessageStatusInfo(message.state);
+  const StatusIconComponent = messageStatusInfo.icon;
+
+  const messageDate = useMemo(() => message.date ? new Date(message.date) : null, [message.date]);
+  const locale = 'en-US'; // TODO: Make dynamic via props or context
+
+  const formattedTime = useMemo(() =>
+    messageDate?.toLocaleTimeString(locale, { hour: 'numeric', minute: '2-digit', hour12: true }) ?? '',
+    [messageDate, locale]);
+
+  const fullDateTime = useMemo(() =>
+    messageDate?.toLocaleString(locale, { dateStyle: 'medium', timeStyle: 'short' }) ?? '',
+    [messageDate, locale]);
+
+  const isSender = myNodeNum !== undefined && message.from === myNodeNum;
+  const isOnPrimaryChannel = message.channel === Types.ChannelNumber.Primary; // Use the enum
+  const shouldShowStatusIcon = isSender && isOnPrimaryChannel;
+
 
   const messageItemWrapperClass = cn(
     "group w-full py-2 relative list-none",
@@ -106,39 +95,48 @@ export const MessageItem = ({ message }: MessageProps) => {
     "hover:bg-slate-300/15 dark:hover:bg-slate-600/20",
     "transition-colors duration-100 ease-in-out",
   );
+  const dateTextStyle = "text-xs text-slate-500 dark:text-slate-400";
 
-  const gridGapClass = "gap-x-2";
-
-  const baseTextStyle = "text-sm text-slate-800 dark:text-slate-200";
-  const nameTextStyle = "font-medium text-slate-900 dark:text-slate-100 mr-2";
-  const dateTextStyle = "text-slate-500 dark:text-slate-400";
 
   return (
     <li className={messageItemWrapperClass}>
-      <div className={cn("grid grid-cols-[auto_1fr]", gridGapClass)}>
+      <div className="grid grid-cols-[auto_1fr] gap-x-2">
         <Avatar size="sm" text={shortName} className="pt-0.5" />
 
-        <div className="flex flex-col gap-1.5 min-w-0">
-          {messageDate != null ? (
-            <div className="flex items-center gap-1.5">
-              <span className={nameTextStyle} aria-hidden="true">
-                {displayName}
-              </span>
-              <TimeDisplay date={messageDate} className={dateTextStyle} />
-              <StatusIcon status={messageStatus} />
-            </div>
-          ) : null}
-
-          <div className={cn(baseTextStyle, "whitespace-pre-wrap")}>
-            {messageText}
+        <div className="flex flex-col gap-0.5 min-w-0">
+          <div className="flex items-center gap-1.5">
+            <span className="font-medium text-sm text-slate-900 dark:text-slate-100 truncate mr-1">
+              {displayName}
+            </span>
+            {messageDate && (
+              <time dateTime={messageDate.toISOString()} className={dateTextStyle}>
+                <span aria-hidden="true">{formattedTime}</span>
+                <span className="sr-only">{fullDateTime}</span>
+              </time>
+            )}
+            {shouldShowStatusIcon && (
+              <StatusTooltip statusInfo={messageStatusInfo}>
+                <span aria-label={messageStatusInfo.ariaLabel} role="img">
+                  <StatusIconComponent
+                    className={cn("size-4 shrink-0", messageStatusInfo.iconClassName)}
+                    aria-hidden="true"
+                  />
+                </span>
+              </StatusTooltip>
+            )}
           </div>
 
+          {message?.message && (
+            <div className="text-sm text-slate-800 dark:text-slate-200 whitespace-pre-wrap break-words">
+              {message.message}
+            </div>
+          )}
         </div>
       </div>
-      {/* TODO: Restore when reactions/emojis are functional  */}
-      {/* <MessageActionsMenu
-        onReply={() => console.log("Reply to message:", message.messageId)}
-      /> */}
+      {/* Actions Menu Placeholder */}
+      {/* <div className="absolute top-1 right-1">
+        <MessageActionsMenu onReply={() => console.log("Reply")} />
+       </div> */}
     </li>
   );
 };

src/components/PageLayout.tsx

@@ -48,7 +48,7 @@ export const PageLayout = ({
         {leftBar && (
           <aside
             className={cn(
-              "px-2 shrink-0 border-r-[0.5px] border-slate-300 dark:border-slate-700 ",
+              "px-2 pr-0 shrink-0 border-r-[0.5px] border-slate-300 dark:border-slate-700 ",
               leftBarClassName
             )}
           >
@@ -113,7 +113,7 @@ export const PageLayout = ({
         {rightBar && (
           <aside
             className={cn(
-              "w-64 shrink-0 border-l border-slate-300 dark:border-slate-700 px-2 overflow-hidden",
+              "w-48 lg:w-[270px] shrink-0 border-l border-slate-300 dark:border-slate-700 px-2 overflow-hidden",
               rightBarClassName
             )}
           >

src/components/Sidebar.tsx

@@ -46,7 +46,7 @@ const CollapseToggleButton = () => {
       aria-label={buttonLabel}
       onClick={toggleSidebar}
       className={cn(
-        'absolute top-21 -right-2 z-10 p-0.5 rounded-full transform translate-x-1/2',
+        'absolute top-20 right-0 z-10 p-0.5 rounded-full transform translate-x-1/2',
         'transition-colors duration-300 ease-in-out',
         'border border-slate-300 dark:border-slate-200',
         'text-slate-500 dark:text-slate-200 hover:text-slate-400 dark:hover:text-slate-400',
@@ -137,7 +137,6 @@ export const Sidebar = ({ children }: SidebarProps) => {
       </SidebarSection>
 
       <div className={cn(
-        '',
         'flex-1 min-h-0',
         isCollapsed && 'overflow-hidden'
       )}

src/core/stores/messageStore/index.ts

@@ -50,163 +50,163 @@ export interface MessageStore {
 const CURRENT_STORE_VERSION = 0;
 
 export const useMessageStore = create<MessageStore>()(
-  persist(
-    (set, get) => ({
-      messages: {
-        direct: new Map<ConversationId, MessageLogMap>(),
-        broadcast: new Map<ChannelId, MessageLogMap>(),
-      },
-      draft: new Map<number, string>(),
-      activeChat: 0,
-      chatType: MessageType.Broadcast,
-      nodeNum: 0,
-      setNodeNum: (nodeNum) => {
-        set(produce((state: MessageStore) => {
-          state.nodeNum = nodeNum;
-        }));
-      },
-      getMyNodeNum: () => get().nodeNum,
-      setActiveChat: (chat) => {
-        set(produce((state: MessageStore) => {
-          state.activeChat = chat;
-        }));
-      },
-      setChatType: (type) => {
-        set(produce((state: MessageStore) => {
-          state.chatType = type;
-        }));
-      },
-      saveMessage: (message: Message) => {
-        set(
-          produce((state: MessageStore) => {
-            if (message.type === MessageType.Direct) {
-              const conversationId = getConversationId(message.from, message.to);
-              if (!state.messages.direct.has(conversationId)) {
-                state.messages.direct.set(conversationId, new Map<MessageId, Message>());
-              }
-              state.messages.direct.get(conversationId)!.set(message.messageId, message);
-            } else if (message.type === MessageType.Broadcast) {
-              const channelId = message.channel as ChannelId;
-              if (!state.messages.broadcast.has(channelId)) {
-                state.messages.broadcast.set(channelId, new Map<MessageId, Message>());
-              }
-              state.messages.broadcast.get(channelId)!.set(message.messageId, message);
+  // persist(
+  (set, get) => ({
+    messages: {
+      direct: new Map<ConversationId, MessageLogMap>(),
+      broadcast: new Map<ChannelId, MessageLogMap>(),
+    },
+    draft: new Map<number, string>(),
+    activeChat: 0,
+    chatType: MessageType.Broadcast,
+    nodeNum: 0,
+    setNodeNum: (nodeNum) => {
+      set(produce((state: MessageStore) => {
+        state.nodeNum = nodeNum;
+      }));
+    },
+    getMyNodeNum: () => get().nodeNum,
+    setActiveChat: (chat) => {
+      set(produce((state: MessageStore) => {
+        state.activeChat = chat;
+      }));
+    },
+    setChatType: (type) => {
+      set(produce((state: MessageStore) => {
+        state.chatType = type;
+      }));
+    },
+    saveMessage: (message: Message) => {
+      set(
+        produce((state: MessageStore) => {
+          if (message.type === MessageType.Direct) {
+            const conversationId = getConversationId(message.from, message.to);
+            if (!state.messages.direct.has(conversationId)) {
+              state.messages.direct.set(conversationId, new Map<MessageId, Message>());
             }
-          })
-        );
-      },
-
-      setMessageState: (params: SetMessageStateParams) => {
-        set(
-          produce((state: MessageStore) => {
-            let messageLog: MessageLogMap | undefined;
-            let targetMessage: Message | undefined;
-
-            if (params.type === MessageType.Direct) {
-              const conversationId = getConversationId(params.nodeA, params.nodeB);
-              messageLog = state.messages.direct.get(conversationId);
-              if (messageLog) {
-                targetMessage = messageLog.get(params.messageId);
-              }
-            } else { // Broadcast
-              messageLog = state.messages.broadcast.get(params.channelId);
-              if (messageLog) {
-                targetMessage = messageLog.get(params.messageId);
-              }
+            state.messages.direct.get(conversationId)!.set(message.messageId, message);
+          } else if (message.type === MessageType.Broadcast) {
+            const channelId = message.channel as ChannelId;
+            if (!state.messages.broadcast.has(channelId)) {
+              state.messages.broadcast.set(channelId, new Map<MessageId, Message>());
             }
-
-            if (targetMessage) {
-              targetMessage.state = params.newState ?? MessageState.Ack;
-            } else {
-              console.warn(`Message or conversation/channel not found for state update. Params: ${JSON.stringify(params)}`);
+            state.messages.broadcast.get(channelId)!.set(message.messageId, message);
+          }
+        })
+      );
+    },
+
+    setMessageState: (params: SetMessageStateParams) => {
+      set(
+        produce((state: MessageStore) => {
+          let messageLog: MessageLogMap | undefined;
+          let targetMessage: Message | undefined;
+
+          if (params.type === MessageType.Direct) {
+            const conversationId = getConversationId(params.nodeA, params.nodeB);
+            messageLog = state.messages.direct.get(conversationId);
+            if (messageLog) {
+              targetMessage = messageLog.get(params.messageId);
             }
-          })
-        );
-      },
-      getMessages: (params: GetMessagesParams): Message[] => {
-        const state = get();
-        let messageMap: MessageLogMap | undefined;
-
-        if (params.type === MessageType.Direct) {
-          const conversationId = getConversationId(params.nodeA, params.nodeB);
-          messageMap = state.messages.direct.get(conversationId);
-
-        } else {
-          messageMap = state.messages.broadcast.get(params.channelId);
-        }
-
-        if (messageMap === undefined) {
-          return [];
-        }
-
-        const messagesArray = Array.from(messageMap.values());
-        messagesArray.sort((a, b) => a.date - b.date);
-        return messagesArray;
-      },
-
-      clearMessageByMessageId: (params: ClearMessageParams) => {
-        set(
-          produce((state: MessageStore) => {
-            let messageLog: MessageLogMap | undefined;
-            let parentMap: Map<ConversationId | ChannelId, MessageLogMap>;
-            let parentKey: ConversationId | ChannelId;
-
-            if (params.type === MessageType.Direct) {
-              parentKey = getConversationId(params.nodeA, params.nodeB);
-              parentMap = state.messages.direct;
-              messageLog = parentMap.get(parentKey);
-            } else {
-              parentKey = params.channelId;
-              parentMap = state.messages.broadcast;
-              messageLog = parentMap.get(parentKey);
+          } else { // Broadcast
+            messageLog = state.messages.broadcast.get(params.channelId);
+            if (messageLog) {
+              targetMessage = messageLog.get(params.messageId);
             }
+          }
+
+          if (targetMessage) {
+            targetMessage.state = params.newState ?? MessageState.Ack;
+          } else {
+            console.warn(`Message or conversation/channel not found for state update. Params: ${JSON.stringify(params)}`);
+          }
+        })
+      );
+    },
+    getMessages: (params: GetMessagesParams): Message[] => {
+      const state = get();
+      let messageMap: MessageLogMap | undefined;
+
+      if (params.type === MessageType.Direct) {
+        const conversationId = getConversationId(params.nodeA, params.nodeB);
+        messageMap = state.messages.direct.get(conversationId);
+
+      } else {
+        messageMap = state.messages.broadcast.get(params.channelId);
+      }
 
-            if (messageLog) {
-              const deleted = messageLog.delete(params.messageId);
-
-              if (deleted) {
-                console.log(`Deleted message ${params.messageId} from ${params.type} message ${parentKey}`);
-                // Clean up empty MessageLogMap and its entry in the parent map
-                if (messageLog.size === 0) {
-                  parentMap.delete(parentKey);
-                  console.log(`Cleaned up empty message entry for ${parentKey}`);
-                }
-              } else {
-                console.warn(`Message ${params.messageId} not found in ${params.type} chat ${parentKey} for deletion.`);
+      if (messageMap === undefined) {
+        return [];
+      }
+
+      const messagesArray = Array.from(messageMap.values());
+      messagesArray.sort((a, b) => a.date - b.date);
+      return messagesArray;
+    },
+
+    clearMessageByMessageId: (params: ClearMessageParams) => {
+      set(
+        produce((state: MessageStore) => {
+          let messageLog: MessageLogMap | undefined;
+          let parentMap: Map<ConversationId | ChannelId, MessageLogMap>;
+          let parentKey: ConversationId | ChannelId;
+
+          if (params.type === MessageType.Direct) {
+            parentKey = getConversationId(params.nodeA, params.nodeB);
+            parentMap = state.messages.direct;
+            messageLog = parentMap.get(parentKey);
+          } else {
+            parentKey = params.channelId;
+            parentMap = state.messages.broadcast;
+            messageLog = parentMap.get(parentKey);
+          }
+
+          if (messageLog) {
+            const deleted = messageLog.delete(params.messageId);
+
+            if (deleted) {
+              console.log(`Deleted message ${params.messageId} from ${params.type} message ${parentKey}`);
+              // Clean up empty MessageLogMap and its entry in the parent map
+              if (messageLog.size === 0) {
+                parentMap.delete(parentKey);
+                console.log(`Cleaned up empty message entry for ${parentKey}`);
               }
             } else {
-              console.warn(`Message entry ${parentKey} not found for message deletion.`);
+              console.warn(`Message ${params.messageId} not found in ${params.type} chat ${parentKey} for deletion.`);
             }
-          })
-        );
-      },
-      getDraft: (key) => {
-        return get().draft.get(key) ?? '';
-      },
-      setDraft: (key, message) => {
-        set(produce((state: MessageStore) => {
-          state.draft.set(key, message);
-        }));
-      },
-      clearDraft: (key) => {
-        set(produce((state: MessageStore) => {
-          state.draft.delete(key);
-        }));
-      },
-      deleteAllMessages: () => {
-        set(produce((state: MessageStore) => {
-          state.messages.direct = new Map<ConversationId, MessageLogMap>();
-          state.messages.broadcast = new Map<ChannelId, MessageLogMap>();
-        }));
-      }
-    }),
-    {
-      name: 'meshtastic-message-store',
-      storage: storageWithMapSupport,
-      version: CURRENT_STORE_VERSION,
-      partialize: (state) => ({
-        messages: state.messages,
-        nodeNum: state.nodeNum,
-      }),
-    })
+          } else {
+            console.warn(`Message entry ${parentKey} not found for message deletion.`);
+          }
+        })
+      );
+    },
+    getDraft: (key) => {
+      return get().draft.get(key) ?? '';
+    },
+    setDraft: (key, message) => {
+      set(produce((state: MessageStore) => {
+        state.draft.set(key, message);
+      }));
+    },
+    clearDraft: (key) => {
+      set(produce((state: MessageStore) => {
+        state.draft.delete(key);
+      }));
+    },
+    deleteAllMessages: () => {
+      set(produce((state: MessageStore) => {
+        state.messages.direct = new Map<ConversationId, MessageLogMap>();
+        state.messages.broadcast = new Map<ChannelId, MessageLogMap>();
+      }));
+    }
+  }),
+  // {
+  //   name: 'meshtastic-message-store',
+  //   storage: storageWithMapSupport,
+  //   version: CURRENT_STORE_VERSION,
+  //   partialize: (state) => ({
+  //     messages: state.messages,
+  //     nodeNum: state.nodeNum,
+  //   }),
+  // })
 )

src/core/stores/messageStore/types.ts

@@ -7,7 +7,7 @@ type ChannelId = Types.ChannelNumber;
 type ConversationId = string;
 type MessageLogMap = Map<MessageId, Message>;
 
-export interface MessageBase {
+interface MessageBase {
   channel: Types.ChannelNumber;
   to: number;
   from: number;
@@ -21,7 +21,7 @@ interface GenericMessage<T extends MessageType> extends MessageBase {
   type: T;
 }
 
-export type Message = GenericMessage<MessageType.Direct> | GenericMessage<MessageType.Broadcast>;
+type Message = GenericMessage<MessageType.Direct> | GenericMessage<MessageType.Broadcast>;
 
 
 type GetMessagesParams =
@@ -58,6 +58,7 @@ type ClearMessageParams =
   };
 
 export type {
+  Message,
   ConversationId,
   NodeNum,
   MessageLogMap,

src/core/subscriptions.ts

@@ -69,10 +69,8 @@ export const subscribeAll = (
   });
 
   connection.events.onNodeInfoPacket.subscribe((nodeInfo) => {
-    // const nodeWithUser = NodeInfoFactory.ensureDefaultUser(nodeInfo);
-    // console.log("Node Info", nodeWithUser);
-
-    device.addNodeInfo(nodeInfo);
+    const nodeWithUser = NodeInfoFactory.ensureDefaultUser(nodeInfo);
+    device.addNodeInfo(nodeWithUser);
   });
 
   connection.events.onChannelPacket.subscribe((channel) => {