dingtalk-pingo 0.1.0 → 0.2.0

package/dist/pingo.js

@@ -7421,10 +7421,22 @@ var FORMAT_REJECTION_CODES = /* @__PURE__ */ new Set([
 var PingoError = class extends Error {
   category;
   code;
-  constructor(category, message, code) {
+  /** 为 true 时,发送管线可以降级到下一种消息格式重试(目前仅用于卡片被钉钉明确拒绝)。 */
+  degradable;
+  constructor(category, message, code, options) {
     super(message);
     this.category = category;
     this.code = code;
+    this.degradable = options?.degradable === true;
+  }
+};
+var PartialSendError = class extends PingoError {
+  sent;
+  failed;
+  constructor(cause, sent, failed) {
+    super(cause.category, cause.message, cause.code);
+    this.sent = sent;
+    this.failed = failed;
   }
 };
 function classifyDingTalkError(httpStatus, code) {
@@ -7443,6 +7455,7 @@ function isFormatRejection(code) {
 var CRED_KEYS = ["clientId", "clientSecret", "robotCode", "userId"];
 var MESSAGE_TYPES = ["success", "warning", "error", "info"];
 var FORMATS = ["text", "markdown"];
+var SEND_FORMATS = ["card", "markdown", "text"];
 function fail(message) {
   throw new PingoError("config", message);
 }
@@ -7509,15 +7522,36 @@ function validateConfig(raw, opts) {
   const device = { id, name: str(deviceRaw.name) ?? id };
   const icon = str(deviceRaw.icon);
   if (icon !== void 0) device.icon = icon;
+  const avatar = str(deviceRaw.avatar);
+  if (avatar !== void 0) {
+    if (!/^https?:\/\//i.test(avatar)) {
+      fail(`\u914D\u7F6E\u9879 device.avatar \u5FC5\u987B\u662F http(s) \u56FE\u7247\u5730\u5740,\u5F53\u524D\u503C:${avatar}\u3002`);
+    }
+    device.avatar = avatar;
+  }
+  const cardRaw = isRecord(raw.card) ? raw.card : {};
+  const card = {};
+  const templateId = str(cardRaw.templateId);
+  if (templateId !== void 0) card.templateId = templateId;
+  const preferredFormat = pickEnum(
+    msgRaw.preferredFormat,
+    SEND_FORMATS,
+    card.templateId !== void 0 ? "card" : "markdown",
+    "message.preferredFormat"
+  );
+  if (preferredFormat === "card" && card.templateId === void 0) {
+    fail("message.preferredFormat \u4E3A card \u65F6\u5FC5\u987B\u914D\u7F6E card.templateId(\u9489\u9489\u5361\u7247\u6A21\u677F ID)\u3002");
+  }
   return {
     device,
     dingtalk,
     message: {
       defaultType: pickEnum(msgRaw.defaultType, MESSAGE_TYPES, "info", "message.defaultType"),
-      preferredFormat: pickEnum(msgRaw.preferredFormat, FORMATS, "markdown", "message.preferredFormat"),
+      preferredFormat,
       fallbackFormat: pickEnum(msgRaw.fallbackFormat, FORMATS, "text", "message.fallbackFormat"),
       timeoutMs
     },
+    card,
     templates
   };
 }
@@ -7616,10 +7650,14 @@ function loadConfig(opts) {
   const deviceId = nonEmpty(opts.env.PINGO_DEVICE_ID) ?? nonEmpty(deviceYaml.id) ?? opts.hostname;
   const deviceName = nonEmpty(opts.env.PINGO_DEVICE_NAME) ?? nonEmpty(deviceYaml.name) ?? opts.hostname;
   const deviceIcon = nonEmpty(opts.env.PINGO_DEVICE_ICON) ?? nonEmpty(deviceYaml.icon);
+  const deviceAvatar = nonEmpty(opts.env.PINGO_DEVICE_AVATAR) ?? nonEmpty(deviceYaml.avatar);
+  const cardYaml = isRecord2(yamlRaw.card) ? yamlRaw.card : {};
+  const templateId = nonEmpty(opts.env.PINGO_CARD_TEMPLATE_ID) ?? nonEmpty(cardYaml.templateId);
   const merged = {
-    device: { id: deviceId, name: deviceName, icon: deviceIcon },
+    device: { id: deviceId, name: deviceName, icon: deviceIcon, avatar: deviceAvatar },
     dingtalk: creds,
     message: yamlRaw.message,
+    card: { templateId },
     templates: yamlRaw.templates
   };
   const config = validateConfig(merged, { requireCredentials: opts.requireCredentials });
@@ -7680,6 +7718,12 @@ var TYPE_ICONS = {
   error: "\u274C",
   info: "\u2139\uFE0F"
 };
+var TYPE_LABELS = {
+  success: "\u5DF2\u5B8C\u6210",
+  warning: "\u9700\u8981\u5173\u6CE8",
+  error: "\u4EFB\u52A1\u5F02\u5E38",
+  info: "\u6D88\u606F\u62A5\u544A"
+};
 var ACTION_TEXT = "\u26A0\uFE0F \u9700\u8981\u4EBA\u5DE5\u5904\u7406";
 function nonBlank(value) {
   if (value === void 0) return void 0;
@@ -7729,7 +7773,14 @@ function buildMessage(input, ctx) {
   let bodyTemplate = override.body ?? defaults.body;
   if (!isMarkdown) bodyTemplate = bodyTemplate.replaceAll("**", "");
   const title = collapseSpaces(renderTemplate(titleTemplate, titleVars));
-  const body = renderTemplate(bodyTemplate, bodyVars);
+  let body = renderTemplate(bodyTemplate, bodyVars);
+  const links = input.links ?? [];
+  if (links.length > 0 && body !== "") {
+    const linkLines = isMarkdown ? [links.map((l) => `[${escapeMarkdown(l.text)}](${l.url})`).join(" \xB7 ")] : links.map((l) => `${l.text}:${l.url}`);
+    body = `${body}
+
+${linkLines.join("\n")}`;
+  }
   if (title === "" || body === "") {
     throw new PingoError("content", "\u6E32\u67D3\u540E\u7684\u6807\u9898\u6216\u6B63\u6587\u4E3A\u7A7A,\u8BF7\u68C0\u67E5\u6D88\u606F\u5185\u5BB9\u4E0E\u6A21\u677F\u3002");
   }
@@ -7755,6 +7806,395 @@ ${body}`,
   };
 }
 
+// src/messages/card.ts
+import { randomUUID } from "node:crypto";
+function nonBlank2(value) {
+  if (value === void 0) return void 0;
+  const t = value.trim();
+  return t === "" ? void 0 : t;
+}
+function senderName(device, agent, project) {
+  return [device.name, nonBlank2(agent), nonBlank2(project)].filter((s) => s !== void 0).join(" \xB7 ");
+}
+function titleOf(type, title) {
+  return `${TYPE_ICONS[type]} ${nonBlank2(title) ?? TYPE_LABELS[type]}`;
+}
+function btnsOf(links) {
+  return JSON.stringify(
+    links.map((l) => ({
+      text: l.text,
+      color: "blue",
+      status: "normal",
+      event: { type: "openLink", params: { url: l.url } }
+    }))
+  );
+}
+var CHART_TYPES = ["lineChart", "histogram", "pieChart"];
+function parseChart(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (err) {
+    throw new PingoError("usage", `--chart \u6587\u4EF6\u4E0D\u662F\u5408\u6CD5 JSON:${err.message}`);
+  }
+  const chart = value;
+  if (chart === null || typeof chart !== "object" || Array.isArray(chart)) {
+    throw new PingoError("usage", '--chart \u5FC5\u987B\u662F JSON \u5BF9\u8C61:{"type":"lineChart","data":[...],"config":{}}\u3002');
+  }
+  if (typeof chart.type !== "string" || !CHART_TYPES.includes(chart.type)) {
+    throw new PingoError("usage", `--chart \u7684 type \u5FC5\u987B\u662F ${CHART_TYPES.join(" / ")} \u4E4B\u4E00\u3002`);
+  }
+  if (!Array.isArray(chart.data) || chart.data.length === 0) {
+    throw new PingoError("usage", "--chart \u7684 data \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4\u3002");
+  }
+  return JSON.stringify({ ...chart, config: chart.config ?? {} });
+}
+function contentOf(p, mediaIds) {
+  const body = p.markdown !== void 0 && p.markdown.trim() !== "" ? p.markdown : nonBlank2(p.message);
+  if (body === void 0) {
+    throw new PingoError("content", "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A:\u8BF7\u63D0\u4F9B --message \u6216 --markdown\u3002");
+  }
+  const parts = [];
+  if (p.actionRequired) parts.push(ACTION_TEXT);
+  const task = nonBlank2(p.task);
+  if (task !== void 0) parts.push(`\u4EFB\u52A1:${task}`);
+  parts.push(body);
+  if (mediaIds.length > 0) parts.push(mediaIds.map((id) => `![image](${id})`).join("\n"));
+  const content = parts.join("\n\n");
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes > MAX_MSGPARAM_BYTES) {
+    throw new PingoError(
+      "content",
+      `\u6D88\u606F\u8FC7\u957F:${bytes} \u5B57\u8282,\u8D85\u8FC7\u4E0A\u9650 ${MAX_MSGPARAM_BYTES} \u5B57\u8282,\u8BF7\u7CBE\u7B80\u5185\u5BB9\u540E\u91CD\u8BD5\u3002`
+    );
+  }
+  return content;
+}
+function renderCard(input, ctx, mediaIds) {
+  const content = contentOf(input, mediaIds);
+  const cardParamMap = {
+    senderName: senderName(ctx.device, input.agent, input.project),
+    title: titleOf(input.type, input.title),
+    content,
+    btns: btnsOf(input.links ?? [])
+  };
+  if (ctx.device.avatar !== void 0) cardParamMap.avatar = ctx.device.avatar;
+  const date = nonBlank2(input.date);
+  if (date !== void 0) cardParamMap.date = date;
+  if (input.chart !== void 0) cardParamMap.chart = input.chart;
+  const preview = [cardParamMap.senderName, cardParamMap.title, "", content].join("\n");
+  return { cardParamMap, preview, bytes: Buffer.byteLength(content, "utf8") };
+}
+function renderCardUpdate(input, ctx, mediaIds) {
+  const map = {};
+  if (input.type !== void 0 || input.title !== void 0) {
+    map.title = titleOf(input.type ?? input.defaultType, input.title);
+  }
+  if (input.message !== void 0 || input.markdown !== void 0 || input.actionRequired === true || mediaIds.length > 0) {
+    map.content = contentOf(input, mediaIds);
+  }
+  if (input.agent !== void 0 || input.project !== void 0) {
+    map.senderName = senderName(ctx.device, input.agent, input.project);
+  }
+  if (input.links !== void 0) {
+    map.btns = btnsOf(input.links);
+  }
+  const date = nonBlank2(input.date);
+  if (date !== void 0) map.date = date;
+  if (input.chart !== void 0) map.chart = input.chart;
+  if (Object.keys(map).length === 0) {
+    throw new PingoError(
+      "usage",
+      "pingo update \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u8981\u66F4\u65B0\u7684\u5B57\u6BB5(--type\u3001--title\u3001--message\u3001--markdown\u3001--image\u3001--link\u3001--agent\u3001--project\u3001--date\u3001--chart)\u3002"
+    );
+  }
+  return map;
+}
+var CARD_ID = /^pingo-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function newCardId() {
+  return `pingo-${randomUUID()}`;
+}
+function isCardId(value) {
+  return CARD_ID.test(value);
+}
+
+// src/messages/links.ts
+var MAX_LINKS = 3;
+function parseLinks(values) {
+  if (values.length > MAX_LINKS) {
+    throw new PingoError("usage", `--link \u6700\u591A ${MAX_LINKS} \u4E2A,\u5F53\u524D ${values.length} \u4E2A\u3002`);
+  }
+  return values.map((raw) => {
+    const idx = raw.indexOf("=");
+    const text = idx < 0 ? "" : raw.slice(0, idx).trim();
+    const url = idx < 0 ? "" : raw.slice(idx + 1).trim();
+    if (idx < 0 || text === "" || url === "") {
+      throw new PingoError("usage", `--link \u683C\u5F0F\u5E94\u4E3A "\u6587\u5B57=URL":${raw}`);
+    }
+    if (!/^https?:\/\//i.test(url)) {
+      throw new PingoError("usage", `--link \u53EA\u652F\u6301 http(s) \u5730\u5740:${url}`);
+    }
+    return { text, url };
+  });
+}
+
+// src/media/cover.ts
+import { spawn } from "node:child_process";
+import { deflateSync } from "node:zlib";
+var FFMPEG_TIMEOUT_MS = 1e4;
+var ffmpegFrameGrabber = (videoPath, atSec) => new Promise((resolve2) => {
+  let settled = false;
+  const done = (v) => {
+    if (!settled) {
+      settled = true;
+      resolve2(v);
+    }
+  };
+  let child;
+  try {
+    child = spawn(
+      "ffmpeg",
+      ["-loglevel", "error", "-ss", String(atSec), "-i", videoPath, "-frames:v", "1", "-f", "image2", "-vcodec", "mjpeg", "pipe:1"],
+      { stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    done(void 0);
+    return;
+  }
+  const chunks = [];
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    done(void 0);
+  }, FFMPEG_TIMEOUT_MS);
+  child.stdout?.on("data", (c) => chunks.push(c));
+  child.on("error", () => {
+    clearTimeout(timer);
+    done(void 0);
+  });
+  child.on("close", (code) => {
+    clearTimeout(timer);
+    done(code === 0 && chunks.length > 0 ? Buffer.concat(chunks) : void 0);
+  });
+});
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? c >>> 1 ^ 3988292384 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(buf) {
+  let c = 4294967295;
+  for (const byte of buf) c = CRC_TABLE[(c ^ byte) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const typed = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(typed));
+  return Buffer.concat([len, typed, crc]);
+}
+function hash(seed) {
+  let h = 2166136261;
+  for (const ch of Buffer.from(seed, "utf8")) {
+    h ^= ch;
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+function hslToRgb(h, s, l) {
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => {
+    const k = (n + h / 30) % 12;
+    return Math.round(255 * (l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1))));
+  };
+  return [f(0), f(8), f(4)];
+}
+var COVER_W = 320;
+var COVER_H = 180;
+function generateGradientCover(seed) {
+  const hue = hash(seed) % 360;
+  const from = hslToRgb(hue, 0.65, 0.45);
+  const to = hslToRgb((hue + 40) % 360, 0.7, 0.62);
+  const rows = [];
+  for (let y = 0; y < COVER_H; y++) {
+    const row = Buffer.alloc(1 + COVER_W * 3);
+    for (let x = 0; x < COVER_W; x++) {
+      const t = (x / (COVER_W - 1) + y / (COVER_H - 1)) / 2;
+      for (let i = 0; i < 3; i++) row[1 + x * 3 + i] = Math.round(from[i] + (to[i] - from[i]) * t);
+    }
+    rows.push(row);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(COVER_W, 0);
+  ihdr.writeUInt32BE(COVER_H, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 2;
+  return Buffer.concat([
+    Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(Buffer.concat(rows))),
+    chunk("IEND", Buffer.alloc(0))
+  ]);
+}
+function isJpeg(b) {
+  return b !== void 0 && b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255;
+}
+async function resolveCover(p) {
+  if (p.cover !== void 0) return { file: p.cover, source: "cover" };
+  let frame;
+  try {
+    frame = await p.grab(p.video.path, p.video.durationSec > 1 ? 1 : 0);
+  } catch {
+    frame = void 0;
+  }
+  if (isJpeg(frame)) {
+    return { file: { path: "cover.jpg", name: "cover.jpg", mime: "image/jpeg", bytes: frame }, source: "ffmpeg" };
+  }
+  return {
+    file: { path: "cover.png", name: "cover.png", mime: "image/png", bytes: generateGradientCover(p.seed) },
+    source: "generated"
+  };
+}
+
+// src/media/image.ts
+import { basename, extname } from "node:path";
+var MAX_IMAGES = 5;
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp"
+};
+var MAGIC = {
+  "image/png": [137, 80, 78, 71],
+  "image/jpeg": [255, 216, 255],
+  "image/gif": [71, 73, 70, 56],
+  "image/bmp": [66, 77]
+};
+function matchesMagic(bytes, mime) {
+  const sig = MAGIC[mime];
+  return bytes.length >= sig.length && sig.every((b, i) => bytes[i] === b);
+}
+function mib(n) {
+  return `${(n / 1024 / 1024).toFixed(1)} MiB`;
+}
+function loadImages(paths, readBytes, maxBytes = MAX_IMAGE_BYTES) {
+  if (paths.length > MAX_IMAGES) {
+    throw new PingoError("usage", `--image \u6700\u591A ${MAX_IMAGES} \u5F20,\u5F53\u524D ${paths.length} \u5F20\u3002`);
+  }
+  return paths.map((path) => {
+    const mime = BY_EXT[extname(path).toLowerCase()];
+    let bytes;
+    try {
+      bytes = readBytes(path);
+    } catch (err) {
+      throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247 ${path}:${err.message}`);
+    }
+    if (mime === void 0) {
+      throw new PingoError("content", `\u4E0D\u652F\u6301\u7684\u56FE\u7247\u683C\u5F0F:${path}(\u652F\u6301 png\u3001jpg\u3001gif\u3001bmp)\u3002`);
+    }
+    if (bytes.length === 0) {
+      throw new PingoError("content", `\u56FE\u7247\u6587\u4EF6\u4E3A\u7A7A:${path}`);
+    }
+    if (!matchesMagic(bytes, mime)) {
+      throw new PingoError("content", `\u56FE\u7247\u5185\u5BB9\u4E0E\u6269\u5C55\u540D\u4E0D\u4E00\u81F4:${path}(\u6587\u4EF6\u5185\u5BB9\u4E0D\u662F ${mime})\u3002`);
+    }
+    if (bytes.length > maxBytes) {
+      throw new PingoError(
+        "content",
+        `\u56FE\u7247\u8FC7\u5927:${path} \u4E3A ${mib(bytes.length)}(${bytes.length} \u5B57\u8282),\u4E0A\u9650 ${maxBytes} \u5B57\u8282(${mib(maxBytes)})\u3002`
+      );
+    }
+    return { path, name: basename(path), mime, bytes };
+  });
+}
+
+// src/media/video.ts
+import { basename as basename2, extname as extname2 } from "node:path";
+var MAX_VIDEO_BYTES = 19 * 1024 * 1024;
+function bad(message) {
+  throw new PingoError("content", `\u65E0\u6CD5\u8BFB\u53D6 mp4 \u65F6\u957F:${message}`);
+}
+function* boxes(buf, start, end) {
+  let off = start;
+  while (off + 8 <= end) {
+    let size = buf.readUInt32BE(off);
+    const type = buf.toString("latin1", off + 4, off + 8);
+    let header = 8;
+    if (size === 1) {
+      if (off + 16 > end) bad("\u6587\u4EF6\u88AB\u622A\u65AD");
+      const large = buf.readBigUInt64BE(off + 8);
+      if (large > BigInt(Number.MAX_SAFE_INTEGER)) bad("box \u5C3A\u5BF8\u8FC7\u5927");
+      size = Number(large);
+      header = 16;
+    } else if (size === 0) {
+      size = end - off;
+    }
+    if (size < header || off + size > end) bad("\u6587\u4EF6\u88AB\u622A\u65AD\u6216\u683C\u5F0F\u9519\u8BEF");
+    yield { type, start: off, contentStart: off + header, end: off + size };
+    off += size;
+  }
+}
+function parseMp4Duration(buf) {
+  for (const top of boxes(buf, 0, buf.length)) {
+    if (top.type !== "moov") continue;
+    for (const child of boxes(buf, top.contentStart, top.end)) {
+      if (child.type !== "mvhd") continue;
+      const c = child.contentStart;
+      const version = buf[c];
+      let timescale;
+      let duration;
+      if (version === 1) {
+        if (c + 32 > child.end) bad("mvhd \u88AB\u622A\u65AD");
+        timescale = buf.readUInt32BE(c + 20);
+        duration = Number(buf.readBigUInt64BE(c + 24));
+      } else {
+        if (c + 20 > child.end) bad("mvhd \u88AB\u622A\u65AD");
+        timescale = buf.readUInt32BE(c + 12);
+        duration = buf.readUInt32BE(c + 16);
+      }
+      if (timescale === 0) bad("mvhd \u7684 timescale \u4E3A 0");
+      return Math.max(1, Math.ceil(duration / timescale));
+    }
+    bad("moov \u4E2D\u6CA1\u6709 mvhd");
+  }
+  return bad("\u6587\u4EF6\u4E2D\u6CA1\u6709 moov(\u4E0D\u662F\u5B8C\u6574\u7684 mp4)");
+}
+function mib2(n) {
+  return `${(n / 1024 / 1024).toFixed(1)} MiB`;
+}
+function loadVideo(path, readBytes) {
+  let bytes;
+  try {
+    bytes = readBytes(path);
+  } catch (err) {
+    throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6\u89C6\u9891 ${path}:${err.message}`);
+  }
+  if (extname2(path).toLowerCase() !== ".mp4") {
+    throw new PingoError("content", `\u53EA\u652F\u6301 mp4 \u89C6\u9891:${path}`);
+  }
+  if (bytes.length === 0) {
+    throw new PingoError("content", `\u89C6\u9891\u6587\u4EF6\u4E3A\u7A7A:${path}`);
+  }
+  if (bytes.length < 8 || bytes.toString("latin1", 4, 8) !== "ftyp") {
+    throw new PingoError("content", `\u6587\u4EF6\u5185\u5BB9\u4E0D\u662F mp4:${path}`);
+  }
+  if (bytes.length > MAX_VIDEO_BYTES) {
+    throw new PingoError(
+      "content",
+      `\u89C6\u9891\u8FC7\u5927:${path} \u4E3A ${mib2(bytes.length)}(${bytes.length} \u5B57\u8282),\u4E0A\u9650 ${MAX_VIDEO_BYTES} \u5B57\u8282(19 MiB)\u3002`
+    );
+  }
+  return { path, name: basename2(path), bytes, durationSec: parseMp4Duration(bytes) };
+}
+
 // src/utils/redact.ts
 function maskSecret(value) {
   if (value.length <= 4) return "***";
@@ -7779,8 +8219,15 @@ function redact(text, secrets) {
 // src/providers/dingtalk.ts
 var TOKEN_URL = "https://api.dingtalk.com/v1.0/oauth2/accessToken";
 var SEND_URL = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
+var CARD_DELIVER_URL = "https://api.dingtalk.com/v1.0/card/instances/createAndDeliver";
+var CARD_UPDATE_URL = "https://api.dingtalk.com/v1.0/card/instances";
+var UPLOAD_URL = "https://oapi.dingtalk.com/media/upload";
 var TOKEN_REFRESH_MARGIN_SEC = 300;
 var RETRY_DELAYS_MS = [500, 1e3];
+function uploadTimeoutMs(bytes, baseTimeoutMs) {
+  const estimate = 3e4 + Math.ceil(bytes / (128 * 1024)) * 1e3;
+  return Math.max(baseTimeoutMs, estimate);
+}
 function defaultSleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -7790,11 +8237,11 @@ function createDingTalkClient(opts) {
   const sleep = opts.sleep ?? defaultSleep;
   let cached;
   const scrub = (text) => redact(text, [opts.creds.clientSecret, cached?.token ?? ""]);
-  async function request(url, init, onFetchError) {
+  async function request(url, init, onFetchError, timeoutMs = opts.timeoutMs) {
     let res;
     let text;
     try {
-      res = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(opts.timeoutMs) });
+      res = await fetchImpl(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
       text = await res.text();
     } catch (err) {
       throw new PingoError(onFetchError, `\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25:${scrub(err.message)}`);
@@ -7892,7 +8339,247 @@ function createDingTalkClient(opts) {
     const token = await getToken();
     return withRetry(() => sendOnce(token, msg));
   }
-  return { getToken, send };
+  function failCard(res) {
+    const code = typeof res.json?.code === "string" ? res.json.code : void 0;
+    const message = typeof res.json?.message === "string" ? res.json.message : `HTTP ${res.status}`;
+    const label = scrub(code ? `${code}: ${message}` : message);
+    const classified = classifyDingTalkError(res.status, code);
+    if (classified === "auth") {
+      throw new PingoError("auth", `\u9489\u9489\u5361\u7247\u63A5\u53E3\u9274\u6743\u5931\u8D25(HTTP ${res.status}):${label}`, code);
+    }
+    if (res.status === 429 || res.status >= 500) {
+      throw new PingoError("transient", `\u9489\u9489\u5361\u7247\u63A5\u53E3\u6682\u65F6\u4E0D\u53EF\u7528(HTTP ${res.status}):${label}`, code);
+    }
+    throw new PingoError("config", `\u9489\u9489\u62D2\u7EDD\u4E86\u5361\u7247(HTTP ${res.status}):${label}`, code, { degradable: true });
+  }
+  async function deliverCardOnce(token, p) {
+    const res = await request(
+      CARD_DELIVER_URL,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "x-acs-dingtalk-access-token": token },
+        body: JSON.stringify({
+          cardTemplateId: p.templateId,
+          outTrackId: p.outTrackId,
+          cardData: { cardParamMap: p.cardParamMap },
+          callbackType: "STREAM",
+          openSpaceId: `dtv1.card//IM_ROBOT.${opts.creds.userId}`,
+          imRobotOpenSpaceModel: { supportForward: true },
+          imRobotOpenDeliverModel: { spaceType: "IM_ROBOT", robotCode: opts.creds.robotCode },
+          userIdType: 1
+        })
+      },
+      "network_unknown"
+    );
+    if (res.status !== 200) failCard(res);
+    if (res.json === void 0) {
+      throw new PingoError("network_unknown", "\u9489\u9489\u5361\u7247\u54CD\u5E94\u4E3A\u7A7A\u6216\u4E0D\u662F JSON,\u65E0\u6CD5\u786E\u8BA4\u5361\u7247\u662F\u5426\u5DF2\u53D1\u51FA\u3002");
+    }
+    const result = res.json.result;
+    const results = result?.deliverResults ?? [];
+    if (results.length === 0) {
+      throw new PingoError("network_unknown", "\u9489\u9489\u5361\u7247\u54CD\u5E94\u4E2D\u6CA1\u6709\u6295\u9012\u7ED3\u679C,\u65E0\u6CD5\u786E\u8BA4\u5361\u7247\u662F\u5426\u5DF2\u53D1\u51FA\u3002");
+    }
+    const failedItem = results.find((r) => r.success !== true);
+    if (failedItem !== void 0) {
+      throw new PingoError(
+        "config",
+        `\u9489\u9489\u5361\u7247\u6295\u9012\u5931\u8D25:${scrub(failedItem.errorMsg || "\u672A\u77E5\u539F\u56E0")}`,
+        void 0,
+        { degradable: true }
+      );
+    }
+  }
+  async function deliverCard(p) {
+    const token = await getToken();
+    let hadTransient = false;
+    return withRetry(async () => {
+      try {
+        return await deliverCardOnce(token, p);
+      } catch (err) {
+        if (err instanceof PingoError && err.category === "transient") {
+          hadTransient = true;
+        } else if (hadTransient && err instanceof PingoError && err.degradable) {
+          throw new PingoError(
+            "network_unknown",
+            `\u9489\u9489\u5361\u7247\u63A5\u53E3\u5728\u91CD\u8BD5\u540E\u62D2\u7EDD\u4E86\u8BF7\u6C42,\u4E4B\u524D\u7684\u8BF7\u6C42\u53EF\u80FD\u5DF2\u6295\u653E\u6210\u529F:${err.message}`,
+            err.code
+          );
+        }
+        throw err;
+      }
+    });
+  }
+  async function updateCardOnce(token, p) {
+    const res = await request(
+      CARD_UPDATE_URL,
+      {
+        method: "PUT",
+        headers: { "Content-Type": "application/json", "x-acs-dingtalk-access-token": token },
+        body: JSON.stringify({
+          outTrackId: p.outTrackId,
+          cardData: { cardParamMap: p.cardParamMap },
+          cardUpdateOptions: { updateCardDataByKey: true },
+          userIdType: 1
+        })
+      },
+      "network_unknown"
+    );
+    if (res.status !== 200) {
+      try {
+        failCard(res);
+      } catch (err) {
+        if (err instanceof PingoError && err.degradable) throw new PingoError(err.category, err.message, err.code);
+        throw err;
+      }
+    }
+    if (res.json === void 0) {
+      throw new PingoError("network_unknown", "\u9489\u9489\u5361\u7247\u66F4\u65B0\u54CD\u5E94\u4E3A\u7A7A\u6216\u4E0D\u662F JSON,\u65E0\u6CD5\u786E\u8BA4\u662F\u5426\u5DF2\u66F4\u65B0\u3002");
+    }
+    if (res.json.result !== true) {
+      throw new PingoError("config", "\u9489\u9489\u5361\u7247\u66F4\u65B0\u5931\u8D25:cardId \u53EF\u80FD\u65E0\u6548\u6216\u5361\u7247\u5DF2\u4E0D\u53EF\u66F4\u65B0\u3002");
+    }
+  }
+  async function updateCard(p) {
+    const token = await getToken();
+    return withRetry(() => updateCardOnce(token, p));
+  }
+  async function uploadOnce(token, file, type) {
+    const form = new FormData();
+    form.append("media", new Blob([new Uint8Array(file.bytes)], { type: file.mime }), file.name);
+    const url = `${UPLOAD_URL}?access_token=${encodeURIComponent(token)}&type=${type}`;
+    const res = await request(url, { method: "POST", body: form }, "transient", uploadTimeoutMs(file.bytes.length, opts.timeoutMs));
+    if (res.status === 413) {
+      throw new PingoError("content", `\u6587\u4EF6 ${file.name} \u8D85\u8FC7\u9489\u9489\u4E0A\u4F20\u4E0A\u9650(HTTP 413),\u8BF7\u538B\u7F29\u540E\u91CD\u8BD5\u3002`);
+    }
+    if (res.status === 429 || res.status >= 500) {
+      throw new PingoError("transient", `\u9489\u9489\u5A92\u4F53\u4E0A\u4F20\u6682\u65F6\u4E0D\u53EF\u7528(HTTP ${res.status})\u3002`);
+    }
+    const errcode = res.json?.errcode;
+    const mediaId = res.json?.media_id;
+    if (res.status !== 200 || errcode !== 0 || typeof mediaId !== "string" || mediaId === "") {
+      const errmsg = typeof res.json?.errmsg === "string" ? res.json.errmsg : "";
+      throw new PingoError(
+        "content",
+        `\u6587\u4EF6 ${file.name} \u4E0A\u4F20\u5931\u8D25:HTTP ${res.status},errcode=${String(errcode)} ${scrub(errmsg)}`.trim()
+      );
+    }
+    return mediaId;
+  }
+  async function uploadMedia(file, type) {
+    const token = await getToken();
+    return withRetry(() => uploadOnce(token, file, type));
+  }
+  async function uploadImage(file) {
+    return uploadMedia(file, "image");
+  }
+  return { getToken, send, deliverCard, updateCard, uploadMedia, uploadImage };
+}
+
+// src/send/fallback.ts
+function decideFallback(from, err, opts) {
+  if (!(err instanceof PingoError)) return void 0;
+  if (from === "card") return err.degradable ? "markdown" : void 0;
+  if (from === "markdown") {
+    if (isFormatRejection(err.code) && opts.fallbackFormat === "text" && !opts.markdownFromFile) {
+      return "text";
+    }
+    return void 0;
+  }
+  return void 0;
+}
+
+// src/send/pipeline.ts
+function toPingoError(err) {
+  return err instanceof PingoError ? err : new PingoError("transient", String(err?.message ?? err));
+}
+async function runPipeline(p, client, newId = newCardId) {
+  const mediaIds = [];
+  for (const image of p.images) {
+    mediaIds.push(await client.uploadMedia(image, "image"));
+  }
+  let videoMsgParam;
+  if (p.video !== void 0) {
+    const picMediaId = await client.uploadMedia(p.video.cover, "image");
+    const videoMediaId = await client.uploadMedia(
+      { bytes: p.video.file.bytes, name: p.video.file.name, mime: "video/mp4" },
+      "video"
+    );
+    videoMsgParam = JSON.stringify({
+      duration: String(p.video.file.durationSec),
+      videoMediaId,
+      videoType: "mp4",
+      picMediaId
+    });
+  }
+  async function sendVideo(sent) {
+    if (videoMsgParam === void 0) return;
+    try {
+      await client.send({ msgKey: "sampleVideo", msgParam: videoMsgParam });
+      sent.push("video");
+    } catch (err) {
+      throw new PartialSendError(toPingoError(err), sent, ["video"]);
+    }
+  }
+  async function attemptCard() {
+    if (p.templateId === void 0) {
+      throw new PingoError("config", "\u4F7F\u7528\u5361\u7247\u683C\u5F0F\u9700\u8981\u914D\u7F6E card.templateId\u3002");
+    }
+    const { cardParamMap } = renderCard(p.input, { device: p.device }, mediaIds);
+    const cardId = newId();
+    await client.deliverCard({ templateId: p.templateId, outTrackId: cardId, cardParamMap });
+    const sent = ["card"];
+    await sendVideo(sent);
+    return { cardId, sent };
+  }
+  async function attemptPlain(format2) {
+    const built = buildMessage(p.input, { device: p.device, templates: p.templates, format: format2 });
+    const result = await client.send({ msgKey: built.msgKey, msgParam: built.msgParam });
+    const sent = ["text-message"];
+    for (let i = 0; i < mediaIds.length; i++) {
+      try {
+        await client.send({ msgKey: "sampleImageMsg", msgParam: JSON.stringify({ photoURL: mediaIds[i] }) });
+        sent.push(`image-${i + 1}`);
+      } catch (err) {
+        const failed = mediaIds.slice(i).map((_, j) => `image-${i + j + 1}`);
+        if (videoMsgParam !== void 0) failed.push("video");
+        throw new PartialSendError(toPingoError(err), sent, failed);
+      }
+    }
+    await sendVideo(sent);
+    return { processQueryKey: result.processQueryKey, sent };
+  }
+  let format = p.format;
+  let degradedFrom;
+  let degradeReason;
+  for (; ; ) {
+    try {
+      const attempt = format === "card" ? await attemptCard() : await attemptPlain(format);
+      return {
+        format,
+        degraded: degradedFrom !== void 0,
+        degradedFrom,
+        degradeReason,
+        cardId: attempt.cardId,
+        processQueryKey: attempt.processQueryKey,
+        images: mediaIds.length,
+        video: videoMsgParam !== void 0,
+        sent: attempt.sent
+      };
+    } catch (err) {
+      if (err instanceof PartialSendError) throw err;
+      const next = decideFallback(format, err, {
+        fallbackFormat: p.fallbackFormat,
+        markdownFromFile: p.markdownFromFile
+      });
+      if (next === void 0) throw err;
+      if (degradedFrom === void 0) {
+        degradedFrom = format;
+        degradeReason = err.message;
+      }
+      format = next;
+    }
+  }
 }
 
 // src/skills/install.ts
