weaver-work-cli 0.1.29 → 0.1.31

package/dist/chunks/chunk-QWY6PGL6.js

@@ -0,0 +1,3472 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  collapseNewlines,
+  collectI18nIds,
+  collectPersonIds,
+  escapePipe,
+  extractFiles,
+  extractImgs,
+  extractVideos,
+  parseContent,
+  senderName
+} from "./chunk-YLCYX7LE.js";
+import {
+  imBusinessError,
+  imConfirmationError,
+  imValidationError
+} from "./chunk-ZEDWSH32.js";
+
+// src/shortcuts/im/operations/types.ts
+var READ = "read";
+var WRITE = "write";
+function imSuccess(action, data, meta) {
+  const payload = { ok: true, action, data };
+  if (meta && Object.keys(meta).length > 0) payload.meta = meta;
+  return payload;
+}
+function schemaOf(properties, options = {}) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties,
+    ...options.required?.length ? { required: options.required } : {},
+    ...options.description ? { description: options.description } : {}
+  };
+}
+
+// src/shortcuts/im/operations/shared.ts
+var DEFAULT_PAGE_SIZE = 50;
+var MAX_PAGE_SIZE = 50;
+var MAX_AUTO_PAGES = 100;
+var AUTO_PAGE_INTERVAL_MS = 60;
+var TIME_RANGE_MAX_DAYS = 7;
+var SECONDS_PER_DAY = 24 * 3600;
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype", "user", "sender", "operator"]);
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw imValidationError("input_not_object", "\u8F93\u5165\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  }
+  return value;
+}
+function assertNoForbiddenKeys(input) {
+  for (const key of Object.keys(input)) {
+    if (FORBIDDEN_KEYS.has(key)) {
+      throw imValidationError("forbidden_key", `\u8F93\u5165\u5305\u542B\u975E\u6CD5\u5B57\u6BB5\uFF1A${key}`);
+    }
+  }
+}
+function splitIds(value, field) {
+  if (value === void 0 || value === null || value === "") {
+    throw imValidationError("id_list_required", `${field} \u5FC5\u586B`);
+  }
+  const list = String(value).split(",").map((s) => s.trim()).filter(Boolean);
+  if (list.length === 0) {
+    throw imValidationError("id_list_empty", `${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+  }
+  for (const item of list) {
+    if (!/^\d+$/.test(item) || item === "0") {
+      throw imValidationError("id_invalid", `${field} \u542B\u975E\u6CD5 id\uFF08\u5FC5\u987B\u975E 0 \u6570\u5B57\uFF09\uFF1A${item}`);
+    }
+  }
+  return list;
+}
+function toUint(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const numeric = Number(value);
+  if (!Number.isInteger(numeric) || numeric < 0) {
+    throw imValidationError("number_invalid", `${field} \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570`);
+  }
+  return numeric;
+}
+function toPositiveInt(value, field) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const numeric = Number(value);
+  if (!Number.isInteger(numeric) || numeric <= 0) {
+    throw imValidationError("number_invalid", `${field} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
+  }
+  return numeric;
+}
+function compact(body) {
+  for (const key of Object.keys(body)) {
+    if (body[key] === void 0) delete body[key];
+  }
+  return body;
+}
+function normalizeAliases(input, aliases) {
+  const out = { ...input };
+  for (const [canonical, oldKeys] of Object.entries(aliases)) {
+    for (const oldKey of oldKeys) {
+      if (!(oldKey in out)) continue;
+      const oldValue = out[oldKey];
+      if (oldValue === void 0 || oldValue === null || oldValue === "") {
+        delete out[oldKey];
+        continue;
+      }
+      const canonicalValue = out[canonical];
+      const hasCanonical = canonicalValue !== void 0 && canonicalValue !== null && canonicalValue !== "";
+      if (hasCanonical && JSON.stringify(canonicalValue) !== JSON.stringify(oldValue)) {
+        throw imValidationError(
+          "alias_conflict",
+          `\u5B57\u6BB5 ${canonical} \u4E0E\u65E7\u5B57\u6BB5 ${oldKey} \u540C\u65F6\u51FA\u73B0\u4E14\u53D6\u503C\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u53EA\u4FDD\u7559\u4E00\u4E2A`
+        );
+      }
+      if (!hasCanonical) out[canonical] = oldValue;
+      delete out[oldKey];
+    }
+  }
+  return out;
+}
+function makeMinMaxIdByTm(tmSec) {
+  if (!tmSec || tmSec <= 0) return { min: "0", max: "0" };
+  const base = BigInt(Math.floor(tmSec)) * 1000000000n;
+  return { min: base.toString(), max: (base + 999999999n).toString() };
+}
+function parseTimeToSec(arg, isEnd) {
+  if (arg === void 0 || arg === null || arg === "") return 0;
+  const s = String(arg).trim();
+  if (/^\d{10}$/.test(s)) return Number(s);
+  const m = s.match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{1,2})(?::(\d{1,2}))?)?$/);
+  if (!m) {
+    throw imValidationError("time_invalid", `\u65E0\u6CD5\u89E3\u6790\u65F6\u95F4\u53C2\u6570: ${s}\uFF08\u652F\u6301 unix \u79D2 / YYYY-MM-DD / YYYY-MM-DD HH:mm:ss\uFF09`);
+  }
+  const hh = m[4] !== void 0 ? Number(m[4]) : isEnd ? 23 : 0;
+  const mm = m[5] !== void 0 ? Number(m[5]) : isEnd ? 59 : 0;
+  const ss = m[6] !== void 0 ? Number(m[6]) : isEnd ? 59 : 0;
+  return Math.floor(new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), hh, mm, ss).getTime() / 1e3);
+}
+function todayRange() {
+  const now = /* @__PURE__ */ new Date();
+  const start = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0);
+  const end = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59);
+  return { fromSec: Math.floor(start.getTime() / 1e3), toSec: Math.floor(end.getTime() / 1e3) };
+}
+function clampTimeRangeTo7Days(fromSec, toSec) {
+  let f = Number(fromSec) > 0 ? Number(fromSec) : 0;
+  let t = Number(toSec) > 0 ? Number(toSec) : 0;
+  if (f <= 0 && t <= 0) {
+    return { fromSec: f, toSec: t, shrunk: false, origFromSec: f, origToSec: t };
+  }
+  const nowSec = Math.floor(Date.now() / 1e3);
+  if (t <= 0) t = nowSec;
+  if (f <= 0) f = t - TIME_RANGE_MAX_DAYS * SECONDS_PER_DAY;
+  const maxSpan = TIME_RANGE_MAX_DAYS * SECONDS_PER_DAY;
+  if (t - f > maxSpan) {
+    const d = new Date(t * 1e3);
+    const start = new Date(d.getFullYear(), d.getMonth(), d.getDate() - (TIME_RANGE_MAX_DAYS - 1), 0, 0, 0);
+    return {
+      fromSec: Math.floor(start.getTime() / 1e3),
+      toSec: t,
+      shrunk: true,
+      origFromSec: f,
+      origToSec: t
+    };
+  }
+  return { fromSec: f, toSec: t, shrunk: false, origFromSec: f, origToSec: t };
+}
+function formatSec(sec) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const d = new Date(Number(sec) * 1e3);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function timeRangeShrinkNotice(clamp) {
+  return `\u26A0\uFE0F \u6307\u5B9A\u65F6\u95F4\u8303\u56F4\u8D85\u8FC7 ${TIME_RANGE_MAX_DAYS} \u5929\uFF0C\u5DF2\u81EA\u52A8\u7F29\u77ED\u4E3A\u8BE5\u8303\u56F4\u6700\u540E ${TIME_RANGE_MAX_DAYS} \u5929\uFF1A${formatSec(clamp.origFromSec)} ~ ${formatSec(clamp.origToSec)}  \u2192  ${formatSec(clamp.fromSec)} ~ ${formatSec(clamp.toSec)}\uFF08\u5982\u9700\u66F4\u65E9\u5386\u53F2\uFF0C\u8BF7\u5206\u6BB5\u6307\u5B9A \u2264 ${TIME_RANGE_MAX_DAYS} \u5929\u7684\u65F6\u95F4\u8303\u56F4\uFF09`;
+}
+function formatFullTime(ts) {
+  if (ts === void 0 || ts === null || ts === "") return "-";
+  const d = new Date(Number(ts) * 1e3);
+  if (Number.isNaN(d.getTime())) return "-";
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}/${d.getMonth() + 1}/${d.getDate()} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+function findActionMsg(value) {
+  const candidate = value?.data?.actionMsg ?? value?.actionMsg;
+  if (candidate === void 0 || candidate === null) return null;
+  return {
+    code: candidate.code !== void 0 ? candidate.code : 0,
+    message: candidate.message ?? candidate.msg ?? ""
+  };
+}
+function assertImOk(value, actionLabel) {
+  const msg = findActionMsg(value);
+  if (msg === null) {
+    if (Number(value?.code) === 200 && value?.status) return;
+    throw imBusinessError("business_error", `${actionLabel}\u5931\u8D25\uFF1A\u7F3A\u5C11 actionMsg`, {
+      details: { raw: value }
+    });
+  }
+  if (Number(msg.code) === 0) return;
+  const message = msg.message || `${actionLabel}\u5931\u8D25\uFF08actionMsg.code=${msg.code}\uFF09`;
+  throw imBusinessError("action_failed", message, { code: msg.code });
+}
+function unwrapInner(value) {
+  return value?.data?.data ?? value?.data;
+}
+function isMemberRow(value) {
+  return Boolean(value) && typeof value === "object" && (value.uid !== void 0 || value.user !== void 0);
+}
+function extractGroupMembers(inner) {
+  if (!inner || typeof inner !== "object") return [];
+  for (const key of ["users", "members"]) {
+    const list = inner[key];
+    if (Array.isArray(list) && list.some(isMemberRow)) return list;
+  }
+  const datas = Array.isArray(inner.datas) ? inner.datas : [];
+  if (datas.some(isMemberRow)) return datas;
+  const nested = [];
+  for (const group of datas) {
+    if (Array.isArray(group?.datas)) nested.push(...group.datas);
+  }
+  return nested;
+}
+async function resolveAuthUid(host) {
+  try {
+    const session = await host.getSession();
+    return str(session?.userId);
+  } catch {
+    return "";
+  }
+}
+async function pullPaged(options) {
+  const maxNum = Math.min(options.num > 0 ? options.num : DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+  const idOf = options.idOf ?? ((row) => str(row?.ser_msgid));
+  const endBig = /^\d+$/.test(String(options.end ?? "")) ? BigInt(String(options.end)) : 0n;
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  let curStart = options.start;
+  let pages = 0;
+  let lastStart = "";
+  let exhausted = false;
+  let hasMore = false;
+  let cappedAtMaxPages = false;
+  for (; ; ) {
+    const page = await options.requestOnePage(curStart, options.end, maxNum);
+    pages += 1;
+    if (!page || page.length === 0) {
+      exhausted = true;
+      break;
+    }
+    let added = 0;
+    let minId = "";
+    for (const row of page) {
+      const id = idOf(row);
+      if (!/^\d+$/.test(id) || seen.has(id)) continue;
+      seen.add(id);
+      rows.push(row);
+      added += 1;
+      if (minId === "" || BigInt(id) < BigInt(minId)) minId = id;
+    }
+    if (added === 0 || minId === "") {
+      exhausted = true;
+      break;
+    }
+    lastStart = minId;
+    curStart = minId;
+    if (endBig > 0n && BigInt(curStart) <= endBig) {
+      exhausted = true;
+      break;
+    }
+    if (!options.autoLoop) {
+      if (page.length >= maxNum) hasMore = endBig > 0n ? BigInt(curStart) > endBig : true;
+      break;
+    }
+    if (pages >= MAX_AUTO_PAGES) {
+      hasMore = true;
+      cappedAtMaxPages = true;
+      break;
+    }
+    if (AUTO_PAGE_INTERVAL_MS > 0) {
+      await new Promise((resolve3) => setTimeout(resolve3, AUTO_PAGE_INTERVAL_MS));
+    }
+  }
+  return { rows, pages, lastStart, exhausted, hasMore, autoPaged: options.autoLoop, cappedAtMaxPages };
+}
+function paginationMeta(result, num) {
+  return {
+    pageSize: num,
+    pages: result.pages,
+    autoPaged: result.autoPaged,
+    maxAutoPages: MAX_AUTO_PAGES,
+    exhausted: result.exhausted,
+    hasMore: result.hasMore,
+    ...result.hasMore && result.lastStart ? {
+      nextStart: result.lastStart,
+      resumeHint: "\u9700\u8981\u66F4\u65E9\u6570\u636E\u65F6\uFF0C\u7528\u76F8\u540C\u8303\u56F4\u518D\u6B21\u8C03\u7528\u5E76\u4F20 start=nextStart\uFF08\u670D\u52A1\u7AEF\u4F1A\u91CD\u590D\u8FD4\u56DE\u8FB9\u754C\u90A3\u6761\uFF0C\u5DF2\u6309\u6D88\u606F id \u53BB\u91CD\uFF09"
+    } : {},
+    ...result.cappedAtMaxPages ? {
+      cappedAtMaxPages: true,
+      cappedNote: `\u5DF2\u8FBE\u5355\u6B21\u81EA\u52A8\u7FFB\u9875\u4E0A\u9650 ${MAX_AUTO_PAGES} \u9875\uFF0C\u533A\u95F4\u5185\u4ECD\u6709\u66F4\u65E7\u6570\u636E\uFF0C\u7528 nextStart \u7EE7\u7EED`
+    } : {}
+  };
+}
+function rangeShrinkMeta(clamp) {
+  return {
+    shrunk: true,
+    maxDays: TIME_RANGE_MAX_DAYS,
+    originalFrom: formatSec(clamp.origFromSec),
+    originalTo: formatSec(clamp.origToSec),
+    from: formatSec(clamp.fromSec),
+    to: formatSec(clamp.toSec),
+    notice: timeRangeShrinkNotice(clamp)
+  };
+}
+function sortMessagesNewestFirst(messages) {
+  return messages.sort((a, b) => {
+    const ai = str(a.msgid);
+    const bi = str(b.msgid);
+    const aOk = /^\d+$/.test(ai);
+    const bOk = /^\d+$/.test(bi);
+    if (!aOk && !bOk) return 0;
+    if (!aOk) return 1;
+    if (!bOk) return -1;
+    return BigInt(bi) === BigInt(ai) ? 0 : BigInt(bi) > BigInt(ai) ? 1 : -1;
+  });
+}
+function str(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value);
+}
+function parseMsg(value) {
+  if (!value) return null;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value === "object") return value;
+  return null;
+}
+var MAX_UPLOAD_BYTES = 1024 * 1024 * 200;
+
+// src/shortcuts/im/operations/group-read.ts
+var SEARCH_TYPE_MASK = {
+  type: 1,
+  key: 2,
+  members: 8,
+  precise: 16,
+  owners: 32,
+  creators: 64,
+  create: 256
+};
+function requireCidUid(cid, uid) {
+  const c = String(cid ?? "");
+  const u = String(uid ?? "");
+  if (!c || !u || c === "0" || u === "0") {
+    throw imValidationError("self_identity_missing", "\u8BE5\u67E5\u8BE2\u9700\u8981\u5F53\u524D\u767B\u5F55\u4EBA\u7684 cid/uid\uFF08\u975E 0\uFF09\uFF0C\u8BF7\u786E\u8BA4\u767B\u5F55\u6001\u5B8C\u6574");
+  }
+  return { cid: c, uid: u };
+}
+function requireGroupId(value) {
+  const text = String(value ?? "").trim();
+  if (!/^\d+$/.test(text) || text === "0") {
+    throw imValidationError("id_invalid", `groupId \u5FC5\u987B\u662F\u975E 0 \u6570\u5B57 ID\uFF08\u6536\u5230\uFF1A${text || "(\u7A7A)"}\uFF09`);
+  }
+  return text;
+}
+function dayRangeShanghai(offsetDay) {
+  const now = /* @__PURE__ */ new Date();
+  const tzMs = 8 * 3600 * 1e3;
+  const local = new Date(now.getTime() + tzMs);
+  const dayStart = Date.UTC(local.getUTCFullYear(), local.getUTCMonth(), local.getUTCDate() + offsetDay);
+  return { begin: Math.floor((dayStart - tzMs) / 1e3), end: Math.floor((dayStart + 864e5 - tzMs) / 1e3) - 1 };
+}
+function maskTypeName(mask) {
+  const names = [
+    [1, "\u5168\u5458\u7FA4"],
+    [2, "\u90E8\u95E8\u7FA4"],
+    [4, "\u5916\u90E8\u7FA4"],
+    [8, "\u4E8B\u9879\u7FA4"],
+    [16, "\u8BDD\u9898\u7FA4"]
+  ];
+  const hit = names.filter(([bit]) => (mask & bit) !== 0).map(([, name]) => name);
+  return hit.length ? hit.join("|") : String(mask);
+}
+function stateName(state) {
+  if (state === 1) return "\u6B63\u5E38";
+  if (state === 0) return "\u5DF2\u9500\u6BC1";
+  return `\u72B6\u6001${state}`;
+}
+var groupSearch = {
+  name: "im.group.search",
+  resource: "group",
+  method: "group.search",
+  action: "im.group.search",
+  summary: "\u6309\u6761\u4EF6\u641C\u7D22\u7FA4\uFF08cond+mask \u5168\u670D\u52A1\u7AEF\u8FC7\u6EE4\uFF0C\u7981\u6B62\u672C\u5730\u8FC7\u6EE4\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    name: { type: "string", description: "\u7FA4\u540D\u5173\u952E\u5B57" },
+    precise: { type: "boolean", description: "\u7CBE\u786E\u5339\u914D\u540D\u79F0" },
+    type: { type: "integer", description: "\u7FA4\u7C7B\u578B\u7B5B\u9009\uFF081 \u666E\u901A/6 \u90E8\u95E8/7 \u5168\u5458\u7B49\uFF09" },
+    members: { type: "boolean", description: "\u6211\u6240\u5728\u7684\u7FA4" },
+    owner: { type: "boolean", description: "\u6211\u662F\u7FA4\u4E3B\u7684\u7FA4" },
+    creator: { type: "boolean", description: "\u6211\u521B\u5EFA\u7684\u7FA4" },
+    today: { type: "boolean", description: "\u4ECA\u5929\u521B\u5EFA\u7684\u7FA4" },
+    yesterday: { type: "boolean", description: "\u6628\u5929\u521B\u5EFA\u7684\u7FA4" },
+    createBegin: { type: "integer", description: "\u521B\u5EFA\u65F6\u95F4\u4E0B\u754C\uFF08unix \u79D2\uFF09" },
+    createEnd: { type: "integer", description: "\u521B\u5EFA\u65F6\u95F4\u4E0A\u754C\uFF08unix \u79D2\uFF09" },
+    pageSize: { type: "integer", minimum: 1, maximum: 200, description: "\u6BCF\u9875\u5927\u5C0F\uFF08\u9ED8\u8BA4 100\uFF09" }
+  }, { description: "\u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A\u641C\u7D22\u6761\u4EF6" }),
+  handler: async (args, { host }) => {
+    const cond = {};
+    let mask = 0;
+    if (args.type !== void 0) {
+      mask |= SEARCH_TYPE_MASK.type;
+      cond.type = toUint(args.type, "type");
+    }
+    if (args.name !== void 0 && args.name !== "") {
+      mask |= SEARCH_TYPE_MASK.key;
+      cond.key = String(args.name);
+    }
+    if (args.members === true) {
+      const self = await host.getSelfIdentity();
+      const { cid, uid } = requireCidUid(self.cid, self.uid);
+      mask |= SEARCH_TYPE_MASK.members;
+      cond.members = [{ cid, uid }];
+    }
+    if (args.precise === true) {
+      mask |= SEARCH_TYPE_MASK.precise;
+      cond.precise = 1;
+    }
+    if (args.owner === true) {
+      const self = await host.getSelfIdentity();
+      const { cid, uid } = requireCidUid(self.cid, self.uid);
+      mask |= SEARCH_TYPE_MASK.owners;
+      cond.owners = [{ cid, uid }];
+    }
+    if (args.creator === true) {
+      const self = await host.getSelfIdentity();
+      const { cid, uid } = requireCidUid(self.cid, self.uid);
+      mask |= SEARCH_TYPE_MASK.creators;
+      cond.creators = [{ cid, uid }];
+    }
+    let create;
+    if (args.today === true) create = dayRangeShanghai(0);
+    else if (args.yesterday === true) create = dayRangeShanghai(-1);
+    else if (args.createBegin !== void 0 || args.createEnd !== void 0) {
+      create = { begin: Number(args.createBegin ?? 0), end: Number(args.createEnd ?? 0) };
+    }
+    if (create) {
+      mask |= SEARCH_TYPE_MASK.create;
+      cond.create = create;
+    }
+    if (mask === 0) throw imValidationError("cond_required", "\u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A\u641C\u7D22\u6761\u4EF6\uFF08name/type/members/owner/creator/today/yesterday/create*\uFF09");
+    cond.mask = mask;
+    const pageSize = Math.min(toPositiveInt(args.pageSize, "pageSize") ?? 100, 200);
+    const body = { page: { size: pageSize, num: 1 }, cond };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/searchGroup",
+      body,
+      operation: "im.group.search"
+    });
+    assertImOk(res, "\u641C\u7D22\u7FA4");
+    const inner = unwrapInner(res);
+    const datas = inner?.datas || [];
+    return imSuccess("im.group.search", {
+      total: inner?.total ?? datas.length,
+      groups: datas.map((g) => ({
+        id: str(g.id),
+        name: g.name ?? "",
+        type: g.type,
+        num: g.num,
+        createTime: formatFullTime(g.create)
+      }))
+    });
+  }
+};
+var groupInfo = {
+  name: "im.group.info",
+  resource: "group",
+  method: "group.info",
+  action: "im.group.info",
+  summary: "\u6309\u7FA4 id \u67E5\u57FA\u7840\u4FE1\u606F\uFF08\u652F\u6301\u6279\u91CF\uFF1B\u7C7B\u578B\u4F4D\u7EC4\u5408 + \u72B6\u6001\u5C55\u793A\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupIds: { type: "array", items: { type: "string" }, description: "\u7FA4 id \u5217\u8868\uFF08\u9017\u53F7\u4E32\u6216\u6570\u7EC4\uFF09" },
+    groupId: { type: "string", description: "\u5355\u7FA4 id\uFF08groupIds \u7684\u4FBF\u6377\u5F62\u5F0F\uFF09" }
+  }, { description: "groupIds / groupId \u81F3\u5C11\u5176\u4E00" }),
+  handler: async (args, { host }) => {
+    let ids = [];
+    if (Array.isArray(args.groupIds)) ids = args.groupIds.map((x) => String(x));
+    else if (args.groupIds) ids = splitIds(args.groupIds, "groupIds");
+    if (args.groupId) ids.push(String(args.groupId));
+    ids = [...new Set(ids)];
+    if (ids.length === 0) throw imValidationError("group_ids_required", "groupIds / groupId \u81F3\u5C11\u5176\u4E00");
+    for (const id of ids) {
+      if (!/^\d+$/.test(id) || id === "0") throw imValidationError("id_invalid", `\u7FA4 id \u5FC5\u987B\u975E 0 \u6570\u5B57\uFF1A${id}`);
+    }
+    const body = { trans_id: 0, type: 0, mask: 0, group_id: ids, flag: 0 };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/queryGroupInfo",
+      body,
+      operation: "im.group.info"
+    });
+    assertImOk(res, "\u67E5\u8BE2\u7FA4\u4FE1\u606F");
+    const inner = unwrapInner(res);
+    const datas = inner?.datas || [];
+    const groups = datas.map((g) => ({
+      groupId: str(g.group_id ?? g.id),
+      name: g.name ?? "",
+      mask: Number(g.mask ?? 0),
+      maskName: maskTypeName(Number(g.mask ?? 0)),
+      userNum: g.user_num,
+      maxNum: g.max_num,
+      hostUid: str(g.host_uid ?? g.hostUid ?? ""),
+      state: Number(g.state ?? -1),
+      stateName: stateName(Number(g.state ?? -1)),
+      createTime: formatFullTime(g.create_time ?? g.createTime)
+    }));
+    return imSuccess("im.group.info", { total: groups.length, groups });
+  }
+};
+var groupUsers = {
+  name: "im.group.users",
+  resource: "group",
+  method: "group.users",
+  action: "im.group.users",
+  summary: "\u62C9\u53D6\u7FA4\u6210\u5458\u5217\u8868\uFF08\u59D3\u540D\u4E00\u5F8B\u8D70 hrm\uFF0C\u9ED8\u8BA4 mask \u4E0D\u542B name \u4F4D\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    mask: { type: "integer", description: "member_mask\uFF08\u9ED8\u8BA4 142=cid|uid|role|add_time\uFF09" },
+    syncType: { type: "integer", enum: [0, 1], description: "0 \u5168\u91CF\uFF08\u9ED8\u8BA4\uFF09/1 \u589E\u91CF" },
+    clientUc: { type: "string", description: "\u589E\u91CF\u6E38\u6807 server_uc" }
+  }, { required: ["groupId"], description: "\u62C9\u53D6\u7FA4\u6210\u5458" }),
+  handler: async (args, { host }) => {
+    const groupId = requireGroupId(args.groupId);
+    const memberMask = Number(args.mask ?? 142);
+    const body = compact({
+      group_id: groupId,
+      type: 0,
+      sync_type: Number(args.syncType ?? 0),
+      member_mask: memberMask,
+      client_uc: args.clientUc !== void 0 ? String(args.clientUc) : "0"
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/getGroupUsers",
+      body,
+      operation: "im.group.users"
+    });
+    assertImOk(res, "\u62C9\u53D6\u7FA4\u6210\u5458");
+    const inner = unwrapInner(res);
+    const members = extractGroupMembers(inner);
+    const hasRole = (memberMask & 8) !== 0;
+    const hasAddTime = (memberMask & 128) !== 0;
+    const hasCid = (memberMask & 2) !== 0;
+    const hasUid = (memberMask & 4) !== 0;
+    const roleNames = { 0: "\u4E0D\u53EF\u7528", 1: "\u666E\u901A\u6210\u5458", 2: "\u7BA1\u7406\u5458", 3: "\u7FA4\u4E3B", 4: "\u5BA2\u6237", 5: "\u8D1F\u8D23\u4EBA", 6: "\u534F\u52A9\u4EBA\u5458" };
+    const personIds = members.map((m) => String(m?.uid ?? "")).filter((x) => x && x !== "0");
+    const personMap = personIds.length ? await host.resolveUsersByIds([...new Set(personIds)]) : {};
+    const rows = members.map((m) => ({
+      uid: hasUid ? str(m.uid) : void 0,
+      cid: hasCid ? str(m.cid) : void 0,
+      name: personMap[str(m.uid)]?.name || str(m.uid),
+      role: hasRole ? Number(m.role_type ?? m.role ?? -1) : void 0,
+      roleName: hasRole ? roleNames[Number(m.role_type ?? m.role ?? -1)] ?? "-" : void 0,
+      addTime: hasAddTime ? formatFullTime(m.add_time ?? m.addTime) : void 0
+    }));
+    return imSuccess("im.group.users", {
+      groupId,
+      totalNum: inner?.total_num ?? rows.length,
+      endFlag: inner?.end_flag,
+      serverUc: str(inner?.server_uc ?? ""),
+      members: rows
+    });
+  }
+};
+var groupAdmins = {
+  name: "im.group.admins",
+  resource: "group",
+  method: "group.admins",
+  action: "im.group.admins",
+  summary: "\u6279\u91CF\u83B7\u53D6\u7FA4\u4E3B/\u7BA1\u7406\u5458\uFF08mask \u4F4D 1=\u7FA4\u4E3B/\u8D1F\u8D23\u4EBA 2=\u7BA1\u7406\u5458\uFF0C\u9ED8\u8BA4 3\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupIds: { type: "array", items: { type: "string" }, description: "\u7FA4 id \u5217\u8868" },
+    mask: { type: "integer", description: "\u89D2\u8272\u4F4D\u63A9\u7801\uFF08\u9ED8\u8BA4 3\uFF09" }
+  }, { required: ["groupIds"], description: "\u6279\u91CF\u67E5\u8BE2\u7FA4\u7BA1\u7406\u5458" }),
+  handler: async (args, { host }) => {
+    const ids = Array.isArray(args.groupIds) ? args.groupIds.map((x) => String(x)) : splitIds(args.groupIds, "groupIds");
+    const body = { group_ids: ids, mask: Number(args.mask ?? 3) };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/getGroupAdminBatch",
+      body,
+      operation: "im.group.admins"
+    });
+    assertImOk(res, "\u67E5\u8BE2\u7FA4\u7BA1\u7406\u5458");
+    const inner = unwrapInner(res);
+    const datas = inner?.datas || [];
+    const roleNames = { 3: "\u7FA4\u4E3B", 2: "\u7BA1\u7406\u5458" };
+    const allUids = /* @__PURE__ */ new Set();
+    for (const g of datas) {
+      for (const it of g?.datas || []) {
+        if (it?.user?.uid) allUids.add(String(it.user.uid));
+      }
+    }
+    const personMap = await host.resolveUsersByIds([...allUids]);
+    const groups = datas.map((g) => ({
+      groupId: str(g.group_id),
+      admins: (g?.datas || []).map((it) => ({
+        name: personMap[str(it.user?.uid)]?.name || str(it.user?.uid),
+        uid: str(it.user?.uid),
+        cid: str(it.user?.cid),
+        role: Number(it.role ?? -1),
+        roleName: roleNames[Number(it.role ?? -1)] ?? "-"
+      }))
+    }));
+    return imSuccess("im.group.admins", { total: groups.length, groups });
+  }
+};
+var groupExist = {
+  name: "im.group.exist",
+  resource: "group",
+  method: "group.exist",
+  action: "im.group.exist",
+  summary: "\u6279\u91CF\u5224\u65AD\u7FA4\u662F\u5426\u5B58\u5728\uFF08ret=0 \u5B58\u5728\uFF1B1209 \u4E0D\u5B58\u5728\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupIds: { type: "array", items: { type: "string" }, description: "\u7FA4 id \u5217\u8868" }
+  }, { required: ["groupIds"], description: "\u6279\u91CF\u5224\u65AD\u7FA4\u662F\u5426\u5B58\u5728" }),
+  handler: async (args, { host }) => {
+    const ids = Array.isArray(args.groupIds) ? args.groupIds.map((x) => String(x)) : splitIds(args.groupIds, "groupIds");
+    for (const id of ids) {
+      if (!/^\d+$/.test(id) || id === "0") throw imValidationError("id_invalid", `\u7FA4 id \u5FC5\u987B\u975E 0 \u6570\u5B57\uFF1A${id || "(\u7A7A)"}`);
+    }
+    const body = { groupIds: ids };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/checkGroupExist",
+      body,
+      operation: "im.group.exist"
+    });
+    assertImOk(res, "\u68C0\u67E5\u7FA4\u662F\u5426\u5B58\u5728");
+    const inner = unwrapInner(res);
+    const results = inner?.results || [];
+    return imSuccess("im.group.exist", {
+      groups: results.map((r) => ({
+        groupId: str(r.group_id),
+        exists: Number(r.ret) === 0,
+        ret: r.ret
+      }))
+    });
+  }
+};
+var groupUserExist = {
+  name: "im.group.userExist",
+  resource: "group",
+  method: "group.userExist",
+  action: "im.group.userExist",
+  summary: "\u68C0\u67E5\u7528\u6237\u662F\u5426\u5728\u67D0\u7FA4\u5185\uFF08tenantKey \u81EA\u52A8\u6CE8\u5165\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    users: { type: "array", items: { type: "string" }, description: "\u5F85\u68C0\u67E5 uid \u5217\u8868" }
+  }, { required: ["groupId", "users"], description: "\u68C0\u67E5\u7528\u6237\u662F\u5426\u5728\u7FA4\u5185" }),
+  handler: async (args, { host }) => {
+    const groupId = requireGroupId(args.groupId);
+    const users = Array.isArray(args.users) ? args.users.map((x) => String(x)) : splitIds(args.users, "users");
+    const session = await host.getSession();
+    if (!session.tenantKey) throw imValidationError("tenant_key_missing", "\u767B\u5F55\u6001\u7F3A\u5C11 tenantKey\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+    const body = { tenantKey: session.tenantKey, groupId, users };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/checkGroupUserExist",
+      body,
+      operation: "im.group.userExist"
+    });
+    assertImOk(res, "\u68C0\u67E5\u7FA4\u6210\u5458");
+    const inner = unwrapInner(res);
+    const inGroup = Array.isArray(inner?.users) ? inner.users.map((x) => String(x)) : [];
+    const inSet = new Set(inGroup);
+    const personMap = await host.resolveUsersByIds(users);
+    const rows = users.map((uid) => ({
+      uid,
+      name: personMap[uid]?.name || uid,
+      inGroup: inSet.has(uid)
+    }));
+    return imSuccess("im.group.userExist", { groupId, total: rows.length, users: rows });
+  }
+};
+var groupAnnounceGet = {
+  name: "im.group.announce.get",
+  resource: "group",
+  method: "group.announce.get",
+  action: "im.group.announce.get",
+  summary: "\u83B7\u53D6\u7FA4\u516C\u544A\uFF08aid=0/\u4E0D\u4F20=\u6700\u65B0\u516C\u544A\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    aid: { type: "string", description: "\u516C\u544A id\uFF08\u9ED8\u8BA4 0=\u6700\u65B0\uFF09" }
+  }, { required: ["groupId"], description: "\u83B7\u53D6\u7FA4\u516C\u544A" }),
+  handler: async (args, { host }) => {
+    const body = { groupId: requireGroupId(args.groupId), aid: args.aid !== void 0 ? String(args.aid) : "0" };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/getAnnouce",
+      body,
+      operation: "im.group.announce.get"
+    });
+    assertImOk(res, "\u83B7\u53D6\u7FA4\u516C\u544A");
+    const inner = unwrapInner(res);
+    const data = inner && typeof inner === "object" && inner.data && typeof inner.data === "object" ? inner.data : inner;
+    if (!data || data.aid === void 0 && data.annouce === void 0) {
+      return imSuccess("im.group.announce.get", { found: false });
+    }
+    const personMap = await host.resolveUsersByIds(data?.add_user?.uid ? [String(data.add_user.uid)] : []);
+    return imSuccess("im.group.announce.get", {
+      found: true,
+      aid: str(data.aid),
+      annouce: data.annouce ?? "",
+      addUserName: personMap[str(data.add_user?.uid)]?.name || str(data.add_user?.uid),
+      time: formatFullTime(data.time),
+      updateTime: formatFullTime(data.update_tm ?? data.update_time),
+      fmark: Number(data.fmark ?? 0),
+      mustRead: Number(data.fmark ?? 0) === 1,
+      related: str(data.related ?? "")
+    });
+  }
+};
+var groupAnnounceList = {
+  name: "im.group.announce.list",
+  resource: "group",
+  method: "group.announce.list",
+  action: "im.group.announce.list",
+  summary: "\u7FA4\u516C\u544A\u5217\u8868\uFF08\u6309 id \u964D\u5E8F\uFF0Cend_flag=1 \u8FD8\u6709\u4E0B\u4E00\u9875\uFF09",
+  capability: "group",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    aid: { type: "string", description: "\u5206\u9875\u8D77\u59CB\u516C\u544A id\uFF08\u9ED8\u8BA4 0\uFF09" },
+    pageSize: { type: "integer", description: "\u5206\u9875\u5927\u5C0F\uFF08\u9ED8\u8BA4\u670D\u52A1\u7AEF\u6700\u5927\uFF09" }
+  }, { required: ["groupId"], description: "\u7FA4\u516C\u544A\u5217\u8868" }),
+  handler: async (args, { host }) => {
+    const body = compact({
+      groupId: requireGroupId(args.groupId),
+      aid: args.aid !== void 0 ? String(args.aid) : "0",
+      pageSize: args.pageSize !== void 0 ? toUint(args.pageSize, "pageSize") : void 0
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/getAnnouceList",
+      body,
+      operation: "im.group.announce.list"
+    });
+    assertImOk(res, "\u83B7\u53D6\u516C\u544A\u5217\u8868");
+    const inner = unwrapInner(res);
+    const datas = inner?.datas || inner?.list || [];
+    const personIds = datas.map((d) => String(d?.add_user?.uid ?? "")).filter((x) => x && x !== "0");
+    const personMap = await host.resolveUsersByIds([...new Set(personIds)]);
+    const rows = datas.map((d) => ({
+      aid: str(d.aid),
+      annouce: d.annouce ?? "",
+      deleted: d.annouce === void 0 || d.annouce === null || d.annouce === "",
+      addUserName: personMap[str(d.add_user?.uid)]?.name || str(d.add_user?.uid),
+      time: formatFullTime(d.time),
+      updateTime: formatFullTime(d.update_tm ?? d.update_time),
+      mustRead: Number(d.fmark ?? 0) === 1,
+      related: str(d.related ?? "")
+    }));
+    return imSuccess("im.group.announce.list", {
+      total: rows.length,
+      endFlag: inner?.end_flag,
+      hasMore: Number(inner?.end_flag) === 1,
+      announcements: rows
+    });
+  }
+};
+var groupReadOperations = [
+  groupSearch,
+  groupInfo,
+  groupUsers,
+  groupAdmins,
+  groupExist,
+  groupUserExist,
+  groupAnnounceGet,
+  groupAnnounceList
+];
+
+// src/shortcuts/im/operations/write-util.ts
+import { createHash } from "node:crypto";
+function fingerprint(value) {
+  return createHash("sha256").update(JSON.stringify(value ?? null)).digest("hex").slice(0, 32);
+}
+function requireConfirm(action) {
+  throw imConfirmationError(action, { hint: "\u91CD\u65B0\u8C03\u7528\u65F6\u4F20\u5165 confirm=true \u4E0E prepare \u8FD4\u56DE\u7684 continuation" });
+}
+async function verifyLease(continuationToken, action, env) {
+  const lease = await env.continuation.verify(continuationToken, action);
+  const session = await env.host.getSession();
+  if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+    throw imValidationError("context_mismatch", "\u786E\u8BA4\u4E0A\u4E0B\u6587\u5DF2\u53D8\u5316\uFF08\u79DF\u6237\u6216\u767B\u5F55\u8D26\u53F7\u4E0D\u540C\uFF09\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+  }
+  return lease;
+}
+function makeWritePair(options) {
+  return {
+    async prepare(args, env) {
+      assertNoForbiddenKeys(args);
+      const plan = await options.plan(args, env);
+      const session = await env.host.getSession();
+      const token = await env.continuation.issue({
+        operation: options.action,
+        baseUrl: session.baseUrl,
+        profile: session.profile,
+        userId: session.userId,
+        snapshotFingerprint: fingerprint(plan.snapshot),
+        plan: plan.snapshot
+      });
+      return imSuccess(`${options.action}.prepare`, {
+        summary: plan.summary,
+        continuation: token,
+        hint: "\u786E\u8BA4\u65E0\u8BEF\u540E\u8C03\u7528 " + options.action + ".apply\uFF0C\u4F20 confirm:true \u4E0E continuation"
+      });
+    },
+    async apply(args, env) {
+      assertNoForbiddenKeys(args);
+      if (args.confirm !== true) requireConfirm(options.action);
+      const lease = await verifyLease(String(args.continuation ?? ""), options.action, env);
+      const plan = lease.plan;
+      if (lease.snapshotFingerprint !== fingerprint(plan)) {
+        throw imValidationError("target_changed", "\u5199\u5165\u76EE\u6807/\u5185\u5BB9\u4E0E prepare \u65F6\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C prepare");
+      }
+      const data = await options.execute(plan, env);
+      return imSuccess(`${options.action}.apply`, data);
+    }
+  };
+}
+function fileObjToImg(fileObj) {
+  const img = { src: String(fileObj.id || fileObj.fileid) };
+  if (fileObj.name) img.nm = String(fileObj.name);
+  if (fileObj.type) img.t = String(fileObj.type);
+  if (fileObj.imgWidth !== void 0 && fileObj.imgWidth !== null) img.w = String(fileObj.imgWidth);
+  if (fileObj.imgHeight !== void 0 && fileObj.imgHeight !== null) img.h = String(fileObj.imgHeight);
+  if (fileObj.size !== void 0 && fileObj.size !== null) img.s = String(fileObj.size);
+  return img;
+}
+function fileObjToFile(fileObj) {
+  const f = { id: String(fileObj.id || fileObj.fileid) };
+  if (fileObj.name) f.nm = String(fileObj.name);
+  if (fileObj.type) f.t = String(fileObj.type);
+  if (fileObj.size !== void 0 && fileObj.size !== null) f.s = String(fileObj.size);
+  return f;
+}
+
+// src/shortcuts/im/operations/group-write.ts
+async function resolveMembers(args, env) {
+  const raw = Array.isArray(args.users) ? args.users.map((x) => String(x)) : splitIds(args.users, "users");
+  const map = await env.host.resolveUsersByIds(raw);
+  const users = [];
+  const failed = [];
+  const names = {};
+  for (const uid of raw) {
+    const p = map[uid];
+    const cid = p?.cid || "";
+    if (p?.name) names[uid] = p.name;
+    if (!uid || uid === "0" || !cid || cid === "0") {
+      failed.push({ uid, name: p?.name || "" });
+      continue;
+    }
+    users.push({ cid, uid });
+  }
+  return { users, failed, names };
+}
+async function defaultGroupName(members, nameOf, selfUid, env) {
+  let selfName = selfUid ? nameOf(selfUid) : "";
+  if (!selfName) {
+    try {
+      const self = await env.host.getSelfIdentity();
+      if (self.name) selfName = self.name;
+    } catch {
+    }
+  }
+  if (!selfName) selfName = selfUid || "\u6211";
+  const others = [];
+  for (const member of members) {
+    if (member.uid === selfUid) continue;
+    if (others.length >= 4) break;
+    others.push(nameOf(member.uid));
+  }
+  return [selfName, ...others].join("\u3001");
+}
+var groupCreatePair = makeWritePair({
+  action: "im.group.create",
+  async plan(args, env) {
+    const rawUsers = Array.isArray(args.users) ? args.users.map((x) => String(x)) : splitIds(args.users, "users");
+    const names = Array.isArray(args.names) ? args.names.map((x) => String(x)) : [];
+    if (names.length && names.length !== rawUsers.length) {
+      throw imValidationError("names_mismatch", "names \u6570\u91CF\u5FC5\u987B\u4E0E users \u4E00\u81F4\uFF08\u987A\u5E8F\u4E00\u4E00\u5BF9\u5E94\uFF09");
+    }
+    const { users, failed, names: resolvedNames } = await resolveMembers(args, env);
+    if (failed.length && args.removeFailed !== true) {
+      throw imValidationError("members_resolve_failed", `\u4EE5\u4E0B\u6210\u5458\u4FE1\u606F\u83B7\u53D6\u5931\u8D25\uFF08cid/uid \u7F3A\u5931\u6216\u4E3A 0\uFF09\uFF1A${failed.map((f) => f.name || f.uid).join("\u3001")}\uFF1B\u786E\u8BA4\u79FB\u9664\u8BF7\u4F20 removeFailed:true`, { details: failed });
+    }
+    if (users.length === 0) throw imValidationError("members_empty", "\u6CA1\u6709\u53EF\u5165\u7FA4\u7684\u6210\u5458");
+    const selfUid = str((await env.host.getSession()).userId);
+    if (selfUid && !users.some((u) => u.uid === selfUid)) {
+      throw imValidationError(
+        "self_not_included",
+        `\u4E0D\u5141\u8BB8\u521B\u5EFA\u4E0D\u5305\u542B\u81EA\u5DF1\u7684\u7FA4\u804A\uFF1Ausers \u5FC5\u987B\u5305\u542B\u64CD\u4F5C\u8005\u81EA\u5DF1\uFF08uid=${selfUid}\uFF09`
+      );
+    }
+    const providedNames = {};
+    rawUsers.forEach((uid, index) => {
+      if (names[index]) providedNames[uid] = names[index];
+    });
+    const nameOf = (uid) => providedNames[uid] || resolvedNames[uid] || uid;
+    const name = args.name ? String(args.name) : await defaultGroupName(users, nameOf, selfUid, env);
+    let admins = [];
+    if (args.admins) {
+      const adminRaw = Array.isArray(args.admins) ? args.admins.map((x) => String(x)) : splitIds(args.admins, "admins");
+      const adminMap = await env.host.resolveUsersByIds(adminRaw);
+      const adminFailed = adminRaw.filter((uid) => {
+        const cid = adminMap[uid]?.cid || "";
+        return !uid || uid === "0" || !cid || cid === "0";
+      });
+      if (adminFailed.length) {
+        throw imValidationError(
+          "admins_resolve_failed",
+          `\u7BA1\u7406\u5458\u4FE1\u606F\u83B7\u53D6\u5931\u8D25\uFF08cid/uid \u7F3A\u5931\u6216\u4E3A 0\uFF09\uFF1A${adminFailed.map((uid) => adminMap[uid]?.name || uid).join("\u3001")}\uFF1B\u8BF7\u786E\u8BA4\u540E\u91CD\u8BD5\uFF08\u4E0D\u53EF\u9759\u9ED8\u66FF\u6362\u64CD\u4F5C\u4EBA\u8EAB\u4EFD\uFF09`,
+          { details: adminFailed }
+        );
+      }
+      admins = adminRaw.map((uid) => ({ cid: adminMap[uid]?.cid || "", uid }));
+    }
+    return {
+      summary: {
+        action: "\u521B\u5EFA\u666E\u901A\u7FA4",
+        name,
+        memberCount: users.length,
+        members: users.map((u) => u.uid),
+        adminCount: admins.length,
+        removeFailed: args.removeFailed === true ? failed.map((f) => f.uid) : []
+      },
+      snapshot: { name, users, admins, failed, removeFailed: args.removeFailed === true }
+    };
+  },
+  async execute(plan, env) {
+    const { name, users, admins } = plan;
+    const body = compact({
+      name,
+      type: 0,
+      users,
+      attr: admins.length ? { admins } : {}
+    });
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/groupCreate",
+      body,
+      operation: "im.group.create"
+    });
+    assertImOk(res, "\u521B\u5EFA\u7FA4");
+    const payload = res?.data ?? {};
+    const inner = payload?.data ?? {};
+    const groupId = str(
+      inner.groupId ?? inner.group_id ?? inner.id ?? payload.groupId ?? payload.group_id ?? payload.id ?? ""
+    );
+    return { groupId, name, rawData: inner && Object.keys(inner).length ? inner : payload };
+  }
+});
+var groupInvitePair = makeWritePair({
+  action: "im.group.invite",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const { users, failed } = await resolveMembers(args, env);
+    if (failed.length && args.removeFailed !== true) {
+      throw imValidationError("members_resolve_failed", `\u4EE5\u4E0B\u6210\u5458\u89E3\u6790\u5931\u8D25\uFF1A${failed.map((f) => f.name || f.uid).join("\u3001")}\uFF1B\u786E\u8BA4\u79FB\u9664\u8BF7\u4F20 removeFailed:true`);
+    }
+    if (users.length === 0) throw imValidationError("members_empty", "\u6CA1\u6709\u53EF\u9080\u8BF7\u7684\u6210\u5458");
+    return {
+      summary: { action: "\u9080\u8BF7\u5165\u7FA4", groupId, inviteCount: users.length, users: users.map((u) => u.uid), removeFailed: args.removeFailed === true ? failed.map((f) => f.uid) : [] },
+      snapshot: { groupId, users }
+    };
+  },
+  async execute(plan, env) {
+    const body = { groupId: plan.groupId, users: plan.users };
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/inviteGroupUsers",
+      body,
+      operation: "im.group.invite"
+    });
+    assertImOk(res, "\u9080\u8BF7\u5165\u7FA4");
+    return { groupId: plan.groupId, invited: plan.users.length };
+  }
+});
+var groupKickPair = makeWritePair({
+  action: "im.group.kick",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const { users, failed } = await resolveMembers(args, env);
+    if (failed.length && args.removeFailed !== true) {
+      throw imValidationError("members_resolve_failed", `\u4EE5\u4E0B\u6210\u5458\u89E3\u6790\u5931\u8D25\uFF1A${failed.map((f) => f.name || f.uid).join("\u3001")}\uFF1B\u786E\u8BA4\u79FB\u9664\u8BF7\u4F20 removeFailed:true`);
+    }
+    if (users.length === 0) throw imValidationError("members_empty", "\u6CA1\u6709\u53EF\u79FB\u9664\u7684\u6210\u5458");
+    return {
+      summary: { action: "\u8E22\u51FA\u7FA4\u6210\u5458", groupId, kickCount: users.length, users: users.map((u) => u.uid) },
+      snapshot: { groupId, users }
+    };
+  },
+  async execute(plan, env) {
+    const body = { groupId: plan.groupId, users: plan.users };
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/kickGroupUsers",
+      body,
+      operation: "im.group.kick"
+    });
+    assertImOk(res, "\u8E22\u51FA\u7FA4\u6210\u5458");
+    return { groupId: plan.groupId, kicked: plan.users.length };
+  }
+});
+var groupExitPair = makeWritePair({
+  action: "im.group.exit",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    let memberCount;
+    let isOwner = false;
+    try {
+      const infoRes = await env.host.request({
+        method: "POST",
+        path: "/api/em/msg/executeIm/group/queryGroupInfo",
+        body: { trans_id: 0, type: 0, mask: 0, group_id: [groupId], flag: 0 },
+        operation: "im.group.exit.plan.info"
+      });
+      const info = (unwrapInner(infoRes)?.datas || [])[0];
+      if (info) {
+        const raw = info.user_num ?? info.userNum;
+        memberCount = raw === void 0 || raw === null ? void 0 : Number(raw);
+        const hostUid = str(info.host_uid ?? info.hostUid ?? "");
+        if (hostUid) {
+          const self = await env.host.getSelfIdentity();
+          isOwner = hostUid === String(self.uid);
+        }
+      }
+    } catch {
+    }
+    const orphanRisk = isOwner || memberCount !== void 0 && memberCount <= 1;
+    if (orphanRisk && args.acknowledgeOrphanRisk !== true) {
+      throw imValidationError(
+        "owner_exit_ack_required",
+        `\u9000\u7FA4\u98CE\u9669\u786E\u8BA4\u7F3A\u5931\uFF1A${isOwner ? "\u4F60\u662F\u8BE5\u7FA4\u7FA4\u4E3B" : "\u4F60\u662F\u8BE5\u7FA4\u6700\u540E\u4E00\u4E2A\u6210\u5458"}\uFF0C\u9000\u7FA4\u540E\u8BE5\u7FA4\u4F1A\u53D8\u6210\u65E0\u4E3B\u7A7A\u7FA4\uFF0C\u4E4B\u540E join/destroy \u90FD\u4F1A\u88AB\u670D\u52A1\u7AEF\u62D2\u7EDD\uFF081210\uFF09\uFF0C\u53EA\u80FD\u7531\u5BA2\u6237\u7AEF\u6216\u7BA1\u7406\u5458\u5904\u7406\u3002\u786E\u8BA4\u4ECD\u8981\u9000\u7FA4\u8BF7\u4F20 acknowledgeOrphanRisk:true`,
+        { details: { groupId, isOwner, memberCount } }
+      );
+    }
+    return {
+      summary: {
+        action: "\u9000\u51FA\u7FA4\u804A",
+        groupId,
+        ...memberCount === void 0 ? {} : { memberCount },
+        isOwner,
+        ...orphanRisk ? {
+          orphanRisk: true,
+          riskNote: `${isOwner ? "\u4F60\u662F\u7FA4\u4E3B" : "\u4F60\u662F\u6700\u540E\u4E00\u4E2A\u6210\u5458"}\uFF1A\u9000\u7FA4\u540E\u8BE5\u7FA4\u4F1A\u6210\u4E3A\u65E0\u4E3B\u7A7A\u7FA4\uFF0C\u65E0\u6CD5\u518D\u4ECE CLI \u91CD\u65B0\u8FDB\u7FA4\u6216\u89E3\u6563\uFF08\u5B9E\u6D4B 1210 \u6CA1\u6709\u6743\u9650\uFF09\uFF0C\u9700\u7531\u5BA2\u6237\u7AEF\u6216\u7BA1\u7406\u5458\u5904\u7406\u3002`
+        } : {}
+      },
+      snapshot: { groupId, acknowledgeOrphanRisk: args.acknowledgeOrphanRisk === true }
+    };
+  },
+  async execute(plan, env) {
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/exit",
+      body: { groupId: plan.groupId },
+      operation: "im.group.exit"
+    });
+    assertImOk(res, "\u9000\u51FA\u7FA4\u804A");
+    return { groupId: plan.groupId };
+  }
+});
+var groupDestroyPair = makeWritePair({
+  action: "im.group.destroy",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    return {
+      summary: { action: "\u89E3\u6563\u7FA4\u804A\uFF08\u4EC5\u7FA4\u4E3B\u53EF\u6267\u884C\uFF0C\u4E0D\u53EF\u6062\u590D\uFF09", groupId },
+      snapshot: { groupId }
+    };
+  },
+  async execute(plan, env) {
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/destroy",
+      body: { groupId: plan.groupId },
+      operation: "im.group.destroy"
+    });
+    assertImOk(res, "\u89E3\u6563\u7FA4\u804A");
+    return { groupId: plan.groupId };
+  }
+});
+var groupJoinPair = makeWritePair({
+  action: "im.group.join",
+  async plan(args, env) {
+    const groupId = args.groupId !== void 0 && args.groupId !== "" ? str(args.groupId) : "";
+    const token = args.token !== void 0 && args.token !== "" ? String(args.token) : "";
+    if (!groupId && !token) throw imValidationError("target_required", "groupId \u4E0E token \u81F3\u5C11\u5176\u4E00");
+    if (groupId && groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    if (token && token.length > 500) throw imValidationError("token_invalid", "token \u8FC7\u957F");
+    const mark = args.mark !== void 0 && args.mark !== "" ? String(args.mark) : "";
+    if (mark.length > 100) throw imValidationError("mark_too_long", "mark \u4E0D\u80FD\u8D85\u8FC7 100 \u5B57\u8282");
+    return {
+      summary: { action: "\u7533\u8BF7\u52A0\u5165\u7FA4\u804A", groupId: groupId || "(token)", hasMark: Boolean(mark), needApproval: true },
+      snapshot: compact({ groupId: groupId || void 0, token: token || void 0, mark: mark || void 0 })
+    };
+  },
+  async execute(plan, env) {
+    const body = compact({
+      trans_id: 0,
+      dev: 4,
+      rule: 0,
+      auto: 0,
+      group_id: plan.groupId || void 0,
+      mark: plan.mark || void 0,
+      token: plan.token || void 0
+    });
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/joinGroup",
+      body,
+      operation: "im.group.join"
+    });
+    assertImOk(res, "\u7533\u8BF7\u5165\u7FA4");
+    const flag = Number(res?.data?.data?.flag ?? res?.data?.flag ?? -1);
+    return {
+      flag,
+      note: flag === 1 ? "\u65E0\u9700\u9A8C\u8BC1\uFF0C\u5DF2\u76F4\u63A5\u52A0\u5165" : flag === 0 ? "\u9700\u7BA1\u7406\u5458/\u7FA4\u4E3B\u5BA1\u6279" : "\u672A\u77E5\u7ED3\u679C"
+    };
+  }
+});
+function parseSwitchs(raw) {
+  const text = String(raw ?? "");
+  if (!text) return [];
+  return text.split(",").map((pair) => {
+    const [flagRaw, onoffRaw] = pair.split(":");
+    const flag = Number(flagRaw);
+    const onOff = Number(onoffRaw);
+    if (!Number.isInteger(flag) || !Number.isInteger(onOff)) {
+      throw imValidationError("switchs_invalid", `switchs \u5FC5\u987B\u5F62\u5982 flag:onoff\uFF08\u5982 1:1,2:0\uFF09\uFF0C\u6536\u5230\uFF1A${pair}`);
+    }
+    return { flag, on_off: onOff };
+  });
+}
+var groupModifyPair = makeWritePair({
+  action: "im.group.modify",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    if (args.onoff !== void 0) {
+      throw imValidationError("field_forbidden", "onoff \u5B57\u6BB5\u670D\u52A1\u7AEF\u4E0D\u5904\u7406\uFF0C\u8BF7\u7528 switchs");
+    }
+    const body = { group_id: groupId };
+    let mask = 0;
+    const set = (bit, key, value) => {
+      if (value !== void 0) {
+        mask |= bit;
+        body[key] = value;
+      }
+    };
+    if (args.num !== void 0) set(1 << 1, "num", toUint(args.num, "num"));
+    if (args.rsonoff !== void 0) set(1 << 3, "rsonoff", toUint(args.rsonoff, "rsonoff"));
+    if (args.history !== void 0) set(1 << 5, "history", toUint(args.history, "history"));
+    if (args.switchs !== void 0) {
+      const list = parseSwitchs(args.switchs);
+      if (list.length) set(1 << 8, "switchs", list);
+    }
+    if (args.gtId !== void 0) set(1 << 11, "gt_id", String(args.gtId));
+    if (args.copyGroupids) {
+      const ids = Array.isArray(args.copyGroupids) ? args.copyGroupids.map((x) => String(x)) : splitIds(args.copyGroupids, "copyGroupids");
+      set(1 << 9, "copy_groupids", ids.map((x) => Number(x)));
+    }
+    const resolveOrFail = async (raw, label) => {
+      const { users, failed } = await resolveMembers({ users: raw }, env);
+      if (failed.length && args.removeFailed !== true) {
+        throw imValidationError(
+          "members_resolve_failed",
+          `${label}\u4FE1\u606F\u83B7\u53D6\u5931\u8D25\uFF08cid/uid \u7F3A\u5931\u6216\u4E3A 0\uFF09\uFF1A${failed.map((f) => f.name ? `${f.name}(${f.uid})` : f.uid).join("\u3001")}\uFF1B\u786E\u8BA4\u79FB\u9664\u8BF7\u4F20 removeFailed:true`,
+          { details: failed }
+        );
+      }
+      return users;
+    };
+    if (args.admins) {
+      const users = await resolveOrFail(args.admins, "\u7BA1\u7406\u5458");
+      if (users.length === 0) throw imValidationError("members_empty", "\u7BA1\u7406\u5458\u89E3\u6790\u4E3A\u7A7A");
+      set(1 << 7, "admins", users);
+    }
+    if (args.delAdmins) {
+      const users = await resolveOrFail(args.delAdmins, "\u5F85\u79FB\u9664\u7BA1\u7406\u5458");
+      if (users.length === 0) throw imValidationError("members_empty", "\u5F85\u79FB\u9664\u7BA1\u7406\u5458\u89E3\u6790\u4E3A\u7A7A");
+      set(1 << 7, "del_admins", users);
+    }
+    if (args.creator) {
+      const users = await resolveOrFail(args.creator, "\u65B0\u7FA4\u4E3B");
+      if (!users.length) throw imValidationError("members_empty", "\u65B0\u7FA4\u4E3B\u89E3\u6790\u5931\u8D25");
+      set(1 << 6, "creator", users[0]);
+    }
+    if (mask === 0) throw imValidationError("field_required", "\u81F3\u5C11\u4FEE\u6539\u4E00\u9879\uFF08num/rsonoff/history/switchs/gtId/copyGroupids/admins/delAdmins/creator\uFF09");
+    body.mask = mask;
+    return {
+      summary: { action: "\u6279\u91CF\u4FEE\u6539\u7FA4\u5C5E\u6027", groupId, mask, changedFields: Object.keys(body).filter((k) => k !== "group_id" && k !== "mask") },
+      snapshot: { groupId, body }
+    };
+  },
+  async execute(plan, env) {
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/batModGroupInfo",
+      body: plan.body,
+      operation: "im.group.modify"
+    });
+    assertImOk(res, "\u4FEE\u6539\u7FA4\u5C5E\u6027");
+    return { groupId: plan.groupId };
+  }
+});
+var groupRenamePair = makeWritePair({
+  action: "im.group.rename",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const forbidden = ["announce", "type", "state"];
+    for (const key of forbidden) {
+      if (args[key] !== void 0) throw imValidationError("field_forbidden", `${key} \u5B57\u6BB5\u7981\u7528\uFF1Aannounce \u8BF7\u7528\u516C\u544A\u64CD\u4F5C\uFF0Ctype/state \u4F1A\u89E6\u53D1\u9AD8\u5371\u884C\u4E3A`);
+    }
+    const fieldKeys = ["name", "history", "host", "display", "msgSetting", "mark", "gtid"].filter((k) => args[k] !== void 0);
+    if (fieldKeys.length === 0) throw imValidationError("field_required", "\u81F3\u5C11\u4FEE\u6539\u4E00\u9879\uFF1Aname/history/host/display/msgSetting/mark/gtid");
+    if (fieldKeys.length > 1) throw imValidationError("field_conflict", "\u672C\u63A5\u53E3\u4E00\u6B21\u53EA\u80FD\u6539\u4E00\u9879");
+    const field = fieldKeys[0];
+    const maskOrder = { name: 0, history: 8, host: 4, display: 5, msgSetting: 6, mark: 7, gtid: 9 };
+    let info = {};
+    if (field === "host") {
+      const { users, failed } = await resolveMembers({ users: args.host }, env);
+      if (failed.length) {
+        throw imValidationError(
+          "members_resolve_failed",
+          `\u7FA4\u4E3B\u4FE1\u606F\u83B7\u53D6\u5931\u8D25\uFF08cid/uid \u7F3A\u5931\u6216\u4E3A 0\uFF09\uFF1A${failed.map((f) => f.name ? `${f.name}(${f.uid})` : f.uid).join("\u3001")}`,
+          { details: failed }
+        );
+      }
+      if (!users.length) throw imValidationError("members_empty", "\u65B0\u7FA4\u4E3B\u89E3\u6790\u5931\u8D25");
+      info = { host: users[0] };
+    } else if (field === "history" || field === "display" || field === "msgSetting" || field === "mark") {
+      info = { [field === "msgSetting" ? "msg_setting" : field]: toUint(args[field], field) };
+    } else {
+      info = { [field]: field === "gtid" ? String(args[field]) : String(args[field]) };
+    }
+    const data = {
+      trans_id: 0,
+      group_id: groupId,
+      type: 0,
+      dev: 4,
+      mask: maskOrder[field],
+      info
+    };
+    return {
+      summary: { action: `\u4FEE\u6539\u7FA4\u4FE1\u606F\uFF08${field}\uFF09`, groupId, field, value: info[field === "msgSetting" ? "msg_setting" : field] },
+      snapshot: { groupId, data }
+    };
+  },
+  async execute(plan, env) {
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/modifyGroupInfo",
+      body: { data: plan.data },
+      operation: "im.group.rename"
+    });
+    assertImOk(res, "\u4FEE\u6539\u7FA4\u4FE1\u606F");
+    return { groupId: plan.groupId };
+  }
+});
+var groupAnnounceModifyPair = makeWritePair({
+  action: "im.group.announce.modify",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const isDel = args.del === true || String(args.del) === "1" || String(args.flag) === "1";
+    const aid = args.aid !== void 0 && args.aid !== "" ? String(args.aid) : "0";
+    if (isDel && (!aid || aid === "0")) throw imValidationError("aid_required", "\u5220\u9664\u516C\u544A\u5FC5\u987B\u6307\u5B9A aid");
+    if (!isDel) {
+      const annouce = args.annouce !== void 0 ? String(args.annouce) : "";
+      if (!annouce) throw imValidationError("annouce_required", "\u65B0\u589E/\u4FEE\u6539\u516C\u544A\u5FC5\u987B\u63D0\u4F9B annouce");
+      if (annouce.length > 5e3) throw imValidationError("annouce_too_long", "\u516C\u544A\u5185\u5BB9\u8FC7\u957F");
+    }
+    const summary = { action: isDel ? "\u5220\u9664\u7FA4\u516C\u544A" : aid && aid !== "0" ? "\u4FEE\u6539\u7FA4\u516C\u544A" : "\u65B0\u589E\u7FA4\u516C\u544A", groupId, aid };
+    const snapshot = { groupId, flag: isDel ? 1 : 0, aid };
+    if (!isDel) {
+      const notice = args.notice !== void 0 ? toUint(args.notice, "notice") : 0;
+      const fmark = args.fmark !== void 0 ? toUint(args.fmark, "fmark") : void 0;
+      summary.notice = notice;
+      summary.mustRead = fmark === 1;
+      snapshot.annouce = String(args.annouce);
+      snapshot.notice = notice;
+      if (fmark !== void 0) snapshot.fmark = fmark;
+      if (args.related !== void 0) snapshot.related = String(args.related);
+    }
+    return { summary, snapshot };
+  },
+  async execute(plan, env) {
+    const body = compact({
+      groupId: plan.groupId,
+      flag: plan.flag,
+      aid: plan.aid,
+      annouce: plan.annouce,
+      notice: plan.notice,
+      fmark: plan.fmark,
+      related: plan.related,
+      sensitive_flag: plan.flag === 1 ? void 0 : 1
+    });
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/modifyAnnouce",
+      body,
+      operation: "im.group.announce.modify"
+    });
+    assertImOk(res, "\u4FEE\u6539\u7FA4\u516C\u544A");
+    const responseAid = str(res?.data?.data?.aid ?? res?.data?.aid ?? "");
+    const deleted = plan.flag === 1;
+    return {
+      groupId: plan.groupId,
+      aid: responseAid && responseAid !== "0" ? responseAid : plan.aid,
+      deleted,
+      ...deleted ? {} : { created: plan.aid === "0" }
+    };
+  }
+});
+function buildWriteDefinition(name, method, summary, inputProps, pair) {
+  const requiredInput = Object.keys(inputProps).filter((k) => {
+    const prop = inputProps[k];
+    return prop?.required === true;
+  });
+  const prepareSchema2 = schemaOf(
+    { ...inputProps, removeFailed: { type: "boolean", description: "\u786E\u8BA4\u79FB\u9664\u89E3\u6790\u5931\u8D25\u6210\u5458" } },
+    { required: requiredInput, description: summary }
+  );
+  return [
+    {
+      name: `${name}.prepare`,
+      resource: "group",
+      method: `${method}.prepare`,
+      action: `${name}.prepare`,
+      summary: `${summary}\uFF08prepare\uFF1A\u53EA\u8BFB\u6821\u9A8C + \u5DEE\u5F02\u6458\u8981 + \u7B7E\u53D1\u786E\u8BA4\uFF09`,
+      capability: "group",
+      risk: "read-before-write",
+      requiresConfirmation: true,
+      inputSchema: prepareSchema2,
+      handler: pair.prepare
+    },
+    {
+      name: `${name}.apply`,
+      resource: "group",
+      method: `${method}.apply`,
+      action: `${name}.apply`,
+      summary: `${summary}\uFF08apply\uFF1A\u9700 confirm:true + continuation\uFF09`,
+      capability: "group",
+      risk: WRITE,
+      requiresConfirmation: true,
+      inputSchema: schemaOf({
+        confirm: { type: "boolean", description: "\u5FC5\u987B\u4E3A true" },
+        continuation: { type: "string", minLength: 1 }
+      }, { required: ["confirm", "continuation"], description: summary }),
+      handler: pair.apply
+    }
+  ];
+}
+var groupWriteOps = [
+  ...buildWriteDefinition("im.group.create", "group.create", "\u521B\u5EFA\u666E\u901A\u7FA4", {
+    users: { type: "array", items: { type: "string" }, description: "\u7FA4\u6210\u5458 uid\uFF08\u9017\u53F7\u4E32\u6216\u6570\u7EC4\uFF09" },
+    name: { type: "string", description: "\u7FA4\u540D\uFF08\u7F3A\u7701\u81EA\u52A8\u751F\u6210\uFF09" },
+    names: { type: "array", items: { type: "string" }, description: "\u4E0E users \u987A\u5E8F\u5BF9\u5E94\u59D3\u540D\uFF08\u7528\u4E8E\u9ED8\u8BA4\u7FA4\u540D\uFF09" },
+    admins: { type: "array", items: { type: "string" }, description: "\u7BA1\u7406\u5458 uid" }
+  }, groupCreatePair),
+  ...buildWriteDefinition("im.group.invite", "group.invite", "\u9080\u8BF7\u6210\u5458\u5165\u7FA4", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    users: { type: "array", items: { type: "string" }, description: "\u88AB\u9080\u8BF7 uid" }
+  }, groupInvitePair),
+  ...buildWriteDefinition("im.group.kick", "group.kick", "\u8E22\u51FA\u7FA4\u6210\u5458", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    users: { type: "array", items: { type: "string" }, description: "\u88AB\u8E22 uid" }
+  }, groupKickPair),
+  ...buildWriteDefinition("im.group.exit", "group.exit", "\u9000\u51FA\u7FA4\u804A", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    acknowledgeOrphanRisk: {
+      type: "boolean",
+      description: "\u7FA4\u4E3B\u6216\u6700\u540E\u4E00\u4E2A\u6210\u5458\u9000\u7FA4\u65F6\u5FC5\u987B\u663E\u5F0F\u4F20 true\uFF08\u9000\u7FA4\u540E\u8BE5\u7FA4\u4F1A\u53D8\u6210\u65E0\u4E3B\u7A7A\u7FA4\uFF0C\u65E0\u6CD5\u518D join/destroy\uFF09"
+    }
+  }, groupExitPair),
+  ...buildWriteDefinition("im.group.destroy", "group.destroy", "\u89E3\u6563\u7FA4\u804A\uFF08\u4EC5\u7FA4\u4E3B\uFF0C\u4E0D\u53EF\u6062\u590D\uFF09", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" }
+  }, groupDestroyPair),
+  ...buildWriteDefinition("im.group.join", "group.join", "\u7533\u8BF7\u52A0\u5165\u7FA4\u804A", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id\uFF08token \u4E8C\u9009\u4E00\uFF09" },
+    token: { type: "string", description: "\u7FA4 token/\u4E8C\u7EF4\u7801\u52A0\u5165" },
+    mark: { type: "string", maxLength: 100, description: "\u7533\u8BF7\u7406\u7531" }
+  }, groupJoinPair),
+  ...buildWriteDefinition("im.group.modify", "group.modify", "\u6279\u91CF\u4FEE\u6539\u7FA4\u5C5E\u6027\uFF08batModGroupInfo\uFF09", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    num: { type: "integer", description: "\u6700\u5927\u4EBA\u6570" },
+    switchs: { type: "string", description: "\u7FA4\u5F00\u5173\uFF08flag:onoff \u9017\u53F7\u5206\u9694\uFF0C\u5982 1:1,8:0\uFF09" },
+    rsonoff: { type: "integer", enum: [0, 1], description: "\u6D88\u606F\u9605\u8BFB\u72B6\u6001\u5F00\u5173" },
+    history: { type: "integer", description: "\u65B0\u4EBA\u53EF\u770B\u5386\u53F2\u8303\u56F4" },
+    admins: { type: "array", items: { type: "string" }, description: "\u65B0\u589E\u7BA1\u7406\u5458 uid" },
+    delAdmins: { type: "array", items: { type: "string" }, description: "\u79FB\u9664\u7BA1\u7406\u5458 uid" },
+    creator: { type: "string", description: "\u8F6C\u8BA9\u7FA4\u4E3B\uFF08\u5355 uid\uFF09" },
+    copyGroupids: { type: "array", items: { type: "string" }, description: "\u62F7\u8D1D\u7FA4\u5217\u8868" },
+    gtId: { type: "string", description: "\u5173\u8054\u7FA4\u7C7B\u578B id" }
+  }, groupModifyPair),
+  ...buildWriteDefinition("im.group.rename", "group.rename", "\u4FEE\u6539\u7FA4\u4FE1\u606F\uFF08\u4E00\u6B21\u4E00\u9879\uFF1A\u7FA4\u540D/\u5386\u53F2/\u7FA4\u4E3B/\u663E\u793A/\u6253\u6270/\u6807\u8BB0/gtid\uFF09", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    name: { type: "string", description: "\u6539\u7FA4\u540D" },
+    history: { type: "integer", description: "\u65B0\u4EBA\u5386\u53F2\u6D88\u606F\u8303\u56F4" },
+    host: { type: "string", description: "\u8F6C\u8BA9\u7FA4\u4E3B\uFF08\u5355 uid\uFF09" },
+    display: { type: "integer", enum: [0, 1], description: "\u662F\u5426\u5728\u7FA4\u5217\u8868\u663E\u793A" },
+    msgSetting: { type: "integer", description: "\u6D88\u606F\u6253\u6270\u8BBE\u7F6E" },
+    mark: { type: "integer", description: "\u6807\u8BB0\u4F4D" },
+    gtid: { type: "string", description: "GTID" }
+  }, groupRenamePair),
+  ...buildWriteDefinition("im.group.announce.modify", "group.announce.modify", "\u65B0\u589E/\u4FEE\u6539/\u5220\u9664\u7FA4\u516C\u544A", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    annouce: { type: "string", description: "\u516C\u544A\u5185\u5BB9\uFF08\u5220\u9664\u65F6\u4E0D\u9700\u8981\uFF09" },
+    aid: { type: "string", description: "\u516C\u544A id\uFF080/\u4E0D\u4F20=\u65B0\u589E\uFF1B\u975E 0=\u4FEE\u6539\uFF1B\u5220\u9664\u5FC5\u586B\uFF09" },
+    del: { type: "boolean", description: "\u5220\u9664\u5F00\u5173" },
+    notice: { type: "integer", enum: [0, 1, 2], description: "0 \u53D1\u901A\u77E5(\u9ED8\u8BA4)/1 \u4E0D\u53D1/2 \u53D1\u5E76@\u5168\u4F53" },
+    fmark: { type: "integer", enum: [0, 1], description: "\u65B0\u4EBA\u5FC5\u770B" },
+    related: { type: "string", description: "\u5173\u8054\u9644\u4EF6 id" }
+  }, groupAnnounceModifyPair)
+];
+var groupWriteOperations = groupWriteOps;
+
+// src/shortcuts/im/operations/msg-sync.ts
+var MAX_MSG_ID = String((1n << 63n) - 1n);
+function resolveRange(args, idKeys = { start: "start", end: "end" }) {
+  const explicitStart = args[idKeys.start];
+  const explicitEnd = args[idKeys.end];
+  if (explicitStart !== void 0 && explicitStart !== null && explicitStart !== "") {
+    return {
+      start: String(explicitStart),
+      end: explicitEnd !== void 0 && explicitEnd !== null && explicitEnd !== "" ? String(explicitEnd) : "0",
+      scope: "explicit-id",
+      shrink: null
+    };
+  }
+  if (args.latest === true) {
+    return { start: MAX_MSG_ID, end: "0", scope: "latest", shrink: null };
+  }
+  const hasFrom = args.from !== void 0 && args.from !== null && args.from !== "";
+  const hasTo = args.to !== void 0 && args.to !== null && args.to !== "";
+  if (hasFrom || hasTo) {
+    const clamp = clampTimeRangeTo7Days(parseTimeToSec(args.from, false), parseTimeToSec(args.to, true));
+    return {
+      start: clamp.toSec > 0 ? makeMinMaxIdByTm(clamp.toSec).max : MAX_MSG_ID,
+      end: clamp.fromSec > 0 ? makeMinMaxIdByTm(clamp.fromSec).min : "0",
+      scope: "range",
+      shrink: clamp.shrunk ? clamp : null
+    };
+  }
+  const range = todayRange();
+  return {
+    start: makeMinMaxIdByTm(range.toSec).max,
+    end: makeMinMaxIdByTm(range.fromSec).min,
+    scope: "today",
+    shrink: null
+  };
+}
+function pageSizeOf(args) {
+  const raw = args.num;
+  if (raw === void 0 || raw === null || raw === "") return DEFAULT_PAGE_SIZE;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) throw imValidationError("num_invalid", "num \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+  return Math.min(n, 50);
+}
+function emptyPageNote(args) {
+  if (args.latest === true) return "\u8BE5\u4F1A\u8BDD\u6682\u65E0\u4EFB\u4F55\u6D88\u606F\u8BB0\u5F55";
+  const hasRange = args.from !== void 0 && args.from !== "" || args.to !== void 0 && args.to !== "";
+  if (hasRange) return "\u8BE5\u65F6\u95F4\u8303\u56F4\u5185\u65E0\u6D88\u606F\u8BB0\u5F55";
+  return "\u5F53\u5929\u65E0\u6D88\u606F\uFF08\u5982\u9700\u6700\u65B0\u6D88\u606F\u8BF7\u4F20 latest:true\uFF0C\u6216\u6307\u5B9A from/to \u65F6\u95F4\u8303\u56F4\uFF09";
+}
+async function enrichMessages(rawRows, host, options = {}) {
+  const rows = rawRows.filter(Boolean);
+  if (rows.length === 0) return [];
+  const i18nIds = collectI18nIds(rows);
+  const personIds = collectPersonIds(rows);
+  const fromUids = rows.map((r) => r.from_uid).filter((x) => Boolean(x));
+  for (const uid of fromUids) personIds.push(uid);
+  const [i18nMap, personMap] = await Promise.all([
+    host.fetchI18nLabels(i18nIds),
+    host.resolveUsersByIds([...new Set(personIds)])
+  ]);
+  const nameMap = {};
+  for (const [uid, p] of Object.entries(personMap)) nameMap[uid] = p.name;
+  const enriched = [];
+  for (const row of rows) {
+    const msgObj = parseMsg(row.msg);
+    const parsed = parseContent(msgObj, { i18nMap, nameMap });
+    const imgs = msgObj ? extractImgs(msgObj) : [];
+    const videos = msgObj ? extractVideos(msgObj) : [];
+    const files = msgObj ? extractFiles(msgObj) : [];
+    const imgFormat = options.imgFormat || "small";
+    const media = [];
+    for (const img of imgs) {
+      media.push({
+        kind: "img",
+        fileId: img.fileId,
+        name: img.name,
+        w: img.w,
+        h: img.h,
+        previewUrl: await host.buildPreviewUrl({
+          fileId: img.fileId,
+          msgid: String(row.ser_msgid ?? ""),
+          kind: "img",
+          imgFormat,
+          ...options.groupId ? { groupId: options.groupId } : {},
+          ...options.user ? { user: options.user } : {}
+        }),
+        downloadUrl: await host.buildDownloadUrl({
+          fileId: img.fileId,
+          msgid: String(row.ser_msgid ?? ""),
+          kind: "img",
+          imgFormat,
+          ...options.groupId ? { groupId: options.groupId } : {},
+          ...options.user ? { user: options.user } : {}
+        })
+      });
+    }
+    for (const v of videos) {
+      media.push({
+        kind: "video",
+        fileId: v.fileId,
+        name: v.name,
+        ext: v.ext,
+        previewUrl: await host.buildPreviewUrl({
+          fileId: v.fileId,
+          msgid: String(row.ser_msgid ?? ""),
+          kind: "video",
+          ...options.groupId ? { groupId: options.groupId } : {},
+          ...options.user ? { user: options.user } : {}
+        }),
+        downloadUrl: await host.buildDownloadUrl({
+          fileId: v.fileId,
+          msgid: String(row.ser_msgid ?? ""),
+          kind: "video",
+          ...options.groupId ? { groupId: options.groupId } : {},
+          ...options.user ? { user: options.user } : {}
+        })
+      });
+    }
+    for (const f of files) {
+      media.push({
+        kind: "file",
+        fileId: f.fileId,
+        name: f.name,
+        size: f.size,
+        downloadUrl: await host.buildDownloadUrl({
+          fileId: f.fileId,
+          msgid: String(row.ser_msgid ?? ""),
+          kind: "img",
+          imgFormat,
+          ...options.groupId ? { groupId: options.groupId } : {},
+          ...options.user ? { user: options.user } : {}
+        })
+      });
+    }
+    const sender = senderName(msgObj || {}, row.from_uid, options.authUid, nameMap);
+    enriched.push({
+      msgid: str(row.ser_msgid),
+      sender,
+      from_uid: str(row.from_uid),
+      time: formatFullTime(row.msgtime),
+      msgtime: row.msgtime,
+      type: parsed.type,
+      typeName: parsed.typeName,
+      title: options.titleFirst ? parsed.title : void 0,
+      content: collapseNewlines(parsed.content),
+      must: parsed.must,
+      fileName: parsed.fileName,
+      media,
+      ...msgObj ? { msg: msgObj } : {}
+    });
+  }
+  return enriched;
+}
+var msgSyncSingle = {
+  name: "im.msg.sync.single",
+  resource: "msg",
+  method: "msg.sync.single",
+  action: "im.msg.sync.single",
+  summary: "\u62C9\u53D6\u4E0E\u67D0\u4EBA\u7684\u5355\u804A\u6D88\u606F\uFF08\u5012\u5E8F\uFF0C\u9ED8\u8BA4\u5F53\u5929\uFF1B\u65F6\u95F4\u8303\u56F4\u8F6C\u6D88\u606F id \u533A\u95F4\u5E76\u81EA\u52A8\u7FFB\u9875\u62C9\u5B8C\uFF09",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    fromUid: { type: "string", pattern: "^\\d+$", description: "\u5BF9\u65B9 uid\uFF08\u5FC5\u586B\uFF09" },
+    fromCid: { type: "string", pattern: "^\\d+$", description: "\u5BF9\u65B9 cid\uFF08\u5FC5\u586B\uFF09" },
+    num: { type: "integer", minimum: 1, maximum: 50, description: "\u6BCF\u9875\u6570\u91CF\uFF08\u9ED8\u8BA4 50\uFF0C\u6700\u591A 50\uFF09" },
+    latest: { type: "boolean", description: "\u62C9\u6700\u65B0\u4E0D\u9650\u65E5\u671F\uFF08\u65E0\u754C\u533A\u95F4\uFF0C\u53EA\u62C9\u4E00\u9875\uFF09" },
+    from: { type: "string", description: "\u8D77\u59CB\u65F6\u95F4\uFF08YYYY-MM-DD \u6216 YYYY-MM-DD HH:mm:ss \u6216 unix \u79D2\uFF09\uFF1B\u8DE8\u5EA6 > 7 \u5929\u81EA\u52A8\u6536\u655B\u4E3A\u8BE5\u8303\u56F4\u6700\u540E 7 \u5929" },
+    to: { type: "string", description: "\u7ED3\u675F\u65F6\u95F4\uFF08\u540C\u4E0A\uFF09" },
+    start: { type: "string", description: "\u663E\u5F0F\u8D77\u59CB\u6D88\u606F id\uFF08\u6700\u9AD8\u4F18\u5148\uFF09" },
+    end: { type: "string", description: "\u663E\u5F0F\u7ED3\u675F\u6D88\u606F id" },
+    imgFormat: { type: "string", enum: ["small", "large", "original"], description: "\u9884\u89C8\u89C4\u683C\uFF08\u9ED8\u8BA4 small\uFF09" }
+  }, { required: ["fromUid", "fromCid"], description: "\u62C9\u53D6\u5355\u804A\u6D88\u606F" }),
+  handler: async (args, { host }) => {
+    const fromUid = String(args.fromUid);
+    const fromCid = String(args.fromCid);
+    if (!fromUid || !fromCid || fromUid === "0" || fromCid === "0") {
+      throw imValidationError("id_invalid", "fromUid/fromCid \u5FC5\u987B\u975E 0");
+    }
+    const { start, end, scope, shrink } = resolveRange(args);
+    const num = pageSizeOf(args);
+    const autoLoop = end !== "0";
+    let actCode = 0;
+    const pulled = await pullPaged({
+      num,
+      start,
+      end,
+      autoLoop,
+      requestOnePage: async (pageStart, pageEnd, maxNum) => {
+        const body = {
+          trans_id: 0,
+          dev: 4,
+          enc_type: 0,
+          datas: [{ from_cid: fromCid, from_uid: fromUid, start: pageStart, end: pageEnd, max_num: maxNum }]
+        };
+        const res = await host.request({
+          method: "POST",
+          path: "/api/em/msg/executeIm/msg/syncSingleMsg",
+          body,
+          operation: "im.msg.sync.single"
+        });
+        actCode = Number(res?.data?.actionMsg?.code ?? -1);
+        if (actCode === 1303) return [];
+        assertImOk(res, "\u62C9\u53D6\u5355\u804A\u6D88\u606F");
+        const inner = unwrapInner(res);
+        const outerDatas = inner?.datas || [];
+        const rows = [];
+        for (const group of outerDatas) {
+          const list = group?.datas || group?.data || [];
+          if (Array.isArray(list)) rows.push(...list);
+        }
+        return rows;
+      }
+    });
+    const authUid = await resolveAuthUid(host);
+    const messages = await enrichMessages(pulled.rows, host, {
+      authUid,
+      user: { cid: fromCid, uid: fromUid },
+      imgFormat: args.imgFormat
+    });
+    sortMessagesNewestFirst(messages);
+    return imSuccess("im.msg.sync.single", {
+      total: messages.length,
+      messages,
+      range: { from: args.from, to: args.to, start, end, scope, autoPaged: autoLoop },
+      ...paginationMeta(pulled, num),
+      ...shrink ? { rangeShrink: rangeShrinkMeta(shrink) } : {},
+      ...actCode === 1303 ? { empty: true, emptyReason: emptyPageNote(args) } : {}
+    });
+  }
+};
+var msgSyncGroup = {
+  name: "im.msg.sync.group",
+  resource: "msg",
+  method: "msg.sync.group",
+  action: "im.msg.sync.group",
+  summary: "\u62C9\u53D6\u67D0\u7FA4\u804A\u5929\u6D88\u606F\uFF08\u5012\u5E8F\uFF0C\u9ED8\u8BA4\u5F53\u5929\uFF1B\u6709\u754C\u533A\u95F4\u81EA\u52A8\u7FFB\u9875\u62C9\u5B8C\uFF1Btype=0 \u5FC5\u4F20\uFF09",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id\uFF08\u5FC5\u586B\uFF09" },
+    num: { type: "integer", minimum: 1, maximum: 50, description: "\u6BCF\u9875\u6570\u91CF\uFF08\u9ED8\u8BA4 50\uFF0C\u6700\u591A 50\uFF09" },
+    latest: { type: "boolean", description: "\u62C9\u6700\u65B0\u4E0D\u9650\u65E5\u671F\uFF08\u65E0\u754C\u533A\u95F4\uFF0C\u53EA\u62C9\u4E00\u9875\uFF09" },
+    from: { type: "string", description: "\u8D77\u59CB\u65F6\u95F4\uFF1B\u8DE8\u5EA6 > 7 \u5929\u81EA\u52A8\u6536\u655B\u4E3A\u8BE5\u8303\u56F4\u6700\u540E 7 \u5929" },
+    to: { type: "string", description: "\u7ED3\u675F\u65F6\u95F4\uFF08\u540C\u4E0A\uFF09" },
+    startId: { type: "string", description: "\u663E\u5F0F\u8D77\u59CB\u6D88\u606F id\uFF08\u6700\u9AD8\u4F18\u5148\uFF09" },
+    endId: { type: "string", description: "\u663E\u5F0F\u7ED3\u675F\u6D88\u606F id" },
+    imgFormat: { type: "string", enum: ["small", "large", "original"], description: "\u9884\u89C8\u89C4\u683C\uFF08\u9ED8\u8BA4 small\uFF09" }
+  }, { required: ["groupId"], description: "\u62C9\u53D6\u7FA4\u804A\u6D88\u606F" }),
+  handler: async (args, { host }) => {
+    const groupId = String(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const { start, end, scope, shrink } = resolveRange(args, { start: "startId", end: "endId" });
+    const num = pageSizeOf(args);
+    const autoLoop = end !== "0";
+    let actCode = 0;
+    const pulled = await pullPaged({
+      num,
+      start,
+      end,
+      autoLoop,
+      requestOnePage: async (pageStart, pageEnd, maxNum) => {
+        const body = {
+          trans_id: 0,
+          dev: 4,
+          type: 0,
+          enc_type: 0,
+          datas: [{ group_id: groupId, start: pageStart, end: pageEnd, max_num: maxNum }]
+        };
+        const res = await host.request({
+          method: "POST",
+          path: "/api/em/msg/executeIm/chat/syncGroupMsg",
+          body,
+          operation: "im.msg.sync.group"
+        });
+        actCode = Number(res?.data?.actionMsg?.code ?? -1);
+        if (actCode === 1303) return [];
+        assertImOk(res, "\u62C9\u53D6\u7FA4\u804A\u6D88\u606F");
+        const inner = unwrapInner(res);
+        const outerDatas = inner?.datas || [];
+        const rows = [];
+        for (const group of outerDatas) {
+          const list = group?.datas || group?.data || [];
+          if (Array.isArray(list)) rows.push(...list);
+        }
+        return rows;
+      }
+    });
+    const authUid = await resolveAuthUid(host);
+    const messages = await enrichMessages(pulled.rows, host, {
+      authUid,
+      groupId,
+      imgFormat: args.imgFormat
+    });
+    sortMessagesNewestFirst(messages);
+    return imSuccess("im.msg.sync.group", {
+      groupId,
+      total: messages.length,
+      messages,
+      range: { from: args.from, to: args.to, start, end, scope, autoPaged: autoLoop },
+      ...paginationMeta(pulled, num),
+      ...shrink ? { rangeShrink: rangeShrinkMeta(shrink) } : {},
+      ...actCode === 1303 ? { empty: true, emptyReason: emptyPageNote(args) } : {}
+    });
+  }
+};
+var msgTopSync = {
+  name: "im.msg.top.sync",
+  resource: "msg",
+  method: "msg.top.sync",
+  action: "im.msg.top.sync",
+  summary: "\u540C\u6B65\u7FA4\u7F6E\u9876\u6D88\u606F\uFF08\u6458\u8981 + \u6D88\u606F\u5185\u5BB9\uFF09",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id\uFF08\u5FC5\u586B\uFF09" },
+    msgids: { type: "array", items: { type: "string" }, description: "\u4EC5\u540C\u6B65\u6307\u5B9A\u6D88\u606F id\uFF08\u7F3A\u7701=\u5168\u90E8\u7F6E\u9876\uFF09" },
+    encType: { type: "integer", enum: [0, 1, 2, 3], description: "\u52A0\u5BC6\u7C7B\u578B\uFF08\u9ED8\u8BA4 0\uFF0C\u4E0D\u89E3\u5BC6\uFF09" },
+    imgFormat: { type: "string", enum: ["small", "large", "original"], description: "\u7F6E\u9876\u6D88\u606F\u5185\u56FE\u7247\u7684\u9884\u89C8\u89C4\u683C\uFF08\u9ED8\u8BA4 small\uFF09" }
+  }, { required: ["groupId"], description: "\u540C\u6B65\u7FA4\u7F6E\u9876\u6D88\u606F" }),
+  handler: async (args, { host }) => {
+    const groupId = String(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const body = compact({
+      group_id: groupId,
+      enc_type: Number(args.encType ?? 0),
+      msgids: Array.isArray(args.msgids) && args.msgids.length ? args.msgids.map((x) => String(x)) : void 0
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/msg/syncGroupTopMsg",
+      body,
+      operation: "im.msg.top.sync"
+    });
+    assertImOk(res, "\u540C\u6B65\u7F6E\u9876\u6D88\u606F");
+    const inner = unwrapInner(res);
+    const infos = inner?.infos || [];
+    const personIds = infos.map((it) => String(it?.user?.uid ?? "")).filter((x) => x && x !== "0");
+    const personMap = await host.resolveUsersByIds([...new Set(personIds)]);
+    const summary = infos.map((it) => ({
+      msgid: str(it.msgid ?? it.ser_msgid),
+      operator: personMap[str(it.user?.uid)]?.name || str(it.user?.uid),
+      updateTime: formatFullTime(it.update_tm ?? it.time),
+      status: Number(it.status ?? 0),
+      statusNote: Number(it.status) === 1 ? "\u65E0\u6743\u9650/\u5DF2\u5220\u9664" : "\u6B63\u5E38"
+    }));
+    const topRaw = Array.isArray(inner?.datas) ? inner.datas : [];
+    const messages = await enrichMessages(topRaw, host, {
+      groupId,
+      imgFormat: args.imgFormat,
+      authUid: await resolveAuthUid(host)
+    });
+    return imSuccess("im.msg.top.sync", {
+      groupId,
+      total: summary.length,
+      infos: summary,
+      messages
+    });
+  }
+};
+var msgReadSingle = {
+  name: "im.msg.read.single",
+  resource: "msg",
+  method: "msg.read.single",
+  action: "im.msg.read.single",
+  summary: "\u67E5\u8BE2\u5355\u804A\u6D88\u606F\u9605\u8BFB\u72B6\u6001\uFF08msgids=\u81EA\u5DF1\u53D1\u51FA / recvMsgids=\u81EA\u5DF1\u63A5\u6536\uFF09",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    toUid: { type: "string", pattern: "^\\d+$", description: "\u5BF9\u65B9 uid" },
+    toCid: { type: "string", pattern: "^\\d+$", description: "\u5BF9\u65B9 cid" },
+    msgids: { type: "array", items: { type: "string" }, description: "\u81EA\u5DF1\u53D1\u51FA\u7684\u6D88\u606F id\uFF08\u6700\u591A 50\uFF09" },
+    recvMsgids: { type: "array", items: { type: "string" }, description: "\u81EA\u5DF1\u63A5\u6536\u7684\u6D88\u606F id\uFF08\u6700\u591A 50\uFF09" }
+  }, { required: ["toUid", "toCid"], description: "\u67E5\u8BE2\u5355\u804A\u9605\u8BFB\u72B6\u6001\uFF08msgids/recvMsgids \u81F3\u5C11\u5176\u4E00\uFF09" }),
+  handler: async (args, { host }) => {
+    const hasSent = Array.isArray(args.msgids) && args.msgids.length > 0;
+    const hasRecv = Array.isArray(args.recvMsgids) && args.recvMsgids.length > 0;
+    if (!hasSent && !hasRecv) throw imValidationError("msgids_required", "msgids / recvMsgids \u81F3\u5C11\u5176\u4E00");
+    const body = compact({
+      data: {
+        trans_id: 0,
+        user: { cid: String(args.toCid), uid: String(args.toUid) },
+        msgids: hasSent ? args.msgids.map((x) => String(x)) : void 0,
+        recv_msgids: hasRecv ? args.recvMsgids.map((x) => String(x)) : void 0
+      }
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/msg/getSingleMsgReadStatus",
+      body,
+      operation: "im.msg.read.single"
+    });
+    assertImOk(res, "\u67E5\u8BE2\u5355\u804A\u9605\u8BFB\u72B6\u6001");
+    const inner = unwrapInner(res);
+    const datas = inner?.datas || [];
+    const rows = Array.isArray(datas) ? datas.map((d) => ({
+      msgid: str(d.msgid),
+      status: Number(d.status),
+      statusName: Number(d.status) === 1 ? "\u5DF2\u8BFB" : "\u672A\u8BFB",
+      time: formatFullTime(d.time),
+      dev: d.dev
+    })) : [];
+    return imSuccess("im.msg.read.single", { total: rows.length, items: rows });
+  }
+};
+var msgReadGroup = {
+  name: "im.msg.read.group",
+  resource: "msg",
+  method: "msg.read.group",
+  action: "im.msg.read.group",
+  summary: "\u67E5\u8BE2\u7FA4\u6D88\u606F\u9605\u8BFB\u72B6\u6001\u6C47\u603B\uFF08\u6BCF\u6761\u6D88\u606F\u5DF2\u8BFB/\u672A\u8BFB\u60C5\u51B5\uFF0C\u539F\u6837\u8F93\u51FA\uFF09",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    msgids: { type: "array", items: { type: "string" }, description: "\u81EA\u5DF1\u53D1\u51FA\u7684\u6D88\u606F id\uFF08\u6700\u591A 50\uFF09" },
+    recvMsgids: { type: "array", items: { type: "string" }, description: "\u522B\u4EBA\u53D1\u51FA\u7684\u6D88\u606F id\uFF08\u6700\u591A 50\uFF09" }
+  }, { required: ["groupId"], description: "\u67E5\u8BE2\u7FA4\u6D88\u606F\u9605\u8BFB\u72B6\u6001" }),
+  handler: async (args, { host }) => {
+    const hasSent = Array.isArray(args.msgids) && args.msgids.length > 0;
+    const hasRecv = Array.isArray(args.recvMsgids) && args.recvMsgids.length > 0;
+    if (!hasSent && !hasRecv) throw imValidationError("msgids_required", "msgids / recvMsgids \u81F3\u5C11\u5176\u4E00");
+    const body = compact({
+      trans_id: 0,
+      group_id: String(args.groupId),
+      msgids: hasSent ? args.msgids.map((x) => String(x)) : void 0,
+      recv_msgids: hasRecv ? args.recvMsgids.map((x) => String(x)) : void 0
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/msg/getGroupMsgReadStatus",
+      body,
+      operation: "im.msg.read.group"
+    });
+    assertImOk(res, "\u67E5\u8BE2\u7FA4\u9605\u8BFB\u72B6\u6001");
+    const inner = unwrapInner(res);
+    return imSuccess("im.msg.read.group", {
+      groupId: String(args.groupId),
+      raw: Array.isArray(inner) ? inner : inner
+    });
+  }
+};
+var msgReadGroupDetail = {
+  name: "im.msg.read.group.detail",
+  resource: "msg",
+  method: "msg.read.group.detail",
+  action: "im.msg.read.group.detail",
+  summary: "\u7FA4\u6D88\u606F\u9605\u8BFB\u8BE6\u60C5\uFF08unread/read count + \u6BCF\u4EBA\u72B6\u6001\uFF09\uFF0C\u652F\u6301\u5206\u9875",
+  capability: "msg",
+  risk: READ,
+  inputSchema: schemaOf({
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    msgid: { type: "string", pattern: "^\\d+$", description: "\u6D88\u606F id" },
+    pageSize: { type: "integer", minimum: 1, maximum: 100, description: "\u5206\u9875\u5927\u5C0F\uFF08\u9ED8\u8BA4 10\uFF09" },
+    pageNum: { type: "integer", minimum: 1, description: "\u9875\u7801\uFF08\u9ED8\u8BA4 1\uFF09" },
+    ptype: { type: "integer", description: "MsgPageType\uFF08\u5206\u9875\u542F\u7528\u65F6\u6709\u6548\uFF09" }
+  }, { required: ["groupId", "msgid"], description: "\u7FA4\u6D88\u606F\u9605\u8BFB\u8BE6\u60C5" }),
+  handler: async (args, { host }) => {
+    const paging = args.pageSize !== void 0 || args.pageNum !== void 0;
+    const body = compact({
+      trans_id: 0,
+      group_id: String(args.groupId),
+      msgid: String(args.msgid),
+      page: paging ? { size: Number(args.pageSize ?? 10), num: Number(args.pageNum ?? 1) } : void 0,
+      ptype: paging && args.ptype !== void 0 ? Number(args.ptype) : void 0
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/group/syncGroupReadStatus",
+      body,
+      operation: "im.msg.read.group.detail"
+    });
+    assertImOk(res, "\u540C\u6B65\u7FA4\u9605\u8BFB\u8BE6\u60C5");
+    const inner = unwrapInner(res);
+    const personIds = (inner?.datas || []).map((d) => String(d?.user?.uid ?? "")).filter((x) => x && x !== "0");
+    const personMap = await host.resolveUsersByIds([...new Set(personIds)]);
+    const rows = (inner?.datas || []).map((d) => ({
+      name: personMap[str(d.user?.uid)]?.name || str(d.user?.uid),
+      uid: str(d.user?.uid),
+      cid: str(d.user?.cid),
+      status: Number(d.status),
+      statusName: Number(d.status) === 1 ? "\u5DF2\u8BFB" : "\u672A\u8BFB",
+      dev: d.dev,
+      time: formatFullTime(d.time)
+    }));
+    return imSuccess("im.msg.read.group.detail", {
+      groupId: String(args.groupId),
+      msgid: String(args.msgid),
+      unreadCount: inner?.unread_count,
+      readCount: inner?.read_count,
+      endFlag: inner?.end_flag,
+      hasMore: Number(inner?.end_flag) === 1,
+      total: rows.length,
+      items: rows
+    });
+  }
+};
+var msgReadOperations = [
+  msgSyncSingle,
+  msgSyncGroup,
+  msgTopSync,
+  msgReadSingle,
+  msgReadGroup,
+  msgReadGroupDetail
+];
+
+// src/shortcuts/im/operations/msg-write.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function assertLocalFile(pathValue, field) {
+  const abs = resolve(String(pathValue ?? ""));
+  if (!existsSync(abs)) throw imValidationError("file_not_found", `${field} \u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`);
+  return abs;
+}
+function normalizeContent(args) {
+  const txtRaw = args.txt !== void 0 && args.txt !== null ? String(args.txt) : "";
+  const txt = txtRaw.trim() !== "" ? txtRaw : void 0;
+  const imgPath = args.img || args.imgPath ? String(args.img || args.imgPath) : void 0;
+  const filePath = args.file || args.filePath ? String(args.file || args.filePath) : void 0;
+  if (!txt && !imgPath && !filePath) {
+    throw imValidationError("content_required", "txt / img / file \u81F3\u5C11\u63D0\u4F9B\u4E00\u79CD\uFF08\u7A7A\u767D\u6587\u672C\u4E0D\u7B97\u5185\u5BB9\uFF0C\u7981\u6B62\u53D1\u9001\u7A7A\u767D\u6D88\u606F\uFF09");
+  }
+  if (imgPath && filePath) {
+    throw imValidationError("content_conflict", "img \u4E0E file \u4E0D\u80FD\u540C\u65F6\u63D0\u4F9B\uFF08\u4E00\u6B21\u53D1\u4E00\u79CD\u5A92\u4F53\uFF09");
+  }
+  return { txt, imgPath, filePath };
+}
+var sendSinglePair = makeWritePair({
+  action: "im.msg.send.single",
+  async plan(args, env) {
+    const toUid = str(args.toUid);
+    const toCid = str(args.toCid);
+    if (!toUid || !toCid || toUid === "0" || toCid === "0") {
+      throw imValidationError("id_invalid", "toUid/toCid \u5FC5\u987B\u975E 0");
+    }
+    const content = normalizeContent(args);
+    const summary = {
+      action: "\u53D1\u9001\u5355\u804A\u6D88\u606F",
+      toUid,
+      toCid,
+      hasTxt: Boolean(content.txt),
+      hasImg: Boolean(content.imgPath),
+      hasFile: Boolean(content.filePath)
+    };
+    const snapshot = { toUid, toCid };
+    if (content.txt) {
+      snapshot.txt = content.txt;
+      summary.textPreview = content.txt.length > 60 ? `${content.txt.slice(0, 60)}\u2026` : content.txt;
+    }
+    if (content.imgPath) {
+      const abs = assertLocalFile(content.imgPath, "img");
+      snapshot.imgPath = abs;
+      summary.fileName = abs.split(/[\\/]/).pop();
+    }
+    if (content.filePath) {
+      const abs = assertLocalFile(content.filePath, "file");
+      snapshot.filePath = abs;
+      summary.fileName = abs.split(/[\\/]/).pop();
+    }
+    return { summary, snapshot };
+  },
+  async execute(plan, env) {
+    const body = { reciver: { cid: plan.toCid, uid: plan.toUid } };
+    if (plan.txt !== void 0) body.txt = plan.txt;
+    if (plan.imgPath) {
+      const fileObj = await env.host.uploadFile(plan.imgPath, { shareUsers: plan.toUid });
+      body.img = fileObjToImg(fileObj);
+    }
+    if (plan.filePath) {
+      const fileObj = await env.host.uploadFile(plan.filePath, { shareUsers: plan.toUid });
+      body.file = fileObjToFile(fileObj);
+    }
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/send/sendSingleMsg",
+      body,
+      operation: "im.msg.send.single"
+    });
+    assertImOk(res, "\u53D1\u9001\u5355\u804A\u6D88\u606F");
+    return { toUid: plan.toUid, toCid: plan.toCid, sent: true };
+  }
+});
+var sendGroupPair = makeWritePair({
+  action: "im.msg.send.group",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const content = normalizeContent(args);
+    const summary = { action: "\u53D1\u9001\u7FA4\u804A\u6D88\u606F", groupId, hasTxt: Boolean(content.txt), hasImg: Boolean(content.imgPath), hasFile: Boolean(content.filePath) };
+    const snapshot = { groupId };
+    if (content.txt) {
+      snapshot.txt = content.txt;
+      summary.textPreview = content.txt.length > 60 ? `${content.txt.slice(0, 60)}\u2026` : content.txt;
+    }
+    if (content.imgPath) {
+      const abs = assertLocalFile(content.imgPath, "img");
+      snapshot.imgPath = abs;
+      summary.fileName = abs.split(/[\\/]/).pop();
+    }
+    if (content.filePath) {
+      const abs = assertLocalFile(content.filePath, "file");
+      snapshot.filePath = abs;
+      summary.fileName = abs.split(/[\\/]/).pop();
+    }
+    return { summary, snapshot };
+  },
+  async execute(plan, env) {
+    const body = { groupId: plan.groupId };
+    if (plan.txt !== void 0) body.txt = plan.txt;
+    if (plan.imgPath) {
+      const fileObj = await env.host.uploadFile(plan.imgPath, { shareGroups: plan.groupId });
+      body.img = fileObjToImg(fileObj);
+    }
+    if (plan.filePath) {
+      const fileObj = await env.host.uploadFile(plan.filePath, { shareGroups: plan.groupId });
+      body.file = fileObjToFile(fileObj);
+    }
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/send/sendGroupMsg",
+      body,
+      operation: "im.msg.send.group"
+    });
+    assertImOk(res, "\u53D1\u9001\u7FA4\u804A\u6D88\u606F");
+    return { groupId: plan.groupId, sent: true };
+  }
+});
+function findWithdrawTimeOut(value) {
+  if (!value || typeof value !== "object") return null;
+  if (value.time_out !== void 0 && value.time_out !== null && String(value.time_out) !== "") {
+    return String(value.time_out);
+  }
+  for (const key of Object.keys(value)) {
+    const found = findWithdrawTimeOut(value[key]);
+    if (found !== null) return found;
+  }
+  return null;
+}
+function formatWithdrawInterval(seconds) {
+  const total = parseInt(seconds, 10);
+  if (!Number.isFinite(total) || total <= 0) return `${seconds} \u79D2`;
+  if (total < 60) return `${total} \u79D2`;
+  const minutes = Math.floor(total / 60);
+  const rest = total % 60;
+  return rest > 0 ? `${minutes} \u5206\u949F ${rest} \u79D2` : `${minutes} \u5206\u949F`;
+}
+var withdrawPair = makeWritePair({
+  action: "im.msg.withdraw",
+  async plan(args, env) {
+    const type = String(args.type || "single");
+    if (type !== "single" && type !== "group") throw imValidationError("type_invalid", "type \u5FC5\u987B\u662F single \u6216 group");
+    const msgid = str(args.msgid);
+    if (!msgid || msgid === "0") throw imValidationError("id_invalid", "msgid \u5FC5\u987B\u975E 0");
+    const snapshot = { type, msgid };
+    let source;
+    if (type === "single") {
+      const toUid = str(args.toUid);
+      const toCid = str(args.toCid);
+      if (!toUid || !toCid || toUid === "0" || toCid === "0") throw imValidationError("id_invalid", "toUid/toCid \u5FC5\u987B\u975E 0\uFF08\u64A4\u56DE\u5355\u804A\u6D88\u606F\uFF09");
+      snapshot.toUid = toUid;
+      snapshot.toCid = toCid;
+      source = { flag: 0, user: { cid: toCid, uid: toUid } };
+    } else {
+      const groupId = str(args.groupId);
+      if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+      snapshot.groupId = groupId;
+      source = { flag: 1, group_id: groupId };
+    }
+    return {
+      summary: { action: type === "single" ? "\u64A4\u56DE\u5355\u804A\u6D88\u606F" : "\u64A4\u56DE\u7FA4\u804A\u6D88\u606F", msgid, source },
+      snapshot: { ...snapshot, source }
+    };
+  },
+  async execute(plan, env) {
+    const self = await env.host.getSelfIdentity();
+    const name = self.name || self.uid || "\u6211";
+    const withdrawMsg = JSON.stringify({
+      display: "0",
+      dt: [{ txt: { id18n: "103838", kvs: { "%NAME%": name, "%UNAME%": "" }, ot: "1", ou: { c: self.cid, u: self.uid }, v: `${name}\u64A4\u56DE\u4E86\u4E00\u6761\u6D88\u606F` } }],
+      scid: self.cid,
+      suid: self.uid,
+      sname: name,
+      type: "10",
+      ver: "1.0"
+    });
+    const body = {
+      source: plan.source,
+      msgid: plan.msgid,
+      dev: 5,
+      msg: withdrawMsg,
+      title: withdrawMsg,
+      trans_id: String(Math.floor(Date.now() / 1e3)),
+      sensitive_confirm: "0"
+    };
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/msg/makeMsgWithdraw",
+      body,
+      operation: "im.msg.withdraw"
+    });
+    const actCode = Number(res?.data?.actionMsg?.code ?? res?.code ?? -1);
+    const timeOut = findWithdrawTimeOut(res);
+    const interval = timeOut !== null ? formatWithdrawInterval(timeOut) : "";
+    if (actCode === 1505) {
+      throw imValidationError(
+        "withdraw_timeout",
+        `\u64A4\u9500\u8D85\u65F6${interval ? `\uFF08\u64A4\u56DE\u65F6\u9650 ${interval}\uFF09` : "\uFF08\u53D1\u51FA\u8D85\u8FC7\u7EA6 2 \u5206\u949F\uFF09"}\uFF1A\u6D88\u606F\u53D1\u9001\u5DF2\u8D85\u8FC7\u53EF\u64A4\u56DE\u65F6\u9650\uFF0C\u65E0\u6CD5\u64A4\u56DE`,
+        { code: 1505, details: interval ? { withdrawInterval: interval } : void 0 }
+      );
+    }
+    if (actCode === 1506) throw imValidationError("withdraw_not_owner", "\u6D88\u606F\u4E0D\u662F\u81EA\u5DF1\u53D1\u9001\u7684\uFF0C\u65E0\u6CD5\u64A4\u56DE", { code: 1506 });
+    if (actCode === 1507) throw imValidationError("withdraw_edit_timeout", "\u7F16\u8F91\u64A4\u56DE\u8D85\u65F6", { code: 1507 });
+    if (actCode !== 0) throw imValidationError("withdraw_failed", `\u64A4\u56DE\u5931\u8D25\uFF08code=${actCode}\uFF09`, { code: actCode });
+    return {
+      msgid: plan.msgid,
+      withdrawn: true,
+      ...interval ? { withdrawInterval: interval, withdrawIntervalSeconds: Number(timeOut) } : {}
+    };
+  }
+});
+var topSetPair = makeWritePair({
+  action: "im.msg.top.set",
+  async plan(args, env) {
+    const groupId = str(args.groupId);
+    if (!groupId || groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const msgid = str(args.msgid);
+    if (!msgid || msgid === "0") throw imValidationError("id_invalid", "msgid \u5FC5\u987B\u975E 0");
+    let type;
+    if (args.cancel === true) type = 2;
+    else if (args.type !== void 0) {
+      type = Number(args.type);
+      if (type !== 1 && type !== 2) throw imValidationError("type_invalid", "type \u5FC5\u987B\u662F 1\uFF08\u7F6E\u9876\uFF09\u6216 2\uFF08\u53D6\u6D88\u7F6E\u9876\uFF09");
+    } else type = 1;
+    return {
+      summary: { action: type === 1 ? "\u7FA4\u6D88\u606F\u7F6E\u9876" : "\u53D6\u6D88\u7FA4\u6D88\u606F\u7F6E\u9876", groupId, msgid },
+      snapshot: { groupId, msgid, type }
+    };
+  },
+  async execute(plan, env) {
+    const body = { group_id: plan.groupId, type: plan.type, msgid: plan.msgid };
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/msg/setGroupTopMsg",
+      body,
+      operation: "im.msg.top.set"
+    });
+    assertImOk(res, plan.type === 1 ? "\u7F6E\u9876\u6D88\u606F" : "\u53D6\u6D88\u7F6E\u9876");
+    return { groupId: plan.groupId, msgid: plan.msgid, type: plan.type };
+  }
+});
+var dingSendPair = makeWritePair({
+  action: "im.ding.send",
+  async plan(args, env) {
+    const groupId = args.groupId !== void 0 && args.groupId !== "" ? str(args.groupId) : "";
+    const toUid = args.toUid !== void 0 && args.toUid !== "" ? str(args.toUid) : "";
+    const convertMsgid = args.convertMsgid !== void 0 && args.convertMsgid !== "" ? str(args.convertMsgid) : "";
+    if (!groupId && !toUid) throw imValidationError("target_required", "groupId\uFF08\u7FA4\u5FC5\u8FBE\uFF09\u4E0E toUid\uFF08\u5355\u804A\u5FC5\u8FBE\uFF09\u81F3\u5C11\u5176\u4E00");
+    if (groupId && groupId === "0") throw imValidationError("id_invalid", "groupId \u5FC5\u987B\u975E 0");
+    const txtRaw = args.txt !== void 0 && args.txt !== null ? String(args.txt) : "";
+    const txt = txtRaw.trim() !== "" ? txtRaw : "";
+    if (!convertMsgid && !txt) throw imValidationError("content_required", "\u666E\u901A\u5FC5\u8FBE\u9700 txt\uFF1B\u8F6C\u5FC5\u8FBE\u9700 convertMsgid");
+    if (args.unreadOnly === true && !groupId) {
+      throw imValidationError("unread_only_group_only", "unreadOnly \u4EC5\u652F\u6301\u7FA4\u804A\u8F6C\u5FC5\u8FBE\uFF08\u9700\u63D0\u4F9B groupId\uFF09");
+    }
+    if (!groupId && convertMsgid && !str(args.toCid)) {
+      throw imValidationError("to_cid_required", "\u5355\u804A\u8F6C\u5FC5\u8FBE\u9700\u63D0\u4F9B toCid\uFF08\u7528\u4E8E\u6309\u6D88\u606F id \u62C9\u53D6\u6E90\u6D88\u606F\uFF09");
+    }
+    const summary = {
+      action: convertMsgid ? "\u5DF2\u6709\u6D88\u606F\u8F6C\u5FC5\u8FBE" : "\u53D1\u9001\u5FC5\u8FBE\u6D88\u606F",
+      targetType: groupId ? "\u7FA4\u804A" : "\u5355\u804A",
+      ...groupId ? { groupId } : { toUid },
+      ...convertMsgid ? { convertMsgid } : { textPreview: txt.length > 60 ? `${txt.slice(0, 60)}\u2026` : txt },
+      sendMsg: args.sendMsg !== void 0 ? Number(args.sendMsg) : 1,
+      showType: args.showType !== void 0 ? Number(args.showType) : 0
+    };
+    const snapshot = {
+      groupId: groupId || void 0,
+      toUid: toUid || void 0,
+      toCid: args.toCid !== void 0 ? str(args.toCid) : void 0,
+      txt: txt || void 0,
+      convertMsgid: convertMsgid || void 0,
+      unreadOnly: args.unreadOnly === true,
+      toUids: args.toUids !== void 0 ? Array.isArray(args.toUids) ? args.toUids.map((x) => String(x)) : String(args.toUids).split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+      sendMsg: args.sendMsg !== void 0 ? Number(args.sendMsg) : 1,
+      showType: args.showType !== void 0 ? Number(args.showType) : 0,
+      removeFailed: args.removeFailed === true
+    };
+    if (groupId) {
+      const self = await env.host.getSelfIdentity();
+      const myUid = self.uid || (await env.host.getSession()).userId;
+      const requested = Array.isArray(snapshot.toUids) ? [...new Set(snapshot.toUids.map((x) => String(x)))] : [];
+      const groupUsers2 = [];
+      let receiverSource = "\u5168\u4F53\u6210\u5458";
+      if (requested.length) {
+        receiverSource = "\u6307\u5B9A\u4EBA\u5458";
+        const map = await env.host.resolveUsersByIds(requested);
+        const failed = requested.filter((uid) => !map[uid]?.cid || map[uid].cid === "0");
+        if (failed.length && snapshot.removeFailed !== true) {
+          throw imValidationError(
+            "members_resolve_failed",
+            `\u6307\u5B9A\u63A5\u6536\u4EBA\u4FE1\u606F\u83B7\u53D6\u5931\u8D25\uFF08cid \u7F3A\u5931\u6216\u4E3A 0\uFF09\uFF1A${failed.map((uid) => map[uid]?.name || uid).join("\u3001")}\uFF1B\u786E\u8BA4\u8DF3\u8FC7\u8BF7\u4F20 removeFailed:true`,
+            { details: failed }
+          );
+        }
+        for (const uid of requested) {
+          const cid = map[uid]?.cid;
+          if (!cid || cid === "0" || uid === myUid) continue;
+          groupUsers2.push({ cid, uid });
+        }
+      } else if (snapshot.unreadOnly === true) {
+        receiverSource = "\u4EC5\u672A\u8BFB\u4EBA\u5458";
+        const readRes = await env.host.request({
+          method: "POST",
+          path: "/api/em/msg/executeIm/group/syncGroupReadStatus",
+          body: { trans_id: 0, group_id: groupId, msgid: convertMsgid || "0" },
+          operation: "im.ding.send.unread"
+        });
+        const readDatas = readRes?.data?.data?.datas || [];
+        const unread = readDatas.filter((d) => Number(d.status) === 0);
+        const uidArr = [
+          ...new Set(unread.map((d) => String(d?.user?.uid)).filter((uid) => Boolean(uid) && uid !== myUid))
+        ];
+        if (uidArr.length === 0) {
+          throw imValidationError(
+            "unread_empty",
+            "\u7FA4\u5185\u6CA1\u6709\u672A\u8BFB\u4EBA\u5458\uFF08unreadOnly=true \u4E0D\u81EA\u52A8\u56DE\u9000\u5168\u5458\uFF09\uFF1A\u8BF7\u786E\u8BA4\u6539\u53D1\u5168\u4F53\u6210\u5458\u3001\u6307\u5B9A\u4EBA\u5458\uFF0C\u6216\u653E\u5F03\u53D1\u9001"
+          );
+        }
+        const map = await env.host.resolveUsersByIds(uidArr);
+        for (const uid of uidArr) {
+          const cid = map[uid]?.cid;
+          if (cid && cid !== "0") groupUsers2.push({ cid, uid });
+        }
+      } else {
+        const memRes = await env.host.request({
+          method: "POST",
+          path: "/api/em/msg/executeIm/group/getGroupUsers",
+          body: { group_id: groupId, type: 0, sync_type: 0, member_mask: 6, client_uc: "0" },
+          operation: "im.ding.send.members"
+        });
+        const uidArr = [...new Set(extractGroupMembers(memRes?.data?.data).map((m) => String(m?.uid)).filter((uid) => uid && uid !== myUid))];
+        const map = await env.host.resolveUsersByIds(uidArr);
+        for (const uid of uidArr) {
+          const cid = map[uid]?.cid;
+          if (cid && cid !== "0") groupUsers2.push({ cid, uid });
+        }
+      }
+      if (groupUsers2.length === 0) {
+        throw imValidationError("members_empty", "\u7FA4\u5185\u6CA1\u6709\u53EF\u63A5\u6536\u5FC5\u8FBE\u6D88\u606F\u7684\u6210\u5458\uFF08\u5DF2\u6392\u9664\u672C\u4EBA\uFF1B\u6307\u5B9A/\u672A\u8BFB\u4EBA\u5458\u53EF\u80FD\u4E3A\u7A7A\uFF09");
+      }
+      snapshot.groupUsers = groupUsers2;
+      snapshot.receiveUserIds = groupUsers2.map((u) => u.uid).join(",");
+      summary.receiverSource = receiverSource;
+      summary.receiverCount = groupUsers2.length;
+    } else {
+      summary.receiverSource = "\u5355\u804A\u5BF9\u65B9";
+      summary.receiverCount = 1;
+    }
+    return { summary, snapshot };
+  },
+  async execute(plan, env) {
+    const self = await env.host.getSelfIdentity();
+    const session = await env.host.getSession();
+    const myUid = self.uid || session.userId;
+    const myCid = self.cid;
+    const myName = self.name || myUid;
+    let receiveUserIds = "";
+    let targetType;
+    let targetId = "";
+    let mkind;
+    let msgEntity;
+    let msgTitle;
+    let groupUsers2;
+    let fileIds = "";
+    let extraInfo = "";
+    let content = "";
+    if (plan.convertMsgid) {
+      const sourceReq = plan.groupId ? { trans_id: 0, dev: 4, type: 0, enc_type: 0, datas: [{ group_id: plan.groupId, start: plan.convertMsgid, end: "0", max_num: 1 }] } : { trans_id: 0, dev: 4, enc_type: 0, datas: [{ from_cid: plan.toCid, from_uid: plan.toUid, start: plan.convertMsgid, end: "0", max_num: 1 }] };
+      const sourcePath = plan.groupId ? "/api/em/msg/executeIm/chat/syncGroupMsg" : "/api/em/msg/executeIm/msg/syncSingleMsg";
+      const srcRes = await env.host.request({ method: "POST", path: sourcePath, body: sourceReq, operation: "im.ding.send.source" });
+      const srcMsg = srcRes?.data?.data?.datas?.[0]?.datas?.[0] ?? srcRes?.data?.data?.datas?.[0];
+      if (!srcMsg?.msg) throw imValidationError("source_not_found", `\u672A\u627E\u5230\u6E90\u6D88\u606F ${plan.convertMsgid}`);
+      let msgObj;
+      try {
+        msgObj = typeof srcMsg.msg === "string" ? JSON.parse(srcMsg.msg) : srcMsg.msg;
+      } catch {
+        throw imValidationError("source_invalid", "\u6E90\u6D88\u606F\u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+      }
+      const mtype = Number(msgObj.type ?? 0);
+      let tag;
+      let titleDt;
+      const nm = msgObj.dt?.[0]?.file?.nm || msgObj.dt?.[0]?.img?.nm || msgObj.dt?.[0]?.media?.nm || "";
+      if (mtype === 4) {
+        tag = "2";
+        content = `[\u6587\u4EF6]${nm}`;
+        mkind = 512;
+        titleDt = [{ txt: { v: nm } }];
+        fileIds = String(msgObj.dt?.[0]?.file?.id || "");
+      } else if (mtype === 2) {
+        tag = "0";
+        content = "[\u56FE\u7247]";
+        mkind = 64;
+        titleDt = [];
+        fileIds = String(msgObj.dt?.[0]?.img?.src || msgObj.dt?.[0]?.img?.id || "");
+      } else if (mtype === 7) {
+        tag = "1";
+        content = "[\u89C6\u9891]";
+        mkind = 2048;
+        titleDt = [];
+        fileIds = String(msgObj.dt?.[0]?.media?.src || msgObj.dt?.[0]?.media?.id || "");
+      } else {
+        tag = "3";
+        content = msgObj.dt?.[0]?.txt?.v || "";
+        mkind = 1;
+        titleDt = [{ txt: { v: content } }];
+      }
+      msgEntity = JSON.stringify({ ...msgObj, tf: "1" });
+      msgTitle = JSON.stringify({ sname: myName, suid: myUid, scid: myCid, display: "0", type: String(mtype), dt: titleDt, vv: "", des: "", tf: "1" });
+      extraInfo = JSON.stringify({ msgSource: { source: { tag, msgid: String(plan.convertMsgid), flag: plan.groupId ? 1 : 0, ...plan.groupId ? { group_id: plan.groupId } : { user: { cid: plan.toCid, uid: plan.toUid } } } } });
+    } else {
+      content = plan.txt;
+      mkind = 1;
+      msgEntity = JSON.stringify({
+        ver: "1.0",
+        dev: 5,
+        guid: "0",
+        cnt: "0",
+        idx: "0",
+        sname: myName,
+        suid: myUid,
+        scid: myCid,
+        display: "",
+        sysId: "",
+        weaOaId: "",
+        bgc: "",
+        type: "1",
+        dt: [{ txt: { v: plan.txt, next: "0", ft: "china" } }],
+        tf: "1"
+      });
+      msgTitle = JSON.stringify({ sname: myName, suid: myUid, scid: myCid, display: "0", type: "1", dt: [{ txt: { v: plan.txt, next: "0", ft: "china" } }], vv: "", des: "", tf: "1" });
+    }
+    if (plan.groupId) {
+      targetType = 2;
+      targetId = plan.groupId;
+      groupUsers2 = Array.isArray(plan.groupUsers) ? plan.groupUsers : [];
+      receiveUserIds = str(plan.receiveUserIds) || groupUsers2.map((u) => u.uid).join(",");
+      if (!receiveUserIds) throw imValidationError("members_empty", "\u7FA4\u5185\u6CA1\u6709\u53EF\u63A5\u6536\u5FC5\u8FBE\u6D88\u606F\u7684\u6210\u5458");
+    } else {
+      targetType = 1;
+      const toUid = plan.toUid;
+      targetId = `${myUid}|${toUid}`;
+      receiveUserIds = toUid;
+    }
+    const body = compact({
+      content,
+      receiveUserIds,
+      fileIds,
+      sendMsg: plan.sendMsg,
+      showType: plan.showType,
+      mkind,
+      msgEntity,
+      msgTitle,
+      targetType,
+      targetId,
+      groupUsers: groupUsers2,
+      extraInfo: extraInfo || void 0
+    });
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/createDing",
+      body,
+      operation: "im.ding.send"
+    });
+    const code = Number(res?.code ?? -1);
+    if (code !== 200 || !res?.status) {
+      throw imValidationError("ding_failed", `\u5FC5\u8FBE\u53D1\u9001\u5931\u8D25\uFF1Acode=${code} msg=${res?.msg ?? ""}`, { code });
+    }
+    return { id: str(res?.data?.id ?? ""), msg: res?.data?.msg ?? "" };
+  }
+});
+function buildMsgWriteDefinition(name, method, summary, inputProps, pair) {
+  const requiredInput = Object.keys(inputProps).filter((k) => {
+    const prop = inputProps[k];
+    return prop?.required === true;
+  });
+  return [
+    {
+      name: `${name}.prepare`,
+      resource: "msg",
+      method: `${method}.prepare`,
+      action: `${name}.prepare`,
+      summary: `${summary}\uFF08prepare\uFF1A\u53EA\u8BFB\u6821\u9A8C + \u5DEE\u5F02\u6458\u8981 + \u7B7E\u53D1\u786E\u8BA4\uFF09`,
+      capability: "msg",
+      risk: "read-before-write",
+      requiresConfirmation: true,
+      inputSchema: schemaOf(inputProps, { required: requiredInput, description: summary }),
+      handler: pair.prepare
+    },
+    {
+      name: `${name}.apply`,
+      resource: "msg",
+      method: `${method}.apply`,
+      action: `${name}.apply`,
+      summary: `${summary}\uFF08apply\uFF1A\u9700 confirm:true + continuation\uFF09`,
+      capability: "msg",
+      risk: "high-risk-write",
+      requiresConfirmation: true,
+      inputSchema: schemaOf({
+        confirm: { type: "boolean", description: "\u5FC5\u987B\u4E3A true" },
+        continuation: { type: "string", minLength: 1 }
+      }, { required: ["confirm", "continuation"], description: summary }),
+      handler: pair.apply
+    }
+  ];
+}
+var msgWriteOps = [
+  ...buildMsgWriteDefinition("im.msg.send.single", "msg.send.single", "\u53D1\u9001\u5355\u804A\u6D88\u606F\uFF08\u6587\u672C/\u56FE\u7247/\u6587\u4EF6\uFF09", {
+    toUid: { type: "string", pattern: "^\\d+$", description: "\u63A5\u6536\u4EBA uid" },
+    toCid: { type: "string", pattern: "^\\d+$", description: "\u63A5\u6536\u4EBA cid" },
+    txt: { type: "string", description: "\u6587\u672C\u5185\u5BB9" },
+    img: { type: "string", description: "\u672C\u5730\u56FE\u7247\u8DEF\u5F84\uFF08\u53D1\u9001\u524D\u4F1A\u4E0A\u4F20\u5230 E10 \u6587\u4EF6\u670D\u52A1\uFF09" },
+    file: { type: "string", description: "\u672C\u5730\u6587\u4EF6\u8DEF\u5F84" }
+  }, sendSinglePair),
+  ...buildMsgWriteDefinition("im.msg.send.group", "msg.send.group", "\u53D1\u9001\u7FA4\u804A\u6D88\u606F\uFF08\u6587\u672C/\u56FE\u7247/\u6587\u4EF6\uFF09", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    txt: { type: "string", description: "\u6587\u672C\u5185\u5BB9" },
+    img: { type: "string", description: "\u672C\u5730\u56FE\u7247\u8DEF\u5F84" },
+    file: { type: "string", description: "\u672C\u5730\u6587\u4EF6\u8DEF\u5F84" }
+  }, sendGroupPair),
+  ...buildMsgWriteDefinition("im.msg.withdraw", "msg.withdraw", "\u64A4\u56DE\u6D88\u606F\uFF08\u5355\u804A/\u7FA4\u804A\uFF0C\u9650\u672C\u4EBA 2 \u5206\u949F\u5185\uFF09", {
+    type: { type: "string", enum: ["single", "group"], description: "single \u6216 group" },
+    msgid: { type: "string", pattern: "^\\d+$", description: "\u6D88\u606F id\uFF08ser_msgid\uFF09" },
+    toUid: { type: "string", pattern: "^\\d+$", description: "\u5355\u804A\uFF1A\u5BF9\u65B9 uid" },
+    toCid: { type: "string", pattern: "^\\d+$", description: "\u5355\u804A\uFF1A\u5BF9\u65B9 cid" },
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4\u804A\uFF1A\u7FA4 id" }
+  }, withdrawPair),
+  ...buildMsgWriteDefinition("im.msg.top.set", "msg.top.set", "\u7FA4\u6D88\u606F\u7F6E\u9876 / \u53D6\u6D88\u7F6E\u9876", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4 id" },
+    msgid: { type: "string", pattern: "^\\d+$", description: "\u76EE\u6807\u6D88\u606F id" },
+    type: { type: "integer", enum: [1, 2], description: "1 \u7F6E\u9876 / 2 \u53D6\u6D88" },
+    cancel: { type: "boolean", description: "\u7B49\u4EF7 type=2" }
+  }, topSetPair),
+  ...buildMsgWriteDefinition("im.ding.send", "ding.send", "\u53D1\u9001\u5FC5\u8FBE\u6D88\u606F / \u5DF2\u6709\u6D88\u606F\u8F6C\u5FC5\u8FBE\uFF08createDing\uFF09", {
+    groupId: { type: "string", pattern: "^\\d+$", description: "\u7FA4\u573A\u666F\u7FA4 id" },
+    toUid: { type: "string", pattern: "^\\d+$", description: "\u5355\u804A\u573A\u666F\u5BF9\u65B9 uid" },
+    toCid: { type: "string", pattern: "^\\d+$", description: "\u5355\u804A\u8F6C\u5FC5\u8FBE\u5BF9\u65B9 cid" },
+    txt: { type: "string", description: "\u666E\u901A\u5FC5\u8FBE\u6587\u672C" },
+    convertMsgid: { type: "string", pattern: "^\\d+$", description: "\u8F6C\u5FC5\u8FBE\u6E90\u6D88\u606F id" },
+    unreadOnly: { type: "boolean", description: "\u7FA4\u8F6C\u5FC5\u8FBE\u4EC5\u53D1\u7ED9\u672A\u8BFB\u4EBA\u5458" },
+    toUids: { type: "array", items: { type: "string" }, description: "\u6307\u5B9A\u63A5\u6536\u4EBA uid" },
+    sendMsg: { type: "integer", enum: [0, 1], description: "\u53D1\u77ED\u4FE1\uFF08\u9ED8\u8BA4 1 \u53D1\uFF09" },
+    showType: { type: "integer", enum: [0, 1], description: "0 \u5168\u4F53\u53EF\u89C1\uFF08\u9ED8\u8BA4\uFF09/1 \u4EC5\u53D1\u9001\u4EBA\u53EF\u89C1" }
+  }, dingSendPair)
+];
+var msgWriteOperations = msgWriteOps;
+
+// src/shortcuts/im/operations/session.ts
+var MAX_MSG_ID2 = String((1n << 63n) - 1n);
+var SESSION_DEFAULT_PAGE_SIZE = 20;
+function sessionTypeName(type) {
+  if ([1, 6, 9].includes(type)) return "\u5355\u804A";
+  if ([2, 3, 7, 11].includes(type)) return "\u7FA4\u804A";
+  if ([4, 10].includes(type)) return "\u7CFB\u7EDF";
+  return "\u5176\u5B83";
+}
+var sessionList = {
+  name: "im.session.list",
+  resource: "session",
+  method: "session.list",
+  action: "im.session.list",
+  summary: "\u62C9\u53D6\u5F53\u524D\u7528\u6237\u4F1A\u8BDD\u5217\u8868\uFF08\u5355\u804A/\u7FA4\u804A/\u7CFB\u7EDF\u6D88\u606F\uFF0C\u89E3\u6790\u540D\u79F0\u4E0E\u526F\u6807\u9898\uFF09",
+  capability: "session",
+  risk: READ,
+  inputSchema: schemaOf({
+    num: { type: "integer", minimum: 1, maximum: 50, description: "\u5355\u9875\u6761\u6570\uFF08\u9ED8\u8BA4 20\uFF09" },
+    msgid: { type: "string", description: "\u951A\u70B9\u6D88\u606F id\uFF08\u9ED8\u8BA4 int64 max \u4ECE\u6700\u65B0\uFF09" },
+    flag: { type: "integer", enum: [0, 1, 2], description: "0 up+down / 1 up / 2 down\uFF08\u9ED8\u8BA4 2\uFF09" },
+    type: { type: "integer", description: "\u4EC5\u5C55\u793A\u8BE5 session_type" },
+    around: { type: "boolean", description: "\u9644\u8FD1\u8BED\u4E49\uFF08flag=0 \u4E14 up/down \u5404\u534A\uFF09" }
+  }, { description: "\u62C9\u53D6\u4F1A\u8BDD\u5217\u8868" }),
+  handler: async (args, { host }) => {
+    const num = Math.min(toUint(args.num, "num") ?? SESSION_DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+    const flag = args.flag !== void 0 ? Number(args.flag) : 2;
+    const around = args.around === true;
+    const curAnchor = args.msgid !== void 0 && args.msgid !== "" ? String(args.msgid) : MAX_MSG_ID2;
+    const isNewestAnchor = curAnchor === MAX_MSG_ID2;
+    const splitUpDown = around || flag === 0 && !isNewestAnchor;
+    const half = Math.floor(num / 2);
+    const downSize = splitUpDown ? Math.max(half, 1) : num;
+    const upSize = splitUpDown ? Math.max(num - half, 1) : num;
+    const body = {
+      msgid: curAnchor,
+      flag,
+      view: 0,
+      sview: 0,
+      reminder: 0,
+      top: 1
+    };
+    if (flag !== 2) body.up = { page_size: upSize, msgid: "0" };
+    if (flag !== 1) body.down = { page_size: downSize, msgid: "0" };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/data/getSessionContext",
+      body,
+      operation: "im.session.list"
+    });
+    assertImOk(res, "\u62C9\u53D6\u4F1A\u8BDD\u5217\u8868");
+    const inner = unwrapInner(res);
+    const sessions = [...inner?.down_datas || [], ...inner?.up_datas || []];
+    const singleTargets = /* @__PURE__ */ new Map();
+    const groupIds = /* @__PURE__ */ new Set();
+    const sysGroupIds = /* @__PURE__ */ new Set();
+    for (const s of sessions) {
+      const type = Number(s?.session_type ?? -1);
+      if ([1, 6, 9].includes(type) && s?.fuser?.uid) {
+        singleTargets.set(String(s.fuser.uid), { cid: str(s.fuser.cid), uid: str(s.fuser.uid) });
+      } else if ([2, 3, 7, 11].includes(type) && s?.group_id) {
+        groupIds.add(String(s.group_id));
+      } else if ([4, 10].includes(type) && s?.group) {
+        sysGroupIds.add(Number(s.group));
+      }
+    }
+    const [personMap, groupRes] = await Promise.all([
+      host.resolveUsersByIds([...singleTargets.keys()]),
+      groupIds.size ? host.request({ method: "POST", path: "/api/em/msg/executeIm/group/queryGroupInfo", body: { trans_id: 0, type: 0, mask: 0, group_id: [...groupIds], flag: 0 }, operation: "im.session.list.groups" }) : Promise.resolve(null)
+    ]);
+    const groupInfoMap = /* @__PURE__ */ new Map();
+    if (groupRes) {
+      const gi = unwrapInner(groupRes)?.datas || [];
+      for (const g of gi) if (g?.name) groupInfoMap.set(str(g.group_id ?? g.id), g.name);
+    }
+    const sysNameMap = /* @__PURE__ */ new Map();
+    if (sysGroupIds.size) {
+      const sysRes = await host.request({
+        method: "POST",
+        path: "/api/em/msg/executeIm/system-msg/syncGroupType",
+        body: { gids: [...sysGroupIds], tids: [], lang: "zh_CN", showdel: 1 },
+        operation: "im.session.list.sysgroups"
+      });
+      const sg = unwrapInner(sysRes)?.groups || [];
+      for (const g of sg) if (g?.groupName) sysNameMap.set(Number(g.groupId), g.groupName);
+    }
+    const rows = [];
+    for (const s of sessions) {
+      const type = Number(s?.session_type ?? -1);
+      const typeName = sessionTypeName(type);
+      let name = "";
+      if ([1, 6, 9].includes(type)) {
+        const target = singleTargets.get(str(s?.fuser?.uid));
+        name = target ? personMap[target.uid]?.name || target.uid : str(s?.name || s?.title || "");
+      } else if ([2, 3, 7, 11].includes(type)) {
+        name = groupInfoMap.get(str(s?.group_id)) || str(s?.group_id);
+      } else if ([4, 10].includes(type)) {
+        name = sysNameMap.get(Number(s?.group)) || str(s?.group);
+      } else {
+        name = str(s?.name || s?.title || "");
+      }
+      const unread = s?.unread_count ?? s?.unread ?? 0;
+      const dontDisturb = Number(s?.reminder ?? s?.reminder_type ?? 0) === 1;
+      const titleRaw = s?.title;
+      const titleObj = typeof titleRaw === "string" ? parseMsg(titleRaw) : titleRaw && typeof titleRaw === "object" ? titleRaw : null;
+      let subtitleSender = "";
+      let subtitleContent = "";
+      let subtitleMedia = "";
+      if (titleObj) {
+        const parsed = parseContent(titleObj, { i18nMap: {}, nameMap: {} });
+        const sname = str(titleObj.sname);
+        if (sname) subtitleSender = sname;
+        else if (titleObj.scid || titleObj.suid) {
+          const hit = await host.resolveUsersByIds([str(titleObj.suid)]);
+          subtitleSender = hit[str(titleObj.suid)]?.name || str(titleObj.suid);
+        }
+        const imgs = extractImgs(titleObj);
+        const videos = extractVideos(titleObj);
+        const files = extractFiles(titleObj);
+        if (imgs.length) subtitleMedia = `[\u56FE\u7247]${imgs[0].name}`;
+        else if (videos.length) subtitleMedia = `[\u89C6\u9891]${videos[0].name}`;
+        else if (files.length) subtitleMedia = `[\u6587\u4EF6]${files[0].name}`;
+        const mustFlag = Number(titleObj.tf ?? 0) & 1;
+        const prefix = mustFlag ? "[\u5FC5\u8FBE]" : "";
+        subtitleContent = subtitleMedia ? `${prefix}${subtitleMedia}` : `${prefix}${collapseNewlines(parsed.content)}`;
+      } else {
+        subtitleContent = collapseNewlines(String(titleRaw ?? ""));
+      }
+      const subtitle = subtitleSender ? `${subtitleSender}\uFF1A${subtitleContent}` : subtitleContent;
+      rows.push({
+        sessionId: str(s?.session_id ?? s?.id ?? ""),
+        sessionType: type,
+        sessionTypeName: typeName,
+        name,
+        unread: Number(unread),
+        dontDisturb,
+        unreadLabel: Number(unread) > 0 ? dontDisturb ? `${unread}\uFF08\u514D\u6253\u6270\uFF09` : String(unread) : "",
+        time: formatFullTime(s?.update_tm ?? s?.update_time ?? s?.last_time ?? s?.create),
+        subtitle,
+        lastMsgid: str(s?.last_msgid ?? "")
+      });
+    }
+    rows.sort((a, b) => BigInt(a.lastMsgid || "0") < BigInt(b.lastMsgid || "0") ? 1 : -1);
+    const filterType = args.type !== void 0 ? Number(args.type) : void 0;
+    const filtered = filterType !== void 0 ? rows.filter((r) => r.sessionType === filterType) : rows;
+    const minLast = filtered.length ? filtered[filtered.length - 1].lastMsgid : "";
+    return imSuccess("im.session.list", {
+      total: filtered.length,
+      sessions: filtered,
+      nextMsgid: minLast && BigInt(minLast) > 0n ? minLast : void 0,
+      hasMore: filtered.length > 0,
+      pageSize: num
+    });
+  }
+};
+var sysmsgGroupSearch = {
+  name: "im.sysmsg.groupSearch",
+  resource: "sysmsg",
+  method: "sysmsg.groupSearch",
+  action: "im.sysmsg.groupSearch",
+  summary: "\u6309\u540D\u79F0\u641C\u7D22\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4/\u7C7B\u578B\u914D\u7F6E\uFF08\u4F9B querySysMsgInfo \u4F7F\u7528\uFF09",
+  capability: "sysmsg",
+  risk: READ,
+  inputSchema: schemaOf({
+    name: { type: "string", minLength: 1, description: "\u5206\u7EC4/\u7C7B\u578B\u540D\u79F0\uFF08\u6A21\u7CCA\uFF09" },
+    type: { type: "integer", enum: [0, 1], description: "0 \u641C group\uFF08\u9ED8\u8BA4\uFF09/1 \u641C type" }
+  }, { required: ["name"], description: "\u641C\u7D22\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4\u914D\u7F6E" }),
+  handler: async (args, { host }) => {
+    const body = {
+      data: {
+        cond: { mask: 1, groupName: String(args.name) },
+        lang: "zh_CN",
+        page: { current: 1, pageSize: 30 },
+        type: Number(args.type ?? 0),
+        order: 0
+      }
+    };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/system-msg/searchSysMsgGroup",
+      body,
+      operation: "im.sysmsg.groupSearch"
+    });
+    assertImOk(res, "\u641C\u7D22\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4");
+    const inner = unwrapInner(res);
+    const groups = (inner?.groups || []).map((g) => ({
+      groupId: g.groupId,
+      groupName: g.groupName,
+      typesIds: g.typesIds || [],
+      i18nName: g.i18nName,
+      enable: g.enable,
+      state: g.state
+    }));
+    const types = (inner?.types || []).map((t) => ({
+      typeId: t.typeId,
+      typeName: t.typeName,
+      i18nName: t.i18nName,
+      state: t.state
+    }));
+    return imSuccess("im.sysmsg.groupSearch", { groups, types, total: Math.max(groups.length, types.length) });
+  }
+};
+var sysmsgTypeSync = {
+  name: "im.sysmsg.typeSync",
+  resource: "sysmsg",
+  method: "sysmsg.typeSync",
+  action: "im.sysmsg.typeSync",
+  summary: "\u6309 gids/tids \u62C9\u53D6\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4/\u7C7B\u578B\u914D\u7F6E",
+  capability: "sysmsg",
+  risk: READ,
+  inputSchema: schemaOf({
+    gids: { type: "array", items: { type: "integer" }, description: "\u7CFB\u7EDF\u5206\u7EC4 id\uFF08\u4E0E tids \u81F3\u5C11\u5176\u4E00\uFF09" },
+    tids: { type: "array", items: { type: "integer" }, description: "\u6D88\u606F\u7C7B\u578B id" }
+  }, { description: "gids / tids \u81F3\u5C11\u5176\u4E00" }),
+  handler: async (args, { host }) => {
+    const gids = Array.isArray(args.gids) ? args.gids.map((x) => Number(x)).filter((n) => Number.isInteger(n)) : [];
+    const tids = Array.isArray(args.tids) ? args.tids.map((x) => Number(x)).filter((n) => Number.isInteger(n)) : [];
+    if (!gids.length && !tids.length) throw imValidationError("target_required", "gids \u4E0E tids \u81F3\u5C11\u5176\u4E00");
+    const body = { gids, tids, lang: "zh_CN", showdel: 1 };
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/system-msg/syncGroupType",
+      body,
+      operation: "im.sysmsg.typeSync"
+    });
+    assertImOk(res, "\u540C\u6B65\u7CFB\u7EDF\u6D88\u606F\u914D\u7F6E");
+    const inner = unwrapInner(res);
+    const groups = (inner?.groups || []).map((g) => ({
+      groupId: g.groupId,
+      groupName: g.groupName,
+      typesIds: g.typesIds || [],
+      i18nName: g.i18nName,
+      enable: g.enable,
+      state: g.state,
+      sunread: g.sunread
+    }));
+    const types = (inner?.types || []).map((t) => ({
+      typeId: t.typeId,
+      typeName: t.typeName,
+      i18nName: t.i18nName,
+      state: t.state
+    }));
+    return imSuccess("im.sysmsg.typeSync", { groups, types });
+  }
+};
+var sysmsgQuery = {
+  name: "im.sysmsg.query",
+  resource: "sysmsg",
+  method: "sysmsg.query",
+  action: "im.sysmsg.query",
+  summary: "\u62C9\u53D6\u7CFB\u7EDF\u6D88\u606F\uFF08\u6D41\u7A0B/\u4EFB\u52A1/\u516C\u6587\u7B49\uFF09\uFF0C\u652F\u6301\u9605\u8BFB\u7EF4\u5EA6/\u5904\u7406\u72B6\u6001/\u65F6\u95F4\u8303\u56F4\uFF0C\u9ED8\u8BA4\u5F53\u5929\u4E14\u6709\u754C\u533A\u95F4\u81EA\u52A8\u7FFB\u9875\u62C9\u5B8C",
+  capability: "sysmsg",
+  risk: READ,
+  inputSchema: schemaOf({
+    group: { type: "integer", minimum: 1, description: "\u7CFB\u7EDF\u5206\u7EC4 id" },
+    type: { type: "integer", description: "\u6D88\u606F\u7C7B\u578B id" },
+    num: { type: "integer", minimum: 1, maximum: 50, description: "\u6BCF\u9875\u6761\u6570\uFF08\u9ED8\u8BA4 50\uFF0C\u6700\u591A 50\uFF09" },
+    flag: { type: "integer", enum: [0, 1, 2], description: "0 \u4E0D\u5206(\u9ED8\u8BA4)/1 \u5DF2\u8BFB/2 \u672A\u8BFB" },
+    deal: { type: "integer", enum: [0, 1, 2], description: "0 \u5168\u90E8(\u9ED8\u8BA4)/1 \u672A\u5904\u7406/2 \u5DF2\u5904\u7406" },
+    from: { type: "string", description: "\u8D77\u59CB\u65F6\u95F4\uFF1B\u8DE8\u5EA6 > 7 \u5929\u81EA\u52A8\u6536\u655B\u4E3A\u8BE5\u8303\u56F4\u6700\u540E 7 \u5929" },
+    to: { type: "string", description: "\u7ED3\u675F\u65F6\u95F4\uFF08\u540C\u4E0A\uFF09" },
+    latest: { type: "boolean", description: "\u62C9\u6700\u65B0\u4E0D\u9650\u65E5\u671F\uFF08\u65E0\u754C\u533A\u95F4\uFF0C\u53EA\u62C9\u4E00\u9875\uFF09" },
+    start: { type: "string", description: "\u624B\u52A8\u8D77\u59CB\u6D88\u606F id\uFF08\u6700\u9AD8\u4F18\u5148\uFF09" },
+    end: { type: "string", description: "\u624B\u52A8\u7ED3\u675F\u6D88\u606F id" }
+  }, { required: ["group"], description: "\u62C9\u53D6\u7CFB\u7EDF\u6D88\u606F" }),
+  handler: async (args, { host }) => {
+    const group = toUint(args.group, "group");
+    if (group === void 0 || group <= 0) {
+      throw imValidationError("group_required", "group\uFF08\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4 id\uFF0C\u6765\u81EA sysmsg.groupSearch \u6216\u4F1A\u8BDD\u5217\u8868\uFF09\u5FC5\u586B\u4E14\u4E3A\u6B63\u6574\u6570");
+    }
+    const hasType = args.type !== void 0 && args.type !== null && args.type !== "";
+    const msgType = { group };
+    if (hasType) msgType.type = toUint(args.type, "type");
+    let start = MAX_MSG_ID2;
+    let end = "0";
+    let scope = "today";
+    let shrink = null;
+    if (args.start !== void 0 && args.start !== null && args.start !== "") {
+      start = String(args.start);
+      end = args.end !== void 0 && args.end !== "" ? String(args.end) : "0";
+      scope = "explicit-id";
+    } else if (args.latest === true) {
+      scope = "latest";
+    } else if (args.from || args.to) {
+      const clamp = clampTimeRangeTo7Days(parseTimeToSec(args.from, false), parseTimeToSec(args.to, true));
+      if (clamp.toSec > 0) start = makeMinMaxIdByTm(clamp.toSec).max;
+      if (clamp.fromSec > 0) end = makeMinMaxIdByTm(clamp.fromSec).min;
+      shrink = clamp.shrunk ? clamp : null;
+      scope = "range";
+    } else {
+      const range = todayRange();
+      start = makeMinMaxIdByTm(range.toSec).max;
+      end = makeMinMaxIdByTm(range.fromSec).min;
+    }
+    const num = Math.min(toUint(args.num, "num") ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+    const autoLoop = end !== "0";
+    const pulled = await pullPaged({
+      num,
+      start,
+      end,
+      autoLoop,
+      requestOnePage: async (pageStart, pageEnd, maxNum) => {
+        const body = {
+          trans_id: 0,
+          dev: 4,
+          enc_type: 0,
+          flag: Number(args.flag ?? 0),
+          deal_status: Number(args.deal ?? 0),
+          datas: [{ msg_type: msgType, max_num: maxNum, start: pageStart, end: pageEnd }]
+        };
+        const res = await host.request({
+          method: "POST",
+          path: "/api/em/msg/executeIm/system-msg/querySysMsgInfo",
+          body,
+          operation: "im.sysmsg.query"
+        });
+        assertImOk(res, "\u62C9\u53D6\u7CFB\u7EDF\u6D88\u606F");
+        const inner = unwrapInner(res);
+        return Array.isArray(inner?.datas) ? inner.datas : [];
+      }
+    });
+    const rawRows = pulled.rows;
+    let dealMode = false;
+    try {
+      const cfgRes = await host.request({
+        method: "POST",
+        path: "/api/em/msg/executeIm/system-msg/syncGroupType",
+        body: { gids: [group], tids: [], lang: "zh_CN", showdel: 1 },
+        operation: "im.sysmsg.query.cfg"
+      });
+      const cfg = unwrapInner(cfgRes)?.groups?.[0];
+      dealMode = Number(cfg?.sunread) === 1;
+    } catch {
+    }
+    const msgRows = rawRows.map((r) => ({
+      msg: r?.msg,
+      ser_msgid: r?.ser_msgid,
+      from_uid: r?.from_uid,
+      msgtime: r?.msgtime,
+      read_status: r?.read_status,
+      deal_status: r?.deal_status
+    }));
+    const { collectI18nIds: collectI18nIds2, collectPersonIds: collectPersonIds2 } = await import("./msg-parse-4GSQ2WTO.js");
+    const i18nIds = collectI18nIds2(msgRows);
+    const personIds = collectPersonIds2(msgRows);
+    for (const r of msgRows) if (r.from_uid) personIds.push(String(r.from_uid));
+    const [i18nMap, personMap] = await Promise.all([
+      host.fetchI18nLabels(i18nIds),
+      host.resolveUsersByIds([...new Set(personIds)])
+    ]);
+    const nameMap = {};
+    for (const [uid, p] of Object.entries(personMap)) nameMap[uid] = p.name;
+    const authUid = await resolveAuthUid(host);
+    const messages = msgRows.map((row) => {
+      const msgObj = parseMsg(row.msg);
+      const parsed = parseContent(msgObj, { i18nMap, nameMap });
+      const sender = senderName(msgObj || {}, row.from_uid, authUid, nameMap);
+      const statusLabel = dealMode ? Number(row.deal_status) === 1 ? "\u5DF2\u5904\u7406" : "\u672A\u5904\u7406" : row.read_status === true || row.read_status === 1 ? "\u5DF2\u8BFB" : "\u672A\u8BFB";
+      return {
+        msgid: str(row.ser_msgid),
+        sender,
+        time: formatFullTime(row.msgtime),
+        title: parsed.title,
+        content: escapePipe(collapseNewlines(parsed.content)),
+        typeName: parsed.typeName,
+        must: parsed.must,
+        statusLabel
+      };
+    });
+    sortMessagesNewestFirst(messages);
+    return imSuccess("im.sysmsg.query", {
+      group,
+      type: hasType ? Number(args.type) : void 0,
+      dealMode,
+      total: messages.length,
+      messages,
+      range: { start, end, scope, autoPaged: autoLoop },
+      ...paginationMeta(pulled, num),
+      ...shrink ? { rangeShrink: rangeShrinkMeta(shrink) } : {}
+    });
+  }
+};
+var sessionOperations = [
+  sessionList,
+  sysmsgGroupSearch,
+  sysmsgTypeSync,
+  sysmsgQuery
+];
+
+// src/shortcuts/im/operations/person.ts
+var personResolve = {
+  name: "im.person.resolve",
+  resource: "person",
+  method: "person.resolve",
+  action: "im.person.resolve",
+  summary: "\u6309\u59D3\u540D/\u5DE5\u53F7/\u624B\u673A/\u90AE\u7BB1\u6A21\u7CCA\u67E5\u8BE2\u5728\u804C\u5458\u5DE5\uFF0C\u8FD4\u56DE uid/cid/\u90E8\u95E8\u7B49\uFF08\u4F9B\u53D1\u6D88\u606F\u4E0E\u6210\u5458\u89E3\u6790\uFF09",
+  capability: "person",
+  risk: READ,
+  inputSchema: schemaOf({
+    name: { type: "string", minLength: 1, description: "\u59D3\u540D\uFF08\u6A21\u7CCA\uFF09/\u5DE5\u53F7/\u624B\u673A/\u90AE\u7BB1" }
+  }, { required: ["name"], description: "\u4EBA\u5458\u89E3\u6790\uFF1A\u8F93\u5165\u4E00\u4E2A\u67E5\u8BE2\u5173\u952E\u5B57" }),
+  handler: async (args, { host }) => {
+    const name = String(args.name ?? "").trim();
+    if (!name) throw imValidationError("name_required", "name \u5FC5\u586B");
+    const employees = await host.searchEmployeeByName(name);
+    const rows = employees.map((e) => ({
+      uid: e.uid,
+      name: e.name,
+      department: e.department,
+      departmentId: e.departmentId,
+      subCompany: e.subCompany,
+      position: e.position,
+      jobNum: e.jobNum,
+      mobile: e.mobile,
+      cid: e.cid,
+      ok: Boolean(e.uid && e.cid && e.uid !== "0" && e.cid !== "0")
+    }));
+    return imSuccess("im.person.resolve", {
+      total: rows.length,
+      keyword: name,
+      employees: rows
+    });
+  }
+};
+var personResolveByIds = {
+  name: "im.person.resolveByIds",
+  resource: "person",
+  method: "person.resolveByIds",
+  action: "im.person.resolveByIds",
+  summary: "\u6309 uid \u5217\u8868\u6279\u91CF\u89E3\u6790\u4EBA\u5458\u59D3\u540D/\u90E8\u95E8/\u5C97\u4F4D/cid\uFF08\u4E00\u6B21\u6700\u591A 100\uFF0C\u8D85\u51FA\u81EA\u52A8\u5206\u6279\uFF09",
+  capability: "person",
+  risk: READ,
+  inputSchema: schemaOf({
+    ids: { type: "array", items: { type: "string" }, description: "\u4EBA\u5458 uid \u5217\u8868" }
+  }, { required: ["ids"], description: "\u6309 id \u6279\u91CF\u89E3\u6790\u4EBA\u5458" }),
+  handler: async (args, { host }) => {
+    const ids = Array.isArray(args.ids) ? args.ids.map((x) => String(x)).filter(Boolean) : [];
+    if (ids.length === 0) throw imValidationError("ids_required", "ids \u4E0D\u80FD\u4E3A\u7A7A");
+    const map = await host.resolveUsersByIds(ids);
+    return imSuccess("im.person.resolveByIds", {
+      requested: ids.length,
+      resolved: Object.keys(map).length,
+      employees: ids.map((uid) => map[uid]).filter(Boolean).map((u) => ({
+        uid: u.uid,
+        name: u.name,
+        department: u.department,
+        departmentId: u.departmentId,
+        subCompany: u.subCompany,
+        position: u.position,
+        jobNum: u.jobNum,
+        mobile: u.mobile,
+        cid: u.cid,
+        ok: Boolean(u.uid && u.cid && u.uid !== "0" && u.cid !== "0")
+      }))
+    });
+  }
+};
+var personOperations = [
+  personResolve,
+  personResolveByIds
+];
+
+// src/shortcuts/im/operations/file-user.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { rename, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, resolve as resolve2 } from "node:path";
+var FILE_UPLOAD_ALIASES = {
+  file: ["filePath"],
+  shareGroup: ["shareGroups"]
+};
+var fileUpload = {
+  name: "im.file.upload",
+  resource: "file",
+  method: "file.upload",
+  action: "im.file.upload",
+  summary: "\u4E0A\u4F20\u672C\u5730\u6587\u4EF6\u5230 E10 \u6587\u4EF6\u670D\u52A1\uFF08module=im\uFF09\uFF0C\u8FD4\u56DE\u6587\u4EF6 id\uFF08\u4F9B\u6D88\u606F img/file \u5F15\u7528\uFF09",
+  capability: "file",
+  risk: "external-artifact",
+  deprecatedInputAliases: FILE_UPLOAD_ALIASES,
+  inputSchema: {
+    ...schemaOf({
+      file: { type: "string", description: "\u672C\u5730\u6587\u4EF6\u8DEF\u5F84\uFF08\u5FC5\u586B\uFF09" },
+      filePath: { type: "string", description: "\u65E7\u540D\u5B57\u6BB5\uFF0C\u7B49\u4EF7 file\uFF08\u5DF2\u5E9F\u5F03\uFF0C\u4E0E\u65B0\u540D\u540C\u65F6\u51FA\u73B0\u4E14\u4E0D\u4E00\u81F4\u4F1A\u62A5 alias_conflict\uFF09" },
+      name: { type: "string", description: "\u6587\u4EF6\u540D\uFF08\u9ED8\u8BA4\u53D6 basename\uFF09" },
+      shareGroup: { type: "string", description: "\u5206\u4EAB\u7FA4 id\uFF08\u53D1\u7FA4\u6D88\u606F\u7528\uFF09" },
+      shareGroups: { type: "string", description: "\u65E7\u540D\u5B57\u6BB5\uFF0C\u7B49\u4EF7 shareGroup\uFF08\u5DF2\u5E9F\u5F03\uFF09" },
+      shareUsers: { type: "array", items: { type: "string" }, description: "\u5206\u4EAB\u7528\u6237 uid\uFF08\u53D1\u5355\u804A\u7528\uFF09" },
+      permission: { type: "string", description: "\u6587\u4EF6\u6743\u9650\uFF08\u9ED8\u8BA4 3\uFF09" }
+    }, { description: "\u6587\u4EF6\u4E0A\u4F20\uFF1Afile\uFF08\u6216\u65E7\u540D filePath\uFF09\u5FC5\u586B" }),
+    anyOf: [{ required: ["file"] }, { required: ["filePath"] }]
+  },
+  handler: async (args, { host }) => {
+    const input = normalizeAliases(args, FILE_UPLOAD_ALIASES);
+    const filePath = String(input.file ?? "");
+    if (!filePath) throw imValidationError("file_required", "file \u5FC5\u586B");
+    const abs = resolve2(filePath);
+    if (!existsSync2(abs)) throw imValidationError("file_not_found", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${abs}`);
+    const shareUsers = Array.isArray(input.shareUsers) ? input.shareUsers.join(",") : String(input.shareUsers ?? "");
+    const shareGroups = input.shareGroup;
+    const fileObj = await host.uploadFile(abs, {
+      name: input.name !== void 0 ? String(input.name) : void 0,
+      shareGroups: shareGroups !== void 0 && shareGroups !== "" ? String(shareGroups) : void 0,
+      shareUsers: shareUsers || void 0,
+      permission: input.permission !== void 0 ? String(input.permission) : void 0
+    });
+    return imSuccess("im.file.upload", {
+      fileObj,
+      img: fileObjToImg(fileObj),
+      file: fileObjToFile(fileObj)
+    });
+  }
+};
+var filePreview = {
+  name: "im.file.preview",
+  resource: "file",
+  method: "file.preview",
+  action: "im.file.preview",
+  summary: "\u751F\u6210\u56FE\u7247/\u89C6\u9891\u9884\u89C8\u4E0E\u4E0B\u8F7D URL\uFF08\u9700\u767B\u5F55\u6001\u8BBF\u95EE\uFF1B\u56FE\u7247\u652F\u6301 small/large/original\uFF09",
+  capability: "file",
+  risk: READ,
+  inputSchema: schemaOf({
+    kind: { type: "string", enum: ["img", "video"], description: "img\uFF08\u9ED8\u8BA4\uFF09/ video" },
+    fileId: { type: "string", minLength: 1, description: "\u6587\u4EF6 id" },
+    msgid: { type: "string", pattern: "^\\d+$", description: "\u6D88\u606F id" },
+    groupId: { type: "string", description: "\u7FA4\u804A\u573A\u666F\u7FA4 id" },
+    toUid: { type: "string", description: "\u5355\u804A\u573A\u666F\u5BF9\u65B9 uid" },
+    toCid: { type: "string", description: "\u5355\u804A\u573A\u666F\u5BF9\u65B9 cid" },
+    imgFormat: { type: "string", enum: ["small", "large", "original"], description: "\u56FE\u7247\u89C4\u683C\uFF08\u9ED8\u8BA4 small\uFF09" }
+  }, { required: ["fileId", "msgid"], description: "\u5A92\u4F53\u9884\u89C8 URL" }),
+  handler: async (args, { host }) => {
+    const kind = String(args.kind ?? "img") === "video" ? "video" : "img";
+    const fileId = String(args.fileId);
+    const msgid = String(args.msgid);
+    const groupId = args.groupId !== void 0 && args.groupId !== "" ? String(args.groupId) : void 0;
+    const user = args.toUid || args.toCid ? { cid: str(args.toCid), uid: str(args.toUid) } : void 0;
+    if (!groupId && !user) {
+      throw imValidationError("context_required", "groupId\uFF08\u7FA4\u804A\uFF09\u6216 toUid+toCid\uFF08\u5355\u804A\uFF09\u5FC5\u987B\u63D0\u4F9B\u5176\u4E00");
+    }
+    const opts = {
+      fileId,
+      msgid,
+      kind,
+      imgFormat: args.imgFormat || "small",
+      ...groupId ? { groupId } : {},
+      ...user ? { user } : {}
+    };
+    return imSuccess("im.file.preview", {
+      kind,
+      fileId,
+      previewUrl: await host.buildPreviewUrl(opts),
+      downloadUrl: await host.buildDownloadUrl(opts),
+      note: "\u9884\u89C8/\u4E0B\u8F7D URL \u9700\u8981\u767B\u5F55\u6001\uFF08Cookie+eteamsid\uFF09\uFF0C\u76F4\u63A5\u5D4C\u5165 Markdown \u4F1A 401\uFF1B\u9700\u8981\u771F\u6B63\u53EF\u89C1\u8BF7\u7528 im.file.download \u843D\u5730\u5230\u672C\u5730\u3002"
+    });
+  }
+};
+var IMAGE_SIGNATURES = [
+  { ext: ".png", test: (b) => b.length >= 4 && b.subarray(0, 4).toString("hex") === "89504e47" },
+  { ext: ".jpg", test: (b) => b.length >= 3 && b.subarray(0, 3).toString("hex") === "ffd8ff" },
+  { ext: ".gif", test: (b) => b.length >= 4 && b.subarray(0, 4).toString("hex") === "47494638" },
+  {
+    ext: ".webp",
+    test: (b) => b.length >= 12 && b.subarray(0, 4).toString("ascii") === "RIFF" && b.subarray(8, 12).toString("ascii") === "WEBP"
+  }
+];
+function detectImageExt(buffer) {
+  for (const signature of IMAGE_SIGNATURES) {
+    if (signature.test(buffer)) return signature.ext;
+  }
+  return null;
+}
+var fileDownload = {
+  name: "im.file.download",
+  resource: "file",
+  method: "file.download",
+  action: "im.file.download",
+  summary: "\u4E0B\u8F7D\u6D88\u606F\u91CC\u7684\u56FE\u7247/\u89C6\u9891/\u6587\u4EF6\u5230\u672C\u5730\uFF08\u9700\u767B\u5F55\u6001\uFF1B\u7236\u76EE\u5F55\u5FC5\u987B\u5B58\u5728\uFF0C\u7981\u6B62\u8986\u76D6\uFF09",
+  capability: "file",
+  risk: "local-file-write",
+  inputSchema: schemaOf({
+    fileId: { type: "string", minLength: 1, description: "\u6587\u4EF6 id\uFF08\u53D6\u6D88\u606F media[].fileId\uFF09" },
+    msgid: { type: "string", pattern: "^\\d+$", description: "\u6D88\u606F id\uFF08\u53D6\u6D88\u606F media[].msgid / msgid\uFF09" },
+    kind: { type: "string", enum: ["img", "video", "file"], description: "\u5A92\u4F53\u7C7B\u578B\uFF08\u9ED8\u8BA4 img\uFF1B\u6587\u4EF6\u6D88\u606F\u4F20 file\uFF09" },
+    groupId: { type: "string", description: "\u7FA4\u804A\u573A\u666F\u7FA4 id\uFF08\u4E0E\u5355\u804A\u8EAB\u4EFD\u4E8C\u9009\u4E00\uFF09" },
+    toUid: { type: "string", description: "\u5355\u804A\u573A\u666F\u5BF9\u65B9 uid\uFF08\u4E0E groupId \u4E8C\u9009\u4E00\uFF09" },
+    toCid: { type: "string", description: "\u5355\u804A\u573A\u666F\u5BF9\u65B9 cid\uFF08\u4E0E groupId \u4E8C\u9009\u4E00\uFF09" },
+    imgFormat: { type: "string", enum: ["small", "large", "original"], description: "\u56FE\u7247\u89C4\u683C\uFF08\u9ED8\u8BA4 small\uFF1B\u8981\u539F\u56FE\u4F20 original\uFF09" },
+    output: { type: "string", minLength: 1, description: "\u672C\u5730\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84\uFF08\u7236\u76EE\u5F55\u5FC5\u987B\u5B58\u5728\uFF0C\u5DF2\u5B58\u5728\u5219\u62D2\u7EDD\uFF09" }
+  }, { required: ["fileId", "msgid", "output"], description: "\u5A92\u4F53/\u6587\u4EF6\u843D\u5730\u5230\u672C\u5730" }),
+  handler: async (args, { host }) => {
+    const fileId = String(args.fileId ?? "");
+    const msgid = String(args.msgid ?? "");
+    const kindRaw = String(args.kind ?? "img");
+    const kind = kindRaw === "video" ? "video" : "img";
+    const output = String(args.output ?? "").trim();
+    if (!output) throw imValidationError("output_required", "output \u5FC5\u987B\u662F\u660E\u786E\u7684\u672C\u5730\u6587\u4EF6\u8DEF\u5F84");
+    const groupId = args.groupId !== void 0 && args.groupId !== "" ? String(args.groupId) : void 0;
+    const user = args.toUid || args.toCid ? { cid: str(args.toCid), uid: str(args.toUid) } : void 0;
+    if (!groupId && !user) {
+      throw imValidationError("context_required", "groupId\uFF08\u7FA4\u804A\uFF09\u6216 toUid+toCid\uFF08\u5355\u804A\uFF09\u5FC5\u987B\u63D0\u4F9B\u5176\u4E00");
+    }
+    const resolved = resolve2(output);
+    const parent = await stat(dirname(resolved)).catch(() => null);
+    if (!parent) throw imValidationError("output_parent_missing", `\u8F93\u51FA\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${dirname(resolved)}`);
+    if (!parent.isDirectory()) throw imValidationError("output_parent_invalid", "\u8F93\u51FA\u6587\u4EF6\u7684\u7236\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55");
+    if (existsSync2(resolved)) throw imValidationError("output_exists", `\u8F93\u51FA\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u62D2\u7EDD\u8986\u76D6\uFF1A${resolved}`);
+    const url = await host.buildDownloadUrl({
+      fileId,
+      msgid,
+      kind,
+      imgFormat: args.imgFormat || "small",
+      ...groupId ? { groupId } : {},
+      ...user ? { user } : {}
+    });
+    const content = await host.requestBinary(url);
+    await writeFile(resolved, content, { flag: "wx", mode: 384 });
+    let finalPath = resolved;
+    let renamedFrom;
+    if (kind === "img" || kindRaw === "file") {
+      const detected = detectImageExt(content);
+      const currentExt = extname(resolved).toLowerCase();
+      if (detected && detected !== currentExt) {
+        const candidate = currentExt ? `${resolved.slice(0, resolved.length - currentExt.length)}${detected}` : `${resolved}${detected}`;
+        if (!existsSync2(candidate)) {
+          await rename(resolved, candidate);
+          renamedFrom = resolved;
+          finalPath = candidate;
+        }
+      }
+    }
+    return imSuccess("im.file.download", {
+      fileId,
+      msgid,
+      kind: kindRaw,
+      output: finalPath,
+      size: content.length,
+      ...renamedFrom ? { renamedFrom, renameNote: "\u6269\u5C55\u540D\u5DF2\u6309\u6587\u4EF6\u5934\u7EA0\u6B63\uFF08small/large \u9884\u89C8\u4E3A\u670D\u52A1\u7AEF\u8F6C\u6362\u540E\u7684\u683C\u5F0F\uFF09" } : {}
+    });
+  }
+};
+var userState = {
+  name: "im.user.state",
+  resource: "user",
+  method: "user.state",
+  action: "im.user.state",
+  summary: "\u67E5\u8BE2\u6307\u5B9A\u4EBA\u5458\u5404\u5728\u7EBF\u8BBE\u5907\u72B6\u6001\uFF08sub_state \u5F3A\u5236 0 \u4E0D\u8BA2\u9605\uFF09",
+  capability: "user",
+  risk: READ,
+  inputSchema: schemaOf({
+    users: { type: "array", items: { type: "string" }, description: "\u4EBA\u5458 uid \u5217\u8868" },
+    devType: { type: "integer", description: "\u8BBE\u5907\u7C7B\u578B\uFF08\u7F3A\u7701\u67E5\u5168\u90E8\u5728\u7EBF\u8BBE\u5907\uFF09" },
+    mask: { type: "integer", description: "\u4FE1\u606F\u63A9\u7801\uFF08\u9ED8\u8BA4 7\uFF09" },
+    removeFailed: { type: "boolean", description: "\u89E3\u6790\u5931\u8D25\u7684\u4EBA\u5458\u8DF3\u8FC7\uFF08\u9ED8\u8BA4 false\uFF1A\u89E3\u6790\u5931\u8D25\u4F1A\u62A5 members_resolve_failed\uFF09" }
+  }, { required: ["users"], description: "\u67E5\u8BE2\u4EBA\u5458\u5728\u7EBF\u72B6\u6001" }),
+  handler: async (args, { host }) => {
+    const rawUids = Array.isArray(args.users) ? args.users.map((x) => String(x)) : splitIds(args.users, "users");
+    const map = await host.resolveUsersByIds(rawUids);
+    const members = [];
+    const failed = [];
+    for (const uid of rawUids) {
+      const p = map[uid];
+      if (!p?.cid || p.cid === "0") {
+        failed.push({ uid, name: p?.name || "" });
+        continue;
+      }
+      members.push({ cid: p.cid, uid });
+    }
+    if (failed.length && args.removeFailed !== true) {
+      throw imValidationError("members_resolve_failed", `\u4EE5\u4E0B\u4EBA\u5458\u89E3\u6790\u5931\u8D25\uFF1A${failed.map((f) => f.name || f.uid).join("\u3001")}\uFF1B\u786E\u8BA4\u8DF3\u8FC7\u8BF7\u4F20 removeFailed:true`);
+    }
+    const body = compact({
+      users: members,
+      sub_state: 0,
+      dev_type: args.devType !== void 0 ? toUint(args.devType, "devType") : void 0,
+      mask: Number(args.mask ?? 7)
+    });
+    const res = await host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/state/syncUserState",
+      body,
+      operation: "im.user.state"
+    });
+    assertImOk(res, "\u67E5\u8BE2\u4EBA\u5458\u72B6\u6001");
+    const inner = unwrapInner(res);
+    const devTypeNames = {
+      1: "Android",
+      2: "iPhone",
+      3: "iPad",
+      4: "API",
+      5: "PC Web",
+      6: "\u624B\u673AWeb",
+      7: "Mac",
+      8: "Linux",
+      9: "Windows",
+      10: "\u7B2C\u4E09\u65B9",
+      11: "\u5B89\u5353Pad",
+      12: "\u9E3F\u8499",
+      13: "\u9E3F\u8499Pad",
+      0: "\u65E0\u6548"
+    };
+    const infos = (inner?.infos || []).map((it) => {
+      const uid = str(it?.user?.uid);
+      const devices = (it?.dev_infos || []).map((d) => ({
+        dev: Number(d.dev ?? -1),
+        devName: devTypeNames[Number(d.dev)] ?? String(d.dev),
+        status: Number(d.status),
+        online: Number(d.status) === 1,
+        loginTime: formatTime(d.logintime),
+        activeTime: formatTime(d.active_time),
+        imei: str(d.imei)
+      }));
+      return { uid, name: map[uid]?.name || uid, devices };
+    });
+    return imSuccess("im.user.state", { total: infos.length, infos });
+  }
+};
+function formatTime(ts) {
+  if (ts === void 0 || ts === null || ts === "") return "-";
+  const d = new Date(Number(ts) * 1e3);
+  if (Number.isNaN(d.getTime())) return "-";
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}/${d.getMonth() + 1}/${d.getDate()} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+var i18nLabels = {
+  name: "im.i18n.labels",
+  resource: "i18n",
+  method: "i18n.labels",
+  action: "im.i18n.labels",
+  summary: "\u6279\u91CF\u7FFB\u8BD1\u56FD\u9645\u5316\u6807\u7B7E id \u2192 \u5F53\u524D\u8BED\u8A00\u6587\u6848",
+  capability: "i18n",
+  risk: READ,
+  inputSchema: schemaOf({
+    ids: { type: "array", items: { type: "string" }, description: "\u6807\u7B7E id\uFF08\u6570\u5B57\uFF09\u5217\u8868" }
+  }, { required: ["ids"], description: "i18n \u6807\u7B7E\u7FFB\u8BD1" }),
+  handler: async (args, { host }) => {
+    const ids = Array.isArray(args.ids) ? args.ids.map((x) => String(x)) : splitIds(args.ids, "ids");
+    const labels = await host.fetchI18nLabels(ids);
+    return imSuccess("im.i18n.labels", {
+      total: Object.keys(labels).length,
+      labels: ids.map((id) => ({ id, text: labels[id] ?? "(\u672A\u53D6\u5230\u6587\u6848)" }))
+    });
+  }
+};
+var fileUserOperations = [
+  fileUpload,
+  filePreview,
+  fileDownload,
+  userState,
+  i18nLabels
+];
+
+// src/shortcuts/im/operations/user-remind.ts
+var SESSION_TYPE_NAME = {
+  1: "\u5355\u804A\u4F1A\u8BDD",
+  2: "\u7FA4\u804A\u4F1A\u8BDD",
+  4: "\u7CFB\u7EDF\u4F1A\u8BDD"
+};
+var REMINDER_NAME = {
+  0: "\u6D88\u606F\u63A5\u6536\u63D0\u9192",
+  1: "\u6D88\u606F\u63A5\u6536\u4F46\u4E0D\u63D0\u9192\uFF08\u514D\u6253\u6270\uFF09"
+};
+var USER_SESSION_TYPES = /* @__PURE__ */ new Set([1]);
+var GROUP_ID_SESSION_TYPES = /* @__PURE__ */ new Set([2]);
+async function resolveTargetLabel(plan, env) {
+  try {
+    if (GROUP_ID_SESSION_TYPES.has(plan.sessionType) && plan.groupId) {
+      const res = await env.host.request({
+        method: "POST",
+        path: "/api/em/msg/executeIm/group/queryGroupInfo",
+        body: { trans_id: 0, type: 0, mask: 0, group_id: [plan.groupId], flag: 0 },
+        operation: "im.user.setRemind.plan.group"
+      });
+      const info = (unwrapInner(res)?.datas || [])[0];
+      const name = str(info?.name);
+      return name ? `\u7FA4\u300C${name}\u300D(${plan.groupId})` : `\u7FA4 ${plan.groupId}`;
+    }
+    if (USER_SESSION_TYPES.has(plan.sessionType) && plan.user) {
+      const map = await env.host.resolveUsersByIds([plan.user.uid]);
+      const name = map[plan.user.uid]?.name;
+      return name ? `\u4E0E\u300C${name}\u300D\u7684\u4F1A\u8BDD(${plan.user.uid})` : `\u4E0E ${plan.user.uid} \u7684\u4F1A\u8BDD`;
+    }
+    if (plan.sessionType === 4 && plan.group !== void 0) {
+      const res = await env.host.request({
+        method: "POST",
+        path: "/api/em/msg/executeIm/system-msg/syncGroupType",
+        body: { gids: [plan.group], tids: [], lang: "zh_CN", showdel: 1 },
+        operation: "im.user.setRemind.plan.sysgroup"
+      });
+      const groupName = str((unwrapInner(res)?.groups || [])[0]?.groupName);
+      const base = groupName ? `\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4\u300C${groupName}\u300D(${plan.group})` : `\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4 ${plan.group}`;
+      return base;
+    }
+  } catch {
+  }
+  if (plan.groupId) return `\u7FA4 ${plan.groupId}`;
+  if (plan.user) return `\u4E0E ${plan.user.uid} \u7684\u4F1A\u8BDD`;
+  if (plan.group !== void 0) return `\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4 ${plan.group}`;
+  return "\u4F1A\u8BDD\u514D\u6253\u6270\u8BBE\u7F6E";
+}
+var userSetRemindPair = makeWritePair({
+  action: "im.user.setRemind",
+  async plan(args, env) {
+    const sessionType = toUint(args.sessionType, "sessionType");
+    if (sessionType === void 0 || SESSION_TYPE_NAME[sessionType] === void 0) {
+      throw imValidationError(
+        "session_type_invalid",
+        "sessionType \u5FC5\u586B\u4E14\u4EC5\u652F\u6301\u4F1A\u8BDD\u7EF4\u5EA6\uFF1A1 \u5355\u804A\u4F1A\u8BDD\u30012 \u7FA4\u804A\u4F1A\u8BDD\u30014 \u7CFB\u7EDF\u4F1A\u8BDD"
+      );
+    }
+    const reminder = toUint(args.reminder, "reminder");
+    if (reminder === void 0 || REMINDER_NAME[reminder] === void 0) {
+      throw imValidationError("reminder_invalid", "reminder \u5FC5\u586B\u4E14\u4EC5\u652F\u6301 0 \u6D88\u606F\u63A5\u6536\u63D0\u9192 / 1 \u6D88\u606F\u63A5\u6536\u4F46\u4E0D\u63D0\u9192\uFF08\u514D\u6253\u6270\uFF09");
+    }
+    const plan = { sessionType, reminder };
+    if (USER_SESSION_TYPES.has(sessionType)) {
+      const uid = str(args.toUid);
+      const cid = str(args.toCid);
+      if (!uid || !cid || uid === "0" || cid === "0") {
+        throw imValidationError("target_required", `sessionType=${sessionType}\uFF08${SESSION_TYPE_NAME[sessionType]}\uFF09\u9700\u8981 toUid + toCid`);
+      }
+      plan.user = { cid, uid };
+    } else if (GROUP_ID_SESSION_TYPES.has(sessionType)) {
+      const groupId = str(args.groupId);
+      if (!groupId || groupId === "0") {
+        throw imValidationError("target_required", `sessionType=${sessionType}\uFF08${SESSION_TYPE_NAME[sessionType]}\uFF09\u9700\u8981 groupId`);
+      }
+      plan.groupId = groupId;
+    } else {
+      const group = toUint(args.group, "group");
+      if (group === void 0 || group <= 0) {
+        throw imValidationError("target_required", "sessionType=4\uFF08\u7CFB\u7EDF\u4F1A\u8BDD\uFF09\u9700\u8981 group\uFF08\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4 id\uFF09");
+      }
+      plan.group = group;
+    }
+    const target = await resolveTargetLabel(plan, env);
+    return {
+      summary: {
+        action: "\u8BBE\u7F6E\u6D88\u606F\u514D\u6253\u6270",
+        target,
+        sessionType: plan.sessionType,
+        sessionTypeName: SESSION_TYPE_NAME[plan.sessionType],
+        reminder: plan.reminder,
+        reminderName: REMINDER_NAME[plan.reminder],
+        ...plan.groupId ? { groupId: plan.groupId } : {},
+        ...plan.user ? { toUid: plan.user.uid, toCid: plan.user.cid } : {},
+        ...plan.group !== void 0 ? { group: plan.group } : {},
+        note: "\u4EC5\u4FEE\u6539\u5F53\u524D\u767B\u5F55\u4EBA\u81EA\u5DF1\u7684\u4F1A\u8BDD\u63D0\u9192\u8BBE\u7F6E\uFF1Breminder=0 \u63A5\u6536\u5E76\u63D0\u9192\uFF0C1 \u63A5\u6536\u4F46\u4E0D\u63D0\u9192\uFF08\u514D\u6253\u6270\uFF09\u3002"
+      },
+      snapshot: plan
+    };
+  },
+  async execute(plan, env) {
+    const self = await env.host.getSelfIdentity();
+    const remind = {
+      session_type: plan.sessionType,
+      reminder: plan.reminder
+    };
+    if (plan.user) remind.user = { cid: plan.user.cid, uid: plan.user.uid };
+    if (plan.groupId) remind.group_id = plan.groupId;
+    if (plan.group !== void 0) remind.group = plan.group;
+    const res = await env.host.request({
+      method: "POST",
+      path: "/api/em/msg/executeIm/user/setMsgRemind",
+      body: {
+        user: { cid: self.cid, uid: self.uid },
+        data: { trans_id: 0, dev: 4, remind }
+      },
+      operation: "im.user.setRemind"
+    });
+    assertImOk(res, "\u8BBE\u7F6E\u6D88\u606F\u514D\u6253\u6270");
+    return {
+      sessionType: plan.sessionType,
+      sessionTypeName: SESSION_TYPE_NAME[plan.sessionType],
+      reminder: plan.reminder,
+      reminderName: REMINDER_NAME[plan.reminder],
+      ...plan.groupId ? { groupId: plan.groupId } : {},
+      ...plan.user ? { toUid: plan.user.uid } : {},
+      ...plan.group !== void 0 ? { group: plan.group } : {}
+    };
+  }
+});
+var prepareSchema = {
+  ...schemaOf({
+    sessionType: {
+      type: "integer",
+      enum: [1, 2, 4],
+      description: "\u4F1A\u8BDD\u7C7B\u578B\uFF08\u5FC5\u586B\uFF0C\u4EC5\u4F1A\u8BDD\u7EF4\u5EA6\uFF09\uFF1A1 \u5355\u804A\u4F1A\u8BDD\uFF0C2 \u7FA4\u804A\u4F1A\u8BDD\uFF0C4 \u7CFB\u7EDF\u4F1A\u8BDD"
+    },
+    reminder: {
+      type: "integer",
+      enum: [0, 1],
+      description: "\u63D0\u9192\u503C\uFF08\u5FC5\u586B\uFF09\uFF1A0 \u6D88\u606F\u63A5\u6536\u63D0\u9192\uFF0C1 \u6D88\u606F\u63A5\u6536\u4F46\u4E0D\u63D0\u9192\uFF08\u514D\u6253\u6270\uFF09"
+    },
+    toUid: { type: "string", pattern: "^\\d+$", description: "sessionType=1\uFF08\u5355\u804A\u4F1A\u8BDD\uFF09\u65F6\u7684\u5BF9\u65B9 uid" },
+    toCid: { type: "string", pattern: "^\\d+$", description: "sessionType=1\uFF08\u5355\u804A\u4F1A\u8BDD\uFF09\u65F6\u7684\u5BF9\u65B9 cid" },
+    groupId: { type: "string", pattern: "^\\d+$", description: "sessionType=2\uFF08\u7FA4\u804A\u4F1A\u8BDD\uFF09\u65F6\u7684\u7FA4 id" },
+    group: { type: "integer", minimum: 1, description: "sessionType=4\uFF08\u7CFB\u7EDF\u4F1A\u8BDD\uFF09\u65F6\u7684\u7CFB\u7EDF\u6D88\u606F\u5206\u7EC4 id" }
+  }, { required: ["sessionType", "reminder"], description: "\u4F1A\u8BDD\u514D\u6253\u6270\u8BBE\u7F6E\uFF08\u5355\u804A\u4F1A\u8BDD / \u7FA4\u804A\u4F1A\u8BDD / \u7CFB\u7EDF\u4F1A\u8BDD\uFF09" })
+};
+var userRemindOperations = [
+  {
+    name: "im.user.setRemind.prepare",
+    resource: "user",
+    method: "user.setRemind.prepare",
+    action: "im.user.setRemind.prepare",
+    summary: "\u8BBE\u7F6E\u6D88\u606F\u514D\u6253\u6270\uFF08prepare\uFF1A\u6821\u9A8C\u76EE\u6807 + \u53EA\u8BFB\u56DE\u67E5\u76EE\u6807\u540D\u79F0 + \u7B7E\u53D1\u786E\u8BA4\uFF09",
+    capability: "user",
+    risk: "read-before-write",
+    requiresConfirmation: true,
+    inputSchema: prepareSchema,
+    handler: userSetRemindPair.prepare
+  },
+  {
+    name: "im.user.setRemind.apply",
+    resource: "user",
+    method: "user.setRemind.apply",
+    action: "im.user.setRemind.apply",
+    summary: "\u8BBE\u7F6E\u6D88\u606F\u514D\u6253\u6270\uFF08apply\uFF1A\u9700 confirm:true + continuation\uFF09",
+    capability: "user",
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+      confirm: { type: "boolean", description: "\u5FC5\u987B\u4E3A true" },
+      continuation: { type: "string", minLength: 1 }
+    }, { required: ["confirm", "continuation"], description: "\u8BBE\u7F6E\u6D88\u606F\u514D\u6253\u6270\uFF08apply\uFF09" }),
+    handler: userSetRemindPair.apply
+  }
+];
+
+// src/shortcuts/im/operations/registry.ts
+function buildRegistry() {
+  const registry = /* @__PURE__ */ new Map();
+  const definitions = [
+    ...personOperations,
+    ...msgReadOperations,
+    ...msgWriteOperations,
+    ...groupReadOperations,
+    ...groupWriteOperations,
+    ...sessionOperations,
+    ...fileUserOperations,
+    ...userRemindOperations
+  ];
+  for (const definition of definitions) {
+    if (registry.has(definition.name)) {
+      throw new Error(`duplicate im operation: ${definition.name}`);
+    }
+    registry.set(definition.name, definition);
+  }
+  return registry;
+}
+var imOperationRegistry = buildRegistry();
+function imOperationDefinitions() {
+  return [...imOperationRegistry.values()];
+}
+function getImOperation(operation) {
+  const definition = imOperationRegistry.get(operation);
+  if (!definition) {
+    throw imValidationError("operation_unknown", `\u6613\u79D2\u529E\u4E0D\u652F\u6301\u64CD\u4F5C\uFF1A${operation}`);
+  }
+  return definition;
+}
+
+export {
+  asObject,
+  assertNoForbiddenKeys,
+  imOperationDefinitions,
+  getImOperation
+};