chatlab-cli 0.31.0 → 0.31.1

package/dist/{chunk-T64GA5HP.mjs → chunk-KCPGEILH.mjs}

@@ -9,7 +9,7 @@ import {
   createEmptyContactsDiagnostics,
   normalizeContactsTimeRangePreset,
   resolveContactsTimeRange
-} from "./chunk-SNCXU2QL.mjs";
+} from "./chunk-7HBVGVOB.mjs";
 import {
   PEOPLE_RELATIONSHIPS_ALGORITHM_VERSION,
   buildPeopleRelationshipsNeighborhoodGraph,
@@ -18,7 +18,7 @@ import {
   computePeopleRelationshipsSnapshot,
   normalizePeopleRelationshipsTimeRangePreset,
   resolvePeopleRelationshipsTimeRange
-} from "./chunk-RDCUGC24.mjs";
+} from "./chunk-LJXSUN25.mjs";
 import {
   ANNUAL_SUMMARY_ALGORITHM_VERSION
 } from "./chunk-YAQLYL52.mjs";
@@ -93,7 +93,7 @@ import {
   updateSessionOwnerId,
   writeAnnualSummarySnapshot,
   writeAuthProfile
-} from "./chunk-UWWFOEGF.mjs";
+} from "./chunk-DQ45LDKZ.mjs";
 import {
   __commonJS,
   __export,
@@ -3881,6 +3881,9 @@ function extractNameFromFilePath3(filePath) {
   const basename13 = path5.basename(filePath);
   return basename13.replace(/\.json$/i, "") || "\u672A\u77E5\u7FA4\u804A";
 }
+function isPlaceholderSenderId(id) {
+  return id === "0" || id === "\u672A\u77E5";
+}
 function countSenders(content) {
   const sendersStart = content.indexOf('"senders"');
   if (sendersStart === -1) return 0;
@@ -3895,8 +3898,19 @@ function countSenders(content) {
   }
   if (depth !== 0) return 0;
   const sendersContent = content.slice(arrayStart + 1, i - 1);
-  const uidMatches = sendersContent.match(/"uid"\s*:/g);
-  return uidMatches ? uidMatches.length : 0;
+  const uidMatches = sendersContent.matchAll(/"uid"\s*:\s*"([^"]*)"/g);
+  let count = 0;
+  for (const match of uidMatches) {
+    const uid = match[1];
+    if (uid && !isPlaceholderSenderId(uid)) count++;
+  }
+  return count;
+}
+function resolveChatType(chatInfoType, headContent) {
+  if (chatInfoType === "group") return "group" /* GROUP */;
+  const sendersCount = countSenders(headContent);
+  if (chatInfoType === "private") return sendersCount > 2 ? "group" /* GROUP */ : "private" /* PRIVATE */;
+  return sendersCount > 2 ? "group" /* GROUP */ : sendersCount > 0 ? "private" /* PRIVATE */ : "group" /* GROUP */;
 }
 function convertMessageType(messageType, content, isRecalled) {
   if (isRecalled) return 81 /* RECALL */;
@@ -3950,8 +3964,7 @@ async function* parseV4(options2) {
     }
   } catch {
   }
