openzca 0.1.45 → 0.1.47

package/README.md

@@ -69,7 +69,7 @@ You can also open the saved file manually (for example: `open qr.png` on macOS).
 |---------|-------------|
 | `openzca msg send <threadId> <message>` | Send text message |
 | `openzca msg image <threadId> [file]` | Send image(s) from file or URL |
-| `openzca msg video <threadId> [file]` | Send video(s) from file or URL |
+| `openzca msg video <threadId> [file]` | Send video(s) from file or URL; single `.mp4` inputs try native video mode |
 | `openzca msg voice <threadId> [file]` | Send voice message from local file or URL (`.aac`, `.mp3`, `.m4a`, `.wav`, `.ogg`) |
 | `openzca msg sticker <threadId> <stickerId>` | Send a sticker |
 | `openzca msg link <threadId> <url>` | Send a link |
@@ -83,6 +83,7 @@ You can also open the saved file manually (for example: `open qr.png` on macOS).
 | `openzca msg recent <threadId>` | List recent messages (`-n`, `--json`, newest-first); group mode prefers direct group-history endpoint (websocket fallback) |
 
 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.
 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.
 
@@ -126,6 +127,11 @@ For media debugging, grep these events in the debug log:
 | `openzca group info <groupId>` | Get group details |
 | `openzca group members <groupId>` | List members |
 | `openzca group create <name> <members...>` | Create a group |
+| `openzca group poll create <groupId>` | Create a poll (`--question`, repeatable `--option`, optional poll flags) |
+| `openzca group poll detail <pollId>` | Get poll details |
+| `openzca group poll vote <pollId>` | Vote on a poll with repeatable `--option <id>` |
+| `openzca group poll lock <pollId>` | Close a poll |
+| `openzca group poll share <pollId>` | Share a poll |
 | `openzca group rename <groupId> <name>` | Rename group |
 | `openzca group avatar <groupId> <file>` | Change group avatar |
 | `openzca group settings <groupId>` | Update settings (`--lock-name`, `--sign-admin`, etc.) |
@@ -146,6 +152,8 @@ For media debugging, grep these events in the debug log:
 | `openzca group leave <groupId>` | Leave group |
 | `openzca group disperse <groupId>` | Disperse group |
 
+Poll creation currently targets group threads only and maps to the existing `zca-js` group poll APIs. `group poll create` requires `--question` plus at least two `--option` values, and also supports `--multi`, `--allow-add-option`, `--hide-vote-preview`, `--anonymous`, and `--expire-ms`.
+
 ### friend — Friend management
 
 | Command | Description |

package/dist/cli.js

@@ -4,10 +4,10 @@
 import { createRequire } from "module";
 import { spawn as spawn2 } from "child_process";
 import fsSync from "fs";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import net from "net";
-import os3 from "os";
-import path4 from "path";
+import os4 from "os";
+import path5 from "path";
 import util from "util";
 import { Command } from "commander";
 import {
@@ -578,6 +578,60 @@ async function assertFilesExist(files) {
   }
 }
 
