openzca 0.1.56 → 0.1.58

package/README.md

@@ -125,6 +125,7 @@ You can also open the saved file manually (for example: `open qr.png` on macOS).
 
 Media commands accept local files, `file://` paths, and repeatable `--url` options. Add `--group` for group threads.
 `openzca msg video` attempts native video send for a single `.mp4` input by uploading the video and thumbnail to Zalo first. If `ffmpeg` is unavailable, the input is not a single `.mp4`, or native send fails, it falls back to the normal attachment send path. Use `--thumbnail <path-or-url>` to supply the preview image explicitly.
+`openzca msg voice` sends `--url` inputs directly. For local voice files, if both `ffmpeg` and `OPENZCA_VOICE_PUBLISH_CMD` are available, `openzca` normalizes the file to `.m4a`, runs the publish command with the normalized temp file path, expects one public `http(s)` URL on stdout, and sends that URL. Otherwise it falls back to the legacy Zalo upload flow.
 Local paths using `~` are expanded automatically (for positional file args, `--url`, and `OPENZCA_LISTEN_MEDIA_DIR`).
 Group text sends via `openzca msg send --group` resolve unique `@Name` or `@userId` mentions against the current group member list using member ids, display names, and usernames. Mention offsets are computed after formatting markers are parsed, so messages like `**@Alice Nguyen** hello` work. If multiple members share the same label, the command fails instead of guessing.
 When formatted text would produce an oversized outbound payload, `openzca msg send` automatically splits it into multiple sequential text messages using the final outbound text and rebased style/mention offsets. The split happens after formatting is parsed, using both rendered text length and estimated request payload size rather than the raw input string.
@@ -433,6 +434,10 @@ Upload/listener coordination overrides:
 - `OPENZCA_UPLOAD_GROUP_PROBE`: allow `msg upload` to probe `getGroupInfo` when auto thread-type detection is enabled.
   - Default: enabled.
   - Set to `0` to skip probe and rely only on cache matches.
+- `OPENZCA_VOICE_PUBLISH_CMD`: optional command used by `msg voice` for local files.
+  - `openzca` passes one normalized `.m4a` temp file path as the first argument.
+  - The command must print exactly one public `http(s)` URL to stdout.
+  - Requires `ffmpeg`; if unset or `ffmpeg` is unavailable, local voice files keep using the legacy Zalo upload flow.
 
 ### account — Multi-account profiles
 

package/dist/cli.js

@@ -4,10 +4,10 @@
 import { createRequire as createRequire2 } from "module";
 import { spawn as spawn2 } from "child_process";
 import fsSync from "fs";
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import net from "net";
-import os4 from "os";
-import path6 from "path";
+import os5 from "os";
+import path7 from "path";
 import readline from "readline/promises";
 import util from "util";
 import { Command } from "commander";
@@ -3066,6 +3066,110 @@ async function sendNativeVideo(params) {
   }
 }
 
