openzca 0.1.20 → 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]) {
@@ -820,6 +912,66 @@ function isListenerAlreadyStarted(error) {
 function toErrorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
+var SHUTDOWN_CALLBACKS = /* @__PURE__ */ new Set();
+var shutdownSignalReceived = null;
+var shutdownRunning = false;
+function signalExitCode(signal) {
+  if (signal === "SIGINT") return 130;
+  if (signal === "SIGTERM") return 143;
+  return 1;
+}
+function registerShutdownCallback(callback) {
+  SHUTDOWN_CALLBACKS.add(callback);
+  return () => {
+    SHUTDOWN_CALLBACKS.delete(callback);
+  };
+}
+async function runShutdownCallbacks(signal) {
+  if (shutdownRunning) return;
+  shutdownRunning = true;
+  const callbacks = Array.from(SHUTDOWN_CALLBACKS);
+  SHUTDOWN_CALLBACKS.clear();
+  writeDebugLine(
+    "process.signal",
+    {
+      signal,
+      callbackCount: callbacks.length
+    },
+    void 0
+  );
+  for (const callback of callbacks) {
+    try {
+      await Promise.resolve(callback());
+    } catch (error) {
+      writeDebugLine(
+        "process.signal.callback_error",
+        {
+          signal,
+          message: toErrorText(error)
+        },
+        void 0
+      );
+    }
+  }
+}
+function installSignalHandler(signal) {
+  process.on(signal, () => {
+    if (shutdownSignalReceived) return;
+    shutdownSignalReceived = signal;
+    const exitCode = signalExitCode(signal);
+    const forceExitMs = parsePositiveIntFromEnv("OPENZCA_SIGNAL_FORCE_EXIT_MS", 1500);
+    const forceTimer = setTimeout(() => {
+      process.exit(exitCode);
+    }, forceExitMs);
+    forceTimer.unref();
+    void runShutdownCallbacks(signal).finally(() => {
+      clearTimeout(forceTimer);
+      process.exit(exitCode);
+    });
+  });
+}
+installSignalHandler("SIGINT");
+installSignalHandler("SIGTERM");
 async function withTimeout(task, timeoutMs, message) {
   let timeoutId;
   try {
@@ -871,6 +1023,9 @@ async function withUploadListener(api, command, task) {
     12e4
   );
   let startedHere = false;
+  const unregisterSignalCleanup = registerShutdownCallback(async () => {
+    await stopUploadListenerSafely(api, command);
+  });
   const sinkError = (error) => {
     writeDebugLine(
       "msg.upload.listener.error",
@@ -961,6 +1116,7 @@ async function withUploadListener(api, command, task) {
     if (startedHere) {
       await stopUploadListenerSafely(api, command);
     }
+    unregisterSignalCleanup();
     api.listener.off("error", sinkError);
     api.listener.off("closed", sinkClosed);
   }
@@ -2270,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
         },
@@ -2305,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);
@@ -3258,6 +3424,8 @@ ${replyContextText}` : replyContextText;
         let recycleForceExitTimer = null;
         let heartbeatTimer = null;
         let recyclePendingExit = false;
+        let unregisterShutdown = () => {
+        };
         const finish = () => {
           if (settled) return;
           settled = true;
@@ -3273,6 +3441,9 @@ ${replyContextText}` : replyContextText;
             clearInterval(heartbeatTimer);
             heartbeatTimer = null;
           }
+          unregisterShutdown();
+          unregisterShutdown = () => {
+          };
           resolve();
         };
         api.listener.on("closed", (code, reason) => {
@@ -3295,13 +3466,14 @@ ${replyContextText}` : replyContextText;
             finish();
           }
         });
-        const onSigint = () => {
+        const onSignal = () => {
           try {
             api.listener.stop();
           } catch {
           }
           finish();
         };
+        unregisterShutdown = registerShutdownCallback(onSignal);
         if (lifecycleEventsEnabled && heartbeatMs > 0) {
           heartbeatTimer = setInterval(() => {
             emitLifecycle("heartbeat");
@@ -3336,7 +3508,6 @@ ${replyContextText}` : replyContextText;
             finish();
           }, recycleMs);
         }
-        process.once("SIGINT", onSigint);
         api.listener.start({ retryOnClose: supervised ? false : Boolean(opts.keepAlive) });
       });
     }

package/package.json

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