@decentnetwork/lan 0.1.86 → 0.1.87

package/dist/carrier/peer-manager.d.ts

@@ -33,6 +33,12 @@ export declare class PeerManager extends EventEmitter {
      * pubkey is a no-op at the SDK level.
      */
     acceptFriendRequest(pubkey: string): Promise<void>;
+    /**
+     * Remove a friend (by userid/pubkey). Drops them from the Carrier friend
+     * store (and persists the shrunk list). Returns true if a friend was
+     * removed, false if no such friend existed.
+     */
+    removeFriend(userid: string): boolean;
     /**
      * Send an outbound friend request to a Carrier address (NOT a bare
      * userid — sendFriendRequest needs the address form because it

package/dist/carrier/peer-manager.js

@@ -78,6 +78,20 @@ export class PeerManager extends EventEmitter {
         await this.peer.acceptFriendRequest(pubkey);
         this.logger.info(`Accepted friend request from ${pubkey}`);
     }
+    /**
+     * Remove a friend (by userid/pubkey). Drops them from the Carrier friend
+     * store (and persists the shrunk list). Returns true if a friend was
+     * removed, false if no such friend existed.
+     */
+    removeFriend(userid) {
+        if (!this.peer) {
+            throw new Error("Peer not created. Call create() first.");
+        }
+        const removed = this.peer.removeFriend(userid);
+        if (removed)
+            this.logger.info(`Removed friend ${userid}`);
+        return removed;
+    }
     /**
      * Send an outbound friend request to a Carrier address (NOT a bare
      * userid — sendFriendRequest needs the address form because it

package/dist/cli/commands.d.ts

@@ -232,6 +232,18 @@ export declare function cmdProxyUse(args: {
  * `friends.autoAccept: false` (otherwise requests are accepted instantly and
  * never queue).
  */
+/** Remove (unfriend) a peer by userid — drops the Carrier friend, local alias,
+ *  and stored messages. Requires the daemon running. */
+export declare function cmdFriendRemove(args: {
+    userid: string;
+    configDir?: string;
+}): Promise<void>;
+/** Set (or clear, with empty string) a local display alias for a friend. */
+export declare function cmdFriendAlias(args: {
+    userid: string;
+    alias: string;
+    configDir?: string;
+}): Promise<void>;
 /**
  * Send a text message (native Carrier chat, packet 64) to a friend by userid.
  * Routed through the running daemon's Carrier identity over IPC — the daemon

package/dist/cli/commands.js

@@ -1049,6 +1049,25 @@ export async function cmdProxyUse(args) {
  * `friends.autoAccept: false` (otherwise requests are accepted instantly and
  * never queue).
  */
+/** Remove (unfriend) a peer by userid — drops the Carrier friend, local alias,
+ *  and stored messages. Requires the daemon running. */
+export async function cmdFriendRemove(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    const res = await ipcCall(config, { op: "friend-remove", userid: args.userid });
+    if (!res.ok)
+        throw new Error(`Daemon refused: ${res.error}`);
+    console.log(`Removed friend ${args.userid.slice(0, 16)}…`);
+}
+/** Set (or clear, with empty string) a local display alias for a friend. */
+export async function cmdFriendAlias(args) {
+    const dir = args.configDir || ConfigLoader.defaultConfigDir();
+    const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+    const res = await ipcCall(config, { op: "friend-set-alias", userid: args.userid, alias: args.alias });
+    if (!res.ok)
+        throw new Error(`Daemon refused: ${res.error}`);
+    console.log(args.alias ? `Alias set: ${args.userid.slice(0, 12)}… → ${args.alias}` : `Alias cleared for ${args.userid.slice(0, 12)}…`);
+}
 /**
  * Send a text message (native Carrier chat, packet 64) to a friend by userid.
  * Routed through the running daemon's Carrier identity over IPC — the daemon

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // Belt-and-braces — also raise it here in case the CLI is run directly
 // (e.g. `node dist/cli/index.js` rather than via dist/index.js).
 EventEmitter.defaultMaxListeners = 100;
-import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdChatSend, cmdChatHistory, } from "./commands.js";
+import { cmdInit, cmdIdentityShow, cmdPeersList, cmdIpamAssign, cmdGrant, cmdRevoke, cmdResolve, cmdStatus, cmdUp, cmdAuditLog, cmdFriendRequest, cmdFriendAccept, cmdFriendsList, cmdFriendsPending, cmdFriendsAccept, cmdFriendsReject, cmdProxyEnable, cmdProxyDisable, cmdProxyStatus, cmdProxyAllowHost, cmdProxyRevokeHost, cmdProxyListHosts, cmdProxyUse, cmdProxyRouter, cmdDoraEnable, cmdDoraDisable, cmdDoraStatus, cmdDoraAutofriend, cmdDiag, cmdDoctor, cmdDnsInstall, cmdDnsHosts, cmdServiceInstall, cmdRestart, cmdServiceStatus, cmdServiceRestart, cmdUi, cmdChatSend, cmdChatHistory, cmdFriendRemove, cmdFriendAlias, } from "./commands.js";
 async function main() {
     await yargs(hideBin(process.argv))
         .scriptName("agentnet")
@@ -239,6 +239,17 @@ async function main() {
         if (!argv.userid)
             throw new Error("userid is required (positional or --userid)");
         await cmdFriendsReject({ userid: argv.userid, configDir: argv["config-dir"] });
+    })
+        .command("remove <userid>", "Remove (unfriend) a peer — drops the friend, alias, and stored messages", (yy) => yy
+        .positional("userid", { type: "string", demandOption: true, describe: "Friend's Carrier userid" })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdFriendRemove({ userid: argv.userid, configDir: argv["config-dir"] });
+    })
+        .command("alias <userid> <alias>", "Set a local display name for a friend (empty alias clears it)", (yy) => yy
+        .positional("userid", { type: "string", demandOption: true, describe: "Friend's Carrier userid" })
+        .positional("alias", { type: "string", demandOption: true, describe: "Local display name" })
+        .option("config-dir", { type: "string" }), async (argv) => {
+        await cmdFriendAlias({ userid: argv.userid, alias: argv.alias, configDir: argv["config-dir"] });
     })
         .demandCommand(1, "Specify a friends subcommand (run 'agentnet friends --help')"), () => {
         // parent handler — never invoked because demandCommand above

package/dist/daemon/friend-meta.d.ts

@@ -0,0 +1,36 @@
+/**
+ * On-disk friend metadata — local-only UI state that the Carrier friend store
+ * doesn't hold (PRD-DESKTOP-UI §2.2): a local alias, a read cursor for unread
+ * badges, pin/order, and when we added them.
+ *
+ * File: <configDir>/friends-meta.json  ->  { userid: FriendMeta }
+ * Keyed by userid. Identity/accept-state still lives in the Carrier friend
+ * store; this only augments it for display.
+ */
+export interface FriendMeta {
+    userid: string;
+    /** Local display name; falls back to the userid in the UI when absent. */
+    alias?: string;
+    pinned?: boolean;
+    /** ts of the newest message the user has seen — drives unread counts. */
+    lastReadTs?: number;
+    addedAt: number;
+}
+export declare class FriendMetaStore {
+    private path;
+    private byUserid;
+    private logger;
+    private saveTimer?;
+    private dirty;
+    constructor(path: string);
+    private load;
+    get(userid: string): FriendMeta;
+    /** Ensure an entry exists (first time we see a friend). */
+    ensure(userid: string): FriendMeta;
+    setAlias(userid: string, alias: string | undefined): void;
+    markRead(userid: string, ts?: number): void;
+    setPinned(userid: string, pinned: boolean): void;
+    remove(userid: string): void;
+    private scheduleSave;
+    flush(): void;
+}

package/dist/daemon/friend-meta.js

@@ -0,0 +1,97 @@
+/**
+ * On-disk friend metadata — local-only UI state that the Carrier friend store
+ * doesn't hold (PRD-DESKTOP-UI §2.2): a local alias, a read cursor for unread
+ * badges, pin/order, and when we added them.
+ *
+ * File: <configDir>/friends-meta.json  ->  { userid: FriendMeta }
+ * Keyed by userid. Identity/accept-state still lives in the Carrier friend
+ * store; this only augments it for display.
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { Logger } from "../utils/logger.js";
+export class FriendMetaStore {
+    path;
+    byUserid = new Map();
+    logger = new Logger({ prefix: "FriendMeta" });
+    saveTimer;
+    dirty = false;
+    constructor(path) {
+        this.path = path;
+        this.load();
+    }
+    load() {
+        if (!existsSync(this.path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.path, "utf-8"));
+            for (const [userid, meta] of Object.entries(raw)) {
+                if (meta && typeof meta === "object")
+                    this.byUserid.set(userid, { ...meta, userid });
+            }
+            this.logger.info(`Loaded metadata for ${this.byUserid.size} friends`);
+        }
+        catch (err) {
+            this.logger.warn(`Could not load ${this.path}: ${err}`);
+        }
+    }
+    get(userid) {
+        return this.byUserid.get(userid) ?? { userid, addedAt: Date.now() };
+    }
+    /** Ensure an entry exists (first time we see a friend). */
+    ensure(userid) {
+        let m = this.byUserid.get(userid);
+        if (!m) {
+            m = { userid, addedAt: Date.now() };
+            this.byUserid.set(userid, m);
+            this.scheduleSave();
+        }
+        return m;
+    }
+    setAlias(userid, alias) {
+        const m = this.ensure(userid);
+        m.alias = alias && alias.trim() ? alias.trim() : undefined;
+        this.scheduleSave();
+    }
+    markRead(userid, ts = Date.now()) {
+        const m = this.ensure(userid);
+        if (!m.lastReadTs || ts > m.lastReadTs) {
+            m.lastReadTs = ts;
+            this.scheduleSave();
+        }
+    }
+    setPinned(userid, pinned) {
+        const m = this.ensure(userid);
+        m.pinned = pinned || undefined;
+        this.scheduleSave();
+    }
+    remove(userid) {
+        if (this.byUserid.delete(userid))
+            this.scheduleSave();
+    }
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.flush();
+        }, 1000);
+        this.saveTimer.unref?.();
+    }
+    flush() {
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        try {
+            const obj = {};
+            for (const [u, m] of this.byUserid)
+                obj[u] = m;
+            const tmp = `${this.path}.tmp`;
+            writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf-8");
+            renameSync(tmp, this.path);
+        }
+        catch (err) {
+            this.logger.warn(`Could not save ${this.path}: ${err}`);
+        }
+    }
+}