+// src/lib/voice-send.ts
+import { execFile as execFile2 } from "child_process";
+import fs6 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+function sanitizeOutputBasename(filePath) {
+  const parsed = path6.parse(filePath);
+  const base = parsed.name.trim() || "voice";
+  const sanitized = base.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "voice";
+}
+async function runBinary2(command, args) {
+  try {
+    await execFileAsync2(command, args, {
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      throw new Error(`${command} is required for voice publish mode`);
+    }
+    if (error instanceof Error && "stderr" in error) {
+      const stderr = typeof error.stderr === "string" ? error.stderr.trim() : "";
+      throw new Error(stderr ? `${command} failed: ${stderr}` : `${command} failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function getVoicePublishCommandFromEnv(env = process.env) {
+  const configured = env.OPENZCA_VOICE_PUBLISH_CMD?.trim();
+  return configured && configured.length > 0 ? configured : null;
+}
+function extractPublishedVoiceUrl(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const candidate = lines.at(-1);
+  if (!candidate) {
+    throw new Error("Voice publish command did not print a public URL to stdout");
+  }
+  if (!/^https?:\/\/\S+$/i.test(candidate)) {
+    throw new Error(`Voice publish command returned an invalid URL: ${candidate}`);
+  }
+  return candidate;
+}
+async function normalizeVoiceForPublish(inputPath) {
+  const dir = await fs6.mkdtemp(path6.join(os4.tmpdir(), "openzca-voice-"));
+  const outputPath = path6.join(dir, `${sanitizeOutputBasename(inputPath)}.m4a`);
+  try {
+    await runBinary2("ffmpeg", [
+      "-y",
+      "-v",
+      "error",
+      "-i",
+      inputPath,
+      "-vn",
+      "-map_metadata",
+      "-1",
+      "-ac",
+      "1",
+      "-ar",
+      "44100",
+      "-c:a",
+      "aac",
+      "-b:a",
+      "64k",
+      "-movflags",
+      "+faststart",
+      outputPath
+    ]);
+    await fs6.access(outputPath);
+  } catch (error) {
+    await fs6.rm(dir, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    path: outputPath,
+    cleanup: async () => {
+      await fs6.rm(dir, { recursive: true, force: true });
+    }
+  };
+}
+async function publishVoiceFile(command, filePath) {
+  try {
+    const { stdout } = await execFileAsync2(
+      "sh",
+      ["-c", `${command} "$1"`, "openzca-voice-publish", filePath],
+      {
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+      }
+    );
+    return extractPublishedVoiceUrl(stdout);
+  } catch (error) {
+    if (error instanceof Error && "stderr" in error) {
+      const stderr = typeof error.stderr === "string" ? error.stderr.trim() : "";
+      throw new Error(
+        stderr ? `Voice publish command failed: ${stderr}` : `Voice publish command failed: ${error.message}`
+      );
+    }
+    throw error;
+  }
+}
+
 // src/lib/reply.ts
 import { ThreadType as ThreadType2 } from "zca-js";
 function prepareReplyMessage(value, params) {
@@ -3291,6 +3395,125 @@ function inferReplyMessageThreadId(params) {
   return void 0;
 }
 
+// src/lib/adaptive-batch.ts
+var RETRYABLE_LOOKUP_ERROR_PATTERNS = [
+  /retry limit/i,
+  /\brate limit/i,
+  /\btoo many requests?\b/i,
+  /\btimeout\b/i,
+  /\btimed out\b/i,
+  /\betimedout\b/i,
+  /\beconnreset\b/i,
+  /\besockettimedout\b/i,
+  /\bsocket hang up\b/i,
+  /\btemporar(?:y|ily)\b/i
+];
+var SPLITTABLE_LOOKUP_ERROR_PATTERNS = [
+  /\binvalid param(?:eter)?s?\b/i,
+  /\binvalid request\b/i,
+  /\bbad request\b/i,
+  /tham so khong hop le/i,
+  /tham số không hợp lệ/i
+];
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function chunkKeys(keys, size) {
+  const chunkSize = Math.max(1, Math.trunc(size) || 1);
+  const chunks = [];
+  for (let index = 0; index < keys.length; index += chunkSize) {
+    chunks.push(keys.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function toErrorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRetryableLookupError(error) {
+  const message = toErrorText(error);
+  return RETRYABLE_LOOKUP_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+function isSplittableLookupError(error) {
+  const message = toErrorText(error);
+  return SPLITTABLE_LOOKUP_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+async function runAdaptiveBatch(keys, options) {
+  const maxRetries = Math.max(0, options.maxRetries ?? 2);
+  const initialDelayMs = Math.max(0, options.retryDelayMs ?? 400);
+  const backoffMultiplier = Math.max(1, options.backoffMultiplier ?? 2);
+  const shouldRetry = options.shouldRetry ?? isRetryableLookupError;
+  const shouldSplit = options.shouldSplit ?? isSplittableLookupError;
+  let attempt = 0;
+  let delayMs = initialDelayMs;
+  while (true) {
+    try {
+      return await options.fetchBatch(keys) ?? {};
+    } catch (error) {
+      if (keys.length > 1 && shouldSplit(error)) {
+        throw error;
+      }
+      attempt += 1;
+      if (attempt > maxRetries || !shouldRetry(error)) {
+        throw error;
+      }
+      await options.onRetry?.({
+        keys: [...keys],
+        attempt,
+        maxRetries,
+        delayMs,
+        error
+      });
+      if (delayMs > 0) {
+        await sleep2(delayMs);
+      }
+      delayMs = Math.max(delayMs * backoffMultiplier, delayMs + 1);
+    }
+  }
+}
+async function fetchAdaptiveObjectBatches(keys, options) {
+  const uniqueKeys = Array.from(new Set(keys.map((value) => value.trim()).filter(Boolean)));
+  const pending = chunkKeys(uniqueKeys, options.initialBatchSize ?? 5);
+  const values = /* @__PURE__ */ new Map();
+  const errors = [];
+  const shouldRetry = options.shouldRetry ?? isRetryableLookupError;
+  const shouldSplit = options.shouldSplit ?? isSplittableLookupError;
+  const continueOnItemError = options.continueOnItemError ?? true;
+  const batchDelayMs = Math.max(0, options.batchDelayMs ?? 75);
+  while (pending.length > 0) {
+    const batch = pending.shift();
+    if (!batch || batch.length === 0) {
+      continue;
+    }
+    try {
+      const result = await runAdaptiveBatch(batch, options);
+      for (const key of batch) {
+        const value = result[key];
+        if (value !== void 0) {
+          values.set(key, value);
+        }
+      }
+    } catch (error) {
+      if (batch.length > 1 && (shouldSplit(error) || shouldRetry(error))) {
+        pending.unshift(...chunkKeys(batch, Math.ceil(batch.length / 2)));
+        continue;
+      }
+      if (!continueOnItemError || batch.length > 1) {
+        throw error;
+      }
+      const itemError = { key: batch[0], error };
+      errors.push(itemError);
+      await options.onItemError?.(itemError);
+      continue;
+    }
+    if (batchDelayMs > 0 && pending.length > 0) {
+      await sleep2(batchDelayMs);
+    }
+  }
+  return { values, errors };
+}
+
 // src/cli.ts
 var require3 = createRequire2(import.meta.url);
 var { version: PKG_VERSION } = require3("../package.json");
@@ -3372,9 +3595,9 @@ function resolveDebugEnabled(command) {
 }
 function resolveDebugFilePath(command) {
   const options = getDebugOptions(command);
-  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path6.join(APP_HOME, "logs", "openzca-debug.log");
+  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path7.join(APP_HOME, "logs", "openzca-debug.log");
   const normalized = normalizeMediaInput(configured);
-  return path6.isAbsolute(normalized) ? normalized : path6.resolve(process.cwd(), normalized);
+  return path7.isAbsolute(normalized) ? normalized : path7.resolve(process.cwd(), normalized);
 }
 function writeDebugLine(event, details, command) {
   if (!resolveDebugEnabled(command)) {
@@ -3385,7 +3608,7 @@ function writeDebugLine(event, details, command) {
 `;
   const filePath = resolveDebugFilePath(command);
   try {
-    fsSync.mkdirSync(path6.dirname(filePath), { recursive: true });
+    fsSync.mkdirSync(path7.dirname(filePath), { recursive: true });
     fsSync.appendFileSync(filePath, line, "utf8");
   } catch {
   }
@@ -3492,14 +3715,14 @@ function collectIdsFromCacheEntries(entries, keys) {
   return ids;
 }
 function getListenerOwnerLockPath(profile) {
-  return path6.join(getProfileDir(profile), "listener-owner.json");
+  return path7.join(getProfileDir(profile), "listener-owner.json");
 }
 function getListenIpcSocketPath(profile) {
   if (process.platform === "win32") {
     const safe = profile.replace(/[^A-Za-z0-9_-]/g, "_");
     return `\\\\.\\pipe\\openzca-listen-${safe}`;
   }
-  return path6.join(getProfileDir(profile), "listen.sock");
+  return path7.join(getProfileDir(profile), "listen.sock");
 }
 function parsePositiveIntFromUnknown(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -3532,6 +3755,44 @@ function retrySendMethod(operation, command, metaBuilder) {
     }
   });
 }
+var LOOKUP_BATCH_SIZE = 5;
+var LOOKUP_RETRY_COUNT = 2;
+var LOOKUP_RETRY_DELAY_MS = 400;
+var LOOKUP_BATCH_DELAY_MS = 75;
+async function fetchGroupInfoRecords(api, groupIds) {
+  const { values } = await fetchAdaptiveObjectBatches(groupIds, {
+    fetchBatch: async (keys) => {
+      const response = await api.getGroupInfo(keys);
+      return response.gridInfoMap ?? {};
+    },
+    initialBatchSize: LOOKUP_BATCH_SIZE,
+    maxRetries: LOOKUP_RETRY_COUNT,
+    retryDelayMs: LOOKUP_RETRY_DELAY_MS,
+    batchDelayMs: LOOKUP_BATCH_DELAY_MS
+  });
+  return values;
+}
+async function fetchGroupInfoRecord(api, groupId) {
+  const groups = await fetchGroupInfoRecords(api, [groupId]);
+  const group2 = groups.get(groupId);
+  if (!group2) {
+    throw new Error(`Group not found: ${groupId}`);
+  }
+  return group2;
+}
+async function fetchGroupMemberProfiles(api, memberIds) {
+  const { values } = await fetchAdaptiveObjectBatches(memberIds, {
+    fetchBatch: async (keys) => {
+      const response = await api.getGroupMembersInfo(keys);
+      return response.profiles ?? {};
+    },
+    initialBatchSize: LOOKUP_BATCH_SIZE,
+    maxRetries: LOOKUP_RETRY_COUNT,
+    retryDelayMs: LOOKUP_RETRY_DELAY_MS,
+    batchDelayMs: LOOKUP_BATCH_DELAY_MS
+  });
+  return values;
+}
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -3545,7 +3806,7 @@ function isProcessAlive(pid) {
 }
 async function readListenerOwnerRecord(lockPath) {
   try {
-    const raw = await fs6.readFile(lockPath, "utf8");
+    const raw = await fs7.readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw);
     const pid = parsePositiveIntFromUnknown(parsed.pid);
     if (!pid) return null;
@@ -3565,11 +3826,11 @@ async function readActiveListenerOwner(profile) {
   const lockPath = getListenerOwnerLockPath(profile);
   const record = await readListenerOwnerRecord(lockPath);
   if (!record) {
-    await fs6.rm(lockPath, { force: true });
+    await fs7.rm(lockPath, { force: true });
     return null;
   }
   if (!isProcessAlive(record.pid)) {
-    await fs6.rm(lockPath, { force: true });
+    await fs7.rm(lockPath, { force: true });
     return null;
   }
   return record;
@@ -3585,7 +3846,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
   };
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      await fs6.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
+      await fs7.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
 `, {
         encoding: "utf8",
         flag: "wx"
@@ -3598,7 +3859,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           released = true;
           const current = await readListenerOwnerRecord(lockPath);
           if (current && current.pid !== process.pid) return;
-          await fs6.rm(lockPath, { force: true });
+          await fs7.rm(lockPath, { force: true });
           writeDebugLine(
             "listen.owner.released",
             {
@@ -3619,7 +3880,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           `Another openzca listener already owns profile "${profile}" (pid ${owner.pid}).`
         );
       }
-      await fs6.rm(lockPath, { force: true });
+      await fs7.rm(lockPath, { force: true });
     }
   }
   throw new Error(`Unable to acquire listener ownership for profile "${profile}".`);
@@ -3637,7 +3898,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
   }
   const socketPath = getListenIpcSocketPath(profile);
   if (process.platform !== "win32") {
-    await fs6.rm(socketPath, { force: true });
+    await fs7.rm(socketPath, { force: true });
   }
   const uploadTimeoutMs = parsePositiveIntFromEnv(
     "OPENZCA_UPLOAD_IPC_HANDLER_TIMEOUT_MS",
@@ -3737,7 +3998,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
           command
         );
       } catch (error) {
-        fail(parsed.requestId, toErrorText(error));
+        fail(parsed.requestId, toErrorText2(error));
         writeDebugLine(
           "listen.ipc.upload.error",
           {
@@ -3746,7 +4007,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
             requestId: parsed.requestId,
             threadId: parsed.threadId,
             threadType: parsed.threadType,
-            message: toErrorText(error)
+            message: toErrorText2(error)
           },
           command
         );
@@ -3775,7 +4036,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
         {
           profile,
           sessionId,
-          message: toErrorText(error)
+          message: toErrorText2(error)
         },
         command
       );
@@ -3787,7 +4048,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
       {
         profile,
         sessionId,
-        message: toErrorText(error)
+        message: toErrorText2(error)
       },
       command
     );
@@ -3818,7 +4079,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
         server.close(() => resolve());
       });
       if (process.platform !== "win32") {
-        await fs6.rm(socketPath, { force: true });
+        await fs7.rm(socketPath, { force: true });
       }
       writeDebugLine(
         "listen.ipc.stopped",
@@ -3976,7 +4237,7 @@ async function resolveUploadThreadType(api, profile, threadId, groupFlag, comman
       {
         profile,
         threadId,
-        message: toErrorText(error)
+        message: toErrorText2(error)
       },
       command
     );
@@ -4001,7 +4262,7 @@ async function resolveUploadThreadType(api, profile, threadId, groupFlag, comman
       {
         profile,
         threadId,
-        message: toErrorText(error)
+        message: toErrorText2(error)
       },
       command
     );
@@ -4242,8 +4503,8 @@ async function persistOutgoingMessageBestEffort(params) {
     });
   }
 }
-async function persistGroupMembersSnapshot(profile, groupId, api) {
-  const rows = await listGroupMemberRows(api, groupId);
+async function persistGroupMembersSnapshot(profile, groupId, api, groupInfo) {
+  const rows = await listGroupMemberRows(api, groupId, groupInfo);
   const snapshotAtMs = Date.now();
   for (const row of rows) {
     await persistContact({
@@ -4448,7 +4709,15 @@ async function prepareDbGroupTarget(params) {
     isHidden: params.hiddenIds.has(params.groupId),
     rawJson: params.rawJson
   });
-  await persistGroupMembersSnapshot(params.profile, params.groupId, params.api);
+  if (params.hydrateMembers === false) {
+    return {};
+  }
+  try {
+    await persistGroupMembersSnapshot(params.profile, params.groupId, params.api, params.group);
+    return {};
+  } catch (error) {
+    return { memberSnapshotError: toErrorText2(error) };
+  }
 }
 function resolveContactDisplayName(params) {
   return params.displayName?.trim() || params.zaloName?.trim() || params.fallbackTitle?.trim() || params.userId.trim() || void 0;
@@ -4550,18 +4819,17 @@ async function hydrateUnknownLiveGroup(params) {
     }
   }
   if (group2 || title) {
-    await persistThread({
+    await prepareDbGroupTarget({
       profile: params.profile,
-      scopeThreadId: params.groupId,
-      rawThreadId: params.groupId,
-      threadType: "group",
+      api: params.api,
+      groupId: params.groupId,
+      group: group2,
       title,
-      rawJson: group2 ? JSON.stringify(group2) : void 0
+      rawJson: group2 ? JSON.stringify(group2) : void 0,
+      pinnedIds: /* @__PURE__ */ new Set(),
+      hiddenIds: /* @__PURE__ */ new Set(),
+      hydrateMembers: Boolean(group2)
     });
-    try {
-      await persistGroupMembersSnapshot(params.profile, params.groupId, params.api);
-    } catch {
-    }
     return;
   }
   if (params.fallbackTitle?.trim()) {
@@ -4631,16 +4899,23 @@ async function syncDbGroupHistoryFull(params) {
     pagesRequested = result.pagesRequested;
     listenerImportedCount = await getStoredGroupMessageCount() - beforeCount;
   } catch (error) {
-    stopReason = `fallback_window:${toErrorText(error)}`;
+    stopReason = `fallback_window:${toErrorText2(error)}`;
     completeness = "window";
   }
   const fallbackCount = 200;
   params.progress?.(`merging recent group API window (${fallbackCount} per group)`);
   const beforeApiCount = await getStoredGroupMessageCount();
+  const topoffErrors = [];
   for (const groupId of params.targetGroupIds) {
-    const messages = await fetchRecentGroupMessagesViaApi(params.api, groupId, fallbackCount);
-    await persistMessages(messages);
-    params.progress?.(`group ${groupId}: fetched ${messages.length} message(s) from group history API`);
+    try {
+      const messages = await fetchRecentGroupMessagesViaApi(params.api, groupId, fallbackCount);
+      await persistMessages(messages);
+      params.progress?.(`group ${groupId}: fetched ${messages.length} message(s) from group history API`);
+    } catch (error) {
+      const message = toErrorText2(error);
+      topoffErrors.push({ groupId, error: message });
+      params.progress?.(`group ${groupId}: group history API skipped (${message})`);
+    }
   }
   const afterCount = await getStoredGroupMessageCount();
   const apiAddedCount = afterCount - beforeApiCount;
@@ -4670,7 +4945,8 @@ async function syncDbGroupHistoryFull(params) {
     imported,
     completeness,
     stopReason,
-    pagesRequested
+    pagesRequested,
+    topoffErrors
   });
 }
 async function syncDbFriendDirectory(params) {
@@ -4807,25 +5083,70 @@ async function runDbSync(params) {
       });
     }
     if (params.mode === "all" || params.mode === "groups") {
-      const groups = await buildGroupsDetailed(api);
+      const groups = await api.getAllGroups();
+      const groupIds = Object.keys(groups.gridVerMap ?? {});
       const targetGroupIds = /* @__PURE__ */ new Set();
       const titleById = /* @__PURE__ */ new Map();
-      for (const group2 of groups) {
-        const record = group2;
-        const groupId = normalizeCachedId(record.groupId);
-        if (!groupId) continue;
-        const title = typeof record.name === "string" && record.name.trim() ? record.name.trim() : typeof record.groupName === "string" && record.groupName.trim() ? record.groupName.trim() : void 0;
-        targetGroupIds.add(groupId);
-        titleById.set(groupId, title);
-        await prepareDbGroupTarget({
-          profile,
-          api,
-          groupId,
-          title,
-          rawJson: JSON.stringify(group2),
-          pinnedIds,
-          hiddenIds
-        });
+      params.progress?.(`syncing group directory for ${groupIds.length} group(s)`);
+      for (const groupId of groupIds) {
+        let group2;
+        let title;
+        try {
+          try {
+            group2 = await fetchGroupInfoRecord(api, groupId);
+            title = extractGroupTitle(group2);
+          } catch (error) {
+            const message = toErrorText2(error);
+            params.progress?.(`group ${groupId}: metadata unavailable (${message}), continuing`);
+            summary.syncState.push({
+              kind: "group",
+              groupId,
+              status: "warning",
+              stage: "metadata",
+              error: message
+            });
+          }
+          const { memberSnapshotError } = await prepareDbGroupTarget({
+            profile,
+            api,
+            groupId,
+            group: group2,
+            title,
+            rawJson: group2 ? JSON.stringify(group2) : void 0,
+            pinnedIds,
+            hiddenIds,
+            hydrateMembers: Boolean(group2)
+          });
+          if (memberSnapshotError) {
+            params.progress?.(`group ${groupId}: member snapshot unavailable (${memberSnapshotError}), continuing`);
+            summary.syncState.push({
+              kind: "group",
+              groupId,
+              status: "warning",
+              stage: "members",
+              error: memberSnapshotError
+            });
+          }
+          targetGroupIds.add(groupId);
+          titleById.set(groupId, title);
+        } catch (error) {
+          const message = toErrorText2(error);
+          params.progress?.(`group ${groupId}: skipped (${message})`);
+          await setSyncState({
+            profile,
+            scopeThreadId: groupId,
+            threadType: "group",
+            status: "error",
+            error: message
+          });
+          summary.syncState.push({
+            kind: "group",
+            groupId,
+            status: "error",
+            stage: "prepare",
+            error: message
+          });
+        }
       }
       await syncDbGroupHistoryFull({
         profile,
@@ -4841,18 +5162,29 @@ async function runDbSync(params) {
       if (!params.groupId) {
         throw new Error("Missing group id for db sync group.");
       }
-      const groupInfo = await api.getGroupInfo(params.groupId);
-      const group2 = groupInfo.gridInfoMap[params.groupId];
-      const title = typeof group2?.name === "string" && group2.name.trim() ? group2.name.trim() : void 0;
-      await prepareDbGroupTarget({
+      const group2 = await fetchGroupInfoRecord(api, params.groupId);
+      const title = extractGroupTitle(group2);
+      const { memberSnapshotError } = await prepareDbGroupTarget({
         profile,
         api,
         groupId: params.groupId,
+        group: group2,
         title,
         rawJson: group2 ? JSON.stringify(group2) : void 0,
         pinnedIds,
-        hiddenIds
+        hiddenIds,
+        hydrateMembers: Boolean(group2)
       });
+      if (memberSnapshotError) {
+        params.progress?.(`group ${params.groupId}: member snapshot unavailable (${memberSnapshotError}), continuing`);
+        summary.syncState.push({
+          kind: "group",
+          groupId: params.groupId,
+          status: "warning",
+          stage: "members",
+          error: memberSnapshotError
+        });
+      }
       await syncDbGroupHistoryFull({
         profile,
         api,
@@ -4911,8 +5243,8 @@ async function buildGroupsDetailed(api) {
   const groups = await api.getAllGroups();
   const ids = Object.keys(groups.gridVerMap ?? {});
   if (ids.length === 0) return [];
-  const info = await api.getGroupInfo(ids);
-  return ids.map((id) => info.gridInfoMap?.[id]).filter((item) => Boolean(item));
+  const info = await fetchGroupInfoRecords(api, ids);
+  return ids.map((id) => info.get(id)).filter((item) => Boolean(item));
 }
 function normalizeGroupMemberId(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -4923,9 +5255,8 @@ function normalizeGroupMemberId(value) {
   if (!trimmed) return "";
   return trimmed.replace(/_\d+$/, "");
 }
-async function listGroupMemberRows(api, groupId) {
-  const info = await api.getGroupInfo(groupId);
-  const groupInfo = info.gridInfoMap[groupId];
+async function listGroupMemberRows(api, groupId, preloadedGroupInfo) {
+  const groupInfo = preloadedGroupInfo ?? await fetchGroupInfoRecord(api, groupId);
   if (!groupInfo) {
     throw new Error(`Group not found: ${groupId}`);
   }
@@ -4949,10 +5280,9 @@ async function listGroupMemberRows(api, groupId) {
       ...Array.from(currentMemberMap.keys())
     ])
   );
-  const profiles = ids.length > 0 ? await api.getGroupMembersInfo(ids) : { profiles: {} };
-  const rawProfileMap = profiles.profiles;
+  const profileLookup = ids.length > 0 ? await fetchGroupMemberProfiles(api, ids) : /* @__PURE__ */ new Map();
   const profileMap = /* @__PURE__ */ new Map();
-  for (const [key, profile] of Object.entries(rawProfileMap)) {
+  for (const [key, profile] of profileLookup.entries()) {
     if (!profile) continue;
     const normalizedKey = normalizeGroupMemberId(key);
     if (normalizedKey && !profileMap.has(normalizedKey)) {
@@ -5007,7 +5337,7 @@ function isListenerAlreadyStarted(error) {
   if (!(error instanceof Error)) return false;
   return /already started/i.test(error.message);
 }
-function toErrorText(error) {
+function toErrorText2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var SHUTDOWN_CALLBACKS = /* @__PURE__ */ new Set();
@@ -5045,7 +5375,7 @@ async function runShutdownCallbacks(signal) {
         "process.signal.callback_error",
         {
           signal,
-          message: toErrorText(error)
+          message: toErrorText2(error)
         },
         void 0
       );
@@ -5128,7 +5458,7 @@ async function withUploadListener(api, command, task) {
     writeDebugLine(
       "msg.upload.listener.error",
       {
-        message: toErrorText(error)
+        message: toErrorText2(error)
       },
       command
     );
@@ -5170,7 +5500,7 @@ async function withUploadListener(api, command, task) {
         finish();
       };
       const onConnectError = (error) => {
-        finish(new Error(`Upload listener connection error: ${toErrorText(error)}`));
+        finish(new Error(`Upload listener connection error: ${toErrorText2(error)}`));
       };
       const onConnectClosed = (code, reason) => {
         finish(
@@ -5796,7 +6126,7 @@ function toDbRecordFromRecentMessage(params) {
   });
 }
 async function parseCredentialFile(filePath) {
-  const raw = await fs6.readFile(filePath, "utf8");
+  const raw = await fs7.readFile(filePath, "utf8");
   const parsed = JSON.parse(raw);
   if (!parsed.imei || !parsed.cookie || !parsed.userAgent) {
     throw new Error("Credential file must include imei, cookie, and userAgent.");
@@ -5808,7 +6138,7 @@ async function parseCredentialFile(filePath) {
     language: parsed.language
   };
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -5817,13 +6147,13 @@ async function waitForFileContent(filePath, timeoutMs) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
     try {
-      const data = await fs6.readFile(filePath);
+      const data = await fs7.readFile(filePath);
       if (data.length > 0) {
         return data;
       }
     } catch {
     }
-    await sleep2(150);
+    await sleep3(150);
   }
   throw new Error(`Timed out waiting for QR image file: ${filePath}`);
 }
@@ -5832,8 +6162,8 @@ async function emitQrBase64FromDetachedLogin(profile, qrPath) {
   if (!scriptPath) {
     throw new Error("Cannot resolve CLI entrypoint for QR base64 mode.");
   }
-  const tempDir = await fs6.mkdtemp(path6.join(os4.tmpdir(), "openzca-qr-"));
-  const targetPath = path6.resolve(qrPath ?? path6.join(tempDir, "qr.png"));
+  const tempDir = await fs7.mkdtemp(path7.join(os5.tmpdir(), "openzca-qr-"));
+  const targetPath = path7.resolve(qrPath ?? path7.join(tempDir, "qr.png"));
   const child = spawn2(
     process.execPath,
     [scriptPath, "--profile", profile, "auth", "login", "--qr-path", targetPath],
@@ -6111,7 +6441,7 @@ function mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind) {
   if (fromType) return fromType;
   try {
     const parsedUrl = new URL(mediaUrl);
-    const ext = path6.extname(parsedUrl.pathname);
+    const ext = path7.extname(parsedUrl.pathname);
     if (ext) return ext;
   } catch {
   }
@@ -6142,20 +6472,20 @@ function parseInboundMediaFetchTimeoutMs() {
   return Math.trunc(parsed);
 }
 function resolveOpenClawMediaDir() {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path6.join(os4.homedir(), ".openclaw");
-  return path6.join(stateDir, "media");
+  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path7.join(os5.homedir(), ".openclaw");
+  return path7.join(stateDir, "media");
 }
 function resolveInboundMediaDir(profile) {
   const configuredRaw = process.env.OPENZCA_LISTEN_MEDIA_DIR?.trim();
   if (configuredRaw) {
     const configured = normalizeMediaInput(configuredRaw);
-    return path6.isAbsolute(configured) ? configured : path6.resolve(process.cwd(), configured);
+    return path7.isAbsolute(configured) ? configured : path7.resolve(process.cwd(), configured);
   }
   const legacyRequested = process.env.OPENZCA_LISTEN_MEDIA_LEGACY_DIR?.trim() === "1";
   if (legacyRequested) {
-    return path6.join(getProfileDir(profile), "inbound-media");
+    return path7.join(getProfileDir(profile), "inbound-media");
   }
-  return path6.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
+  return path7.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
 }
 async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
   const maxBytes = parseMaxInboundMediaBytes();
@@ -6189,11 +6519,11 @@ async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
     return null;
   }
   const dir = resolveInboundMediaDir(profile);
-  await fs6.mkdir(dir, { recursive: true });
+  await fs7.mkdir(dir, { recursive: true });
   const ext = mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind);
   const id = `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-  const mediaPath = path6.join(dir, `${id}${ext}`);
-  await fs6.writeFile(mediaPath, data);
+  const mediaPath = path7.join(dir, `${id}${ext}`);
+  await fs7.writeFile(mediaPath, data);
   return { mediaPath, mediaType };
 }
 async function cacheRemoteMediaEntries(params) {
@@ -6703,7 +7033,7 @@ auth.command("login").description("Login with QR code").option("-q, --qr-path <p
 auth.command("login-cred [file]").alias("login-creds").description("Login using credential JSON file").action(
   wrapAction(async (file, command) => {
     const profile = await currentProfile(command);
-    const credentials = file ? await parseCredentialFile(path6.resolve(normalizeMediaInput(file))) : toCredentials(
+    const credentials = file ? await parseCredentialFile(path7.resolve(normalizeMediaInput(file))) : toCredentials(
       await loadCredentials(profile) ?? (() => {
         throw new Error(
           `No saved credentials for profile "${profile}". Run: openzca auth login`
@@ -6810,7 +7140,7 @@ dbCmd.command("reset").option("-y, --yes", "Delete the SQLite DB file for the ac
     const removedPaths = [];
     const deleteIfExists = async (filename) => {
       try {
-        await fs6.unlink(filename);
+        await fs7.unlink(filename);
         removedPaths.push(filename);
       } catch (error) {
         if (error.code !== "ENOENT") {
@@ -7523,53 +7853,108 @@ msg.command("voice <threadId> [file]").option("-u, --url <url>", "Voice URL (rep
       }
       const urlInputs = files.filter((entry) => isHttpUrl(entry));
       const localInputs = files.filter((entry) => !isHttpUrl(entry));
+      const publishCommand = getVoicePublishCommandFromEnv();
+      const ffmpegAvailable = localInputs.length > 0 && publishCommand ? await isFfmpegAvailable() : false;
+      const usePublishFlow = localInputs.length > 0 && Boolean(publishCommand) && ffmpegAvailable;
       writeDebugLine(
         "msg.voice.inputs",
         {
           threadId,
           isGroup: Boolean(opts.group),
           localInputs,
-          urlInputs
+          urlInputs,
+          publishConfigured: Boolean(publishCommand),
+          ffmpegAvailable: localInputs.length > 0 ? ffmpegAvailable : void 0,
+          mode: usePublishFlow ? "publish" : "legacy"
         },
         command
       );
-      const downloaded = await downloadUrlsToTempFiles(urlInputs);
-      try {
-        const attachments = [...localInputs, ...downloaded.files];
-        await assertFilesExist(attachments);
-        const results = [];
-        const uploaded = await api.uploadAttachment(attachments, threadId, type);
-        for (const item of uploaded) {
-          if (item.fileType === "others" || item.fileType === "video") {
-            results.push(await sendVoice({ voiceUrl: item.fileUrl }, threadId, type));
+      await assertFilesExist(localInputs);
+      const publishedLocals = [];
+      let uploadedLocals = [];
+      if (usePublishFlow) {
+        for (const localInput of localInputs) {
+          const normalized = await normalizeVoiceForPublish(localInput);
+          try {
+            const mediaUrl = await publishVoiceFile(publishCommand, normalized.path);
+            publishedLocals.push({
+              mediaPath: localInput,
+              mediaUrl
+            });
+          } finally {
+            await normalized.cleanup();
           }
         }
-        if (results.length === 0) {
-          throw new Error(
-            "No valid voice attachment generated. Use an audio file (e.g. .aac, .mp3, .m4a, .wav, .ogg)."
-          );
+      } else if (localInputs.length > 0) {
+        uploadedLocals = await withUploadListener(
+          api,
+          command,
+          async () => api.uploadAttachment(localInputs, threadId, type)
+        );
+      }
+      const pendingPublished = [...publishedLocals];
+      const pendingUploaded = [...uploadedLocals];
+      const outboundVoices = [];
+      for (const entry of files) {
+        if (isHttpUrl(entry)) {
+          outboundVoices.push({
+            mediaUrl: entry
+          });
+          continue;
         }
-        output(results, false);
-        if (await shouldWriteToDb(profile)) {
-          scheduleDbWrite(profile, command, "msg.voice.db.persist_error", async () => {
-            await persistOutgoingMessageBestEffort({
-              profile,
-              api,
-              threadId,
-              group: opts.group,
-              msgType: "voice",
-              response: results,
-              rawPayload: uploaded,
-              media: uploaded.map((item) => ({
-                mediaKind: "voice",
-                mediaUrl: "fileUrl" in item && typeof item.fileUrl === "string" ? item.fileUrl : void 0,
-                rawJson: JSON.stringify(item)
-              }))
-            });
+        if (usePublishFlow) {
+          const nextPublished = pendingPublished.shift();
+          if (!nextPublished) {
+            throw new Error(`Voice publish flow lost local file mapping for: ${entry}`);
+          }
+          outboundVoices.push(nextPublished);
+          continue;
+        }
+        const nextUploaded = pendingUploaded.shift();
+        if (!nextUploaded) {
+          throw new Error(`Voice upload flow lost local file mapping for: ${entry}`);
+        }
+        if (nextUploaded.fileType === "others" || nextUploaded.fileType === "video") {
+          outboundVoices.push({
+            mediaPath: entry,
+            mediaUrl: nextUploaded.fileUrl,
+            rawJson: JSON.stringify(nextUploaded)
           });
         }
-      } finally {
-        await downloaded.cleanup();
+      }
+      if (outboundVoices.length === 0) {
+        throw new Error(
+          "No valid voice attachment generated. Use an audio file (e.g. .aac, .mp3, .m4a, .wav, .ogg)."
+        );
+      }
+      const results = [];
+      for (const item of outboundVoices) {
+        results.push(await sendVoice({ voiceUrl: item.mediaUrl }, threadId, type));
+      }
+      output(results, false);
+      if (await shouldWriteToDb(profile)) {
+        scheduleDbWrite(profile, command, "msg.voice.db.persist_error", async () => {
+          await persistOutgoingMessageBestEffort({
+            profile,
+            api,
+            threadId,
+            group: opts.group,
+            msgType: "voice",
+            response: results,
+            rawPayload: {
+              mode: usePublishFlow ? "publish" : "legacy",
+              directUrls: urlInputs,
+              published: publishedLocals,
+              uploaded: uploadedLocals
+            },
+            media: outboundVoices.map((item) => ({
+              mediaKind: "voice",
+              mediaPath: item.mediaPath,
+              mediaUrl: item.mediaUrl,
+              rawJson: item.rawJson
+            }))
+          });
+        });
       }
     }
   )
@@ -9052,7 +9437,7 @@ ${replyContextText}` : replyContextText;
                       code,
                       reason: reason || void 0,
                       delayMs: keepAliveRestartDelayMs,
-                      message: toErrorText(error),
+                      message: toErrorText2(error),
                       sessionId
                     },
                     command

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {