openzca 0.1.17 → 0.1.19

package/dist/cli.js

@@ -806,6 +806,159 @@ async function refreshCacheForProfile(profile, api) {
     groups: groups.length
   };
 }
+function parsePositiveIntFromEnv(name, fallback) {
+  const raw = process.env[name]?.trim();
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+function isListenerAlreadyStarted(error) {
+  if (!(error instanceof Error)) return false;
+  return /already started/i.test(error.message);
+}
+function toErrorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function withTimeout(task, timeoutMs, message) {
+  let timeoutId;
+  try {
+    const timeout = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    return await Promise.race([task, timeout]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+async function stopUploadListenerSafely(api, command, waitClosedMs = 1500) {
+  await new Promise((resolve) => {
+    let settled = false;
+    let timeoutId;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      api.listener.off("closed", onClosed);
+      resolve();
+    };
+    const onClosed = () => {
+      finish();
+    };
+    api.listener.on("closed", onClosed);
+    timeoutId = setTimeout(finish, waitClosedMs);
+    try {
+      api.listener.stop();
+      writeDebugLine("msg.upload.listener.stop", void 0, command);
+    } catch {
+      finish();
+    }
+  });
+}
+async function withUploadListener(api, command, task) {
+  const connectTimeoutMs = parsePositiveIntFromEnv(
+    "OPENZCA_UPLOAD_LISTENER_CONNECT_TIMEOUT_MS",
+    8e3
+  );
+  const uploadTimeoutMs = parsePositiveIntFromEnv(
+    "OPENZCA_UPLOAD_TIMEOUT_MS",
+    12e4
+  );
+  let startedHere = false;
+  const sinkError = (error) => {
+    writeDebugLine(
+      "msg.upload.listener.error",
+      {
+        message: toErrorText(error)
+      },
+      command
+    );
+  };
+  const sinkClosed = (code, reason) => {
+    writeDebugLine(
+      "msg.upload.listener.closed",
+      {
+        code,
+        reason: reason || void 0
+      },
+      command
+    );
+  };
+  api.listener.on("error", sinkError);
+  api.listener.on("closed", sinkClosed);
+  try {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      let timeoutId;
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        api.listener.off("connected", onConnected);
+        api.listener.off("error", onConnectError);
+        api.listener.off("closed", onConnectClosed);
+      };
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      };
+      const onConnected = () => {
+        writeDebugLine("msg.upload.listener.connected", void 0, command);
+        finish();
+      };
+      const onConnectError = (error) => {
+        finish(new Error(`Upload listener connection error: ${toErrorText(error)}`));
+      };
+      const onConnectClosed = (code, reason) => {
+        finish(
+          new Error(
+            `Upload listener closed before ready (code=${code}${reason ? `, reason=${reason}` : ""}).`
+          )
+        );
+      };
+      timeoutId = setTimeout(() => {
+        finish(new Error(`Timed out waiting ${connectTimeoutMs}ms for upload listener connection.`));
+      }, connectTimeoutMs);
+      api.listener.on("connected", onConnected);
+      api.listener.on("error", onConnectError);
+      api.listener.on("closed", onConnectClosed);
+      try {
+        api.listener.start();
+        startedHere = true;
+        writeDebugLine(
+          "msg.upload.listener.start",
+          {
+            connectTimeoutMs,
+            uploadTimeoutMs
+          },
+          command
+        );
+      } catch (error) {
+        if (isListenerAlreadyStarted(error)) {
+          writeDebugLine("msg.upload.listener.already_started", void 0, command);
+          finish();
+          return;
+        }
+        finish(error);
+      }
+    });
+    return await withTimeout(
+      task(),
+      uploadTimeoutMs,
+      `Timed out waiting ${uploadTimeoutMs}ms for file upload completion.`
+    );
+  } finally {
+    if (startedHere) {
+      await stopUploadListenerSafely(api, command);
+    }
+    api.listener.off("error", sinkError);
+    api.listener.off("closed", sinkClosed);
+  }
+}
 async function fetchRecentMessagesViaListener(api, threadId, threadType, count) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -2137,13 +2290,17 @@ msg.command("upload <arg1> [arg2]").option("-u, --url <url>", "File URL (repeata
           );
         }
         await assertFilesExist(attachments);
-        const response = await api.sendMessage(
-          {
-            msg: "",
-            attachments
-          },
-          threadId,
-          asThreadType(opts.group)
+        const response = await withUploadListener(
+          api,
+          command,
+          async () => api.sendMessage(
+            {
+              msg: "",
+              attachments
+            },
+            threadId,
+            asThreadType(opts.group)
+          )
         );
         output(response, false);
       } finally {

package/package.json

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