openzca 0.1.21 → 0.1.22

package/dist/cli.js

@@ -703,6 +703,98 @@ function output(value, asJson = false) {
 function asThreadType(groupFlag) {
   return groupFlag ? ThreadType.Group : ThreadType.User;
 }
+function parseBooleanFromEnv(name, fallback) {
+  const raw = process.env[name]?.trim();
+  if (!raw) return fallback;
+  const normalized = raw.toLowerCase();
+  if (normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return fallback;
+}
+function normalizeCachedId(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(Math.trunc(value));
+  }
+  return null;
+}
+function collectIdsFromCacheEntries(entries, keys) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    const row = entry;
+    for (const key of keys) {
+      const normalized = normalizeCachedId(row[key]);
+      if (normalized) {
+        ids.add(normalized);
+      }
+    }
+  }
+  return ids;
+}
+async function resolveUploadThreadType(api, profile, threadId, groupFlag, command) {
+  if (groupFlag) {
+    return { type: ThreadType.Group, reason: "explicit_group_flag" };
+  }
+  const autoDetectEnabled = parseBooleanFromEnv("OPENZCA_UPLOAD_AUTO_THREAD_TYPE", true);
+  if (!autoDetectEnabled) {
+    return { type: ThreadType.User, reason: "auto_detect_disabled" };
+  }
+  try {
+    const cache = await readCache(profile);
+    const groupIds = collectIdsFromCacheEntries(cache.groups, ["groupId", "grid", "threadId", "id"]);
+    if (groupIds.has(threadId)) {
+      return { type: ThreadType.Group, reason: "cache_group_match" };
+    }
+    const friendIds = collectIdsFromCacheEntries(cache.friends, ["userId", "uid", "id", "threadId"]);
+    if (friendIds.has(threadId)) {
+      return { type: ThreadType.User, reason: "cache_friend_match" };
+    }
+  } catch (error) {
+    writeDebugLine(
+      "msg.upload.thread_type.cache_error",
+      {
+        profile,
+        threadId,
+        message: toErrorText(error)
+      },
+      command
+    );
+  }
+  const probeEnabled = parseBooleanFromEnv("OPENZCA_UPLOAD_GROUP_PROBE", true);
+  if (!probeEnabled) {
+    return { type: ThreadType.User, reason: "probe_disabled" };
+  }
+  const probeTimeoutMs = parsePositiveIntFromEnv("OPENZCA_UPLOAD_GROUP_PROBE_TIMEOUT_MS", 5e3);
+  try {
+    const groupInfo = await withTimeout(
+      api.getGroupInfo(threadId),
+      probeTimeoutMs,
+      `Timed out waiting ${probeTimeoutMs}ms while probing group thread type.`
+    );
+    if (groupInfo?.gridInfoMap?.[threadId]) {
+      return { type: ThreadType.Group, reason: "probe_group_match" };
+    }
+  } catch (error) {
+    writeDebugLine(
+      "msg.upload.thread_type.probe_error",
+      {
+        profile,
+        threadId,
+        message: toErrorText(error)
+      },
+      command
+    );
+  }
+  return { type: ThreadType.User, reason: "default_user" };
+}
 function parseReaction(input) {
   const normalized = input.trim();
   if (EMOJI_REACTION_MAP[normalized]) {
@@ -2334,18 +2426,28 @@ msg.command("edit <msgId> <cliMsgId> <threadId> <message>").option("-g, --group"
 msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeatable)", collectValues, []).option("-g, --group", "Upload in group").description("Upload and send file(s)").action(
   wrapAction(
     async (arg1, arg2, opts, command) => {
-      const { api } = await requireApi(command);
+      const { api, profile } = await requireApi(command);
       const inputs = normalizeInputList(opts.url);
       const urlInputs = inputs.filter((entry) => isHttpUrl(entry));
       const localInputs = inputs.filter((entry) => !isHttpUrl(entry));
       const [threadId, file] = arg2 ? [arg2, arg1] : [arg1, void 0];
+      const threadResolution = await resolveUploadThreadType(
+        api,
+        profile,
+        threadId,
+        opts.group,
+        command
+      );
       const normalizedFile = file ? normalizeMediaInput(file) : void 0;
       const localFiles = [normalizedFile, ...localInputs].filter(Boolean);
       writeDebugLine(
         "msg.upload.inputs",
         {
           threadId,
-          isGroup: Boolean(opts.group),
+          explicitGroupFlag: Boolean(opts.group),
+          isGroup: threadResolution.type === ThreadType.Group,
+          threadType: threadResolution.type === ThreadType.Group ? "group" : "user",
+          threadTypeReason: threadResolution.reason,
           localFiles,
           urlInputs
         },
@@ -2369,7 +2471,7 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
               attachments
             },
             threadId,
-            asThreadType(opts.group)
+            threadResolution.type
           )
         );
         output(response, false);

package/package.json

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