+// src/lib/group-poll.ts
+function parsePositiveInteger(value, label) {
+  const normalized = value.trim();
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  const parsed = Number.parseInt(normalized, 10);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer.`);
+  }
+  return parsed;
+}
+function requireQuestion(value) {
+  const normalized = value?.trim() ?? "";
+  if (!normalized) {
+    throw new Error("Poll question is required.");
+  }
+  return normalized;
+}
+function normalizeOptions(values) {
+  const normalized = (values ?? []).map((value) => value.trim());
+  if (normalized.length < 2) {
+    throw new Error("Poll must include at least two options.");
+  }
+  for (let index = 0; index < normalized.length; index += 1) {
+    if (!normalized[index]) {
+      throw new Error(`Poll option ${index + 1} cannot be empty.`);
+    }
+  }
+  return normalized;
+}
+function parsePollId(value) {
+  return parsePositiveInteger(value, "Poll id");
+}
+function parsePollOptionIds(values) {
+  const optionIds = values ?? [];
+  if (optionIds.length === 0) {
+    throw new Error("Provide at least one option id.");
+  }
+  return optionIds.map((value) => parsePositiveInteger(value, "Option id"));
+}
+function buildCreatePollOptions(options) {
+  const expireMs = options.expireMs?.trim();
+  return {
+    question: requireQuestion(options.question),
+    options: normalizeOptions(options.option),
+    expiredTime: expireMs ? parsePositiveInteger(expireMs, "expire-ms") : void 0,
+    allowMultiChoices: Boolean(options.multi),
+    allowAddNewOption: Boolean(options.allowAddOption),
+    hideVotePreview: Boolean(options.hideVotePreview),
+    isAnonymous: Boolean(options.anonymous)
+  };
+}
+
 // src/lib/text-send.ts
 import { ThreadType } from "zca-js";
 
@@ -960,6 +1014,187 @@ async function resolveGroupMentionsIfNeeded(params, text) {
   return mentions.length > 0 ? mentions : void 0;
 }
 
+// src/lib/video-send.ts
+import { execFile } from "child_process";
+import fs4 from "fs/promises";
+import os3 from "os";
+import path4 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function planVideoSendMode(params) {
+  const { files, ffmpegAvailable } = params;
+  if (!ffmpegAvailable) {
+    return {
+      mode: "attachment",
+      reason: "ffmpeg is unavailable for native video mode"
+    };
+  }
+  if (files.length !== 1) {
+    return {
+      mode: "attachment",
+      reason: "native-video mode supports one video at a time"
+    };
+  }
+  const ext = path4.extname(files[0] ?? "").toLowerCase();
+  if (ext !== ".mp4") {
+    return {
+      mode: "attachment",
+      reason: "native-video mode currently supports .mp4 inputs only"
+    };
+  }
+  return { mode: "native" };
+}
+function parseVideoProbeOutput(raw) {
+  const parsed = JSON.parse(raw);
+  const videoStream = parsed.streams?.find((stream) => stream.codec_type === "video");
+  const width = toPositiveInteger(videoStream?.width);
+  const height = toPositiveInteger(videoStream?.height);
+  const durationSeconds = toPositiveNumber(videoStream?.duration) ?? toPositiveNumber(parsed.format?.duration);
+  return {
+    durationMs: durationSeconds ? Math.round(durationSeconds * 1e3) : void 0,
+    width,
+    height
+  };
+}
+function toPositiveInteger(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.trunc(value);
+  }
+  if (typeof value === "string") {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0) {
+      return Math.trunc(numeric);
+    }
+  }
+  return void 0;
+}
+function toPositiveNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0) {
+      return numeric;
+    }
+  }
+  return void 0;
+}
+async function runBinary(command, args) {
+  try {
+    const { stdout } = await execFileAsync(command, args, {
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      throw new Error(`${command} is required for native video 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;
+  }
+}
+async function isFfmpegAvailable() {
+  try {
+    await execFileAsync("ffmpeg", ["-version"], {
+      encoding: "utf8",
+      maxBuffer: 1024 * 1024
+    });
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    return false;
+  }
+}
+async function maybeProbeVideoFile(filePath) {
+  try {
+    const raw = await runBinary("ffprobe", [
+      "-v",
+      "error",
+      "-print_format",
+      "json",
+      "-show_format",
+      "-show_streams",
+      filePath
+    ]);
+    return parseVideoProbeOutput(raw);
+  } catch {
+    return {};
+  }
+}
+async function generateVideoThumbnail(videoPath) {
+  const dir = await fs4.mkdtemp(path4.join(os3.tmpdir(), "openzca-video-thumb-"));
+  const outputPath = path4.join(dir, "thumbnail.jpg");
+  try {
+    await runBinary("ffmpeg", [
+      "-y",
+      "-ss",
+      "1",
+      "-i",
+      videoPath,
+      "-frames:v",
+      "1",
+      "-q:v",
+      "2",
+      outputPath
+    ]);
+    await fs4.access(outputPath);
+  } catch (error) {
+    await fs4.rm(dir, { recursive: true, force: true });
+    throw error;
+  }
+  return {
+    path: outputPath,
+    cleanup: async () => {
+      await fs4.rm(dir, { recursive: true, force: true });
+    }
+  };
+}
+function pickUploadedVideoUrl(uploaded) {
+  if (!uploaded || !("fileUrl" in uploaded) || typeof uploaded.fileUrl !== "string" || uploaded.fileUrl.length === 0) {
+    throw new Error("Video upload did not return a file URL");
+  }
+  return uploaded.fileUrl;
+}
+function pickUploadedThumbnailUrl(uploaded) {
+  if (!uploaded || uploaded.fileType !== "image") {
+    throw new Error("Thumbnail upload did not return an image result");
+  }
+  return uploaded.normalUrl || uploaded.hdUrl || uploaded.thumbUrl;
+}
+async function sendNativeVideo(params) {
+  const metadata = await maybeProbeVideoFile(params.videoPath);
+  const generatedThumbnail = params.thumbnailPath ? null : await generateVideoThumbnail(params.videoPath);
+  const thumbnailPath = params.thumbnailPath ?? generatedThumbnail?.path;
+  if (!thumbnailPath) {
+    throw new Error("Unable to resolve thumbnail path for native video send");
+  }
+  try {
+    const uploadedVideo = await params.api.uploadAttachment([params.videoPath], params.threadId, params.threadType);
+    const uploadedThumbnail = await params.api.uploadAttachment([thumbnailPath], params.threadId, params.threadType);
+    return await params.api.sendVideo(
+      {
+        msg: params.message ?? "",
+        videoUrl: pickUploadedVideoUrl(uploadedVideo[0]),
+        thumbnailUrl: pickUploadedThumbnailUrl(uploadedThumbnail[0]),
+        duration: metadata.durationMs,
+        width: metadata.width,
+        height: metadata.height
+      },
+      params.threadId,
+      params.threadType
+    );
+  } finally {
+    await generatedThumbnail?.cleanup();
+  }
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var { version: PKG_VERSION } = require2("../package.json");
@@ -1022,9 +1257,9 @@ function resolveDebugEnabled(command) {
 }
 function resolveDebugFilePath(command) {
   const options = getDebugOptions(command);
-  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path4.join(APP_HOME, "logs", "openzca-debug.log");
+  const configured = options.debugFile?.trim() || process.env.OPENZCA_DEBUG_FILE?.trim() || path5.join(APP_HOME, "logs", "openzca-debug.log");
   const normalized = normalizeMediaInput(configured);
-  return path4.isAbsolute(normalized) ? normalized : path4.resolve(process.cwd(), normalized);
+  return path5.isAbsolute(normalized) ? normalized : path5.resolve(process.cwd(), normalized);
 }
 function writeDebugLine(event, details, command) {
   if (!resolveDebugEnabled(command)) {
@@ -1035,7 +1270,7 @@ function writeDebugLine(event, details, command) {
 `;
   const filePath = resolveDebugFilePath(command);
   try {
-    fsSync.mkdirSync(path4.dirname(filePath), { recursive: true });
+    fsSync.mkdirSync(path5.dirname(filePath), { recursive: true });
     fsSync.appendFileSync(filePath, line, "utf8");
   } catch {
   }
@@ -1123,14 +1358,14 @@ function collectIdsFromCacheEntries(entries, keys) {
   return ids;
 }
 function getListenerOwnerLockPath(profile) {
-  return path4.join(getProfileDir(profile), "listener-owner.json");
+  return path5.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 path4.join(getProfileDir(profile), "listen.sock");
+  return path5.join(getProfileDir(profile), "listen.sock");
 }
 function parsePositiveIntFromUnknown(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -1157,7 +1392,7 @@ function isProcessAlive(pid) {
 }
 async function readListenerOwnerRecord(lockPath) {
   try {
-    const raw = await fs4.readFile(lockPath, "utf8");
+    const raw = await fs5.readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw);
     const pid = parsePositiveIntFromUnknown(parsed.pid);
     if (!pid) return null;
@@ -1177,11 +1412,11 @@ async function readActiveListenerOwner(profile) {
   const lockPath = getListenerOwnerLockPath(profile);
   const record = await readListenerOwnerRecord(lockPath);
   if (!record) {
-    await fs4.rm(lockPath, { force: true });
+    await fs5.rm(lockPath, { force: true });
     return null;
   }
   if (!isProcessAlive(record.pid)) {
-    await fs4.rm(lockPath, { force: true });
+    await fs5.rm(lockPath, { force: true });
     return null;
   }
   return record;
@@ -1197,7 +1432,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
   };
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
-      await fs4.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
+      await fs5.writeFile(lockPath, `${JSON.stringify(record, null, 2)}
 `, {
         encoding: "utf8",
         flag: "wx"
@@ -1210,7 +1445,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           released = true;
           const current = await readListenerOwnerRecord(lockPath);
           if (current && current.pid !== process.pid) return;
-          await fs4.rm(lockPath, { force: true });
+          await fs5.rm(lockPath, { force: true });
           writeDebugLine(
             "listen.owner.released",
             {
@@ -1231,7 +1466,7 @@ async function acquireListenerOwnerLock(profile, sessionId, command) {
           `Another openzca listener already owns profile "${profile}" (pid ${owner.pid}).`
         );
       }
-      await fs4.rm(lockPath, { force: true });
+      await fs5.rm(lockPath, { force: true });
     }
   }
   throw new Error(`Unable to acquire listener ownership for profile "${profile}".`);
@@ -1249,7 +1484,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
   }
   const socketPath = getListenIpcSocketPath(profile);
   if (process.platform !== "win32") {
-    await fs4.rm(socketPath, { force: true });
+    await fs5.rm(socketPath, { force: true });
   }
   const uploadTimeoutMs = parsePositiveIntFromEnv(
     "OPENZCA_UPLOAD_IPC_HANDLER_TIMEOUT_MS",
@@ -1421,7 +1656,7 @@ async function startListenerIpcServer(api, profile, sessionId, command) {
         server.close(() => resolve());
       });
       if (process.platform !== "win32") {
-        await fs4.rm(socketPath, { force: true });
+        await fs5.rm(socketPath, { force: true });
       }
       writeDebugLine(
         "listen.ipc.stopped",
@@ -2364,7 +2599,7 @@ async function fetchRecentUserMessagesViaListener(api, threadId, count) {
   });
 }
 async function parseCredentialFile(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
+  const raw = await fs5.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.");
@@ -2385,7 +2620,7 @@ async function waitForFileContent(filePath, timeoutMs) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
     try {
-      const data = await fs4.readFile(filePath);
+      const data = await fs5.readFile(filePath);
       if (data.length > 0) {
         return data;
       }
@@ -2400,8 +2635,8 @@ async function emitQrBase64FromDetachedLogin(profile, qrPath) {
   if (!scriptPath) {
     throw new Error("Cannot resolve CLI entrypoint for QR base64 mode.");
   }
-  const tempDir = await fs4.mkdtemp(path4.join(os3.tmpdir(), "openzca-qr-"));
-  const targetPath = path4.resolve(qrPath ?? path4.join(tempDir, "qr.png"));
+  const tempDir = await fs5.mkdtemp(path5.join(os4.tmpdir(), "openzca-qr-"));
+  const targetPath = path5.resolve(qrPath ?? path5.join(tempDir, "qr.png"));
   const child = spawn2(
     process.execPath,
     [scriptPath, "--profile", profile, "auth", "login", "--qr-path", targetPath],
@@ -2679,7 +2914,7 @@ function mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind) {
   if (fromType) return fromType;
   try {
     const parsedUrl = new URL(mediaUrl);
-    const ext = path4.extname(parsedUrl.pathname);
+    const ext = path5.extname(parsedUrl.pathname);
     if (ext) return ext;
   } catch {
   }
@@ -2710,20 +2945,20 @@ function parseInboundMediaFetchTimeoutMs() {
   return Math.trunc(parsed);
 }
 function resolveOpenClawMediaDir() {
-  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path4.join(os3.homedir(), ".openclaw");
-  return path4.join(stateDir, "media");
+  const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim() || path5.join(os4.homedir(), ".openclaw");
+  return path5.join(stateDir, "media");
 }
 function resolveInboundMediaDir(profile) {
   const configuredRaw = process.env.OPENZCA_LISTEN_MEDIA_DIR?.trim();
   if (configuredRaw) {
     const configured = normalizeMediaInput(configuredRaw);
-    return path4.isAbsolute(configured) ? configured : path4.resolve(process.cwd(), configured);
+    return path5.isAbsolute(configured) ? configured : path5.resolve(process.cwd(), configured);
   }
   const legacyRequested = process.env.OPENZCA_LISTEN_MEDIA_LEGACY_DIR?.trim() === "1";
   if (legacyRequested) {
-    return path4.join(getProfileDir(profile), "inbound-media");
+    return path5.join(getProfileDir(profile), "inbound-media");
   }
-  return path4.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
+  return path5.join(resolveOpenClawMediaDir(), "openzca", profile, "inbound");
 }
 async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
   const maxBytes = parseMaxInboundMediaBytes();
@@ -2757,11 +2992,11 @@ async function cacheInboundMediaToProfile(profile, mediaUrl, kind) {
     return null;
   }
   const dir = resolveInboundMediaDir(profile);
-  await fs4.mkdir(dir, { recursive: true });
+  await fs5.mkdir(dir, { recursive: true });
   const ext = mediaExtFromTypeOrUrl(mediaType, mediaUrl, kind);
   const id = `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-  const mediaPath = path4.join(dir, `${id}${ext}`);
-  await fs4.writeFile(mediaPath, data);
+  const mediaPath = path5.join(dir, `${id}${ext}`);
+  await fs5.writeFile(mediaPath, data);
   return { mediaPath, mediaType };
 }
 async function cacheRemoteMediaEntries(params) {
@@ -3253,7 +3488,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(path4.resolve(normalizeMediaInput(file))) : toCredentials(
+    const credentials = file ? await parseCredentialFile(path5.resolve(normalizeMediaInput(file))) : toCredentials(
       await loadCredentials(profile) ?? (() => {
         throw new Error(
           `No saved credentials for profile "${profile}". Run: openzca auth login`
@@ -3382,42 +3617,121 @@ msg.command("image <threadId> [file]").option("-u, --url <url>", "Image URL (rep
     }
   )
 );
-msg.command("video <threadId> [file]").option("-u, --url <url>", "Video URL (repeatable)", collectValues, []).option("-m, --message <message>", "Caption").option("--thumbnail <url>", "Thumbnail URL (kept for compatibility)").option("-g, --group", "Send to group").description("Send video(s) from file or URL").action(
+msg.command("video <threadId> [file]").option("-u, --url <url>", "Video URL (repeatable)", collectValues, []).option("-m, --message <message>", "Caption").option("--thumbnail <pathOrUrl>", "Thumbnail image path or URL (optional)").option("-g, --group", "Send to group").description("Send video(s) from file or URL").action(
   wrapAction(
     async (threadId, file, opts, command) => {
-      const { api } = await requireApi(command);
+      const { api, profile } = await requireApi(command);
+      const threadType = asThreadType(opts.group);
       const normalizedFile = file ? normalizeMediaInput(file) : void 0;
       const files = [normalizedFile, ...normalizeInputList(opts.url)].filter(Boolean);
       const urlInputs = files.filter((entry) => isHttpUrl(entry));
       const localInputs = files.filter((entry) => !isHttpUrl(entry));
+      const normalizedThumbnail = opts.thumbnail ? normalizeMediaInput(opts.thumbnail) : void 0;
+      const thumbnailUrlInputs = normalizedThumbnail && isHttpUrl(normalizedThumbnail) ? [normalizedThumbnail] : [];
+      const thumbnailLocalPath = normalizedThumbnail && !isHttpUrl(normalizedThumbnail) ? normalizedThumbnail : void 0;
       writeDebugLine(
         "msg.video.inputs",
         {
           threadId,
           isGroup: Boolean(opts.group),
           localInputs,
-          urlInputs
+          urlInputs,
+          thumbnail: normalizedThumbnail
         },
         command
       );
       const downloaded = await downloadUrlsToTempFiles(urlInputs);
+      const downloadedThumbnail = await downloadUrlsToTempFiles(thumbnailUrlInputs);
       try {
         const attachments = [...localInputs, ...downloaded.files];
         if (attachments.length === 0) {
           throw new Error("Provide at least one video file or --url.");
         }
         await assertFilesExist(attachments);
-        const response = await api.sendMessage(
-          {
-            msg: opts.message ?? "",
-            attachments
-          },
-          threadId,
-          asThreadType(opts.group)
+        if (thumbnailLocalPath) {
+          await assertFilesExist([thumbnailLocalPath]);
+        }
+        const enforceSingleOwner = parseBooleanFromEnv("OPENZCA_UPLOAD_ENFORCE_SINGLE_OWNER", true);
+        if (enforceSingleOwner) {
+          const owner = await readActiveListenerOwner(profile);
+          if (owner && owner.pid !== process.pid) {
+            throw new Error(
+              `Active listener owner detected for profile "${profile}" (pid ${owner.pid}), but video upload IPC is unavailable. Restart \`openzca listen\` with latest version or set OPENZCA_UPLOAD_ENFORCE_SINGLE_OWNER=0 to allow fallback listener startup.`
+            );
+          }
+        }
+        const ffmpegAvailable = await isFfmpegAvailable();
+        const videoPlan = planVideoSendMode({
+          files: attachments,
+          ffmpegAvailable
+        });
+        if (videoPlan.mode === "native") {
+          const thumbnailPath = thumbnailLocalPath ?? downloadedThumbnail.files[0];
+          try {
+            const response2 = await withUploadListener(
+              api,
+              command,
+              async () => sendNativeVideo({
+                api,
+                threadId,
+                threadType,
+                videoPath: attachments[0],
+                message: opts.message,
+                thumbnailPath
+              })
+            );
+            writeDebugLine(
+              "msg.video.native.success",
+              {
+                threadId,
+                isGroup: Boolean(opts.group),
+                videoPath: attachments[0],
+                thumbnailPath: thumbnailPath ?? null
+              },
+              command
+            );
+            output(response2, false);
+            return;
+          } catch (error) {
+            writeDebugLine(
+              "msg.video.native.failed",
+              {
+                threadId,
+                isGroup: Boolean(opts.group),
+                videoPath: attachments[0],
+                thumbnailPath: thumbnailPath ?? null,
+                message: error instanceof Error ? error.message : String(error)
+              },
+              command
+            );
+          }
+        } else {
+          writeDebugLine(
+            "msg.video.native.skipped",
+            {
+              threadId,
+              isGroup: Boolean(opts.group),
+              reason: videoPlan.reason
+            },
+            command
+          );
+        }
+        const response = await withUploadListener(
+          api,
+          command,
+          async () => api.sendMessage(
+            {
+              msg: opts.message ?? "",
+              attachments
+            },
+            threadId,
+            threadType
+          )
         );
         output(response, false);
       } finally {
         await downloaded.cleanup();
+        await downloadedThumbnail.cleanup();
       }
     }
   )
@@ -3867,6 +4181,51 @@ group.command("create <name> <members...>").description("Create new group").acti
     output(response, false);
   })
 );
+var groupPoll = group.command("poll").description("Group poll management");
+groupPoll.command("create <groupId>").requiredOption("-q, --question <text>", "Poll question").requiredOption("-o, --option <text>", "Poll option (repeatable)", collectValues, []).option("--multi", "Allow multiple choices").option("--allow-add-option", "Allow members to add new options").option("--hide-vote-preview", "Hide results until the member votes").option("--anonymous", "Hide voters").option("--expire-ms <ms>", "Poll expiration time in milliseconds").description("Create a poll in a group").action(
+  wrapAction(
+    async (groupId, opts, command) => {
+      const pollOptions = buildCreatePollOptions(opts);
+      const { api } = await requireApi(command);
+      output(await api.createPoll(pollOptions, groupId), false);
+    }
+  )
+);
+groupPoll.command("detail <pollId>").description("Get poll detail").action(
+  wrapAction(async (pollId, command) => {
+    const normalizedPollId = parsePollId(pollId);
+    const { api } = await requireApi(command);
+    output(await api.getPollDetail(normalizedPollId), false);
+  })
+);
+groupPoll.command("vote <pollId>").requiredOption("-o, --option <id>", "Poll option id (repeatable)", collectValues, []).description("Vote on a group poll").action(
+  wrapAction(
+    async (pollId, opts, command) => {
+      const normalizedPollId = parsePollId(pollId);
+      const optionIds = parsePollOptionIds(opts.option);
+      const { api } = await requireApi(command);
+      const response = await api.votePoll(
+        normalizedPollId,
+        optionIds.length === 1 ? optionIds[0] : optionIds
+      );
+      output(response, false);
+    }
+  )
+);
+groupPoll.command("lock <pollId>").description("Close a poll").action(
+  wrapAction(async (pollId, command) => {
+    const normalizedPollId = parsePollId(pollId);
+    const { api } = await requireApi(command);
+    output(await api.lockPoll(normalizedPollId), false);
+  })
+);
+groupPoll.command("share <pollId>").description("Share a poll").action(
+  wrapAction(async (pollId, command) => {
+    const normalizedPollId = parsePollId(pollId);
+    const { api } = await requireApi(command);
+    output(await api.sharePoll(normalizedPollId), false);
+  })
+);
 group.command("rename <groupId> <name>").description("Rename group").action(
   wrapAction(async (groupId, name, command) => {
     const { api } = await requireApi(command);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzca",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Open-source zca-compatible CLI to integrate Zalo with OpenClaw",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
   "scripts": {
     "build": "tsup src/cli.ts --format esm --target node18 --out-dir dist --clean",
     "dev": "tsx src/cli.ts",
+    "test": "tsx --test tests/*.test.ts",
     "typecheck": "tsc -p tsconfig.json",
     "lint": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "npm run build"