@@ -8069,7 +8756,15 @@ function uninstallSkills(opts) {
 
 // src/cli.ts
 var MESSAGE_TYPES2 = ["success", "warning", "error", "info"];
-var FORMATS2 = ["text", "markdown"];
+var SEND_FORMATS2 = ["card", "markdown", "text"];
+var FORMAT_LABELS = { card: "\u5361\u7247", markdown: "Markdown", text: "\u6587\u672C" };
+function sentLabel(item) {
+  if (item === "card") return "\u5361\u7247";
+  if (item === "text-message") return "\u6587\u5B57\u6D88\u606F";
+  if (item === "video") return "\u89C6\u9891";
+  const m = /^image-(\d+)$/.exec(item);
+  return m ? `\u56FE\u7247 ${m[1]}` : item;
+}
 var USAGE = `pingo \u2014 \u628A\u6D88\u606F\u53D1\u5230\u624B\u673A\u9489\u9489
 
 \u7528\u6CD5:
@@ -8080,14 +8775,25 @@ send \u9009\u9879:
   --title <\u6587\u672C>                        \u6807\u9898\u884C(\u663E\u793A\u5728\u6B63\u6587\u5F00\u5934)
   --message <\u6587\u672C>                      \u6D88\u606F\u6B63\u6587
   --markdown <\u6587\u4EF6>                     \u4ECE Markdown \u6587\u4EF6\u8BFB\u53D6\u6B63\u6587(\u53EA\u80FD\u4EE5 markdown \u683C\u5F0F\u53D1\u9001)
-  --format <text|markdown>              \u53D1\u9001\u683C\u5F0F(\u9ED8\u8BA4\u53D6\u914D\u7F6E message.preferredFormat)
+  --format <card|markdown|text>         \u53D1\u9001\u683C\u5F0F(\u9ED8\u8BA4\u53D6\u914D\u7F6E message.preferredFormat;\u914D\u7F6E\u4E86 card.templateId \u65F6\u9ED8\u8BA4 card)
   --agent <\u540D\u79F0>  --project <\u540D\u79F0>  --task <\u540D\u79F0>
   --action-required                     \u6807\u8BB0\u9700\u8981\u4EBA\u5DE5\u5904\u7406
+  --image <\u6587\u4EF6>                        \u9644\u5E26\u56FE\u7247(png/jpg/gif/bmp,\u53EF\u91CD\u590D,\u6700\u591A 5 \u5F20,\u5355\u5F20 \u2264 10 MiB)
+  --video <\u6587\u4EF6.mp4>                    \u9644\u5E26\u89C6\u9891(\u2264 19 MiB,\u5728\u4E3B\u6D88\u606F\u4E4B\u540E\u5355\u72EC\u53D1\u9001)
+  --cover <\u56FE\u7247>                        \u89C6\u9891\u5C01\u9762(\u4E0D\u4F20\u5219\u7528 ffmpeg \u622A\u5E27,\u5931\u8D25\u5219\u81EA\u52A8\u751F\u6210)
+  --date <\u6587\u672C>                         \u5361\u7247 date \u53D8\u91CF(\u65F6\u95F4,\u4EC5\u5361\u7247)
+  --chart <\u6587\u4EF6.json>                   \u5361\u7247 chart \u53D8\u91CF(\u56FE\u8868 JSON,type \u53EF\u9009 lineChart|histogram|pieChart,\u5982 {"type":"lineChart","data":[{"x":"N0","type":"line","y":48}],"config":{}},\u4EC5\u5361\u7247)
+  --link "\u6587\u5B57=URL"                     \u94FE\u63A5\u6309\u94AE(\u53EF\u91CD\u590D,\u6700\u591A 3 \u4E2A,\u4EC5 http(s))
   --config <\u8DEF\u5F84>                       \u6307\u5B9A\u914D\u7F6E\u6587\u4EF6
   --dry-run                             \u53EA\u9884\u89C8, \u4E0D\u53D1\u9001(\u4E0D\u9700\u8981\u51ED\u636E)
   --json                                \u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON
   --help                                \u663E\u793A\u672C\u5E2E\u52A9
 
+pingo update <cardId> [--type ...] [--title ...] [--message ... | --markdown <\u6587\u4EF6>] [--image ...] [--link ...]
+                  [--action-required] [--agent ...] [--project ...] [--date ...] [--chart <\u6587\u4EF6>] [--json]
+  \u539F\u5730\u66F4\u65B0 pingo send --json \u8FD4\u56DE\u7684\u5361\u7247\u3002\u53EA\u66F4\u65B0\u4F20\u5165\u7684\u5B57\u6BB5:--type/--title \u91CD\u65B0\u751F\u6210\u6807\u9898;
+  --message/--markdown/--image/--action-required \u6574\u4F53\u66FF\u6362\u6B63\u6587;--agent/--project \u66F4\u65B0\u53D1\u9001\u8005\u884C\u3002
+
 pingo skills install|uninstall [--tool kiro,claude,codex] [--yes]
   \u5B89\u88C5/\u5378\u8F7D pingo\u3001pingo-follow \u4E24\u4E2A Skill \u5230\u6240\u9009 AI \u5DE5\u5177(Kiro / Claude Code / Codex)\u3002
   --tool \u672A\u6307\u5B9A\u4E14\u5728\u4EA4\u4E92\u7EC8\u7AEF\u4E2D\u8FD0\u884C\u65F6\u4F1A\u8BE2\u95EE; \u975E\u4EA4\u4E92\u73AF\u5883\u5FC5\u987B\u663E\u5F0F\u6307\u5B9A\u3002
@@ -8106,6 +8812,8 @@ function defaultDeps() {
     stderr: (s) => process.stderr.write(`${s}
 `),
     readFile: (p) => readFileSync2(p, "utf8"),
+    readBytes: (p) => readFileSync2(p),
+    grabFrame: ffmpegFrameGrabber,
     // src/cli.ts 与打包后的 dist/pingo.js 都位于包根目录下一层, 所以都能这样反推出包目录。
     packageDir: fileURLToPath(new URL("..", import.meta.url)),
     isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
@@ -8122,18 +8830,24 @@ function defaultDeps() {
 function reportError(r, error) {
   const pingo = error instanceof PingoError ? error : new PingoError("usage", `\u672A\u9884\u671F\u7684\u9519\u8BEF:${error?.message ?? String(error)}`);
   const message = redact(pingo.message, r.secrets);
+  const partial = pingo instanceof PartialSendError ? pingo : void 0;
   if (r.json) {
     r.out(
       JSON.stringify({
         ok: false,
         category: pingo.category,
         code: pingo.code ?? null,
-        message
+        message,
+        ...partial ? { sent: partial.sent, failed: partial.failed } : {}
       })
     );
   } else {
     r.err(`\u2717 ${HINTS[pingo.category]}`);
     r.err(`  \u539F\u56E0:${message}`);
+    if (partial) {
+      r.err(`  \u5DF2\u53D1\u51FA:${partial.sent.map(sentLabel).join("\u3001") || "\u65E0"}`);
+      r.err(`  \u672A\u53D1\u51FA:${partial.failed.map(sentLabel).join("\u3001")}(\u5DF2\u53D1\u51FA\u7684\u4E0D\u4F1A\u91CD\u8BD5\u6216\u64A4\u56DE)`);
+    }
   }
   return EXIT_CODES[pingo.category];
 }
@@ -8142,11 +8856,49 @@ function pickEnum2(value, allowed, flag) {
   if (allowed.includes(value)) return value;
   throw new PingoError("usage", `${flag} \u7684\u503C\u4E0D\u5408\u6CD5:${value}(\u53EF\u9009:${allowed.join(", ")})\u3002`);
 }
+function nonBlank3(value) {
+  return value === void 0 || value.trim() === "" ? void 0 : value;
+}
+function loadChart(path, read) {
+  if (path === void 0) return void 0;
+  let raw;
+  try {
+    raw = read(path);
+  } catch (err) {
+    throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6 --chart \u6587\u4EF6 ${path}:${err.message}`);
+  }
+  return parseChart(raw);
+}
+function mibText(n) {
+  return `${(n / 1024 / 1024).toFixed(1)} MiB`;
+}
 async function runSend(args, d) {
   const r = { secrets: [], json: args.json, out: d.stdout, err: d.stderr };
   try {
     const type = pickEnum2(args.type, MESSAGE_TYPES2, "--type");
-    const formatFlag = pickEnum2(args.format, FORMATS2, "--format");
+    const formatFlag = pickEnum2(args.format, SEND_FORMATS2, "--format");
+    if (args.message !== void 0 && args.markdownPath !== void 0) {
+      throw new PingoError("usage", "--message \u4E0E --markdown \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u3002");
+    }
+    if (args.cover !== void 0 && args.video === void 0) {
+      throw new PingoError("usage", "--cover \u9700\u8981\u4E0E --video \u4E00\u8D77\u4F7F\u7528\u3002");
+    }
+    const links = parseLinks(args.links);
+    const chart = loadChart(args.chart, d.readFile);
+    const images = loadImages(args.images, d.readBytes);
+    const video = args.video !== void 0 ? loadVideo(args.video, d.readBytes) : void 0;
+    const coverFile = args.cover !== void 0 ? loadImages([args.cover], d.readBytes)[0] : void 0;
+    let markdown;
+    if (args.markdownPath !== void 0) {
+      try {
+        markdown = d.readFile(args.markdownPath);
+      } catch (err) {
+        throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6 --markdown \u6587\u4EF6 ${args.markdownPath}:${err.message}`);
+      }
+    }
+    if (nonBlank3(args.message) === void 0 && nonBlank3(markdown) === void 0) {
+      throw new PingoError("content", "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A:\u8BF7\u63D0\u4F9B --message \u6216 --markdown\u3002");
+    }
     const loaded = loadConfig({
       configPath: args.config,
       env: d.env,
@@ -8159,16 +8911,13 @@ async function runSend(args, d) {
     const config = loaded.config;
     r.secrets = [config.dingtalk.clientSecret];
     if (!args.json) for (const w of loaded.warnings) d.stderr(`! ${w}`);
-    if (args.message !== void 0 && args.markdownPath !== void 0) {
-      throw new PingoError("usage", "--message \u4E0E --markdown \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u3002");
+    const preferred = config.message.preferredFormat;
+    const format = formatFlag ?? (markdown !== void 0 && preferred === "text" ? "markdown" : preferred);
+    if (format === "card" && config.card.templateId === void 0) {
+      throw new PingoError("config", "\u4F7F\u7528\u5361\u7247\u683C\u5F0F\u9700\u8981\u914D\u7F6E card.templateId(\u9489\u9489\u5361\u7247\u6A21\u677F ID)\u3002");
     }
-    let markdown;
-    if (args.markdownPath !== void 0) {
-      try {
-        markdown = d.readFile(args.markdownPath);
-      } catch (err) {
-        throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6 --markdown \u6587\u4EF6 ${args.markdownPath}:${err.message}`);
-      }
+    if (format !== "card" && (args.date !== void 0 || chart !== void 0)) {
+      throw new PingoError("usage", "--date / --chart \u53EA\u80FD\u7528\u4E8E\u5361\u7247\u683C\u5F0F(--format card)\u3002");
     }
     const input = {
       type: type ?? config.message.defaultType,
@@ -8178,21 +8927,51 @@ async function runSend(args, d) {
       agent: args.agent,
       project: args.project,
       task: args.task,
-      actionRequired: args.actionRequired
+      actionRequired: args.actionRequired,
+      links,
+      date: args.date,
+      chart
     };
-    const format = formatFlag ?? (markdown !== void 0 ? "markdown" : config.message.preferredFormat);
-    const ctx = { device: config.device, templates: config.templates, format };
-    const built = buildMessage(input, ctx);
+    const placeholders = images.map((_, i) => `<image-${i + 1}>`);
+    const preview = format === "card" ? renderCard(input, { device: config.device }, placeholders) : (() => {
+      const built = buildMessage(input, { device: config.device, templates: config.templates, format });
+      return { preview: built.preview, bytes: built.bytes };
+    })();
     if (args.dryRun) {
+      const coverSource = video === void 0 ? void 0 : coverFile !== void 0 ? "cover" : "ffmpeg(\u5F85\u622A\u53D6,\u5931\u8D25\u5219\u751F\u6210)";
       if (args.json) {
-        d.stdout(JSON.stringify({ ok: true, dryRun: true, format: built.format, bytes: built.bytes, preview: built.preview }));
+        d.stdout(
+          JSON.stringify({
+            ok: true,
+            dryRun: true,
+            format,
+            bytes: preview.bytes,
+            preview: preview.preview,
+            images: images.length,
+            video: video !== void 0,
+            ...video ? { videoDurationSec: video.durationSec, coverSource } : {}
+          })
+        );
       } else {
-        d.stdout(`[dry-run] \u683C\u5F0F:${built.format} | \u5927\u5C0F:${built.bytes} \u5B57\u8282 | \u672A\u53D1\u9001`);
+        d.stdout(`[dry-run] \u683C\u5F0F:${format} | \u5927\u5C0F:${preview.bytes} \u5B57\u8282 | \u56FE\u7247:${images.length} \u5F20 | \u672A\u53D1\u9001`);
         d.stdout("");
-        d.stdout(built.preview);
+        d.stdout(preview.preview);
+        if (format === "card" && nonBlank3(args.date) !== void 0) d.stdout(`
+date:${args.date}`);
+        if (format === "card" && chart !== void 0) d.stdout(`
+chart:${chart}`);
+        if (format === "card" && links.length > 0) {
+          d.stdout("");
+          d.stdout(`\u6309\u94AE:${links.map((l) => `${l.text} \u2192 ${l.url}`).join(" | ")}`);
+        }
+        images.forEach((img, i) => d.stdout(`\u56FE\u7247 ${i + 1}:${img.name}(${img.bytes.length} \u5B57\u8282,${img.mime})`));
+        if (video) {
+          d.stdout(`\u89C6\u9891:${video.name}(${mibText(video.bytes.length)},${video.durationSec} \u79D2,\u5C01\u9762:${coverSource})`);
+        }
       }
       return 0;
     }
+    const cover = video ? await resolveCover({ cover: coverFile, video, seed: config.device.id, grab: d.grabFrame }) : void 0;
     const client = createDingTalkClient({
       creds: config.dingtalk,
       timeoutMs: config.message.timeoutMs,
@@ -8200,26 +8979,128 @@ async function runSend(args, d) {
       sleep: d.sleep,
       now: d.now
     });
-    let degraded = false;
-    let result;
-    let sentFormat = built.format;
-    try {
-      result = await client.send(built);
-    } catch (err) {
-      const canDegrade = err instanceof PingoError && isFormatRejection(err.code) && built.format === "markdown" && markdown === void 0 && config.message.fallbackFormat === "text";
-      if (!canDegrade) throw err;
-      const fallback = buildMessage(input, { ...ctx, format: "text" });
-      result = await client.send(fallback);
-      degraded = true;
-      sentFormat = "text";
-    }
+    const result = await runPipeline(
+      {
+        input,
+        images,
+        format,
+        device: config.device,
+        templates: config.templates,
+        templateId: config.card.templateId,
+        fallbackFormat: config.message.fallbackFormat,
+        markdownFromFile: markdown !== void 0,
+        video: video && cover ? { file: video, cover: cover.file } : void 0
+      },
+      client,
+      d.newCardId
+    );
     if (args.json) {
       d.stdout(
-        JSON.stringify({ ok: true, format: sentFormat, degraded, processQueryKey: result.processQueryKey })
+        JSON.stringify({
+          ok: true,
+          format: result.format,
+          degraded: result.degraded,
+          degradedFrom: result.degradedFrom,
+          cardId: result.cardId,
+          processQueryKey: result.processQueryKey,
+          images: result.images,
+          video: result.video
+        })
       );
     } else {
-      d.stdout(`\u2713 \u9489\u9489\u5DF2\u63A5\u53D7\u8BF7\u6C42(${sentFormat}),processQueryKey: ${result.processQueryKey.slice(0, 8)}\u2026`);
-      if (degraded) d.stdout("! Markdown \u88AB\u9489\u9489\u62D2\u7EDD,\u5DF2\u964D\u7EA7\u4E3A\u6587\u672C\u91CD\u53D1\u3002");
+      const parts = [`\u2713 \u9489\u9489\u5DF2\u63A5\u53D7\u8BF7\u6C42(${FORMAT_LABELS[result.format]})`];
+      if (result.cardId) parts.push(`cardId: ${result.cardId}`);
+      else if (result.processQueryKey) parts.push(`processQueryKey: ${result.processQueryKey.slice(0, 8)}\u2026`);
+      if (result.images > 0) parts.push(`\u56FE\u7247 ${result.images} \u5F20`);
+      if (result.video) parts.push(`\u89C6\u9891 1 \u6761${cover && cover.source !== "cover" ? `(\u5C01\u9762:${cover.source})` : ""}`);
+      d.stdout(parts.join(","));
+      if (result.degradedFrom) {
+        d.stdout(
+          `! ${FORMAT_LABELS[result.degradedFrom]} \u53D1\u9001\u5931\u8D25,\u5DF2\u964D\u7EA7\u4E3A${FORMAT_LABELS[result.format]}:${redact(result.degradeReason ?? "", r.secrets)}`
+        );
+      }
+    }
+    return 0;
+  } catch (error) {
+    return reportError(r, error);
+  }
+}
+async function runUpdate(args, d) {
+  const r = { secrets: [], json: args.json, out: d.stdout, err: d.stderr };
+  try {
+    const cardId = args.positionals[1];
+    if (cardId === void 0) {
+      throw new PingoError("usage", "\u7528\u6CD5:pingo update <cardId> [--type ...] [--title ...] [--message ...] ...");
+    }
+    if (!isCardId(cardId)) {
+      throw new PingoError("usage", `cardId \u683C\u5F0F\u4E0D\u6B63\u786E:${cardId}(\u5E94\u4E3A pingo send --json \u8FD4\u56DE\u7684 cardId)\u3002`);
+    }
+    if (args.format !== void 0) throw new PingoError("usage", "pingo update \u53EA\u7528\u4E8E\u5361\u7247,\u4E0D\u652F\u6301 --format\u3002");
+    if (args.video !== void 0 || args.cover !== void 0) {
+      throw new PingoError("usage", "pingo update \u4E0D\u652F\u6301 --video / --cover,\u8BF7\u7528 pingo send \u53D1\u9001\u89C6\u9891\u3002");
+    }
+    if (args.dryRun) throw new PingoError("usage", "pingo update \u4E0D\u652F\u6301 --dry-run\u3002");
+    if (args.message !== void 0 && args.markdownPath !== void 0) {
+      throw new PingoError("usage", "--message \u4E0E --markdown \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528\u3002");
+    }
+    const type = pickEnum2(args.type, MESSAGE_TYPES2, "--type");
+    const links = args.links.length > 0 ? parseLinks(args.links) : void 0;
+    const chart = loadChart(args.chart, d.readFile);
+    const images = loadImages(args.images, d.readBytes);
+    let markdown;
+    if (args.markdownPath !== void 0) {
+      try {
+        markdown = d.readFile(args.markdownPath);
+      } catch (err) {
+        throw new PingoError("usage", `\u65E0\u6CD5\u8BFB\u53D6 --markdown \u6587\u4EF6 ${args.markdownPath}:${err.message}`);
+      }
+    }
+    const fields = {
+      type,
+      title: args.title,
+      message: args.message,
+      markdown,
+      actionRequired: args.actionRequired ? true : void 0,
+      links,
+      agent: args.agent,
+      project: args.project,
+      task: args.task,
+      date: args.date,
+      chart
+    };
+    renderCardUpdate({ ...fields, defaultType: "info" }, { device: { id: "", name: "" } }, images.map(() => "<image>"));
+    const loaded = loadConfig({
+      configPath: args.config,
+      env: d.env,
+      cwd: d.cwd,
+      homeDir: d.homeDir,
+      platform: d.platform,
+      hostname: d.hostname,
+      requireCredentials: true
+    });
+    const config = loaded.config;
+    r.secrets = [config.dingtalk.clientSecret];
+    if (!args.json) for (const w of loaded.warnings) d.stderr(`! ${w}`);
+    const client = createDingTalkClient({
+      creds: config.dingtalk,
+      timeoutMs: config.message.timeoutMs,
+      fetchImpl: d.fetchImpl,
+      sleep: d.sleep,
+      now: d.now
+    });
+    const mediaIds = [];
+    for (const image of images) mediaIds.push(await client.uploadMedia(image, "image"));
+    const cardParamMap = renderCardUpdate(
+      { ...fields, defaultType: config.message.defaultType },
+      { device: config.device },
+      mediaIds
+    );
+    await client.updateCard({ outTrackId: cardId, cardParamMap });
+    const updated = Object.keys(cardParamMap);
+    if (args.json) {
+      d.stdout(JSON.stringify({ ok: true, cardId, updated }));
+    } else {
+      d.stdout(`\u2713 \u5361\u7247\u5DF2\u66F4\u65B0(${cardId}):${updated.join("\u3001")}`);
     }
     return 0;
   } catch (error) {
@@ -8236,7 +9117,13 @@ var STRING_OPTIONS = /* @__PURE__ */ new Set([
   "project",
   "task",
   "config",
-  "tool"
+  "tool",
+  "image",
+  "link",
+  "video",
+  "cover",
+  "date",
+  "chart"
 ]);
 var KNOWN_OPTIONS = /* @__PURE__ */ new Set([
   ...STRING_OPTIONS,
@@ -8323,9 +9210,9 @@ function printResults(d, results) {
   let hasProblem = false;
   for (const r of results) {
     const label = r.status === "created" ? "\u5DF2\u521B\u5EFA" : r.status === "skipped" ? "\u5DF2\u5B58\u5728, \u8DF3\u8FC7" : r.status === "replaced" ? "\u5DF2\u4FEE\u590D\u8FC7\u671F\u94FE\u63A5" : r.status === "removed" ? "\u5DF2\u5220\u9664" : r.status === "failed" ? `\u5931\u8D25:${r.detail ?? "\u672A\u77E5\u539F\u56E0"}` : "\u51B2\u7A81, \u8DF3\u8FC7(\u8BE5\u8DEF\u5F84\u4E0D\u662F\u672C\u5305\u521B\u5EFA\u7684\u94FE\u63A5)";
-    const bad = r.status === "conflict" || r.status === "failed";
-    d.stdout(`${bad ? "\u2717" : "\u2713"} [${TOOL_LABELS[r.tool]}] ${r.name}:${label} (${r.path})`);
-    if (bad) hasProblem = true;
+    const bad2 = r.status === "conflict" || r.status === "failed";
+    d.stdout(`${bad2 ? "\u2717" : "\u2713"} [${TOOL_LABELS[r.tool]}] ${r.name}:${label} (${r.path})`);
+    if (bad2) hasProblem = true;
   }
   return hasProblem;
 }
@@ -8556,10 +9443,22 @@ function parseSendArgs(argv) {
       json: { type: "boolean" },
       help: { type: "boolean" },
       tool: { type: "string" },
-      yes: { type: "boolean" }
+      yes: { type: "boolean" },
+      image: { type: "string", multiple: true },
+      link: { type: "string", multiple: true },
+      video: { type: "string" },
+      cover: { type: "string" },
+      date: { type: "string" },
+      chart: { type: "string" }
     }
   });
   return {
+    images: values.image ?? [],
+    links: values.link ?? [],
+    video: values.video,
+    cover: values.cover,
+    date: values.date,
+    chart: values.chart,
     positionals,
     help: values.help === true,
     type: values.type,
@@ -8592,6 +9491,7 @@ async function runCli(argv, overrides = {}) {
     return 0;
   }
   if (command === "send") return runSend(args, d);
+  if (command === "update") return runUpdate(args, d);
   if (command === "config") return runConfig(argv.slice(1), d);
   if (command === "doctor") return runDoctor(argv.slice(1), d);
   if (command === "skills") return runSkills(argv.slice(1), d);