package/dist/daemon/ipc.d.ts

@@ -41,8 +41,18 @@ export interface IpcHandlers {
     friendsReject: (userid: string) => Promise<void>;
     /** Send a chat message (Carrier text, packet 64) to a friend and log it. */
     chatSend: (userid: string, text: string) => Promise<void>;
-    /** Return recent chat history grouped by friend userid. */
-    chatHistory: () => Promise<Record<string, unknown>>;
+    /** Return persisted chat history. With `peer`, returns just that thread and
+     *  honours `before`/`limit` pagination; without, every thread (legacy shape). */
+    chatHistory: (peer?: string, before?: number, limit?: number) => Promise<Record<string, unknown>>;
+    /** Friend list for the UI: userid, alias, status, lastSeen, last message
+     *  preview, and unread count (from friends-meta + the message store). */
+    friendsList: () => Promise<Record<string, unknown>>;
+    /** Remove a friend (Carrier friend store + local meta + their messages). */
+    friendRemove: (userid: string) => Promise<void>;
+    /** Set/clear a local display alias for a friend. */
+    friendSetAlias: (userid: string, alias?: string) => Promise<void>;
+    /** Mark a conversation read up to `ts` (defaults to now) — clears unread. */
+    chatMarkRead: (userid: string, ts?: number) => Promise<void>;
     /** Re-read proxy allowlist from config and apply it to the running
      *  proxy WITHOUT restarting the daemon. Lets `agentnet proxy
      *  allow-host` take effect instantly instead of forcing a daemon
@@ -59,11 +69,15 @@ export interface IpcHandlers {
     selfRestart: () => Promise<Record<string, unknown>>;
 }
 export interface IpcRequest {
-    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "proxy-reload" | "self-restart";
+    op: "friend-request" | "ping" | "diag" | "friends-pending" | "friends-accept" | "friends-reject" | "chat-send" | "chat-history" | "friends-list" | "friend-remove" | "friend-set-alias" | "chat-mark-read" | "proxy-reload" | "self-restart";
     address?: string;
     hello?: string;
     userid?: string;
     text?: string;
+    alias?: string;
+    before?: number;
+    limit?: number;
+    ts?: number;
 }
 export interface IpcResponseOk {
     ok: true;

package/dist/daemon/ipc.js

@@ -151,7 +151,27 @@ export class IpcServer {
                 return;
             }
             case "chat-history":
-                return await this.handlers.chatHistory();
+                return await this.handlers.chatHistory(req.userid, req.before, req.limit);
+            case "friends-list":
+                return await this.handlers.friendsList();
+            case "friend-remove": {
+                if (!req.userid)
+                    throw new Error("userid is required");
+                await this.handlers.friendRemove(req.userid);
+                return;
+            }
+            case "friend-set-alias": {
+                if (!req.userid)
+                    throw new Error("userid is required");
+                await this.handlers.friendSetAlias(req.userid, req.alias);
+                return;
+            }
+            case "chat-mark-read": {
+                if (!req.userid)
+                    throw new Error("userid is required");
+                await this.handlers.chatMarkRead(req.userid, req.ts);
+                return;
+            }
             case "proxy-reload":
                 return await this.handlers.proxyReload();
             case "self-restart":

package/dist/daemon/message-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * On-disk chat message store. Replaces the previous in-memory-only chatLog so
+ * conversations survive a daemon restart (PRD-DESKTOP-UI §2.1).
+ *
+ * Format: a single JSON file at <configDir>/messages.json mapping
+ *   userid -> ChatMessage[]   (oldest first)
+ * Loaded fully into memory on start; writes are debounced and atomic
+ * (write tmp + rename). Text chat is low-volume, so a JSON file is plenty;
+ * swap for SQLite later if threads get large (PRD §9).
+ */
+export interface ChatMessage {
+    dir: "in" | "out";
+    text: string;
+    ts: number;
+    /** Stable per-message id (ts + per-process sequence) for UI keys / dedup. */
+    id: string;
+}
+export declare class MessageStore {
+    private path;
+    private byPeer;
+    private logger;
+    private saveTimer?;
+    private dirty;
+    private seq;
+    constructor(path: string);
+    private load;
+    /** Append a message and schedule a flush. Returns the stored message. */
+    append(peer: string, dir: "in" | "out", text: string, ts?: number): ChatMessage;
+    /**
+     * Return history. With no peer, returns every peer's full thread (the legacy
+     * chat-history shape). With a peer, supports pagination: `limit` newest
+     * messages, optionally those strictly older than `before` (ms) for "load
+     * earlier" scrolling.
+     */
+    history(peer?: string, opts?: {
+        before?: number;
+        limit?: number;
+    }): Record<string, ChatMessage[]>;
+    /** Most recent message per peer — for the friend-list preview/sort. */
+    lastMessages(): Map<string, ChatMessage>;
+    /** Count messages newer than `sinceTs` for a peer (unread badge). */
+    unreadCount(peer: string, sinceTs: number): number;
+    removePeer(peer: string): void;
+    private scheduleSave;
+    /** Force a synchronous flush (called on debounce + on daemon shutdown). */
+    flush(): void;
+}

package/dist/daemon/message-store.js

@@ -0,0 +1,133 @@
+/**
+ * On-disk chat message store. Replaces the previous in-memory-only chatLog so
+ * conversations survive a daemon restart (PRD-DESKTOP-UI §2.1).
+ *
+ * Format: a single JSON file at <configDir>/messages.json mapping
+ *   userid -> ChatMessage[]   (oldest first)
+ * Loaded fully into memory on start; writes are debounced and atomic
+ * (write tmp + rename). Text chat is low-volume, so a JSON file is plenty;
+ * swap for SQLite later if threads get large (PRD §9).
+ */
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { Logger } from "../utils/logger.js";
+/** Keep at most this many messages per peer on disk; older ones roll off. */
+const MAX_PER_PEER = 2000;
+/** Debounce window for flushing to disk after a change. */
+const SAVE_DEBOUNCE_MS = 1000;
+export class MessageStore {
+    path;
+    byPeer = new Map();
+    logger = new Logger({ prefix: "MessageStore" });
+    saveTimer;
+    dirty = false;
+    seq = 0;
+    constructor(path) {
+        this.path = path;
+        this.load();
+    }
+    load() {
+        if (!existsSync(this.path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.path, "utf-8"));
+            let total = 0;
+            for (const [peer, msgs] of Object.entries(raw)) {
+                if (Array.isArray(msgs)) {
+                    this.byPeer.set(peer, msgs);
+                    total += msgs.length;
+                }
+            }
+            this.logger.info(`Loaded ${total} messages across ${this.byPeer.size} peers`);
+        }
+        catch (err) {
+            this.logger.warn(`Could not load ${this.path}: ${err}`);
+        }
+    }
+    /** Append a message and schedule a flush. Returns the stored message. */
+    append(peer, dir, text, ts = Date.now()) {
+        const msg = { dir, text, ts, id: `${ts}-${this.seq++}` };
+        let arr = this.byPeer.get(peer);
+        if (!arr) {
+            arr = [];
+            this.byPeer.set(peer, arr);
+        }
+        arr.push(msg);
+        if (arr.length > MAX_PER_PEER)
+            arr.splice(0, arr.length - MAX_PER_PEER);
+        this.scheduleSave();
+        return msg;
+    }
+    /**
+     * Return history. With no peer, returns every peer's full thread (the legacy
+     * chat-history shape). With a peer, supports pagination: `limit` newest
+     * messages, optionally those strictly older than `before` (ms) for "load
+     * earlier" scrolling.
+     */
+    history(peer, opts = {}) {
+        const out = {};
+        const peers = peer ? [peer] : [...this.byPeer.keys()];
+        for (const p of peers) {
+            let arr = this.byPeer.get(p) ?? [];
+            if (opts.before !== undefined)
+                arr = arr.filter((m) => m.ts < opts.before);
+            if (opts.limit !== undefined && arr.length > opts.limit)
+                arr = arr.slice(arr.length - opts.limit);
+            out[p] = arr;
+        }
+        return out;
+    }
+    /** Most recent message per peer — for the friend-list preview/sort. */
+    lastMessages() {
+        const out = new Map();
+        for (const [p, arr] of this.byPeer) {
+            if (arr.length)
+                out.set(p, arr[arr.length - 1]);
+        }
+        return out;
+    }
+    /** Count messages newer than `sinceTs` for a peer (unread badge). */
+    unreadCount(peer, sinceTs) {
+        const arr = this.byPeer.get(peer);
+        if (!arr)
+            return 0;
+        let n = 0;
+        for (let i = arr.length - 1; i >= 0; i--) {
+            if (arr[i].ts <= sinceTs)
+                break;
+            if (arr[i].dir === "in")
+                n++;
+        }
+        return n;
+    }
+    removePeer(peer) {
+        if (this.byPeer.delete(peer))
+            this.scheduleSave();
+    }
+    scheduleSave() {
+        this.dirty = true;
+        if (this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = undefined;
+            this.flush();
+        }, SAVE_DEBOUNCE_MS);
+        this.saveTimer.unref?.();
+    }
+    /** Force a synchronous flush (called on debounce + on daemon shutdown). */
+    flush() {
+        if (!this.dirty)
+            return;
+        this.dirty = false;
+        try {
+            const obj = {};
+            for (const [p, m] of this.byPeer)
+                obj[p] = m;
+            const tmp = `${this.path}.tmp`;
+            writeFileSync(tmp, JSON.stringify(obj), "utf-8");
+            renameSync(tmp, this.path);
+        }
+        catch (err) {
+            this.logger.warn(`Could not save ${this.path}: ${err}`);
+        }
+    }
+}

