weaver-work-cli 0.1.29 → 0.1.31

package/dist/chunks/chunk-GCG2NMWR.js

@@ -0,0 +1,703 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  SCHEMA_ID,
+  meetingStateDir,
+  meetingSuccess,
+  meetingValidationError,
+  schemaOf
+} from "./chunk-H6XSTSLM.js";
+
+// src/shortcuts/meeting/operations/attachment-content.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+// src/shortcuts/meeting/invitation/docx.ts
+import { deflateRawSync, inflateRawSync } from "node:zlib";
+var EOCD_SIG = 101010256;
+var CEN_SIG = 33639248;
+var LOC_SIG = 67324752;
+function findEocd(buf) {
+  const min = Math.max(0, buf.length - 65535 - 22);
+  for (let i = buf.length - 22; i >= min; i -= 1) {
+    if (buf.readUInt32LE(i) === EOCD_SIG) return i;
+  }
+  throw new Error("docx \u89E3\u6790\u5931\u8D25\uFF1A\u627E\u4E0D\u5230 ZIP \u7ED3\u675F\u8BB0\u5F55\uFF08EOCD\uFF09");
+}
+function readDocxEntries(buf) {
+  const eocd = findEocd(buf);
+  const count = buf.readUInt16LE(eocd + 10);
+  let offset = buf.readUInt32LE(eocd + 16);
+  const entries = [];
+  for (let i = 0; i < count; i += 1) {
+    if (buf.readUInt32LE(offset) !== CEN_SIG) {
+      throw new Error("docx \u89E3\u6790\u5931\u8D25\uFF1A\u4E2D\u592E\u76EE\u5F55\u6761\u76EE\u7B7E\u540D\u4E0D\u5339\u914D");
+    }
+    const method = buf.readUInt16LE(offset + 10);
+    const compSize = buf.readUInt32LE(offset + 20);
+    const nameLen = buf.readUInt16LE(offset + 28);
+    const extraLen = buf.readUInt16LE(offset + 30);
+    const commentLen = buf.readUInt16LE(offset + 32);
+    const localOffset = buf.readUInt32LE(offset + 42);
+    const name = buf.subarray(offset + 46, offset + 46 + nameLen).toString("utf8");
+    if (buf.readUInt32LE(localOffset) !== LOC_SIG) {
+      throw new Error(`docx \u89E3\u6790\u5931\u8D25\uFF1A${name} \u7684\u672C\u5730\u5934\u7B7E\u540D\u4E0D\u5339\u914D`);
+    }
+    const localNameLen = buf.readUInt16LE(localOffset + 26);
+    const localExtraLen = buf.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+    const raw = buf.subarray(dataStart, dataStart + compSize);
+    const data = method === 0 ? Buffer.from(raw) : inflateRawSync(raw);
+    entries.push({ name, data });
+    offset += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+var CRC_TABLE = (() => {
+  const table = new Int32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[i] = c;
+  }
+  return table;
+})();
+function crc32(buf) {
+  let crc = -1;
+  for (let i = 0; i < buf.length; i += 1) crc = CRC_TABLE[(crc ^ buf[i]) & 255] ^ crc >>> 8;
+  return (crc ^ -1) >>> 0;
+}
+function dosDateTime(date) {
+  const time = (date.getHours() << 11 | date.getMinutes() << 5 | date.getSeconds() >> 1) & 65535;
+  const d = (date.getFullYear() - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate()) & 65535;
+  return { time, date: d };
+}
+function writeDocxEntries(entries, now = /* @__PURE__ */ new Date()) {
+  const { time, date } = dosDateTime(now);
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBuf = Buffer.from(entry.name, "utf8");
+    const crc = crc32(entry.data);
+    const deflated = deflateRawSync(entry.data);
+    const useDeflate = deflated.length < entry.data.length;
+    const payload = useDeflate ? deflated : entry.data;
+    const method = useDeflate ? 8 : 0;
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(LOC_SIG, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(2048, 6);
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(time, 10);
+    local.writeUInt16LE(date, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(payload.length, 18);
+    local.writeUInt32LE(entry.data.length, 22);
+    local.writeUInt16LE(nameBuf.length, 26);
+    local.writeUInt16LE(0, 28);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(CEN_SIG, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(2048, 8);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt16LE(time, 12);
+    central.writeUInt16LE(date, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(payload.length, 20);
+    central.writeUInt32LE(entry.data.length, 24);
+    central.writeUInt16LE(nameBuf.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    locals.push(local, nameBuf, payload);
+    centrals.push(central, nameBuf);
+    offset += local.length + nameBuf.length + payload.length;
+  }
+  const centralBuf = Buffer.concat(centrals);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(EOCD_SIG, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(entries.length, 8);
+  eocd.writeUInt16LE(entries.length, 10);
+  eocd.writeUInt32LE(centralBuf.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...locals, centralBuf, eocd]);
+}
+var PENDING_MARK = "\u3010\u5F85\u8865\u5145\u3011";
+function unescapeXml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_.]*)\}/g;
+var PLACEHOLDER_TEST = /\{[A-Za-z_][A-Za-z0-9_.]*\}/;
+var UNSAFE_PARAGRAPH_RE = /<w:(drawing|pict|hyperlink|fldSimple|sdt|object|txbxContent)\b/;
+function splitParagraph(paraXml) {
+  const openMatch = /^<w:p(?:\s[^>]*)?>/.exec(paraXml);
+  const open = openMatch ? openMatch[0] : "<w:p>";
+  let body = paraXml.slice(open.length).replace(/<\/w:p>\s*$/, "");
+  let pPr = "";
+  const pPrMatch = /^<w:pPr>[\s\S]*?<\/w:pPr>/.exec(body);
+  if (pPrMatch) {
+    pPr = pPrMatch[0];
+    body = body.slice(pPr.length);
+  }
+  return { open, pPr, body };
+}
+function parseRuns(body) {
+  const runs = [];
+  const runRe = /<w:r(?:\s[^>]*)?>([\s\S]*?)<\/w:r>/g;
+  let match;
+  while ((match = runRe.exec(body)) !== null) {
+    const inner = match[1];
+    const rPrMatch = /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(inner);
+    const rPr = rPrMatch ? rPrMatch[0] : "";
+    let text = "";
+    const tRe = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g;
+    let tMatch;
+    while ((tMatch = tRe.exec(inner)) !== null) text += unescapeXml(tMatch[1]);
+    runs.push({ rPr, text });
+  }
+  return runs;
+}
+function withHighlight(rPr) {
+  const highlight = '<w:highlight w:val="yellow"/>';
+  if (!rPr) return `<w:rPr>${highlight}</w:rPr>`;
+  if (rPr.includes("<w:highlight")) return rPr;
+  return rPr.replace(/<\/w:rPr>$/, `${highlight}</w:rPr>`);
+}
+function emitRun(rPr, text) {
+  return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>`;
+}
+function replaceInParagraph(paraXml, resolver, filled, pending) {
+  if (!paraXml.includes("{")) return null;
+  const { open, pPr, body } = splitParagraph(paraXml);
+  const runs = parseRuns(body);
+  if (runs.length === 0) return null;
+  const concat = runs.map((run) => run.text).join("");
+  if (!PLACEHOLDER_TEST.test(concat)) return null;
+  if (UNSAFE_PARAGRAPH_RE.test(paraXml)) return "unsafe";
+  PLACEHOLDER_RE.lastIndex = 0;
+  const matches = [...concat.matchAll(PLACEHOLDER_RE)];
+  if (matches.length === 0) return null;
+  const spans = [];
+  let cursor = 0;
+  for (const run of runs) {
+    spans.push({ start: cursor, end: cursor + run.text.length });
+    cursor += run.text.length;
+  }
+  const runAt = (pos) => {
+    for (let i = 0; i < spans.length; i += 1) if (pos >= spans[i].start && pos < spans[i].end) return i;
+    return spans.length - 1;
+  };
+  const units = [];
+  runs.forEach((run, index) => {
+    for (const ch of run.text) units.push({ ch, run: index, highlight: false });
+  });
+  for (const match of [...matches].reverse()) {
+    const key = match[1];
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    const value = resolver(key);
+    const text = value.pending ? PENDING_MARK : value.text;
+    (value.pending ? pending : filled).push(key);
+    const firstRun = runAt(start);
+    const replacement = [...text].map((ch) => ({ ch, run: firstRun, highlight: Boolean(value.pending) }));
+    units.splice(start, end - start, ...replacement);
+  }
+  const merged = [];
+  for (const unit of units) {
+    const rPr = runs[unit.run]?.rPr ?? "";
+    const last = merged[merged.length - 1];
+    if (last && last.rPr === rPr && last.highlight === unit.highlight) last.text += unit.ch;
+    else merged.push({ text: unit.ch, rPr, highlight: unit.highlight });
+  }
+  const rendered = merged.map((run) => emitRun(run.highlight ? withHighlight(run.rPr) : run.rPr, run.text)).join("");
+  return `${open}${pPr}${rendered}</w:p>`;
+}
+function replacePlaceholdersInXml(xml, resolver) {
+  const filled = [];
+  const pending = [];
+  let skippedParagraphs = 0;
+  const output = xml.replace(/<w:p(?:\s[^>]*)?>[\s\S]*?<\/w:p>/g, (paraXml) => {
+    if (!paraXml.includes("{")) return paraXml;
+    const replaced = replaceInParagraph(paraXml, resolver, filled, pending);
+    if (replaced === "unsafe") {
+      skippedParagraphs += 1;
+      return paraXml;
+    }
+    if (replaced === null) return paraXml;
+    return replaced;
+  });
+  return {
+    xml: output,
+    filled: [...new Set(filled)],
+    pending: [...new Set(pending)],
+    skippedParagraphs
+  };
+}
+var TR_RE = /<w:tr(?:\s[^>]*)?>[\s\S]*?<\/w:tr>/g;
+var TC_RE = /<w:tc(?:\s[^>]*)?>[\s\S]*?<\/w:tc>/g;
+var WT_RE = /<w:t(?:\s[^>]*)?>([^<]*)<\/w:t>/g;
+function cellText(tc) {
+  return [...tc.matchAll(WT_RE)].map((match) => unescapeXml(match[1])).join("");
+}
+function setCellText(tc, text) {
+  const tcOpen = /^<w:tc(?:\s[^>]*)?>/.exec(tc)?.[0] ?? "<w:tc>";
+  const tcPr = /<w:tcPr>[\s\S]*?<\/w:tcPr>/.exec(tc)?.[0] ?? "";
+  const paragraphs = tc.match(/<w:p(?:\s[^>]*)?>[\s\S]*?<\/w:p>/g) ?? [];
+  const firstParagraph = paragraphs[0] ?? "<w:p></w:p>";
+  const pOpen = /^<w:p(?:\s[^>]*)?>/.exec(firstParagraph)?.[0] ?? "<w:p>";
+  const pPr = /<w:pPr>[\s\S]*?<\/w:pPr>/.exec(firstParagraph)?.[0] ?? "";
+  const firstRun = /<w:r(?:\s[^>]*)?>[\s\S]*?<\/w:r>/.exec(firstParagraph)?.[0] ?? "";
+  const rPr = /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(firstRun)?.[0] ?? /<w:rPr>[\s\S]*?<\/w:rPr>/.exec(pPr)?.[0] ?? "";
+  const run = text ? `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>` : "";
+  return `${tcOpen}${tcPr}${pOpen}${pPr}${run}</w:p></w:tc>`;
+}
+function fillTableRowsInXml(xml, option) {
+  const rows = option.rows.filter((row) => row.some((cell) => String(cell ?? "").trim() !== ""));
+  if (rows.length === 0) return { xml, filled: false, rowCount: 0 };
+  const tables = [...xml.matchAll(/<w:tbl(?:\s[^>]*)?>[\s\S]*?<\/w:tbl>/g)];
+  for (const table of tables) {
+    const tableXml = table[0];
+    const tableRows = tableXml.match(TR_RE) ?? [];
+    if (tableRows.length < 2) continue;
+    const headerRow = tableRows[0];
+    const headerText = (headerRow.match(TC_RE) ?? []).map(cellText).join(" ");
+    if (!headerText.includes(option.headerKeyword)) continue;
+    const dataRows = tableRows.slice(1);
+    const cloneSource = dataRows[dataRows.length - 1];
+    const shadingFill = (rowXml) => {
+      const matched = /<w:shd\b[^>]*w:fill="([^"]*)"/.exec(rowXml);
+      return (matched?.[1] ?? "").trim().toUpperCase();
+    };
+    const isShadedRow = (rowXml) => {
+      const fill = shadingFill(rowXml);
+      return fill !== "" && fill !== "AUTO" && fill !== "FFFFFF";
+    };
+    const shadedRow = dataRows.find((row) => isShadedRow(row));
+    const plainRow = dataRows.find((row) => !isShadedRow(row));
+    const hasZebra = Boolean(shadedRow && plainRow);
+    const rebuilt = [headerRow];
+    rows.forEach((values, index) => {
+      const base = hasZebra ? index % 2 === 0 ? shadedRow : plainRow : dataRows[index] ?? cloneSource;
+      const trOpen = /^<w:tr(?:\s[^>]*)?>/.exec(base)?.[0] ?? "<w:tr>";
+      const trPr = /<w:trPr>[\s\S]*?<\/w:trPr>/.exec(base)?.[0] ?? "";
+      const cells = base.match(TC_RE) ?? [];
+      const rebuiltCells = cells.map((cell, cellIndex) => setCellText(cell, values[cellIndex] ?? ""));
+      rebuilt.push(`${trOpen}${trPr}${rebuiltCells.join("")}</w:tr>`);
+    });
+    const firstRowIndex = tableXml.indexOf(headerRow);
+    const head = tableXml.slice(0, firstRowIndex);
+    const newTableXml = `${head}${rebuilt.join("")}</w:tbl>`;
+    const start = table.index ?? 0;
+    return {
+      xml: `${xml.slice(0, start)}${newTableXml}${xml.slice(start + tableXml.length)}`,
+      filled: true,
+      rowCount: rows.length
+    };
+  }
+  return { xml, filled: false, rowCount: 0 };
+}
+var TEXT_PART_RE = /^word\/(document|header\d*|footer\d*|footnotes|endnotes)\.xml$/;
+function renderDocx(template, resolver, options = {}) {
+  const entries = readDocxEntries(template);
+  const filled = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Set();
+  let skippedParagraphs = 0;
+  let agenda;
+  const updated = entries.map((entry) => {
+    if (!TEXT_PART_RE.test(entry.name)) return entry;
+    let xml = entry.data.toString("utf8");
+    if (options.agenda && entry.name === "word/document.xml") {
+      const tableResult = fillTableRowsInXml(xml, options.agenda);
+      agenda = { filled: tableResult.filled, rowCount: tableResult.rowCount };
+      xml = tableResult.xml;
+    }
+    if (!xml.includes("{")) {
+      return xml === entry.data.toString("utf8") ? entry : { name: entry.name, data: Buffer.from(xml, "utf8") };
+    }
+    const result = replacePlaceholdersInXml(xml, resolver);
+    result.filled.forEach((key) => filled.add(key));
+    result.pending.forEach((key) => pending.add(key));
+    skippedParagraphs += result.skippedParagraphs;
+    return { name: entry.name, data: Buffer.from(result.xml, "utf8") };
+  });
+  return {
+    buffer: writeDocxEntries(updated),
+    filled: [...filled],
+    pending: [...pending],
+    skippedParagraphs,
+    ...options.agenda ? { agenda: agenda ?? { filled: false, rowCount: 0 } } : {}
+  };
+}
+
+// src/shortcuts/meeting/operations/attachment-content.ts
+var MEETING_FILE_FIELDS = ["mt_accessorys", "project_files"];
+var FIELD_LABELS = {
+  mt_accessorys: "\u4F1A\u8BAE\u9644\u4EF6",
+  project_files: "\u9879\u76EE\u6587\u4EF6",
+  related_materials: "\u8BAE\u9898\u8D44\u6599"
+};
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".txt", ".md", ".csv", ".json", ".xml", ".html", ".htm", ".log", ".yaml", ".yml", ".tsv"]);
+function looksLikeFileId(value) {
+  return /^\d{15,}$/.test(String(value ?? "").trim());
+}
+function parseFileIdList(value) {
+  if (value === void 0 || value === null) return [];
+  if (Array.isArray(value)) {
+    return value.map((item) => item && typeof item === "object" ? String(item.id ?? "") : String(item ?? "")).map((item) => item.trim()).filter((item) => item !== "");
+  }
+  const text = String(value).trim();
+  if (text === "") return [];
+  if (text.startsWith("[")) {
+    try {
+      return parseFileIdList(JSON.parse(text));
+    } catch {
+    }
+  }
+  return text.split(/[,;，；\s]+/).map((item) => item.trim()).filter((item) => item !== "" && item !== "[]");
+}
+async function readRawMainTable(env, interfacePk, id, operation) {
+  const session = await env.host.getSession();
+  const response = await env.host.request({
+    method: "POST",
+    path: `/api/ebuilder/form/formdata/v2/getFormDataByPk/${interfacePk}`,
+    operation,
+    body: { datajson: { mainTable: { id }, header: { operator: session.userId } } },
+    acceptBusiness: (value) => {
+      if (!value || typeof value !== "object") return false;
+      if (typeof value.status === "boolean") return value.status;
+      return Number(value.code ?? 200) === 200;
+    }
+  });
+  const dj = response?.datajson ?? response?.data ?? {};
+  const rows = dj?.datas ?? dj?.data ?? (Array.isArray(dj) ? dj : []);
+  const first = Array.isArray(rows) ? rows[0] : rows;
+  return first?.mainTable ?? first ?? {};
+}
+async function listMeetingAttachments(env, mtId) {
+  const main = await readRawMainTable(env, "query_mtDetail_info", mtId, "meeting.attachment.list");
+  const refs = [];
+  for (const field of MEETING_FILE_FIELDS) {
+    for (const value of parseFileIdList(main[field])) {
+      refs.push({
+        fileId: value,
+        idLike: looksLikeFileId(value),
+        source: field,
+        sourceLabel: FIELD_LABELS[field] ?? field,
+        ownerId: mtId
+      });
+    }
+  }
+  return {
+    refs,
+    raw: Object.fromEntries(MEETING_FILE_FIELDS.map((field) => [field, main[field] ?? ""]))
+  };
+}
+async function listTopicAttachments(env, topicId) {
+  const main = await readRawMainTable(env, "query_mt_topic_info_new", topicId, "meeting.attachment.list");
+  return parseFileIdList(main.related_materials).map((value) => ({
+    fileId: value,
+    idLike: looksLikeFileId(value),
+    source: "related_materials",
+    sourceLabel: FIELD_LABELS.related_materials,
+    ownerId: topicId
+  }));
+}
+function extFromContentType(contentType) {
+  const text = String(contentType ?? "").toLowerCase();
+  if (text.includes("wordprocessingml")) return ".docx";
+  if (text.includes("spreadsheetml")) return ".xlsx";
+  if (text.includes("presentationml")) return ".pptx";
+  if (text.includes("pdf")) return ".pdf";
+  if (text.includes("json")) return ".json";
+  if (text.includes("html")) return ".html";
+  if (text.includes("plain")) return ".txt";
+  return "";
+}
+function nameFromDisposition(disposition) {
+  const text = String(disposition ?? "");
+  const encoded = /filename\*=UTF-8''([^;]+)/i.exec(text);
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded[1]).trim();
+    } catch {
+    }
+  }
+  const plain = /filename="?([^";]+)"?/i.exec(text);
+  return plain ? plain[1].trim() : "";
+}
+async function downloadMeetingFile(env, fileId, options = {}) {
+  if (!env.host.download) {
+    throw meetingValidationError("download_unsupported", "\u5F53\u524D host \u4E0D\u652F\u6301\u4E8C\u8FDB\u5236\u4E0B\u8F7D\uFF08\u6D4B\u8BD5\u66FF\u8EAB\uFF1F\uFF09\uFF0C\u65E0\u6CD5\u83B7\u53D6\u9644\u4EF6\u5185\u5BB9");
+  }
+  const response = await env.host.download({
+    path: `/api/file/remotedownload/${encodeURIComponent(fileId)}/meeting/true`
+  });
+  const dispositionName = nameFromDisposition(response.contentDisposition ?? "");
+  const ext = extFromContentType(response.contentType);
+  const baseName = (options.fileName ?? dispositionName) || `${fileId}${ext}`;
+  const safeName = baseName.replace(/[\\/:*?"<>|]/g, "_");
+  const dir = options.outDir ? resolve(options.outDir) : join(meetingStateDir(env.ctx), "attachments");
+  await mkdir(dir, { recursive: true });
+  const target = join(dir, safeName);
+  await writeFile(target, response.buffer);
+  return { path: target, bytes: response.buffer.length, contentType: response.contentType };
+}
+function decodeText(buffer) {
+  const utf8 = buffer.toString("utf8");
+  if (utf8.includes("\uFFFD")) {
+    try {
+      return new TextDecoder("gb18030").decode(buffer);
+    } catch {
+      return utf8;
+    }
+  }
+  return utf8;
+}
+function stripXml(xml) {
+  return xml.replace(/<w:p[ >]/g, "\n<w:p ").replace(/<\/w:p>/g, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\n{2,}/g, "\n").trim();
+}
+function xlsxToText(buffer) {
+  const entries = readDocxEntries(buffer);
+  const find = (suffix) => {
+    const entry = entries.find((item) => item.name === suffix);
+    return entry ? Buffer.from(entry.data).toString("utf8") : "";
+  };
+  const sharedXml = find("xl/sharedStrings.xml");
+  const shared = [...sharedXml.matchAll(/<si>([\s\S]*?)<\/si>/g)].map((match) => stripXml(match[1]).replace(/\n/g, " "));
+  const sheetPaths = entries.map((item) => item.name).filter((path) => /^xl\/worksheets\/sheet\d+\.xml$/.test(path)).sort();
+  const first = sheetPaths[0];
+  if (!first) return "";
+  const sheetXml = find(first);
+  const lines = [];
+  for (const rowMatch of sheetXml.matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)) {
+    const cells = [];
+    for (const cellMatch of rowMatch[1].matchAll(/<c\b([^>]*)>([\s\S]*?)<\/c>/g)) {
+      const attrs = cellMatch[1] ?? "";
+      const type = /\bt="([^"]+)"/.exec(attrs)?.[1] ?? "";
+      const inner = cellMatch[2] ?? "";
+      const value = /<v>([\s\S]*?)<\/v>/.exec(inner)?.[1] ?? "";
+      const inline = /<is>([\s\S]*?)<\/is>/.exec(inner)?.[1] ?? "";
+      if (type === "s") cells.push(shared[Number(value)] ?? "");
+      else if (type === "inlineStr") cells.push(stripXml(inline));
+      else cells.push(stripXml(value));
+    }
+    if (cells.some((cell) => cell !== "")) lines.push(cells.join("	"));
+  }
+  return lines.join("\n");
+}
+function pptxToText(buffer) {
+  const entries = readDocxEntries(buffer);
+  return entries.filter((item) => /^ppt\/slides\/slide\d+\.xml$/.test(item.name)).sort((left, right) => left.name.localeCompare(right.name, void 0, { numeric: true })).map((item, index) => `# \u7B2C ${index + 1} \u9875
+${stripXml(Buffer.from(item.data).toString("utf8"))}`).join("\n\n");
+}
+function extractText(buffer, fileName, contentType = "") {
+  const lower = String(fileName ?? "").toLowerCase();
+  const ext = /\.[a-z0-9]+$/.exec(lower)?.[0] ?? "";
+  if (ext === ".docx" || contentType.includes("wordprocessingml")) {
+    const entries = readDocxEntries(buffer);
+    const document = entries.find((item) => item.name === "word/document.xml");
+    return { text: document ? stripXml(Buffer.from(document.data).toString("utf8")) : "", kind: "docx" };
+  }
+  if (ext === ".xlsx" || contentType.includes("spreadsheetml")) {
+    return { text: xlsxToText(buffer), kind: "xlsx" };
+  }
+  if (ext === ".pptx" || contentType.includes("presentationml")) {
+    return { text: pptxToText(buffer), kind: "pptx" };
+  }
+  if (TEXT_EXTENSIONS.has(ext) || contentType.startsWith("text/") || contentType.includes("json") || contentType.includes("xml")) {
+    return { text: decodeText(buffer), kind: "text" };
+  }
+  return { text: "", kind: "unsupported" };
+}
+var attachmentList = {
+  name: "meeting.attachment.list",
+  resource: "attachment",
+  method: "list",
+  action: "meeting.attachment.list",
+  summary: "\u67E5\u8BE2\u4F1A\u8BAE/\u8BAE\u9898\u7684\u9644\u4EF6\u6E05\u5355\uFF08\u8FD4\u56DE fileId\uFF09\uFF1A\u4F1A\u8BAE\u9644\u4EF6 mt_accessorys\u3001\u9879\u76EE\u6587\u4EF6 project_files\u3001\u8BAE\u9898\u8D44\u6599 related_materials\uFF1B\u76F4\u63A5\u8BFB EB \u8BE6\u60C5\u539F\u59CB\u503C\uFF0C\u4E0D\u7ECF\u6458\u8981\u5C42",
+  capability: "attachment",
+  risk: "read",
+  inputSchema: schemaOf(
+    {
+      mtId: { ...SCHEMA_ID, description: "\u4F1A\u8BAE id\uFF08\u67E5\u4F1A\u8BAE\u9644\u4EF6\u65F6\u5FC5\u586B\uFF0C\u4E0E topicId \u4E8C\u9009\u4E00\uFF09" },
+      topicId: { ...SCHEMA_ID, description: "\u8BAE\u9898 id\uFF08\u67E5\u8BAE\u9898\u8D44\u6599\u65F6\u7528\uFF09" }
+    },
+    { required: [] }
+  ),
+  handler: async (args, env) => {
+    const mtId = String(args.mtId ?? "").trim();
+    const topicId = String(args.topicId ?? "").trim();
+    if (!mtId && !topicId) {
+      throw meetingValidationError("id_required", "\u5FC5\u987B\u63D0\u4F9B mtId\uFF08\u4F1A\u8BAE\uFF09\u6216 topicId\uFF08\u8BAE\u9898\uFF09");
+    }
+    const refs = [];
+    let raw = {};
+    if (mtId) {
+      const result = await listMeetingAttachments(env, mtId);
+      refs.push(...result.refs);
+      raw = result.raw;
+    }
+    if (topicId) refs.push(...await listTopicAttachments(env, topicId));
+    return meetingSuccess(
+      "meeting.attachment.list",
+      {
+        mtId: mtId || null,
+        topicId: topicId || null,
+        count: refs.length,
+        items: refs,
+        raw
+      },
+      refs.length === 0 ? { warnings: ["\u8BE5\u4F1A\u8BAE/\u8BAE\u9898\u5F53\u524D\u6CA1\u6709\u9644\u4EF6\uFF08\u6216\u5B57\u6BB5\u503C\u4E3A\u7A7A\uFF09"] } : {}
+    );
+  }
+};
+var attachmentDownload = {
+  name: "meeting.attachment.download",
+  resource: "attachment",
+  method: "download",
+  action: "meeting.attachment.download",
+  summary: "\u6309 fileId \u4E0B\u8F7D\u9644\u4EF6\u5230\u672C\u5730\uFF08\u9ED8\u8BA4 ~/.weaver-work-cli/meeting/attachments/\uFF09\uFF1B\u4E5F\u53EF\u4F20 mtId \u4E00\u6B21\u4E0B\u8F7D\u8BE5\u4F1A\u8BAE\u5168\u90E8\u9644\u4EF6",
+  capability: "attachment",
+  risk: "read",
+  inputSchema: schemaOf(
+    {
+      fileId: { ...SCHEMA_ID, description: "\u6587\u4EF6 id\uFF08\u4E0E mtId \u4E8C\u9009\u4E00\uFF09" },
+      mtId: { ...SCHEMA_ID, description: "\u4F1A\u8BAE id\uFF1A\u4E00\u6B21\u4E0B\u8F7D\u8BE5\u4F1A\u8BAE\u5168\u90E8\u9644\u4EF6\u4E0E\u9879\u76EE\u6587\u4EF6" },
+      outDir: { type: "string", description: "\u843D\u5730\u76EE\u5F55\uFF08\u9ED8\u8BA4 <state>/meeting/attachments\uFF09" },
+      fileName: { type: "string", description: "\u6307\u5B9A\u6587\u4EF6\u540D\uFF08\u4EC5\u5355\u6587\u4EF6\u65F6\u751F\u6548\uFF09" }
+    },
+    { required: [] }
+  ),
+  handler: async (args, env) => {
+    const fileId = String(args.fileId ?? "").trim();
+    const mtId = String(args.mtId ?? "").trim();
+    if (!fileId && !mtId) {
+      throw meetingValidationError("id_required", "\u5FC5\u987B\u63D0\u4F9B fileId \u6216 mtId");
+    }
+    const outDir = typeof args.outDir === "string" && args.outDir.trim() !== "" ? String(args.outDir) : void 0;
+    if (fileId) {
+      const one = await downloadMeetingFile(env, fileId, {
+        ...outDir ? { outDir } : {},
+        ...typeof args.fileName === "string" ? { fileName: String(args.fileName) } : {}
+      });
+      return meetingSuccess("meeting.attachment.download", { downloaded: [{ fileId, ...one }], count: 1 });
+    }
+    const refs = (await listMeetingAttachments(env, mtId)).refs;
+    if (refs.length === 0) {
+      throw meetingValidationError("attachment_empty", `\u4F1A\u8BAE ${mtId} \u6CA1\u6709\u9644\u4EF6\u53EF\u4E0B\u8F7D`);
+    }
+    const downloaded = [];
+    const warnings = [];
+    for (const ref of refs) {
+      try {
+        const one = await downloadMeetingFile(env, ref.fileId, { ...outDir ? { outDir } : {} });
+        downloaded.push({ fileId: ref.fileId, source: ref.source, ...one });
+      } catch (error) {
+        warnings.push(`\u9644\u4EF6 ${ref.fileId}\uFF08${ref.sourceLabel}\uFF09\u4E0B\u8F7D\u5931\u8D25\uFF1A${String(error?.message ?? error).slice(0, 120)}`);
+      }
+    }
+    return meetingSuccess(
+      "meeting.attachment.download",
+      { mtId, downloaded, count: downloaded.length },
+      warnings.length > 0 ? { warnings } : {}
+    );
+  }
+};
+var attachmentExtract = {
+  name: "meeting.attachment.extract",
+  resource: "attachment",
+  method: "extract",
+  action: "meeting.attachment.extract",
+  summary: "\u4E0B\u8F7D\u9644\u4EF6\u5E76\u62BD\u53D6\u7EAF\u6587\u672C\uFF08txt/md/csv/json/docx/xlsx/pptx\uFF09\uFF0C\u8FD4\u56DE\u6B63\u6587\u4E0E txt \u843D\u5730\u8DEF\u5F84\uFF1Bpdf/\u56FE\u7247\u7B49\u4E0D\u652F\u6301\u683C\u5F0F\u4F1A\u660E\u786E\u6807\u6CE8\uFF0C\u4E0D\u7F16\u9020\u5185\u5BB9",
+  capability: "attachment",
+  risk: "read",
+  inputSchema: schemaOf(
+    {
+      fileId: { ...SCHEMA_ID, description: "\u6587\u4EF6 id\uFF08\u4E0E mtId \u4E8C\u9009\u4E00\uFF09" },
+      mtId: { ...SCHEMA_ID, description: "\u4F1A\u8BAE id\uFF1A\u62BD\u53D6\u8BE5\u4F1A\u8BAE\u5168\u90E8\u9644\u4EF6\uFF08\u6700\u591A 10 \u4E2A\uFF09" },
+      maxChars: { type: "number", description: "\u6BCF\u4E2A\u6587\u4EF6\u8FD4\u56DE\u6B63\u6587\u7684\u6700\u5927\u5B57\u7B26\u6570\uFF08\u9ED8\u8BA4 4000\uFF0C\u6700\u591A 20000\uFF09" },
+      outDir: { type: "string", description: "\u843D\u5730\u76EE\u5F55\uFF08\u9ED8\u8BA4 <state>/meeting/attachments\uFF09" }
+    },
+    { required: [] }
+  ),
+  handler: async (args, env) => {
+    const fileId = String(args.fileId ?? "").trim();
+    const mtId = String(args.mtId ?? "").trim();
+    if (!fileId && !mtId) {
+      throw meetingValidationError("id_required", "\u5FC5\u987B\u63D0\u4F9B fileId \u6216 mtId");
+    }
+    const maxChars = Math.max(200, Math.min(2e4, Number(args.maxChars ?? 4e3) || 4e3));
+    const outDir = typeof args.outDir === "string" && args.outDir.trim() !== "" ? String(args.outDir) : void 0;
+    const refs = fileId ? [{ fileId, idLike: looksLikeFileId(fileId), source: "explicit", sourceLabel: "\u6307\u5B9A\u6587\u4EF6" }] : (await listMeetingAttachments(env, mtId)).refs.slice(0, 10);
+    if (refs.length === 0) {
+      throw meetingValidationError("attachment_empty", `\u4F1A\u8BAE ${mtId} \u6CA1\u6709\u9644\u4EF6\u53EF\u62BD\u53D6`);
+    }
+    const files = [];
+    const warnings = [];
+    for (const ref of refs) {
+      try {
+        const downloaded = await downloadMeetingFile(env, ref.fileId, { ...outDir ? { outDir } : {} });
+        const { readFile } = await import("node:fs/promises");
+        const buffer = await readFile(downloaded.path);
+        const extracted = extractText(buffer, downloaded.path, downloaded.contentType);
+        const text = extracted.text.slice(0, maxChars);
+        let textPath;
+        const absolutePath = downloaded.path;
+        const isPlainText = /\.(txt|md|csv|json|xml|html?|log|ya?ml|tsv)$/i.test(absolutePath);
+        if (extracted.text && !isPlainText) {
+          textPath = `${absolutePath.replace(/\.[a-z0-9]+$/i, "")}.txt`;
+          await writeFile(textPath, extracted.text, "utf8");
+        }
+        files.push({
+          fileId: ref.fileId,
+          source: ref.sourceLabel,
+          path: downloaded.path,
+          bytes: downloaded.bytes,
+          kind: extracted.kind,
+          chars: extracted.text.length,
+          ...textPath ? { textPath } : {},
+          text
+        });
+        if (extracted.kind === "unsupported") {
+          warnings.push(
+            `${downloaded.path} \u662F ${downloaded.contentType || "\u672A\u77E5\u7C7B\u578B"}\uFF0C\u4F1A\u8BAE\u7EBF\u4E0D\u89E3\u6790\u8BE5\u683C\u5F0F\uFF08\u5DF2\u4E0B\u8F7D\uFF0CPDF \u53EF\u7528 pdf \u6280\u80FD\u3001\u56FE\u7247\u7528\u89C6\u89C9\u6A21\u578B\uFF09`
+          );
+        }
+      } catch (error) {
+        warnings.push(`\u9644\u4EF6 ${ref.fileId} \u5904\u7406\u5931\u8D25\uFF1A${String(error?.message ?? error).slice(0, 120)}`);
+      }
+    }
+    return meetingSuccess(
+      "meeting.attachment.extract",
+      { mtId: mtId || null, count: files.length, files },
+      warnings.length > 0 ? { warnings } : {}
+    );
+  }
+};
+var meetingAttachmentContentOperations = [
+  attachmentList,
+  attachmentDownload,
+  attachmentExtract
+];
+
+export {
+  renderDocx,
+  looksLikeFileId,
+  parseFileIdList,
+  listMeetingAttachments,
+  listTopicAttachments,
+  downloadMeetingFile,
+  extractText,
+  meetingAttachmentContentOperations
+};