openzca 0.1.52 → 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 });
 }
@@ -2333,6 +2465,8 @@ function normalizeCodeBlockLeadingWhitespace(line) {
 }
 
 // src/lib/text-send.ts
+var ZALO_TEXT_MESSAGE_MAX_LENGTH = 2e3;
+var ZALO_TEXT_REQUEST_PARAMS_MAX_ESTIMATE = 4e3;
 async function buildTextSendPayload(params) {
   if (params.raw) {
     const mentions2 = await resolveGroupMentionsIfNeeded(params, params.message);
@@ -2368,15 +2502,103 @@ async function analyzeTextSendPayload(params) {
   });
   return {
     payload,
-    payloadObject,
-    rawInputLength: params.message.length,
-    renderedTextLength: payloadObject.msg.length,
-    styleCount: payloadObject.styles?.length ?? 0,
-    mentionCount: payloadObject.mentions?.length ?? 0,
-    textPropertiesLength: textProperties?.length ?? 0,
-    mentionInfoLength: mentionInfo?.length ?? 0,
-    requestParamsLengthEstimate: JSON.stringify(requestParams).length,
-    sendPath: params.threadType === ThreadType.Group ? mentionInfo ? "mention" : "sendmsg" : "sms"
+    ...buildTextSendPayloadAnalysis({
+      payloadObject,
+      rawInputLength: params.message.length,
+      textProperties,
+      mentionInfo,
+      requestParamsLengthEstimate: JSON.stringify(requestParams).length,
+      threadType: params.threadType
+    })
+  };
+}
+function planTextSendPayloadsForDelivery(params) {
+  const maxMessageLength = resolvePositiveLimit(
+    params.maxMessageLength,
+    ZALO_TEXT_MESSAGE_MAX_LENGTH
+  );
+  const maxRequestParamsLengthEstimate = resolvePositiveLimit(
+    params.maxRequestParamsLengthEstimate,
+    ZALO_TEXT_REQUEST_PARAMS_MAX_ESTIMATE
+  );
+  const chunks = [];
+  const analyses = [];
+  const pending = [params.payload];
+  while (pending.length > 0) {
+    const currentPayload = pending.shift();
+    const analysis = analyzePreparedTextSendPayload({
+      payload: currentPayload,
+      threadType: params.threadType,
+      threadId: params.threadId
+    });
+    if (isTextSendPayloadWithinDeliveryLimits(analysis, {
+      maxMessageLength,
+      maxRequestParamsLengthEstimate
+    })) {
+      chunks.push(currentPayload);
+      analyses.push(analysis);
+      continue;
+    }
+    const targetLength = computeNextChunkLength(analysis, {
+      maxMessageLength,
+      maxRequestParamsLengthEstimate
+    });
+    const splitChunks = splitTextSendPayload(currentPayload, targetLength);
+    if (splitChunks.length <= 1) {
+      throw new Error(
+        `Unable to split formatted text payload into deliverable chunks within ${targetLength} characters.`
+      );
+    }
+    pending.unshift(...splitChunks);
+  }
+  return { chunks, analyses };
+}
+function splitTextSendPayload(payload, maxLength = ZALO_TEXT_MESSAGE_MAX_LENGTH) {
+  if (!Number.isInteger(maxLength) || maxLength <= 0) {
+    throw new Error("Text chunk size must be a positive integer");
+  }
+  const payloadObject = normalizeTextSendPayload(payload);
+  if (payloadObject.msg.length <= maxLength) {
+    return [payload];
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < payloadObject.msg.length) {
+    const end = findChunkEnd(payloadObject, start, maxLength);
+    chunks.push(sliceTextSendPayload(payloadObject, start, end));
+    start = end;
+  }
+  return chunks;
+}
+function analyzePreparedTextSendPayload(params) {
+  const payloadObject = normalizeTextSendPayload(params.payload);
+  const textProperties = buildTextProperties(payloadObject.styles);
+  const mentionInfo = buildMentionInfo(
+    params.threadType,
+    payloadObject.msg,
+    payloadObject.mentions
+  );
+  const requestParams = omitUndefined({
+    message: payloadObject.msg,
+    clientId: 17e11,
+    mentionInfo,
+    imei: params.threadType === ThreadType.Group ? void 0 : "000000000000000",
+    ttl: 0,
+    visibility: params.threadType === ThreadType.Group ? 0 : void 0,
+    toid: params.threadType === ThreadType.Group ? void 0 : params.threadId,
+    grid: params.threadType === ThreadType.Group ? params.threadId : void 0,
+    textProperties
+  });
+  return {
+    payload: params.payload,
+    ...buildTextSendPayloadAnalysis({
+      payloadObject,
+      rawInputLength: payloadObject.msg.length,
+      textProperties,
+      mentionInfo,
+      requestParamsLengthEstimate: JSON.stringify(requestParams).length,
+      threadType: params.threadType
+    })
   };
 }
 async function resolveGroupMentionsIfNeeded(params, text) {
@@ -2399,6 +2621,153 @@ function normalizeTextSendPayload(payload) {
   }
   return payload;
 }