package/dist/daemon/server.d.ts

@@ -35,7 +35,8 @@ export declare class DaemonServer {
     private pendingFriends?;
     /** In-memory chat history, keyed by friend userid (last 200 each). Drives
      *  the `agentnet ui` chat window; not persisted across restarts. */
-    private chatLog;
+    private messageStore?;
+    private friendMeta?;
     private startedAt;
     private isRunning;
     private statusTimer?;
@@ -63,7 +64,9 @@ export declare class DaemonServer {
      */
     private startPeerStatusSummary;
     getStatus(): DaemonStatus;
-    /** Append a chat message to the in-memory log (capped at 200 per friend). */
+    /** Append a chat message to the on-disk message store (persists across
+     *  restarts). Also ensures a friend-meta entry exists so the friend shows up
+     *  in the UI list even before it's been renamed. */
     private logChat;
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */

package/dist/daemon/server.js

@@ -17,6 +17,8 @@ import { DoraIntegration } from "../dora/dora-integration.js";
 import { DnsServer } from "../dns/server.js";
 import { IpcServer, ipcSocketPath } from "./ipc.js";
 import { PendingFriendsStore } from "./pending-friends.js";
+import { MessageStore } from "./message-store.js";
+import { FriendMetaStore } from "./friend-meta.js";
 import { Logger } from "../utils/logger.js";
 /**
  * Quote argv safely for `sh -c`. Wraps single-quotes by closing,
@@ -52,7 +54,8 @@ export class DaemonServer {
     pendingFriends;
     /** In-memory chat history, keyed by friend userid (last 200 each). Drives
      *  the `agentnet ui` chat window; not persisted across restarts. */
-    chatLog = new Map();
+    messageStore;
+    friendMeta;
     startedAt = 0;
     isRunning = false;
     statusTimer;
@@ -181,6 +184,9 @@ export class DaemonServer {
             });
             await this.peerManager.start();
             this.logger.info(`Identity: ${this.peerManager.getAddress()}`);
+            // On-disk chat + friend-metadata stores (survive restarts; back the UI).
+            this.messageStore = new MessageStore(resolve(this.configDir, "messages.json"));
+            this.friendMeta = new FriendMetaStore(resolve(this.configDir, "friends-meta.json"));
             // Start IPC as soon as the peer is up. The CLI uses it to drive
             // operations that need the daemon's Carrier identity (e.g.
             // friend-request) without spawning a competing Peer instance.
@@ -219,11 +225,49 @@ export class DaemonServer {
                     await this.peerManager.sendText(userid, text);
                     this.logChat(userid, "out", text);
                 },
-                chatHistory: async () => {
-                    const chats = {};
-                    for (const [userid, msgs] of this.chatLog)
-                        chats[userid] = msgs;
-                    return { chats };
+                chatHistory: async (peer, before, limit) => {
+                    return { chats: this.messageStore?.history(peer, { before, limit }) ?? {} };
+                },
+                friendsList: async () => {
+                    const friends = this.peerManager?.getFriends() ?? [];
+                    const last = this.messageStore?.lastMessages() ?? new Map();
+                    const list = friends.map((f) => {
+                        const uid = f.carrierId ?? f.pubkey ?? "";
+                        const meta = this.friendMeta?.get(uid);
+                        const lastMsg = last.get(uid);
+                        return {
+                            userid: uid,
+                            alias: meta?.alias,
+                            name: meta?.alias || f.name || uid,
+                            status: f.status,
+                            lastSeen: f.lastSeen,
+                            pinned: meta?.pinned ?? false,
+                            lastMessage: lastMsg ? { dir: lastMsg.dir, text: lastMsg.text, ts: lastMsg.ts } : undefined,
+                            unread: this.messageStore?.unreadCount(uid, meta?.lastReadTs ?? 0) ?? 0,
+                        };
+                    });
+                    // Pinned first, then most-recent-message, then by name.
+                    list.sort((a, b) => {
+                        if (!!a.pinned !== !!b.pinned)
+                            return a.pinned ? -1 : 1;
+                        const at = a.lastMessage?.ts ?? 0;
+                        const bt = b.lastMessage?.ts ?? 0;
+                        if (at !== bt)
+                            return bt - at;
+                        return String(a.name).localeCompare(String(b.name));
+                    });
+                    return { friends: list };
+                },
+                friendRemove: async (userid) => {
+                    this.peerManager?.removeFriend(userid);
+                    this.messageStore?.removePeer(userid);
+                    this.friendMeta?.remove(userid);
+                },
+                friendSetAlias: async (userid, alias) => {
+                    this.friendMeta?.setAlias(userid, alias);
+                },
+                chatMarkRead: async (userid, ts) => {
+                    this.friendMeta?.markRead(userid, ts);
                 },
                 proxyReload: async () => {
                     // Re-read the proxy allowlist from disk and push it into the
@@ -690,16 +734,12 @@ export class DaemonServer {
             activeSessions: this.packetRouter?.getStats().activeSessions || 0,
         };
     }
-    /** Append a chat message to the in-memory log (capped at 200 per friend). */
+    /** Append a chat message to the on-disk message store (persists across
+     *  restarts). Also ensures a friend-meta entry exists so the friend shows up
+     *  in the UI list even before it's been renamed. */
     logChat(userid, dir, text) {
-        let msgs = this.chatLog.get(userid);
-        if (!msgs) {
-            msgs = [];
-            this.chatLog.set(userid, msgs);
-        }
-        msgs.push({ dir, text, ts: Date.now() });
-        if (msgs.length > 200)
-            msgs.splice(0, msgs.length - 200);
+        this.messageStore?.append(userid, dir, text);
+        this.friendMeta?.ensure(userid);
     }
     /** Per-peer timestamp of the last self-heal friend-request re-send, so
      *  the watchdog escalates at most once per SELF_HEAL_REFRIEND_MS. */
@@ -815,6 +855,9 @@ export class DaemonServer {
             clearInterval(this.statusTimer);
             this.statusTimer = undefined;
         }
+        // Persist any pending chat/meta writes before we exit.
+        this.messageStore?.flush();
+        this.friendMeta?.flush();
         try {
             if (this.dnsServer) {
                 await this.dnsServer.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.86",
+  "version": "0.1.87",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",