-  const sendersCount = countSenders(headContent);
-  const chatType = sendersCount > 2 ? "group" /* GROUP */ : sendersCount > 0 ? "private" /* PRIVATE */ : "group" /* GROUP */;
+  const chatType = resolveChatType(chatInfo.type, headContent);
   const meta = {
     name: chatInfo.name || extractNameFromFilePath3(filePath),
     platform: KNOWN_PLATFORMS.QQ,
@@ -3970,7 +3983,7 @@ async function* parseV4(options2) {
     const pipeline2 = chain3([readStream, parser4(), pick3({ filter: /^messages\.\d+$/ }), streamValues3()]);
     pipeline2.on("data", ({ value }) => {
       const platformId = value.sender.uin || value.sender.uid || value.rawMessage?.senderUin || value.rawMessage?.senderUid;
-      if (!platformId) {
+      if (!platformId || isPlaceholderSenderId(platformId)) {
         skippedMessages++;
         return;
       }
@@ -3989,9 +4002,11 @@ async function* parseV4(options2) {
         skippedMessages++;
         return;
       }
-      const type = value.isSystemMessage ? 80 /* SYSTEM */ : convertMessageType(value.messageType, value.content, value.isRecalled);
+      const isSystem = value.system ?? value.isSystemMessage;
+      const isRecalled = value.recalled ?? value.isRecalled;
+      const type = isSystem ? 80 /* SYSTEM */ : convertMessageType(value.messageType, value.content, isRecalled);
       let textContent = value.content?.text || "";
-      if (value.isRecalled) textContent = "[\u5DF2\u64A4\u56DE] " + textContent;
+      if (isRecalled) textContent = "[\u5DF2\u64A4\u56DE] " + textContent;
       messageBatch.push({
         platformMessageId: value.messageId,
         // 消息的平台原始 ID
@@ -7890,8 +7905,8 @@ async function streamImportSingle(filePath, deps, formatFeature, formatOptions,
   }
   return { success: true, sessionId, diagnostics };
 }
-async function analyzeNewImport(filePath, onProgress) {
-  const formatFeature = detectFormat(filePath);
+async function analyzeNewImport(filePath, onProgress, options2) {
+  const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
   if (!formatFeature) {
     return {
       totalMessages: 0,
@@ -7908,30 +7923,35 @@ async function analyzeNewImport(filePath, onProgress) {
   let totalMessages = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
-  await streamParseFile(filePath, {
-    onMeta: (parsedMeta) => {
-      meta = { name: parsedMeta.name, platform: parsedMeta.platform, type: parsedMeta.type };
-    },
-    onMembers: (members) => {
-      for (const m of members) memberSet.add(m.platformId);
-    },
-    onProgress: (progress) => {
-      onProgress(progress);
-    },
-    onMessageBatch: (batch) => {
-      for (const msg of batch) {
-        totalMessages++;
-        if (!memberSet.has(msg.senderPlatformId)) memberSet.add(msg.senderPlatformId);
-        const prepared = prepareMessageForCreate(msg);
-        if ("skipCounter" in prepared) continue;
-        if (registerMessageAndCheckDuplicate(prepared.message, dedupState)) {
-          duplicateCount++;
-        } else {
-          newMessageCount++;
+  await streamParseFile(
+    filePath,
+    {
+      formatOptions: options2?.chatIndex === void 0 ? void 0 : { chatIndex: options2.chatIndex },
+      onMeta: (parsedMeta) => {
+        meta = { name: parsedMeta.name, platform: parsedMeta.platform, type: parsedMeta.type };
+      },
+      onMembers: (members) => {
+        for (const m of members) memberSet.add(m.platformId);
+      },
+      onProgress: (progress) => {
+        onProgress(progress);
+      },
+      onMessageBatch: (batch) => {
+        for (const msg of batch) {
+          totalMessages++;
+          if (!memberSet.has(msg.senderPlatformId)) memberSet.add(msg.senderPlatformId);
+          const prepared = prepareMessageForCreate(msg);
+          if ("skipCounter" in prepared) continue;
+          if (registerMessageAndCheckDuplicate(prepared.message, dedupState)) {
+            duplicateCount++;
+          } else {
+            newMessageCount++;
+          }
         }
       }
-    }
-  });
+    },
+    options2?.formatId
+  );
   return { totalMessages, newMessageCount, duplicateCount, totalMembers: memberSet.size, meta };
 }
 async function streamParseFileInfo(filePath, deps) {
@@ -8128,8 +8148,8 @@ function normalizeImportTimestamp(timestamp) {
   const value = typeof timestamp === "string" && timestamp.trim() !== "" ? Number(timestamp) : timestamp;
   return typeof value === "number" && value > 0 && Number.isFinite(value) ? value : null;
 }
-async function analyzeIncrementalImport(sessionId, filePath, deps) {
-  const formatFeature = detectFormat(filePath);
+async function analyzeIncrementalImport(sessionId, filePath, deps, options2) {
+  const formatFeature = options2?.formatId ? getFormatFeatureById(options2.formatId) : detectFormat(filePath);
   if (!formatFeature) {
     return { error: "error.unrecognized_format", newMessageCount: 0, duplicateCount: 0, totalInFile: 0 };
   }
@@ -8144,27 +8164,32 @@ async function analyzeIncrementalImport(sessionId, filePath, deps) {
   let totalInFile = 0;
   let newMessageCount = 0;
   let duplicateCount = 0;
-  await streamParseFile(filePath, {
-    onMeta: () => {
-    },
-    onMembers: () => {
-    },
-    onProgress: (progress) => {
-      deps.onProgress(progress);
-    },
-    onMessageBatch: (batch) => {
-      for (const msg of batch) {
-        totalInFile++;
-        const timestamp = normalizeImportTimestamp(msg.timestamp);
-        if (timestamp === null) continue;
-        if (isDuplicate({ ...msg, timestamp }, existingPlatformMsgIds, existingKeys, existingFallbackOnlyKeys)) {
-          duplicateCount++;
-        } else {
-          newMessageCount++;
+  await streamParseFile(
+    filePath,
+    {
+      formatOptions: options2?.chatIndex === void 0 ? void 0 : { chatIndex: options2.chatIndex },
+      onMeta: () => {
+      },
+      onMembers: () => {
+      },
+      onProgress: (progress) => {
+        deps.onProgress(progress);
+      },
+      onMessageBatch: (batch) => {
+        for (const msg of batch) {
+          totalInFile++;
+          const timestamp = normalizeImportTimestamp(msg.timestamp);
+          if (timestamp === null) continue;
+          if (isDuplicate({ ...msg, timestamp }, existingPlatformMsgIds, existingKeys, existingFallbackOnlyKeys)) {
+            duplicateCount++;
+          } else {
+            newMessageCount++;
+          }
         }
       }
-    }
-  });
+    },
+    options2?.formatId
+  );
   return { newMessageCount, duplicateCount, totalInFile };
 }
 async function incrementalImport(sessionId, filePath, deps, options2) {
@@ -8418,6 +8443,12 @@ async function incrementalImport(sessionId, filePath, deps, options2) {
   }
 }
 
+// ../../packages/node-runtime/src/import/session-id.ts
+var SAFE_IMPORT_SESSION_ID_RE = /^[A-Za-z0-9_@-][A-Za-z0-9._@-]{0,127}$/;
+function isValidImportSessionId(sessionId) {
+  return SAFE_IMPORT_SESSION_ID_RE.test(sessionId) && !sessionId.includes("..");
+}
+
 // ../../packages/node-runtime/src/import/auto-import-matcher.ts
 var MATCH_WINDOW_SIZE = 5;
 function buildPrivateIdentity(ownerId, memberIds) {
@@ -8528,6 +8559,20 @@ async function resolveAutoImportTarget(filePath, deps, formatOptions) {
 }
 
 // ../../packages/node-runtime/src/import/auto-importer.ts
+async function planAutoImport(filePath, deps, options2) {
+  if (options2.explicitSessionId) {
+    if (!isValidImportSessionId(options2.explicitSessionId)) {
+      throw new Error("sessionId contains invalid characters");
+    }
+    return deps.sessionExists(options2.explicitSessionId) ? { action: "incremental", sessionId: options2.explicitSessionId } : { action: "create", sessionId: options2.explicitSessionId };
+  }
+  const decision = await (deps.resolveTarget ?? resolveAutoImportTarget)(
+    filePath,
+    deps,
+    options2.formatOptions
+  );
+  return decision.action === "incremental" ? { action: "incremental", sessionId: decision.sessionId, matchedBy: decision.matchedBy } : { action: "create", reason: decision.reason };
+}
 function mapCreateResult(result, createReason) {
   if (!result.success || !result.sessionId) {
     return { success: false, error: result.error, diagnostics: result.diagnostics };
@@ -8539,6 +8584,11 @@ function mapCreateResult(result, createReason) {
     ...createReason ? { createReason } : {},
     newMessageCount: result.diagnostics?.messagesWritten ?? 0,
     duplicateCount: result.diagnostics?.duplicateCount ?? 0,
+    batch: result.diagnostics ? {
+      receivedCount: result.diagnostics.messagesReceived,
+      writtenCount: result.diagnostics.messagesWritten,
+      duplicateCount: result.diagnostics.duplicateCount
+    } : void 0,
     diagnostics: result.diagnostics
   };
 }
@@ -8550,61 +8600,41 @@ function mapIncrementalResult(sessionId, result, matchedBy) {
     importMode: "incremental",
     ...matchedBy ? { matchedBy } : {},
     newMessageCount: result.newMessageCount,
-    duplicateCount: result.batch?.duplicateCount ?? 0
+    duplicateCount: result.batch?.duplicateCount ?? 0,
+    batch: result.batch,
+    session: result.session,
+    updates: result.updates
   };
 }
 async function autoImportFile(filePath, deps, options2 = {}) {
   try {
-    if (options2.explicitSessionId) {
-      if (deps.sessionExists(options2.explicitSessionId)) {
-        const result3 = mapIncrementalResult(
-          options2.explicitSessionId,
-          await deps.appendSession(options2.explicitSessionId, filePath, options2.formatOptions)
-        );
-        appLogger.info("import", "Explicit incremental import completed", {
-          sessionId: options2.explicitSessionId,
-          success: result3.success,
-          newMessageCount: result3.newMessageCount,
-          duplicateCount: result3.duplicateCount
-        });
-        return result3;
-      }
-      const result2 = mapCreateResult(
-        await deps.createSession(filePath, options2.formatOptions, options2.explicitSessionId)
-      );
-      appLogger.info("import", "Explicit session import completed", {
-        sessionId: result2.sessionId,
-        success: result2.success,
-        importMode: result2.importMode
+    if (!options2.explicitSessionId) {
+      appLogger.info("import", "Automatic session matching started", {
+        candidateCount: deps.listSessionIds().length
       });
-      return result2;
     }
-    appLogger.info("import", "Automatic session matching started", {
-      candidateCount: deps.listSessionIds().length
-    });
-    const decision = await (deps.resolveTarget ?? resolveAutoImportTarget)(
-      filePath,
-      deps,
-      options2.formatOptions
-    );
-    if (decision.action === "incremental") {
+    const plan = await planAutoImport(filePath, deps, options2);
+    if (plan.action === "incremental") {
       const result2 = mapIncrementalResult(
-        decision.sessionId,
-        await deps.appendSession(decision.sessionId, filePath, options2.formatOptions),
-        decision.matchedBy
+        plan.sessionId,
+        await deps.appendSession(plan.sessionId, filePath, options2.formatOptions),
+        plan.matchedBy
       );
-      appLogger.info("import", "Automatic incremental import completed", {
-        sessionId: decision.sessionId,
-        matchedBy: decision.matchedBy,
+      appLogger.info("import", "Incremental import completed", {
+        sessionId: plan.sessionId,
+        matchedBy: plan.matchedBy,
         success: result2.success,
         newMessageCount: result2.newMessageCount,
         duplicateCount: result2.duplicateCount
       });
       return result2;
     }
-    const result = mapCreateResult(await deps.createSession(filePath, options2.formatOptions), decision.reason);
-    appLogger.info("import", "Automatic import created a new session", {
-      reason: decision.reason,
+    const result = mapCreateResult(
+      await deps.createSession(filePath, options2.formatOptions, plan.sessionId),
+      plan.reason
+    );
+    appLogger.info("import", "Import created a new session", {
+      reason: plan.reason,
       sessionId: result.sessionId,
       success: result.success
     });
@@ -8614,6 +8644,53 @@ async function autoImportFile(filePath, deps, options2 = {}) {
     return { success: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
+async function analyzeAutoImportFile(filePath, deps, options2 = {}) {
+  try {
+    const plan = await planAutoImport(filePath, deps, options2);
+    if (plan.action === "incremental") {
+      const analysis2 = await deps.analyzeAppendSession(plan.sessionId, filePath, options2.formatOptions);
+      if (analysis2.error) return { success: false, error: analysis2.error };
+      const result2 = {
+        success: true,
+        importMode: "incremental",
+        sessionId: plan.sessionId,
+        ...plan.matchedBy ? { matchedBy: plan.matchedBy } : {},
+        totalMessageCount: analysis2.totalInFile,
+        newMessageCount: analysis2.newMessageCount,
+        duplicateCount: analysis2.duplicateCount
+      };
+      appLogger.info("import", "Incremental import analysis completed", {
+        sessionId: plan.sessionId,
+        matchedBy: plan.matchedBy,
+        newMessageCount: analysis2.newMessageCount,
+        duplicateCount: analysis2.duplicateCount
+      });
+      return result2;
+    }
+    const analysis = await deps.analyzeCreateSession(filePath, options2.formatOptions);
+    if (analysis.error) return { success: false, error: analysis.error };
+    const result = {
+      success: true,
+      importMode: "created",
+      ...plan.sessionId ? { sessionId: plan.sessionId } : {},
+      ...plan.reason ? { createReason: plan.reason } : {},
+      totalMessageCount: analysis.totalMessages,
+      newMessageCount: analysis.newMessageCount,
+      duplicateCount: analysis.duplicateCount,
+      totalMemberCount: analysis.totalMembers,
+      meta: analysis.meta
+    };
+    appLogger.info("import", "New session import analysis completed", {
+      reason: plan.reason,
+      messageCount: analysis.totalMessages,
+      memberCount: analysis.totalMembers
+    });
+    return result;
+  } catch (error) {
+    appLogger.error("import", "Automatic import analysis failed", error);
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
 
 // ../../packages/node-runtime/src/import/import-lock.ts
 import * as fs21 from "fs";
@@ -20085,17 +20162,41 @@ var MergeSessionCache = class {
 import * as fs34 from "fs";
 var SYSTEM_SENDER_ID = "SYSTEM";
 var SYSTEM_MEMBER_NAME = "\u7CFB\u7EDF\u6D88\u606F";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateOptionalString(value, field) {
+  return value !== void 0 && typeof value !== "string" ? `${field} must be a string` : null;
+}
 function validatePayload(payload, isNew) {
+  if (!isRecord3(payload)) return "payload must be an object";
   const messages = payload.messages;
   if (!Array.isArray(messages) || messages.length === 0) return "messages is required and must be a non-empty array";
+  if (payload.chatlab !== void 0) {
+    if (!isRecord3(payload.chatlab)) return "chatlab must be an object";
+    if (typeof payload.chatlab.version !== "string" || payload.chatlab.version.length === 0)
+      return "chatlab.version must be a string";
+    if (typeof payload.chatlab.exportedAt !== "number" || !Number.isFinite(payload.chatlab.exportedAt))
+      return "chatlab.exportedAt must be a number";
+    const generatorError = validateOptionalString(payload.chatlab.generator, "chatlab.generator");
+    if (generatorError) return generatorError;
+  }
   if (isNew) {
     if (!payload.chatlab) return "chatlab is required for new sessions";
     if (!payload.meta) return "meta is required for new sessions";
-    const m = payload.meta;
-    if (!m.name) return "meta.name is required";
-    if (!m.platform) return "meta.platform is required";
-    if (!m.type) return "meta.type is required";
   }
+  if (payload.meta !== void 0) {
+    if (!isRecord3(payload.meta)) return "meta must be an object";
+    const metaFields = ["name", "platform", "type", "groupId", "groupAvatar", "ownerId"];
+    for (const field of metaFields) {
+      const error = validateOptionalString(payload.meta[field], `meta.${field}`);
+      if (error) return error;
+    }
+    if (isNew && !payload.meta.name) return "meta.name is required";
+    if (isNew && !payload.meta.platform) return "meta.platform is required";
+    if (isNew && !payload.meta.type) return "meta.type is required";
+  }
+  if (payload.options !== void 0 && !isRecord3(payload.options)) return "options must be an object";
   const { metaUpdateMode, memberUpdateMode } = payload.options ?? {};
   if (metaUpdateMode !== void 0 && metaUpdateMode !== "patch" && metaUpdateMode !== "none") {
     return `options.metaUpdateMode must be 'patch' or 'none'`;
@@ -20106,16 +20207,35 @@ function validatePayload(payload, isNew) {
   if (payload.members !== void 0 && !Array.isArray(payload.members)) return "members must be an array";
   if (payload.members) {
     for (let i = 0; i < payload.members.length; i++) {
-      if (typeof payload.members[i].platformId !== "string" || payload.members[i].platformId.length === 0)
+      const member = payload.members[i];
+      if (!isRecord3(member)) return `members[${i}] must be an object`;
+      if (typeof member.platformId !== "string" || member.platformId.length === 0)
         return `members[${i}].platformId must be a string`;
+      for (const field of ["accountName", "groupNickname", "avatar"]) {
+        const error = validateOptionalString(member[field], `members[${i}].${field}`);
+        if (error) return error;
+      }
+      if (member.roles !== void 0) {
+        if (!Array.isArray(member.roles)) return `members[${i}].roles must be an array`;
+        for (let j = 0; j < member.roles.length; j++) {
+          const role = member.roles[j];
+          if (!isRecord3(role) || typeof role.id !== "string" || role.id.length === 0)
+            return `members[${i}].roles[${j}].id must be a string`;
+        }
+      }
     }
   }
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
+    if (!isRecord3(msg)) return `messages[${i}] must be an object`;
     if (typeof msg.sender !== "string" || msg.sender.length === 0) return `messages[${i}].sender must be a string`;
-    if (typeof msg.timestamp !== "number" || msg.timestamp <= 0)
+    if (typeof msg.timestamp !== "number" || !Number.isFinite(msg.timestamp) || msg.timestamp <= 0)
       return `messages[${i}].timestamp must be a positive number`;
-    if (typeof msg.type !== "number") return `messages[${i}].type must be a number`;
+    if (typeof msg.type !== "number" || !Number.isFinite(msg.type)) return `messages[${i}].type must be a number`;
+    for (const field of ["accountName", "groupNickname"]) {
+      const error = validateOptionalString(msg[field], `messages[${i}].${field}`);
+      if (error) return error;
+    }
     if (msg.content !== void 0 && msg.content !== null && typeof msg.content !== "string")
       return `messages[${i}].content must be a string or null`;
     if (msg.platformMessageId !== void 0 && typeof msg.platformMessageId !== "string")
@@ -20136,47 +20256,79 @@ function normalizeSenderAccountName(sender, accountName) {
 function normalizeSenderGroupNickname(sender, groupNickname) {
   return sender === SYSTEM_SENDER_ID ? SYSTEM_MEMBER_NAME : groupNickname;
 }
-function writeMessages(db, messages, existingPmids, existingKeys) {
+function isCountedMember(platformId) {
+  return platformId !== SYSTEM_SENDER_ID;
+}
+function registerPushMessageAndCheckDuplicate(message, dedupState) {
+  return registerMessageAndCheckDuplicate(
+    {
+      platformMessageId: message.platformMessageId,
+      timestamp: message.timestamp,
+      senderPlatformId: message.sender,
+      type: message.type,
+      content: message.content ?? null,
+      replyToMessageId: message.replyToMessageId
+    },
+    dedupState
+  );
+}
+function createExistingMessageDedupState(db) {
+  const existingPmids = /* @__PURE__ */ new Set();
+  const existingKeys = /* @__PURE__ */ new Set();
+  const existingFallbackOnlyKeys = /* @__PURE__ */ new Set();
+  const existingMessages = db.prepare(
+    `SELECT msg.ts, m.platform_id, msg.type, msg.content, msg.reply_to_message_id, msg.platform_message_id
+       FROM message msg
+       JOIN member m ON msg.sender_id = m.id`
+  ).all();
+  for (const message of existingMessages) {
+    if (message.platform_message_id) existingPmids.add(message.platform_message_id);
+    const key = generateFallbackMessageKey({
+      timestamp: message.ts,
+      senderPlatformId: message.platform_id,
+      type: message.type,
+      content: message.content,
+      replyToMessageId: message.reply_to_message_id ?? void 0
+    });
+    existingKeys.add(key);
+    if (!message.platform_message_id) existingFallbackOnlyKeys.add(key);
+  }
+  return createMessageDedupState(existingPmids, existingKeys, existingFallbackOnlyKeys);
+}
+function writeMessages(db, messages, dedupState) {
   const insertMsg = db.prepare(
     `INSERT INTO message (sender_id, sender_account_name, sender_group_nickname, ts, type, content, reply_to_message_id, platform_message_id)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
   );
   const getMemberId = db.prepare("SELECT id FROM member WHERE platform_id = ?");
-  const insertMinimalMember = db.prepare("INSERT OR IGNORE INTO member (platform_id, account_name) VALUES (?, ?)");
+  const insertMinimalMember = db.prepare(
+    "INSERT OR IGNORE INTO member (platform_id, account_name, group_nickname) VALUES (?, ?, ?)"
+  );
   const memberIdCache = /* @__PURE__ */ new Map();
   let writtenCount = 0;
   let duplicateCount = 0;
+  let membersAdded = 0;
   let minWrittenTs = Infinity;
   const ftsEntries = [];
   const sorted = [...messages].sort((a, b) => a.timestamp - b.timestamp);
   db.transaction(() => {
     for (const msg of sorted) {
-      const key = generateMessageKey(msg.timestamp, msg.sender, msg.content ?? null);
-      if (msg.platformMessageId) {
-        if (existingPmids.has(msg.platformMessageId)) {
-          duplicateCount++;
-          continue;
-        }
-        if (existingKeys.has(key)) {
-          duplicateCount++;
-          continue;
-        }
-        existingPmids.add(msg.platformMessageId);
-        existingKeys.add(key);
-      } else {
-        if (existingKeys.has(key)) {
-          duplicateCount++;
-          continue;
-        }
-        existingKeys.add(key);
+      if (registerPushMessageAndCheckDuplicate(msg, dedupState)) {
+        duplicateCount++;
+        continue;
       }
       let memberId = memberIdCache.get(msg.sender);
       if (!memberId) {
-        insertMinimalMember.run(msg.sender, normalizeSenderAccountName(msg.sender, msg.accountName) || null);
+        const insertResult = insertMinimalMember.run(
+          msg.sender,
+          normalizeSenderAccountName(msg.sender, msg.accountName) || null,
+          normalizeSenderGroupNickname(msg.sender, msg.groupNickname) || null
+        );
         const row = getMemberId.get(msg.sender);
         if (row) {
           memberId = row.id;
           memberIdCache.set(msg.sender, memberId);
+          if (isCountedMember(msg.sender)) membersAdded += insertResult.changes;
         }
       }
       if (!memberId) continue;
@@ -20195,7 +20347,7 @@ function writeMessages(db, messages, existingPmids, existingKeys) {
       writtenCount++;
     }
   });
-  return { writtenCount, duplicateCount, minWrittenTs, ftsEntries };
+  return { writtenCount, duplicateCount, membersAdded, minWrittenTs, ftsEntries };
 }
 function fullImport(db, meta, members, messages) {
   db.exec(CHAT_DB_SCHEMA);
@@ -20212,29 +20364,13 @@ function fullImport(db, meta, members, messages) {
     }
   }
   const allMembers = extraMembers.length > 0 ? [...members, ...extraMembers] : members;
-  const pmids = /* @__PURE__ */ new Set();
-  const hashKeys = /* @__PURE__ */ new Set();
+  const dedupState = createMessageDedupState();
   let duplicateCount = 0;
   const dedupedMessages = [];
   for (const msg of messages) {
-    const key = generateMessageKey(msg.timestamp, msg.sender, msg.content ?? null);
-    if (msg.platformMessageId) {
-      if (pmids.has(msg.platformMessageId)) {
-        duplicateCount++;
-        continue;
-      }
-      if (hashKeys.has(key)) {
-        duplicateCount++;
-        continue;
-      }
-      pmids.add(msg.platformMessageId);
-      hashKeys.add(key);
-    } else {
-      if (hashKeys.has(key)) {
-        duplicateCount++;
-        continue;
-      }
-      hashKeys.add(key);
+    if (registerPushMessageAndCheckDuplicate(msg, dedupState)) {
+      duplicateCount++;
+      continue;
     }
     dedupedMessages.push(msg);
   }
@@ -20262,15 +20398,12 @@ function fullImport(db, meta, members, messages) {
     generateSessionIndex(db);
   } catch {
   }
-  return { writtenCount: stats.messageCount, duplicateCount, membersAdded: members.length };
+  return { writtenCount: stats.messageCount, duplicateCount };
 }
-function incrementalImport2(db, payload) {
+function writeIncrementalImport(db, payload) {
   const metaUpdateMode = payload.options?.metaUpdateMode ?? "patch";
   const memberUpdateMode = payload.options?.memberUpdateMode ?? "upsert";
-  const existingPmids = /* @__PURE__ */ new Set();
-  const existingKeys = /* @__PURE__ */ new Set();
-  db.prepare("SELECT platform_message_id FROM message WHERE platform_message_id IS NOT NULL").all().forEach((r) => existingPmids.add(r.platform_message_id));
-  db.prepare(`SELECT msg.ts, m.platform_id, msg.content FROM message msg JOIN member m ON msg.sender_id = m.id`).all().forEach((r) => existingKeys.add(generateMessageKey(r.ts, r.platform_id, r.content)));
+  const dedupState = createExistingMessageDedupState(db);
   let metaUpdated = false;
   let membersAdded = 0;
   let membersUpdated = 0;
@@ -20307,22 +20440,23 @@ function incrementalImport2(db, payload) {
           m.roles ? JSON.stringify(m.roles) : "[]"
         );
         if (!existed) {
-          membersAdded++;
+          if (isCountedMember(m.platformId)) membersAdded++;
           const row = getMemberId.get(m.platformId);
           if (row) existingMemberIds.add(m.platformId);
-        } else {
+        } else if (isCountedMember(m.platformId)) {
           membersUpdated++;
         }
       }
     });
   }
   const preWriteMaxTs = db.prepare("SELECT MAX(ts) as max_ts FROM message").get()?.max_ts ?? 0;
-  const { writtenCount, duplicateCount, minWrittenTs, ftsEntries } = writeMessages(
-    db,
-    payload.messages,
-    existingPmids,
-    existingKeys
-  );
+  const {
+    writtenCount,
+    duplicateCount,
+    membersAdded: autoCreatedMembersAdded,
+    minWrittenTs,
+    ftsEntries
+  } = writeMessages(db, payload.messages, dedupState);
   if (ftsEntries.length > 0) {
     try {
       insertFtsEntries(db, ftsEntries);
@@ -20342,18 +20476,40 @@ function incrementalImport2(db, payload) {
   if (!metaUpdated) {
     db.prepare("UPDATE meta SET imported_at = ?").run(Math.floor(Date.now() / 1e3));
   }
-  return { writtenCount, duplicateCount, metaUpdated, membersAdded, membersUpdated };
+  return {
+    writtenCount,
+    duplicateCount,
+    metaUpdated,
+    membersAdded: membersAdded + autoCreatedMembersAdded,
+    membersUpdated
+  };
+}
+function incrementalImport2(db, payload) {
+  return db.transaction(() => writeIncrementalImport(db, payload));
 }
-var SAFE_SESSION_ID_RE = /^[a-zA-Z0-9_@-][a-zA-Z0-9_@.-]*$/;
 async function pushImport(dbManager, sessionId, payload) {
-  if (!SAFE_SESSION_ID_RE.test(sessionId) || sessionId.includes("..")) {
-    return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
-  }
   try {
-    return await withDataDirImportLock(
-      dbManager.getUserDataDir(),
-      () => pushImportUnlocked(dbManager, sessionId, payload)
-    );
+    return await withDataDirImportLock(dbManager.getUserDataDir(), async () => {
+      const outcome = await executePushImportUnlocked(
+        {
+          getDbPath: (id) => dbManager.getDbPath(id),
+          openDatabase: (id, options2) => dbManager.openRawSessionDatabase(id, options2),
+          deleteDatabase: (id) => {
+            dbManager.deleteSessionDatabaseFiles(id);
+          }
+        },
+        sessionId,
+        payload
+      );
+      if (!outcome.ok) return outcome;
+      try {
+        dbManager.raiseCurrentChatDbCompatibilityGate();
+      } catch (error) {
+        if (outcome.result.created) dbManager.deleteSessionDatabaseFiles(sessionId);
+        throw error;
+      }
+      return outcome;
+    });
   } catch (error) {
     if (error instanceof ImportInProgressError) {
       return {
@@ -20365,8 +20521,11 @@ async function pushImport(dbManager, sessionId, payload) {
     throw error;
   }
 }
-async function pushImportUnlocked(dbManager, sessionId, payload) {
-  const dbPath = dbManager.getDbPath(sessionId);
+async function executePushImportUnlocked(deps, sessionId, payload) {
+  if (!isValidImportSessionId(sessionId)) {
+    return { ok: false, reason: "invalid_payload", message: "sessionId contains invalid characters" };
+  }
+  const dbPath = deps.getDbPath(sessionId);
   const isNew = !fs34.existsSync(dbPath);
   const validationError = validatePayload(payload, isNew);
   if (validationError) {
@@ -20374,17 +20533,12 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
   }
   try {
     if (isNew) {
-      const db2 = dbManager.openRawSessionDatabase(sessionId, { create: true });
+      const db2 = deps.openDatabase(sessionId, { create: true });
       try {
-        const { writtenCount, duplicateCount, membersAdded } = fullImport(
-          db2,
-          payload.meta,
-          payload.members ?? [],
-          payload.messages
-        );
+        const { writtenCount, duplicateCount } = fullImport(db2, payload.meta, payload.members ?? [], payload.messages);
         const session = queryStats(db2);
-        dbManager.raiseCurrentChatDbCompatibilityGate();
-        return {
+        const membersAdded = session.memberCount;
+        const outcome = {
           ok: true,
           result: {
             sessionId,
@@ -20394,16 +20548,17 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
             updates: { metaUpdated: true, membersAdded, membersUpdated: 0 }
           }
         };
+        appLogger.info("push-import", "Push import completed", outcome.result);
+        return outcome;
       } finally {
         db2.close();
       }
     }
-    const db = dbManager.openRawSessionDatabase(sessionId, { readonly: false });
+    const db = deps.openDatabase(sessionId, { readonly: false });
     try {
       const { writtenCount, duplicateCount, metaUpdated, membersAdded, membersUpdated } = incrementalImport2(db, payload);
       const session = queryStats(db);
-      dbManager.raiseCurrentChatDbCompatibilityGate();
-      return {
+      const outcome = {
         ok: true,
         result: {
           sessionId,
@@ -20413,6 +20568,8 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
           updates: { metaUpdated, membersAdded, membersUpdated }
         }
       };
+      appLogger.info("push-import", "Push import completed", outcome.result);
+      return outcome;
     } finally {
       db.close();
     }
@@ -20420,14 +20577,54 @@ async function pushImportUnlocked(dbManager, sessionId, payload) {
     if (err instanceof DataDirCompatibilityError) throw err;
     if (isNew) {
       try {
-        dbManager.deleteSessionDatabaseFiles(sessionId);
+        deps.deleteDatabase(sessionId);
       } catch {
       }
     }
+    appLogger.error("push-import", "Push import failed", err);
     return { ok: false, reason: "import_failed", message: err instanceof Error ? err.message : String(err) };
   }
 }
 
+// ../../packages/node-runtime/src/services/import-idempotency.ts
+import { createHash as createHash4 } from "crypto";
+var DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS = 60 * 60 * 1e3;
+function hashImportBody(body) {
+  return createHash4("sha256").update(JSON.stringify(body ?? "")).digest("hex");
+}
+var ImportIdempotencyCache = class {
+  constructor(ttlMs = DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  entries = /* @__PURE__ */ new Map();
+  start(key, bodyHash, now = Date.now()) {
+    this.prune(now);
+    const entry = this.entries.get(key);
+    if (!entry) {
+      this.entries.set(key, { bodyHash, status: "pending", timestamp: now });
+      return { status: "started" };
+    }
+    if (entry.bodyHash !== bodyHash) return { status: "conflict" };
+    if (entry.status === "pending") return { status: "pending" };
+    return { status: "success", response: entry.response };
+  }
+  success(key, response) {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    entry.status = "success";
+    entry.response = response;
+  }
+  fail(key) {
+    this.entries.delete(key);
+  }
+  prune(now) {
+    for (const [key, entry] of this.entries) {
+      if (now - entry.timestamp > this.ttlMs) this.entries.delete(key);
+    }
+  }
+};
+
 export {
   writeParseResultToDb,
   detectFormat,
@@ -20466,8 +20663,10 @@ export {
   streamParseFileInfo,
   analyzeIncrementalImport,
   incrementalImport,
+  isValidImportSessionId,
   resolveAutoImportTarget,
   autoImportFile,
+  analyzeAutoImportFile,
   IMPORT_LOCK_FILENAME,
   IMPORT_IN_PROGRESS_ERROR_KEY,
   ImportInProgressError,
@@ -20636,6 +20835,10 @@ export {
   createSemanticIndexService,
   SemanticIndexService,
   MergeSessionCache,
-  pushImport
+  pushImport,
+  executePushImportUnlocked,
+  DEFAULT_IMPORT_IDEMPOTENCY_TTL_MS,
+  hashImportBody,
+  ImportIdempotencyCache
 };
-//# sourceMappingURL=chunk-T64GA5HP.mjs.map
+//# sourceMappingURL=chunk-KCPGEILH.mjs.map