openzca 0.1.53 → 0.1.54

package/dist/cli.js

@@ -438,6 +438,35 @@ var INSERT_THREAD_MEMBER_SQL = `
     account_status, member_type, raw_json, snapshot_at_ms, created_at, updated_at
   ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 `;
+var UPSERT_CONTACT_SQL = `
+  INSERT INTO contacts (
+    profile, user_id, display_name, zalo_name, avatar, account_status,
+    relationship, first_seen_at_ms, last_seen_at_ms, raw_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(profile, user_id) DO UPDATE SET
+    display_name = COALESCE(excluded.display_name, contacts.display_name),
+    zalo_name = COALESCE(excluded.zalo_name, contacts.zalo_name),
+    avatar = COALESCE(excluded.avatar, contacts.avatar),
+    account_status = COALESCE(excluded.account_status, contacts.account_status),
+    relationship = CASE
+      WHEN contacts.relationship = 'friend' OR excluded.relationship = 'friend' THEN 'friend'
+      WHEN contacts.relationship = 'seen_dm' OR excluded.relationship = 'seen_dm' THEN 'seen_dm'
+      WHEN contacts.relationship = 'seen_group' OR excluded.relationship = 'seen_group' THEN 'seen_group'
+      ELSE COALESCE(excluded.relationship, contacts.relationship, 'unknown')
+    END,
+    first_seen_at_ms = CASE
+      WHEN contacts.first_seen_at_ms IS NULL THEN excluded.first_seen_at_ms
+      WHEN excluded.first_seen_at_ms IS NULL THEN contacts.first_seen_at_ms
+      ELSE MIN(contacts.first_seen_at_ms, excluded.first_seen_at_ms)
+    END,
+    last_seen_at_ms = CASE
+      WHEN contacts.last_seen_at_ms IS NULL THEN excluded.last_seen_at_ms
+      WHEN excluded.last_seen_at_ms IS NULL THEN contacts.last_seen_at_ms
+      ELSE MAX(contacts.last_seen_at_ms, excluded.last_seen_at_ms)
+    END,
+    raw_json = COALESCE(excluded.raw_json, contacts.raw_json),
+    updated_at = excluded.updated_at
+`;
 var UPSERT_MESSAGE_SQL = `
   INSERT INTO messages (
     profile, message_uid, scope_thread_id, raw_thread_id, thread_type,
@@ -500,6 +529,12 @@ function normalizeOptionalText(value) {
   const trimmed = value.trim();
   return trimmed || void 0;
 }
+function normalizeRelationship(value) {
+  if (value !== "friend" && value !== "seen_dm" && value !== "seen_group" && value !== "unknown") {
+    return void 0;
+  }
+  return value;
+}
 function normalizeSearchText(value) {
   return value.normalize("NFD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLowerCase().trim();
 }
@@ -755,35 +790,23 @@ async function replaceThreadMembers(profile, scopeThreadId, members) {
   ];
   await db.batch(commands, true);
 }
-async function persistFriend(record) {
+async function persistContact(record) {
   const db = await getDb(record.profile);
   const now = nowIso2();
-  await db.run(
-    `
-      INSERT INTO friends (
-        profile, user_id, display_name, zalo_name, avatar,
-        account_status, raw_json, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(profile, user_id) DO UPDATE SET
-        display_name = COALESCE(excluded.display_name, friends.display_name),
-        zalo_name = COALESCE(excluded.zalo_name, friends.zalo_name),
-        avatar = COALESCE(excluded.avatar, friends.avatar),
-        account_status = COALESCE(excluded.account_status, friends.account_status),
-        raw_json = COALESCE(excluded.raw_json, friends.raw_json),
-        updated_at = excluded.updated_at
-    `,
-    [
-      record.profile,
-      record.userId,
-      record.displayName ?? null,
-      record.zaloName ?? null,
-      record.avatar ?? null,
-      record.accountStatus ?? null,
-      record.rawJson ?? null,
-      now,
-      now
-    ]
-  );
+  await db.run(UPSERT_CONTACT_SQL, [
+    record.profile,
+    record.userId,
+    record.displayName ?? null,
+    record.zaloName ?? null,
+    record.avatar ?? null,
+    record.accountStatus ?? null,
+    normalizeRelationship(record.relationship) ?? "unknown",
+    record.firstSeenAtMs ?? null,
+    record.lastSeenAtMs ?? null,
+    record.rawJson ?? null,
+    now,
+    now
+  ]);
 }
 async function persistSelfProfile(params) {
   const db = await getDb(params.profile);
@@ -990,8 +1013,8 @@ async function listMessages(params) {
           NULLIF(m.sender_name, ''),
           NULLIF(tm.display_name, ''),
           NULLIF(tm.zalo_name, ''),
-          NULLIF(f.display_name, ''),
-          NULLIF(f.zalo_name, '')
+          NULLIF(c.display_name, ''),
+          NULLIF(c.zalo_name, '')
         ) AS sender_name,
         m.to_id,
         m.timestamp_ms,
@@ -1008,9 +1031,9 @@ async function listMessages(params) {
         ON tm.profile = m.profile
         AND tm.scope_thread_id = m.scope_thread_id
         AND tm.user_id = m.sender_id
-      LEFT JOIN friends f
-        ON f.profile = m.profile
-        AND f.user_id = m.sender_id
+      LEFT JOIN contacts c
+        ON c.profile = m.profile
+        AND c.user_id = m.sender_id
       WHERE m.profile = ?
         AND m.scope_thread_id = ?
         AND m.thread_type = ?
@@ -1222,34 +1245,74 @@ async function getThreadInfo(params) {
     raw: row.raw_json ? JSON.parse(row.raw_json) : void 0
   };
 }
-async function listFriends(profile) {
-  const db = await getDb(profile);
+var CONTACT_CHAT_CTE = `
+  WITH ranked_contact_threads AS (
+    SELECT
+      c.profile AS contact_profile,
+      c.user_id,
+      t.scope_thread_id,
+      t.title,
+      COUNT(m.message_uid) AS message_count,
+      MAX(m.timestamp_ms) AS last_message_at_ms,
+      ROW_NUMBER() OVER (
+        PARTITION BY c.profile, c.user_id
+        ORDER BY
+          COALESCE(MAX(m.timestamp_ms), 0) DESC,
+          CASE
+            WHEN t.scope_thread_id = c.user_id THEN 0
+            WHEN t.peer_id = c.user_id THEN 1
+            WHEN t.raw_thread_id = c.user_id THEN 2
+            ELSE 3
+          END,
+          t.updated_at DESC,
+          t.scope_thread_id
+      ) AS thread_rank
+    FROM contacts c
+    LEFT JOIN threads t
+      ON t.profile = c.profile
+      AND t.thread_type = 'user'
+      AND (t.peer_id = c.user_id OR t.scope_thread_id = c.user_id OR t.raw_thread_id = c.user_id)
+    LEFT JOIN messages m
+      ON m.profile = t.profile
+      AND m.scope_thread_id = t.scope_thread_id
+    GROUP BY
+      c.profile,
+      c.user_id,
+      t.scope_thread_id,
+      t.title,
+      t.updated_at,
+      t.peer_id,
+      t.raw_thread_id
+  )
+`;
+async function listContacts(params) {
+  const db = await getDb(params.profile);
   const rows = await db.all(
     `
+      ${CONTACT_CHAT_CTE}
       SELECT
-        f.user_id,
-        f.display_name,
-        f.zalo_name,
-        f.avatar,
-        f.account_status,
-        t.scope_thread_id AS chat_id,
-        t.title,
-        COUNT(m.message_uid) AS message_count,
-        MAX(m.timestamp_ms) AS last_message_at_ms
-      FROM friends f
-      LEFT JOIN threads t
-        ON t.profile = f.profile
-        AND t.thread_type = 'user'
-        AND (t.peer_id = f.user_id OR t.scope_thread_id = f.user_id OR t.raw_thread_id = f.user_id)
-      LEFT JOIN messages m
-        ON m.profile = t.profile
-        AND m.scope_thread_id = t.scope_thread_id
-      WHERE f.profile = ?
-      GROUP BY
-        f.user_id, f.display_name, f.zalo_name, f.avatar, f.account_status, t.scope_thread_id, t.title
-      ORDER BY COALESCE(f.display_name, f.zalo_name, f.user_id), f.user_id
+        c.user_id,
+        c.display_name,
+        c.zalo_name,
+        c.avatar,
+        c.account_status,
+        c.relationship,
+        c.first_seen_at_ms,
+        c.last_seen_at_ms,
+        r.scope_thread_id AS chat_id,
+        r.title,
+        COALESCE(r.message_count, 0) AS message_count,
+        r.last_message_at_ms
+      FROM contacts c
+      LEFT JOIN ranked_contact_threads r
+        ON r.contact_profile = c.profile
+        AND r.user_id = c.user_id
+        AND r.thread_rank = 1
+      WHERE c.profile = ?
+        AND (? IS NULL OR c.relationship = ?)
+      ORDER BY COALESCE(c.display_name, c.zalo_name, c.user_id), c.user_id
     `,
-    [profile]
+    [params.profile, params.relationship ?? null, params.relationship ?? null]
   );
   return rows.map((row) => ({
     userId: row.user_id,
@@ -1257,43 +1320,53 @@ async function listFriends(profile) {
     zaloName: row.zalo_name ?? void 0,
     avatar: row.avatar ?? void 0,
     accountStatus: row.account_status ?? void 0,
+    relationship: normalizeRelationship(row.relationship) ?? "unknown",
+    firstSeenAtMs: row.first_seen_at_ms ?? void 0,
+    lastSeenAtMs: row.last_seen_at_ms ?? void 0,
     title: row.title ?? void 0,
     chatId: row.chat_id ?? row.user_id,
     messageCount: row.message_count,
     lastMessageAtMs: row.last_message_at_ms ?? void 0
   }));
 }
-async function getFriendInfo(params) {
+async function listFriends(profile) {
+  return await listContacts({ profile, relationship: "friend" });
+}
+async function getContactInfo(params) {
   const db = await getDb(params.profile);
   const row = await db.get(
     `
+      ${CONTACT_CHAT_CTE}
       SELECT
-        f.user_id,
-        f.display_name,
-        f.zalo_name,
-        f.avatar,
-        f.account_status,
-        f.raw_json,
-        t.scope_thread_id AS chat_id,
-        t.title,
-        COUNT(m.message_uid) AS message_count,
-        MAX(m.timestamp_ms) AS last_message_at_ms
-      FROM friends f
-      LEFT JOIN threads t
-        ON t.profile = f.profile
-        AND t.thread_type = 'user'
-        AND (t.peer_id = f.user_id OR t.scope_thread_id = f.user_id OR t.raw_thread_id = f.user_id)
-      LEFT JOIN messages m
-        ON m.profile = t.profile
-        AND m.scope_thread_id = t.scope_thread_id
-      WHERE f.profile = ?
-        AND f.user_id = ?
-      GROUP BY
-        f.user_id, f.display_name, f.zalo_name, f.avatar, f.account_status,
-        f.raw_json, t.scope_thread_id, t.title
+        c.user_id,
+        c.display_name,
+        c.zalo_name,
+        c.avatar,
+        c.account_status,
+        c.relationship,
+        c.first_seen_at_ms,
+        c.last_seen_at_ms,
+        c.raw_json,
+        r.scope_thread_id AS chat_id,
+        r.title,
+        COALESCE(r.message_count, 0) AS message_count,
+        r.last_message_at_ms
+      FROM contacts c
+      LEFT JOIN ranked_contact_threads r
+        ON r.contact_profile = c.profile
+        AND r.user_id = c.user_id
+        AND r.thread_rank = 1
+      WHERE c.profile = ?
+        AND c.user_id = ?
+        AND (? IS NULL OR c.relationship = ?)
       LIMIT 1
     `,
-    [params.profile, params.userId]
+    [
+      params.profile,
+      params.userId,
+      params.relationship ?? null,
+      params.relationship ?? null
+    ]
   );
   if (!row) {
     return null;
@@ -1304,6 +1377,9 @@ async function getFriendInfo(params) {
     zaloName: row.zalo_name ?? void 0,
     avatar: row.avatar ?? void 0,
     accountStatus: row.account_status ?? void 0,
+    relationship: normalizeRelationship(row.relationship) ?? "unknown",
+    firstSeenAtMs: row.first_seen_at_ms ?? void 0,
+    lastSeenAtMs: row.last_seen_at_ms ?? void 0,
     title: row.title ?? void 0,
     chatId: row.chat_id ?? row.user_id,
     messageCount: row.message_count,
@@ -1311,12 +1387,22 @@ async function getFriendInfo(params) {
     raw: row.raw_json ? JSON.parse(row.raw_json) : void 0
   };
 }
-async function findFriends(params) {
+async function getFriendInfo(params) {
+  return await getContactInfo({
+    profile: params.profile,
+    userId: params.userId,
+    relationship: "friend"
+  });
+}
+async function findContacts(params) {
   const query = normalizeSearchText(params.query);
   if (!query) {
     return [];
   }
-  const rows = await listFriends(params.profile);
+  const rows = await listContacts({
+    profile: params.profile,
+    relationship: params.relationship
+  });
   return rows.filter((row) => {
     const haystacks = [
       row.userId,
@@ -1327,6 +1413,52 @@ async function findFriends(params) {
     return haystacks.some((value) => matchesSearchPattern(value, query));
   });
 }
+async function findFriends(params) {
+  return await findContacts({
+    profile: params.profile,
+    query: params.query,
+    relationship: "friend"
+  });
+}
+async function reconcileFriendRelationships(params) {
+  const db = await getDb(params.profile);
+  const now = nowIso2();
+  const friendIds = Array.from(
+    new Set(params.currentFriendIds.map((value) => normalizeId(value)).filter(Boolean))
+  );
+  const stalePredicate = friendIds.length > 0 ? `AND contacts.user_id NOT IN (${friendIds.map(() => "?").join(", ")})` : "";
+  const sqlParams = [now, params.profile, ...friendIds];
+  await db.run(
+    `
+      UPDATE contacts
+      SET relationship = CASE
+        WHEN EXISTS (
+          SELECT 1
+          FROM threads t
+          WHERE t.profile = contacts.profile
+            AND t.thread_type = 'user'
+            AND (
+              t.peer_id = contacts.user_id
+              OR t.scope_thread_id = contacts.user_id
+              OR t.raw_thread_id = contacts.user_id
+            )
+        ) THEN 'seen_dm'
+        WHEN EXISTS (
+          SELECT 1
+          FROM thread_members tm
+          WHERE tm.profile = contacts.profile
+            AND tm.user_id = contacts.user_id
+        ) THEN 'seen_group'
+        ELSE 'unknown'
+      END,
+      updated_at = ?
+      WHERE contacts.profile = ?
+        AND contacts.relationship = 'friend'
+        ${stalePredicate}
+    `,
+    sqlParams
+  );
+}
 async function listChats(profile) {
   return listThreads({ profile });
 }
@@ -4018,6 +4150,20 @@ async function persistOutgoingMessageBestEffort(params) {
 async function persistGroupMembersSnapshot(profile, groupId, api) {
   const rows = await listGroupMemberRows(api, groupId);
   const snapshotAtMs = Date.now();
+  for (const row of rows) {
+    await persistContact({
+      profile,
+      userId: row.userId,
+      displayName: row.displayName,
+      zaloName: row.zaloName,
+      avatar: row.avatar,
+      accountStatus: row.accountStatus,
+      relationship: "seen_group",
+      firstSeenAtMs: snapshotAtMs,
+      lastSeenAtMs: snapshotAtMs,
+      rawJson: row.rawJson
+    });
+  }
   await replaceThreadMembers(
     profile,
     groupId,
@@ -4027,7 +4173,9 @@ async function persistGroupMembersSnapshot(profile, groupId, api) {
       userId: row.userId,
       displayName: row.displayName,
       zaloName: row.zaloName,
-      rawJson: JSON.stringify(row),
+      avatar: row.avatar,
+      accountStatus: row.accountStatus,
+      rawJson: row.rawJson ?? JSON.stringify(row),
       snapshotAtMs
     }))
   );
@@ -4043,13 +4191,14 @@ async function persistFriendDirectory(profile, api) {
     const zaloName = typeof record.zaloName === "string" && record.zaloName.trim() ? record.zaloName.trim() : void 0;
     const avatar = typeof record.avatar === "string" && record.avatar.trim() ? record.avatar.trim() : void 0;
     const title = displayName || zaloName || userId;
-    await persistFriend({
+    await persistContact({
       profile,
       userId,
       displayName,
       zaloName,
       avatar,
       accountStatus: typeof record.accountStatus === "number" && Number.isFinite(record.accountStatus) ? Math.trunc(record.accountStatus) : void 0,
+      relationship: "friend",
       rawJson: JSON.stringify(friend2)
     });
     await persistThread({
@@ -4063,6 +4212,10 @@ async function persistFriendDirectory(profile, api) {
     });
     nameById.set(userId, title);
   }
+  await reconcileFriendRelationships({
+    profile,
+    currentFriendIds: Array.from(nameById.keys())
+  });
   return nameById;
 }
 function parseSinceDuration(label, value) {
@@ -4202,6 +4355,99 @@ async function prepareDbGroupTarget(params) {
   });
   await persistGroupMembersSnapshot(params.profile, params.groupId, params.api);
 }
+function resolveContactDisplayName(params) {
+  return params.displayName?.trim() || params.zaloName?.trim() || params.fallbackTitle?.trim() || params.userId.trim() || void 0;
+}
+async function persistLiveDmContact(params) {
+  if (!params.peerId) {
+    return;
+  }
+  let displayName = params.senderDisplayName?.trim() || void 0;
+  let zaloName = params.senderName?.trim() || void 0;
+  let avatar;
+  let accountStatus;
+  let rawJson = params.rawJson;
+  const existing = await getContactInfo({
+    profile: params.profile,
+    userId: params.peerId
+  });
+  if (!displayName || !existing?.avatar) {
+    try {
+      const response = await params.api.getUserInfo(params.peerId);
+      const profiles = response.changed_profiles ?? {};
+      const profile = profiles[params.peerId] ?? profiles[`${params.peerId}_0`] ?? Object.values(profiles).find((value) => normalizeCachedId(value?.userId ?? value?.uid) === params.peerId) ?? void 0;
+      if (profile) {
+        displayName = displayName || (typeof profile.displayName === "string" && profile.displayName.trim() ? profile.displayName.trim() : void 0) || (typeof profile.display_name === "string" && profile.display_name.trim() ? profile.display_name.trim() : void 0);
+        zaloName = zaloName || (typeof profile.zaloName === "string" && profile.zaloName.trim() ? profile.zaloName.trim() : void 0) || (typeof profile.zalo_name === "string" && profile.zalo_name.trim() ? profile.zalo_name.trim() : void 0);
+        avatar = typeof profile.avatar === "string" && profile.avatar.trim() ? profile.avatar.trim() : void 0;
+        accountStatus = typeof profile.accountStatus === "number" && Number.isFinite(profile.accountStatus) ? Math.trunc(profile.accountStatus) : void 0;
+        rawJson = JSON.stringify(profile);
+      }
+    } catch {
+    }
+  }
+  const title = resolveContactDisplayName({
+    userId: params.peerId,
+    displayName,
+    zaloName,
+    fallbackTitle: typeof existing?.title === "string" ? existing.title : void 0
+  });
+  await persistContact({
+    profile: params.profile,
+    userId: params.peerId,
+    displayName,
+    zaloName,
+    avatar,
+    accountStatus,
+    relationship: "seen_dm",
+    firstSeenAtMs: params.timestampMs,
+    lastSeenAtMs: params.timestampMs,
+    rawJson
+  });
+  await persistThread({
+    profile: params.profile,
+    scopeThreadId: params.peerId,
+    rawThreadId: params.peerId,
+    threadType: "user",
+    peerId: params.peerId,
+    title,
+    rawJson
+  });
+}
+async function hydrateUnknownLiveGroup(params) {
+  const existing = await getThreadInfo({
+    profile: params.profile,
+    threadId: params.groupId,
+    threadType: "group"
+  });
+  if (existing && (existing.title || typeof existing.memberCount === "number" && existing.memberCount > 0)) {
+    return;
+  }
+  try {
+    const info = await params.api.getGroupInfo(params.groupId);
+    const group2 = info.gridInfoMap[params.groupId];
+    const title = typeof group2?.name === "string" && group2.name.trim() ? group2.name.trim() : typeof group2?.groupName === "string" && group2.groupName.trim() ? group2.groupName.trim() : params.fallbackTitle?.trim() || void 0;
+    await persistThread({
+      profile: params.profile,
+      scopeThreadId: params.groupId,
+      rawThreadId: params.groupId,
+      threadType: "group",
+      title,
+      rawJson: group2 ? JSON.stringify(group2) : void 0
+    });
+    await persistGroupMembersSnapshot(params.profile, params.groupId, params.api);
+  } catch {
+    if (params.fallbackTitle?.trim()) {
+      await persistThread({
+        profile: params.profile,
+        scopeThreadId: params.groupId,
+        rawThreadId: params.groupId,
+        threadType: "group",
+        title: params.fallbackTitle.trim()
+      });
+    }
+  }
+}
 async function syncDbGroupHistoryFull(params) {
   if (params.targetGroupIds.size === 0) {
     return;
@@ -4580,17 +4826,26 @@ async function listGroupMemberRows(api, groupId) {
     if (!profile) continue;
     const normalizedKey = normalizeGroupMemberId(key);
     if (normalizedKey && !profileMap.has(normalizedKey)) {
-      profileMap.set(normalizedKey, profile);
+      profileMap.set(normalizedKey, {
+        ...profile,
+        rawJson: JSON.stringify(profile)
+      });
     }
     const profileId = normalizeGroupMemberId(profile.id);
     if (profileId && !profileMap.has(profileId)) {
-      profileMap.set(profileId, profile);
+      profileMap.set(profileId, {
+        ...profile,
+        rawJson: JSON.stringify(profile)
+      });
     }
   }
   return ids.map((id) => ({
     userId: id,
     displayName: profileMap.get(id)?.displayName ?? currentMemberMap.get(id)?.displayName ?? "",
-    zaloName: profileMap.get(id)?.zaloName ?? currentMemberMap.get(id)?.zaloName ?? ""
+    zaloName: profileMap.get(id)?.zaloName ?? currentMemberMap.get(id)?.zaloName ?? "",
+    avatar: profileMap.get(id)?.avatar,
+    accountStatus: profileMap.get(id)?.accountStatus,
+    rawJson: profileMap.get(id)?.rawJson
   }));
 }
 async function listGroupMentionMembers(api, threadId) {
@@ -6555,52 +6810,69 @@ dbGroup.command("messages <groupId>").option("--since <duration>", "Rolling wind
     );
   })
 );
-var dbFriend = dbCmd.command("friend").description("Query stored friend directory data");
-dbFriend.command("list").option("-j, --json", "JSON output").description("List friends stored in the local DB").action(
-  wrapAction(async (opts, command) => {
-    const profile = await currentProfile(command);
-    output(await listFriends(profile), Boolean(opts.json));
-  })
-);
-dbFriend.command("find <query>").option("-j, --json", "JSON output").description("Find stored friends by ID or name").action(
-  wrapAction(async (query, opts, command) => {
-    const profile = await currentProfile(command);
-    output(await findFriends({ profile, query }), Boolean(opts.json));
-  })
-);
-dbFriend.command("info <userId>").option("-j, --json", "JSON output").description("Show stored info for a friend").action(
-  wrapAction(async (userId, opts, command) => {
-    const profile = await currentProfile(command);
-    const row = await getFriendInfo({ profile, userId });
-    if (!row) {
-      throw new Error(`Friend not found in DB: ${userId}`);
-    }
-    output(row, Boolean(opts.json));
-  })
-);
-dbFriend.command("messages <userId>").option("--since <duration>", "Rolling window ending now: duration like 30s, 7m, 24h, 7d, or 2w").option("--from <time>", "Lower time bound: ISO timestamp, date, or unix seconds/ms").option("--until <time>", "Upper time bound: ISO timestamp, date, or unix seconds/ms").option("--to <time>", "Alias for --until").option("--limit <count>", "Maximum number of rows").option("--all", "Return all matching rows").option("--oldest-first", "Sort oldest-first instead of newest-first").option("-j, --json", "JSON output").description("List stored direct-message rows for a friend").action(
-  wrapAction(async (userId, opts, command) => {
-    const profile = await currentProfile(command);
-    const { sinceMs, untilMs, limit, newestFirst } = resolveMessageQueryOptions(opts);
-    const rows = await listMessages({
-      profile,
-      threadId: userId,
-      threadType: "user",
-      sinceMs,
-      untilMs,
-      limit,
-      newestFirst
-    });
-    output(
-      {
-        userId,
-        count: rows.length,
-        messages: rows
-      },
-      Boolean(opts.json)
-    );
-  })
-);
+function registerDbContactQueryCommand(params) {
+  params.command.command("list").option("-j, --json", "JSON output").description(`List ${params.label} stored in the local DB`).action(
+    wrapAction(async (opts, command) => {
+      const profile = await currentProfile(command);
+      const rows = params.relationship === "friend" ? await listFriends(profile) : await listContacts({ profile });
+      output(rows, Boolean(opts.json));
+    })
+  );
+  params.command.command("find <query>").option("-j, --json", "JSON output").description(`Find stored ${params.label} by ID or name`).action(
+    wrapAction(async (query, opts, command) => {
+      const profile = await currentProfile(command);
+      const rows = params.relationship === "friend" ? await findFriends({ profile, query }) : await findContacts({ profile, query });
+      output(rows, Boolean(opts.json));
+    })
+  );
+  params.command.command("info <userId>").option("-j, --json", "JSON output").description(`Show stored info for a ${params.label.slice(0, -1)}`).action(
+    wrapAction(async (userId, opts, command) => {
+      const profile = await currentProfile(command);
+      const row = params.relationship === "friend" ? await getFriendInfo({ profile, userId }) : await getContactInfo({ profile, userId });
+      if (!row) {
+        throw new Error(`${params.label.slice(0, -1).replace(/^./, (value) => value.toUpperCase())} not found in DB: ${userId}`);
+      }
+      output(row, Boolean(opts.json));
+    })
+  );
+  params.command.command("messages <userId>").option("--since <duration>", "Rolling window ending now: duration like 30s, 7m, 24h, 7d, or 2w").option("--from <time>", "Lower time bound: ISO timestamp, date, or unix seconds/ms").option("--until <time>", "Upper time bound: ISO timestamp, date, or unix seconds/ms").option("--to <time>", "Alias for --until").option("--limit <count>", "Maximum number of rows").option("--all", "Return all matching rows").option("--oldest-first", "Sort oldest-first instead of newest-first").option("-j, --json", "JSON output").description(`List stored direct-message rows for a ${params.label.slice(0, -1)}`).action(
+    wrapAction(async (userId, opts, command) => {
+      const profile = await currentProfile(command);
+      const { sinceMs, untilMs, limit, newestFirst } = resolveMessageQueryOptions(opts);
+      const contact = params.relationship === "friend" ? await getFriendInfo({ profile, userId }) : await getContactInfo({ profile, userId });
+      const threadId = contact && typeof contact.chatId === "string" && contact.chatId.trim() ? contact.chatId : userId;
+      const rows = await listMessages({
+        profile,
+        threadId,
+        threadType: "user",
+        sinceMs,
+        untilMs,
+        limit,
+        newestFirst
+      });
+      output(
+        {
+          userId,
+          chatId: threadId,
+          count: rows.length,
+          messages: rows
+        },
+        Boolean(opts.json)
+      );
+    })
+  );
+}
+var dbContact = dbCmd.command("contact").description("Query stored contact data");
+registerDbContactQueryCommand({
+  command: dbContact,
+  label: "contacts"
+});
+var dbFriend = dbCmd.command("friend").description("Query stored confirmed friend contacts");
+registerDbContactQueryCommand({
+  command: dbFriend,
+  label: "friends",
+  relationship: "friend"
+});
 var dbChat = dbCmd.command("chat").description("Query stored conversation data");
 dbChat.command("list").option("-j, --json", "JSON output").description("List chats stored in the local DB").action(
   wrapAction(async (opts, command) => {
@@ -8409,34 +8681,54 @@ ${replyContextText}` : replyContextText;
               rawJson: JSON.stringify(mention)
             }));
             scheduleDbWrite(profile, command, "listen.db.persist_error", async () => {
-              await persistMessage(
-                normalizeInboundListenRecord({
+              const normalizedRecord = normalizeInboundListenRecord({
+                profile,
+                threadType: chatType,
+                rawThreadId: message.threadId,
+                senderId,
+                senderName: senderDisplayName,
+                toId,
+                selfId,
+                title: chatType === "group" ? threadName : senderDisplayName,
+                msgId: message.data.msgId,
+                cliMsgId: message.data.cliMsgId,
+                actionId: getStringCandidate(messageData, ["actionId"]),
+                timestampMs,
+                msgType: msgType || void 0,
+                contentText: processedText || rawText || void 0,
+                contentJson: rawContent && typeof rawContent === "object" ? JSON.stringify(rawContent) : void 0,
+                quoteMsgId: quote?.globalMsgId ? String(quote.globalMsgId) : void 0,
+                quoteCliMsgId: quote?.cliMsgId ? String(quote.cliMsgId) : void 0,
+                quoteOwnerId: quote?.ownerId ? String(quote.ownerId) : void 0,
+                quoteText: quote?.msg,
+                media: mediaForDb,
+                mentions: mentionsForDb,
+                rawMessage: message.data,
+                rawPayload: payload,
+                source: "listen"
+              });
+              if (chatType === "group") {
+                await hydrateUnknownLiveGroup({
+                  profile,
+                  api,
+                  groupId: normalizedRecord.scopeThreadId,
+                  fallbackTitle: threadName
+                });
+              } else {
+                await persistLiveDmContact({
                   profile,
-                  threadType: chatType,
-                  rawThreadId: message.threadId,
-                  senderId,
+                  api,
+                  peerId: normalizedRecord.scopeThreadId,
+                  senderDisplayName,
                   senderName: senderDisplayName,
-                  toId,
-                  selfId,
-                  title: threadName,
-                  msgId: message.data.msgId,
-                  cliMsgId: message.data.cliMsgId,
-                  actionId: getStringCandidate(messageData, ["actionId"]),
                   timestampMs,
-                  msgType: msgType || void 0,
-                  contentText: processedText || rawText || void 0,
-                  contentJson: rawContent && typeof rawContent === "object" ? JSON.stringify(rawContent) : void 0,
-                  quoteMsgId: quote?.globalMsgId ? String(quote.globalMsgId) : void 0,
-                  quoteCliMsgId: quote?.cliMsgId ? String(quote.cliMsgId) : void 0,
-                  quoteOwnerId: quote?.ownerId ? String(quote.ownerId) : void 0,
-                  quoteText: quote?.msg,
-                  media: mediaForDb,
-                  mentions: mentionsForDb,
-                  rawMessage: message.data,
-                  rawPayload: payload,
-                  source: "listen"
-                })
-              );
+                  rawJson: JSON.stringify({
+                    userId: normalizedRecord.scopeThreadId,
+                    displayName: senderDisplayName
+                  })
+                });
+              }
+              await persistMessage(normalizedRecord);
             });
           }
           if (opts.raw) {

package/dist/db-migrations.js

@@ -0,0 +1,52 @@
+// src/lib/db-migrations.ts
+import fs from "fs/promises";
+var MIGRATIONS = [
+  { version: "001", file: "001-initial-schema.sql" },
+  { version: "002", file: "002-add-contacts.sql" },
+  { version: "003", file: "003-backfill-contacts.sql" }
+];
+var CREATE_MIGRATIONS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS schema_migrations (
+    version TEXT NOT NULL PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  )
+`;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function readMigrationSql(file) {
+  return await fs.readFile(new URL(`./migrations/${file}`, import.meta.url), "utf8");
+}
+function listAppliedVersions(db) {
+  const rows = db.prepare("SELECT version FROM schema_migrations").all();
+  return new Set(
+    rows.map((row) => typeof row.version === "string" ? row.version : "").filter(Boolean)
+  );
+}
+async function runMigrations(db) {
+  db.exec(CREATE_MIGRATIONS_TABLE_SQL);
+  const applied = listAppliedVersions(db);
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.version)) {
+      continue;
+    }
+    const sql = await readMigrationSql(migration.file);
+    db.exec("BEGIN");
+    try {
+      db.exec(sql);
+      db.prepare(
+        "INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)"
+      ).run(migration.version, nowIso());
+      db.exec("COMMIT");
+    } catch (error) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
+}
+export {
+  runMigrations
+};

package/dist/db-worker.js

@@ -1,150 +1,5 @@
 // src/lib/db-worker.ts
 import { parentPort, workerData } from "worker_threads";
-var INIT_SQL = `
-  PRAGMA journal_mode = WAL;
-  PRAGMA synchronous = FULL;
-  PRAGMA busy_timeout = 5000;
-  PRAGMA foreign_keys = ON;
-
-  CREATE TABLE IF NOT EXISTS threads (
-    profile TEXT NOT NULL,
-    scope_thread_id TEXT NOT NULL,
-    raw_thread_id TEXT NOT NULL,
-    thread_type TEXT NOT NULL,
-    peer_id TEXT,
-    title TEXT,
-    is_pinned INTEGER NOT NULL DEFAULT 0,
-    is_hidden INTEGER NOT NULL DEFAULT 0,
-    is_archived INTEGER NOT NULL DEFAULT 0,
-    raw_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, scope_thread_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS thread_members (
-    profile TEXT NOT NULL,
-    scope_thread_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    display_name TEXT,
-    zalo_name TEXT,
-    avatar TEXT,
-    account_status INTEGER,
-    member_type INTEGER,
-    raw_json TEXT,
-    snapshot_at_ms INTEGER NOT NULL,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, scope_thread_id, user_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS friends (
-    profile TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    display_name TEXT,
-    zalo_name TEXT,
-    avatar TEXT,
-    account_status INTEGER,
-    raw_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, user_id)
-  );
-
-  CREATE TABLE IF NOT EXISTS self_profiles (
-    profile TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    display_name TEXT,
-    info_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile)
-  );
-
-  CREATE TABLE IF NOT EXISTS messages (
-    profile TEXT NOT NULL,
-    message_uid TEXT NOT NULL,
-    scope_thread_id TEXT NOT NULL,
-    raw_thread_id TEXT NOT NULL,
-    thread_type TEXT NOT NULL,
-    msg_id TEXT,
-    cli_msg_id TEXT,
-    action_id TEXT,
-    sender_id TEXT,
-    sender_name TEXT,
-    to_id TEXT,
-    timestamp_ms INTEGER NOT NULL,
-    msg_type TEXT,
-    content_text TEXT,
-    content_json TEXT,
-    quote_msg_id TEXT,
-    quote_cli_msg_id TEXT,
-    quote_owner_id TEXT,
-    quote_text TEXT,
-    source TEXT NOT NULL,
-    raw_message_json TEXT,
-    raw_payload_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, message_uid)
-  );
-
-  CREATE TABLE IF NOT EXISTS message_media (
-    profile TEXT NOT NULL,
-    message_uid TEXT NOT NULL,
-    item_index INTEGER NOT NULL,
-    media_kind TEXT,
-    media_url TEXT,
-    media_path TEXT,
-    media_type TEXT,
-    raw_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, message_uid, item_index)
-  );
-
-  CREATE TABLE IF NOT EXISTS message_mentions (
-    profile TEXT NOT NULL,
-    message_uid TEXT NOT NULL,
-    item_index INTEGER NOT NULL,
-    target_user_id TEXT NOT NULL,
-    pos INTEGER,
-    len INTEGER,
-    mention_type INTEGER,
-    raw_json TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, message_uid, item_index)
-  );
-
-  CREATE TABLE IF NOT EXISTS sync_state (
-    profile TEXT NOT NULL,
-    scope TEXT NOT NULL,
-    scope_thread_id TEXT NOT NULL,
-    thread_type TEXT NOT NULL,
-    status TEXT NOT NULL,
-    completeness TEXT,
-    cursor TEXT,
-    last_sync_at TEXT,
-    error TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile, scope)
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_messages_thread_time
-    ON messages (profile, scope_thread_id, timestamp_ms DESC);
-  CREATE INDEX IF NOT EXISTS idx_messages_msg_id
-    ON messages (profile, msg_id);
-  CREATE INDEX IF NOT EXISTS idx_messages_cli_msg_id
-    ON messages (profile, cli_msg_id);
-  CREATE INDEX IF NOT EXISTS idx_threads_type
-    ON threads (profile, thread_type, updated_at DESC);
-  CREATE INDEX IF NOT EXISTS idx_members_thread
-    ON thread_members (profile, scope_thread_id);
-  CREATE INDEX IF NOT EXISTS idx_friends_name
-    ON friends (profile, display_name, zalo_name, user_id);
-`;
 if (!parentPort) {
   throw new Error("DB worker requires parentPort");
 }
@@ -180,6 +35,12 @@ async function loadSqliteModule() {
     process.emitWarning = originalEmitWarning;
   }
 }
+async function loadMigrationModule() {
+  const currentUrl = new URL(import.meta.url);
+  const specifier = currentUrl.pathname.endsWith("/src/lib/db-worker.ts") ? new URL("./db-migrations.ts", currentUrl).href : new URL("./db-migrations.js", currentUrl).href;
+  const importDynamic = new Function("specifier", "return import(specifier);");
+  return await importDynamic(specifier);
+}
 function setDefensiveMode(db) {
   const maybeDb = db;
   if (typeof maybeDb.enableDefensive === "function") {
@@ -197,9 +58,16 @@ function allStatement(db, statement) {
 }
 async function main() {
   const { DatabaseSync } = await loadSqliteModule();
+  const { runMigrations } = await loadMigrationModule();
   const { filename } = workerData;
   const db = new DatabaseSync(filename);
-  db.exec(INIT_SQL);
+  db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = FULL;
+    PRAGMA busy_timeout = 5000;
+    PRAGMA foreign_keys = ON;
+  `);
+  await runMigrations(db);
   setDefensiveMode(db);
   port.postMessage({ type: "ready" });
   port.on("message", (message) => {

package/dist/migrations/001-initial-schema.sql

@@ -0,0 +1,138 @@
+CREATE TABLE IF NOT EXISTS threads (
+  profile TEXT NOT NULL,
+  scope_thread_id TEXT NOT NULL,
+  raw_thread_id TEXT NOT NULL,
+  thread_type TEXT NOT NULL,
+  peer_id TEXT,
+  title TEXT,
+  is_pinned INTEGER NOT NULL DEFAULT 0,
+  is_hidden INTEGER NOT NULL DEFAULT 0,
+  is_archived INTEGER NOT NULL DEFAULT 0,
+  raw_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, scope_thread_id)
+);
+
+CREATE TABLE IF NOT EXISTS thread_members (
+  profile TEXT NOT NULL,
+  scope_thread_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  display_name TEXT,
+  zalo_name TEXT,
+  avatar TEXT,
+  account_status INTEGER,
+  member_type INTEGER,
+  raw_json TEXT,
+  snapshot_at_ms INTEGER NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, scope_thread_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS friends (
+  profile TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  display_name TEXT,
+  zalo_name TEXT,
+  avatar TEXT,
+  account_status INTEGER,
+  raw_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS self_profiles (
+  profile TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  display_name TEXT,
+  info_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile)
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  profile TEXT NOT NULL,
+  message_uid TEXT NOT NULL,
+  scope_thread_id TEXT NOT NULL,
+  raw_thread_id TEXT NOT NULL,
+  thread_type TEXT NOT NULL,
+  msg_id TEXT,
+  cli_msg_id TEXT,
+  action_id TEXT,
+  sender_id TEXT,
+  sender_name TEXT,
+  to_id TEXT,
+  timestamp_ms INTEGER NOT NULL,
+  msg_type TEXT,
+  content_text TEXT,
+  content_json TEXT,
+  quote_msg_id TEXT,
+  quote_cli_msg_id TEXT,
+  quote_owner_id TEXT,
+  quote_text TEXT,
+  source TEXT NOT NULL,
+  raw_message_json TEXT,
+  raw_payload_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, message_uid)
+);
+
+CREATE TABLE IF NOT EXISTS message_media (
+  profile TEXT NOT NULL,
+  message_uid TEXT NOT NULL,
+  item_index INTEGER NOT NULL,
+  media_kind TEXT,
+  media_url TEXT,
+  media_path TEXT,
+  media_type TEXT,
+  raw_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, message_uid, item_index)
+);
+
+CREATE TABLE IF NOT EXISTS message_mentions (
+  profile TEXT NOT NULL,
+  message_uid TEXT NOT NULL,
+  item_index INTEGER NOT NULL,
+  target_user_id TEXT NOT NULL,
+  pos INTEGER,
+  len INTEGER,
+  mention_type INTEGER,
+  raw_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, message_uid, item_index)
+);
+
+CREATE TABLE IF NOT EXISTS sync_state (
+  profile TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  scope_thread_id TEXT NOT NULL,
+  thread_type TEXT NOT NULL,
+  status TEXT NOT NULL,
+  completeness TEXT,
+  cursor TEXT,
+  last_sync_at TEXT,
+  error TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, scope)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_thread_time
+  ON messages (profile, scope_thread_id, timestamp_ms DESC);
+CREATE INDEX IF NOT EXISTS idx_messages_msg_id
+  ON messages (profile, msg_id);
+CREATE INDEX IF NOT EXISTS idx_messages_cli_msg_id
+  ON messages (profile, cli_msg_id);
+CREATE INDEX IF NOT EXISTS idx_threads_type
+  ON threads (profile, thread_type, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_members_thread
+  ON thread_members (profile, scope_thread_id);
+CREATE INDEX IF NOT EXISTS idx_friends_name
+  ON friends (profile, display_name, zalo_name, user_id);

package/dist/migrations/002-add-contacts.sql

@@ -0,0 +1,18 @@
+CREATE TABLE IF NOT EXISTS contacts (
+  profile TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  display_name TEXT,
+  zalo_name TEXT,
+  avatar TEXT,
+  account_status INTEGER,
+  relationship TEXT NOT NULL DEFAULT 'unknown',
+  first_seen_at_ms INTEGER,
+  last_seen_at_ms INTEGER,
+  raw_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (profile, user_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_contacts_name
+  ON contacts (profile, display_name, zalo_name, user_id);

package/dist/migrations/003-backfill-contacts.sql

@@ -0,0 +1,158 @@
+INSERT INTO contacts (
+  profile,
+  user_id,
+  display_name,
+  zalo_name,
+  avatar,
+  account_status,
+  relationship,
+  first_seen_at_ms,
+  last_seen_at_ms,
+  raw_json,
+  created_at,
+  updated_at
+)
+SELECT
+  profile,
+  user_id,
+  display_name,
+  zalo_name,
+  avatar,
+  account_status,
+  'friend',
+  NULL,
+  NULL,
+  raw_json,
+  created_at,
+  updated_at
+FROM friends
+WHERE 1 = 1
+ON CONFLICT(profile, user_id) DO UPDATE SET
+  display_name = COALESCE(excluded.display_name, contacts.display_name),
+  zalo_name = COALESCE(excluded.zalo_name, contacts.zalo_name),
+  avatar = COALESCE(excluded.avatar, contacts.avatar),
+  account_status = COALESCE(excluded.account_status, contacts.account_status),
+  relationship = CASE
+    WHEN contacts.relationship = 'friend' OR excluded.relationship = 'friend' THEN 'friend'
+    WHEN contacts.relationship = 'seen_dm' OR excluded.relationship = 'seen_dm' THEN 'seen_dm'
+    WHEN contacts.relationship = 'seen_group' OR excluded.relationship = 'seen_group' THEN 'seen_group'
+    ELSE COALESCE(excluded.relationship, contacts.relationship, 'unknown')
+  END,
+  raw_json = COALESCE(excluded.raw_json, contacts.raw_json),
+  updated_at = excluded.updated_at;
+
+INSERT INTO contacts (
+  profile,
+  user_id,
+  display_name,
+  zalo_name,
+  avatar,
+  account_status,
+  relationship,
+  first_seen_at_ms,
+  last_seen_at_ms,
+  raw_json,
+  created_at,
+  updated_at
+)
+SELECT
+  profile,
+  user_id,
+  NULLIF(MAX(display_name), ''),
+  NULLIF(MAX(zalo_name), ''),
+  NULLIF(MAX(avatar), ''),
+  MAX(account_status),
+  'seen_group',
+  MIN(snapshot_at_ms),
+  MAX(snapshot_at_ms),
+  NULLIF(MAX(raw_json), ''),
+  MIN(created_at),
+  MAX(updated_at)
+FROM thread_members
+WHERE 1 = 1
+GROUP BY profile, user_id
+ON CONFLICT(profile, user_id) DO UPDATE SET
+  display_name = COALESCE(excluded.display_name, contacts.display_name),
+  zalo_name = COALESCE(excluded.zalo_name, contacts.zalo_name),
+  avatar = COALESCE(excluded.avatar, contacts.avatar),
+  account_status = COALESCE(excluded.account_status, contacts.account_status),
+  relationship = CASE
+    WHEN contacts.relationship = 'friend' OR excluded.relationship = 'friend' THEN 'friend'
+    WHEN contacts.relationship = 'seen_dm' OR excluded.relationship = 'seen_dm' THEN 'seen_dm'
+    WHEN contacts.relationship = 'seen_group' OR excluded.relationship = 'seen_group' THEN 'seen_group'
+    ELSE COALESCE(excluded.relationship, contacts.relationship, 'unknown')
+  END,
+  first_seen_at_ms = CASE
+    WHEN contacts.first_seen_at_ms IS NULL THEN excluded.first_seen_at_ms
+    WHEN excluded.first_seen_at_ms IS NULL THEN contacts.first_seen_at_ms
+    ELSE MIN(contacts.first_seen_at_ms, excluded.first_seen_at_ms)
+  END,
+  last_seen_at_ms = CASE
+    WHEN contacts.last_seen_at_ms IS NULL THEN excluded.last_seen_at_ms
+    WHEN excluded.last_seen_at_ms IS NULL THEN contacts.last_seen_at_ms
+    ELSE MAX(contacts.last_seen_at_ms, excluded.last_seen_at_ms)
+  END,
+  raw_json = COALESCE(excluded.raw_json, contacts.raw_json),
+  updated_at = excluded.updated_at;
+
+INSERT INTO contacts (
+  profile,
+  user_id,
+  display_name,
+  zalo_name,
+  avatar,
+  account_status,
+  relationship,
+  first_seen_at_ms,
+  last_seen_at_ms,
+  raw_json,
+  created_at,
+  updated_at
+)
+SELECT
+  t.profile,
+  COALESCE(NULLIF(t.peer_id, ''), t.scope_thread_id) AS user_id,
+  COALESCE(
+    NULLIF(MAX(CASE
+      WHEN m.sender_id = COALESCE(NULLIF(t.peer_id, ''), t.scope_thread_id) THEN m.sender_name
+      ELSE NULL
+    END), ''),
+    NULLIF(MAX(t.title), '')
+  ) AS display_name,
+  NULL,
+  NULL,
+  NULL,
+  'seen_dm',
+  MIN(m.timestamp_ms),
+  MAX(m.timestamp_ms),
+  t.raw_json,
+  MIN(t.created_at),
+  MAX(COALESCE(m.updated_at, t.updated_at))
+FROM threads t
+LEFT JOIN messages m
+  ON m.profile = t.profile
+  AND m.scope_thread_id = t.scope_thread_id
+  AND m.thread_type = 'user'
+WHERE t.thread_type = 'user'
+  AND COALESCE(NULLIF(t.peer_id, ''), t.scope_thread_id) <> ''
+GROUP BY t.profile, COALESCE(NULLIF(t.peer_id, ''), t.scope_thread_id), t.raw_json
+ON CONFLICT(profile, user_id) DO UPDATE SET
+  display_name = COALESCE(excluded.display_name, contacts.display_name),
+  relationship = CASE
+    WHEN contacts.relationship = 'friend' OR excluded.relationship = 'friend' THEN 'friend'
+    WHEN contacts.relationship = 'seen_dm' OR excluded.relationship = 'seen_dm' THEN 'seen_dm'
+    WHEN contacts.relationship = 'seen_group' OR excluded.relationship = 'seen_group' THEN 'seen_group'
+    ELSE COALESCE(excluded.relationship, contacts.relationship, 'unknown')
+  END,
+  first_seen_at_ms = CASE
+    WHEN contacts.first_seen_at_ms IS NULL THEN excluded.first_seen_at_ms
+    WHEN excluded.first_seen_at_ms IS NULL THEN contacts.first_seen_at_ms
+    ELSE MIN(contacts.first_seen_at_ms, excluded.first_seen_at_ms)
+  END,
+  last_seen_at_ms = CASE
+    WHEN contacts.last_seen_at_ms IS NULL THEN excluded.last_seen_at_ms
+    WHEN excluded.last_seen_at_ms IS NULL THEN contacts.last_seen_at_ms
+    ELSE MAX(contacts.last_seen_at_ms, excluded.last_seen_at_ms)
+  END,
+  raw_json = COALESCE(excluded.raw_json, contacts.raw_json),
+  updated_at = excluded.updated_at;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.53",
+  "version": "0.1.54",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
   "scripts": {
     "build": "npm run build:cli && npm run build:worker",
     "build:cli": "tsup src/cli.ts --format esm --target node22 --out-dir dist --clean",
-    "build:worker": "tsup src/lib/db-worker.ts --format esm --target node22 --out-dir dist",
+    "build:worker": "tsup src/lib/db-worker.ts src/lib/db-migrations.ts --format esm --target node22 --out-dir dist && node scripts/copy-db-migrations.mjs",
     "dev": "tsx src/cli.ts",
     "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc -p tsconfig.json",