+function buildTextSendPayloadAnalysis(params) {
+  return {
+    payloadObject: params.payloadObject,
+    rawInputLength: params.rawInputLength,
+    renderedTextLength: params.payloadObject.msg.length,
+    styleCount: params.payloadObject.styles?.length ?? 0,
+    mentionCount: params.payloadObject.mentions?.length ?? 0,
+    textPropertiesLength: params.textProperties?.length ?? 0,
+    mentionInfoLength: params.mentionInfo?.length ?? 0,
+    requestParamsLengthEstimate: params.requestParamsLengthEstimate,
+    sendPath: params.threadType === ThreadType.Group ? params.mentionInfo ? "mention" : "sendmsg" : "sms"
+  };
+}
+function isTextSendPayloadWithinDeliveryLimits(analysis, limits) {
+  return analysis.renderedTextLength <= limits.maxMessageLength && analysis.requestParamsLengthEstimate <= limits.maxRequestParamsLengthEstimate;
+}
+function computeNextChunkLength(analysis, limits) {
+  const currentLength = analysis.renderedTextLength;
+  const targetLengths = [limits.maxMessageLength, currentLength - 1].filter((value) => value > 0);
+  if (analysis.requestParamsLengthEstimate > limits.maxRequestParamsLengthEstimate) {
+    targetLengths.push(
+      Math.floor(
+        currentLength * limits.maxRequestParamsLengthEstimate / analysis.requestParamsLengthEstimate
+      )
+    );
+  }
+  const targetLength = Math.max(
+    1,
+    Math.min(...targetLengths.filter((value) => Number.isFinite(value) && value > 0))
+  );
+  return Math.min(targetLength, currentLength - 1);
+}
+function resolvePositiveLimit(value, fallback) {
+  if (!value || !Number.isInteger(value) || value <= 0) {
+    return fallback;
+  }
+  return value;
+}
+function sliceTextSendPayload(payloadObject, start, end) {
+  const msg2 = payloadObject.msg.slice(start, end);
+  const styles = sliceStyles(payloadObject.styles, start, end);
+  const mentions = sliceMentions(payloadObject.mentions, start, end);
+  if (!styles && !mentions) {
+    return msg2;
+  }
+  return omitUndefined({
+    msg: msg2,
+    styles,
+    mentions
+  });
+}
+function sliceStyles(styles, start, end) {
+  if (!styles || styles.length === 0) {
+    return void 0;
+  }
+  const sliced = [];
+  for (const style of styles) {
+    const styleStart = style.start;
+    const styleEnd = style.start + style.len;
+    const overlapStart = Math.max(styleStart, start);
+    const overlapEnd = Math.min(styleEnd, end);
+    if (overlapStart >= overlapEnd) {
+      continue;
+    }
+    if (style.st === "ind_$") {
+      sliced.push({
+        start: overlapStart - start,
+        len: overlapEnd - overlapStart,
+        st: style.st,
+        indentSize: style.indentSize
+      });
+      continue;
+    }
+    sliced.push({
+      start: overlapStart - start,
+      len: overlapEnd - overlapStart,
+      st: style.st
+    });
+  }
+  return sliced.length > 0 ? sliced : void 0;
+}
+function sliceMentions(mentions, start, end) {
+  if (!mentions || mentions.length === 0) {
+    return void 0;
+  }
+  const sliced = mentions.filter((mention) => mention.pos >= start && mention.pos + mention.len <= end).map((mention) => ({
+    pos: mention.pos - start,
+    uid: mention.uid,
+    len: mention.len
+  }));
+  return sliced.length > 0 ? sliced : void 0;
+}
+function findChunkEnd(payloadObject, start, maxLength) {
+  const remaining = payloadObject.msg.length - start;
+  if (remaining <= maxLength) {
+    return payloadObject.msg.length;
+  }
+  const maxEnd = start + maxLength;
+  const newlineBreak = findPreferredBreak(payloadObject, start, maxEnd, "\n");
+  if (newlineBreak > start) {
+    return newlineBreak;
+  }
+  const whitespaceBreak = findWhitespaceBreak(payloadObject, start, maxEnd);
+  if (whitespaceBreak > start) {
+    return whitespaceBreak;
+  }
+  for (let cursor = maxEnd; cursor > start; cursor -= 1) {
+    if (isSafeSplitPosition(payloadObject.mentions, cursor)) {
+      return cursor;
+    }
+  }
+  throw new Error(
+    `Unable to split text payload safely within ${maxLength} characters.`
+  );
+}
+function findPreferredBreak(payloadObject, start, maxEnd, marker) {
+  for (let cursor = maxEnd; cursor > start; cursor -= 1) {
+    if (!isSafeSplitPosition(payloadObject.mentions, cursor)) {
+      continue;
+    }
+    if (payloadObject.msg[cursor - 1] === marker) {
+      return cursor;
+    }
+  }
+  return start;
+}
+function findWhitespaceBreak(payloadObject, start, maxEnd) {
+  for (let cursor = maxEnd; cursor > start; cursor -= 1) {
+    if (!isSafeSplitPosition(payloadObject.mentions, cursor)) {
+      continue;
+    }
+    const previousChar = payloadObject.msg[cursor - 1];
+    if (previousChar === " " || previousChar === "	") {
+      return cursor;
+    }
+  }
+  return start;
+}
+function isSafeSplitPosition(mentions, position) {
+  if (!mentions || mentions.length === 0) {
+    return true;
+  }
+  return mentions.every((mention) => {
+    const mentionEnd = mention.pos + mention.len;
+    return position <= mention.pos || position >= mentionEnd;
+  });
+}
 function buildTextProperties(styles) {
   if (!styles || styles.length === 0) {
     return void 0;
@@ -3781,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,
@@ -3790,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
     }))
   );
