openzca 0.1.16 → 0.1.18

package/README.md

@@ -1,13 +1,8 @@
 # openzca
 
-Free and open-source CLI for Zalo, built on [zca-js](https://github.com/nicenathapong/zca-js). Command structure compatible with [zca-cli.dev/docs](https://zca-cli.dev/docs).
+Free and open-source CLI for Zalo, built on [zca-js](https://github.com/RFS-ADRENO/zca-js). Command structure compatible with [zca-cli.dev/docs](https://zca-cli.dev/docs).
 
-## Integrate with OpenClaw ZaloUser plugin
-
-Prompt:
-```
-help me to enable zalouser openclaw plugin. However, don't install zca cli follow their instruction, please use: npm install -g openzca@latest
-```
+## Integrate with OpenClaw OpenZalo plugin (including legacy `zalouser`)
 
 
 ## Install
@@ -296,7 +291,7 @@ Supervised mode notes:
 
 ## Multi-account profiles
 
-Use `--profile <name>` or set `ZCA_PROFILE=<name>` to switch between accounts. Manage profiles with the `account` commands.
+Use `--profile <name>` or set `OPENZCA_PROFILE=<name>` (or legacy `ZCA_PROFILE=<name>`) to switch between accounts. Manage profiles with the `account` commands.
 
 Profile data is stored in `~/.openzca/` (override with `OPENZCA_HOME`):
 

package/dist/cli.js

@@ -164,7 +164,7 @@ async function removeProfile(name) {
 }
 async function resolveProfileName(flagProfile) {
   const db = await ensureProfilesDb();
-  const picked = flagProfile && flagProfile.trim() || process.env.ZCA_PROFILE && process.env.ZCA_PROFILE.trim() || db.defaultProfile || DEFAULT_PROFILE;
+  const picked = flagProfile && flagProfile.trim() || (process.env.OPENZCA_PROFILE?.trim() || process.env.ZCA_PROFILE?.trim()) || db.defaultProfile || DEFAULT_PROFILE;
   if (!db.profiles[picked]) {
     if (picked === DEFAULT_PROFILE) {
       await ensureProfile(DEFAULT_PROFILE);
@@ -765,7 +765,7 @@ async function currentProfile(_command) {
 async function profileForLogin() {
   const opts = program.opts();
   const explicit = opts.profile?.trim();
-  const fromEnv = process.env.ZCA_PROFILE?.trim();
+  const fromEnv = process.env.OPENZCA_PROFILE?.trim() || process.env.ZCA_PROFILE?.trim();
   if (explicit) {
     await ensureProfile(explicit);
     return explicit;
@@ -806,6 +806,139 @@ 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 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 {
+    api.listener.off("error", sinkError);
+    api.listener.off("closed", sinkClosed);
+    if (startedHere) {
+      try {
+        api.listener.stop();
+        writeDebugLine("msg.upload.listener.stop", void 0, command);
+      } catch {
+      }
+    }
+  }
+}
 async function fetchRecentMessagesViaListener(api, threadId, threadType, count) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -1653,7 +1786,7 @@ program.hook("preAction", (_parent, actionCommand) => {
       argv: process.argv.slice(2),
       cwd: process.cwd(),
       profileFlag: getDebugOptions(actionCommand).profile ?? null,
-      envProfile: process.env.ZCA_PROFILE ?? null
+      envProfile: process.env.OPENZCA_PROFILE ?? process.env.ZCA_PROFILE ?? null
     },
     actionCommand
   );
@@ -2082,6 +2215,32 @@ msg.command("undo <msgId> <cliMsgId> <threadId>").option("-g, --group", "Undo in
     }
   )
 );
+msg.command("edit <msgId> <cliMsgId> <threadId> <message>").option("-g, --group", "Edit in group").description("Edit message (compatibility shim: recall old message then resend new text)").action(
+  wrapAction(
+    async (msgId, cliMsgId, threadId, message, opts, command) => {
+      const { api } = await requireApi(command);
+      const type = asThreadType(opts.group);
+      const undoResponse = await api.undo(
+        {
+          msgId,
+          cliMsgId
+        },
+        threadId,
+        type
+      );
+      const sendResponse = await api.sendMessage(message, threadId, type);
+      output(
+        {
+          mode: "undo+send",
+          nativeEditSupported: false,
+          undo: undoResponse,
+          send: sendResponse
+        },
+        false
+      );
+    }
+  )
+);
 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) => {
@@ -2111,13 +2270,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 {
@@ -2164,6 +2327,75 @@ msg.command("recent <threadId>").option("-g, --group", "List recent messages for
     }
   )
 );
+msg.command("pin <threadId>").option("-g, --group", "Pin group conversation").description("Pin conversation").action(
+  wrapAction(async (threadId, opts, command) => {
+    const { api } = await requireApi(command);
+    const type = asThreadType(opts.group);
+    const response = await api.setPinnedConversations(true, threadId, type);
+    output(
+      {
+        threadId,
+        threadType: type === ThreadType.Group ? "group" : "user",
+        pinned: true,
+        response
+      },
+      false
+    );
+  })
+);
+msg.command("unpin <threadId>").option("-g, --group", "Unpin group conversation").description("Unpin conversation").action(
+  wrapAction(async (threadId, opts, command) => {
+    const { api } = await requireApi(command);
+    const type = asThreadType(opts.group);
+    const response = await api.setPinnedConversations(false, threadId, type);
+    output(
+      {
+        threadId,
+        threadType: type === ThreadType.Group ? "group" : "user",
+        pinned: false,
+        response
+      },
+      false
+    );
+  })
+);
+msg.command("list-pins").option("-j, --json", "JSON output").description("List pinned conversations").action(
+  wrapAction(async (opts, command) => {
+    const { api } = await requireApi(command);
+    const response = await api.getPinConversations();
+    if (opts.json) {
+      output(response, true);
+      return;
+    }
+    output(
+      response.conversations.map((threadId) => ({
+        threadId,
+        pinned: true
+      })),
+      false
+    );
+  })
+);
+msg.command("member-info <userId>").option("-j, --json", "JSON output").description("Get member/user profile info").action(
+  wrapAction(async (userId, opts, command) => {
+    const { api } = await requireApi(command);
+    const response = await api.getUserInfo(userId);
+    if (opts.json) {
+      output(response, true);
+      return;
+    }
+    const profiles = response.changed_profiles ?? {};
+    const matchedProfile = profiles[userId] ?? profiles[`${userId}_0`] ?? Object.values(profiles)[0] ?? null;
+    output(
+      {
+        userId,
+        found: Boolean(matchedProfile),
+        profile: matchedProfile
+      },
+      false
+    );
+  })
+);
 var group = program.command("group").description("Group management");
 group.command("list").option("-j, --json", "JSON output").description("List groups").action(
   wrapAction(async (opts, command) => {

package/package.json

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