@@ -3806,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({
@@ -3826,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) {
@@ -3965,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;
@@ -4343,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) {
@@ -6318,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) => {
@@ -6523,20 +7032,67 @@ msg.command("send <threadId> <message>").option("-g, --group", "Send to group").
       ...typeof textPayload === "string" ? { msg: textPayload } : textPayload,
       ...quote ? { quote } : {}
     } : textPayload;
-    const response = await api.sendMessage(payload, threadId, threadType);
+    const deliveryPlan = planTextSendPayloadsForDelivery({
+      payload: textPayload,
+      threadType,
+      threadId,
+      maxMessageLength: parsePositiveIntFromEnv(
+        "OPENZCA_TEXT_MESSAGE_MAX_LENGTH",
+        ZALO_TEXT_MESSAGE_MAX_LENGTH
+      ),
+      maxRequestParamsLengthEstimate: parsePositiveIntFromEnv(
+        "OPENZCA_TEXT_REQUEST_PARAMS_MAX_ESTIMATE",
+        ZALO_TEXT_REQUEST_PARAMS_MAX_ESTIMATE
+      )
+    });
+    const payloadChunks = deliveryPlan.chunks;
+    const responses = [];
+    const sentPayloads = [];
+    for (let index = 0; index < payloadChunks.length; index += 1) {
+      const chunk = payloadChunks[index];
+      const chunkPayload = quote && index === 0 ? {
+        ...typeof chunk === "string" ? { msg: chunk } : chunk,
+        quote
+      } : chunk;
+      sentPayloads.push(chunkPayload);
+      responses.push(await api.sendMessage(chunkPayload, threadId, threadType));
+    }
+    const response = responses.length === 1 ? responses[0] : {
+      chunked: true,
+      chunkCount: responses.length,
+      msgId: responses.at(-1)?.message?.msgId?.toString(),
+      response: responses
+    };
     output(response, false);
     if (await shouldWriteToDb(profile)) {
       scheduleDbWrite(profile, command, "msg.send.db.persist_error", async () => {
-        await persistOutgoingMessageBestEffort({
-          profile,
-          api,
-          threadId,
-          group: opts.group,
-          text: message,
-          msgType: "text",
-          response,
-          rawPayload: payload
-        });
+        if (payloadChunks.length === 1) {
+          await persistOutgoingMessageBestEffort({
+            profile,
+            api,
+            threadId,
+            group: opts.group,
+            text: message,
+            msgType: "text",
+            response,
+            rawPayload: payload
+          });
+          return;
+        }
+        for (let index = 0; index < payloadChunks.length; index += 1) {
+          const chunk = sentPayloads[index];
+          const chunkText = typeof chunk === "string" ? chunk : chunk.msg;
+          await persistOutgoingMessageBestEffort({
+            profile,
+            api,
+            threadId,
+            group: opts.group,
+            text: chunkText,
+            msgType: "text",
+            response: responses[index],
+            rawPayload: chunk
+          });
+        }
       });
     }
   })
@@ -8125,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) {