aai-lark-bridge 0.2.39 → 0.2.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.js CHANGED
@@ -4,7 +4,7 @@ import { Command } from "commander";
4
4
  // package.json
5
5
  var package_default = {
6
6
  name: "aai-lark-bridge",
7
- version: "0.2.39",
7
+ version: "0.2.41",
8
8
  description: "Lark AI Native Bridge - Lark\u57FA\u7840\u8BBE\u65BD\u5C42\u548CCLI\u96C6\u6210",
9
9
  type: "module",
10
10
  main: "./dist/index.js",
@@ -7531,6 +7531,9 @@ var PROMPT_TOOL = `## \u7528\u63D0\u95EE\u4EBA\u7684\u8EAB\u4EFD\u53EA\u8BFB\uFF
7531
7531
  - \`aai-user-read list-chat-messages --chat-id oc_xxx [--page-size N] [--page-token T] [--sort asc|desc]\`\uFF1A\u62C9\u4E00\u4E2A\u4F1A\u8BDD\u7684\u5386\u53F2
7532
7532
  - \`aai-user-read search-docs --query <\u5173\u952E\u8BCD> [--page-size N] [--page-token T]\`\uFF1A\u641C\u4ED6\u80FD\u770B\u7684\u6587\u6863
7533
7533
  - \`aai-user-read fetch-doc --doc <\u6587\u6863\u94FE\u63A5\u6216 token>\`\uFF1A\u8BFB\u6587\u6863\u6B63\u6587
7534
+ - \`aai-user-read read-file --message-id om_xxx --file-key file_xxx [--sheet \u5DE5\u4F5C\u8868\u540D] [--offset N] [--limit N] [--grep \u5173\u952E\u8BCD]\`\uFF1A\u8BFB\u6D88\u606F\u91CC\u7684\u9644\u4EF6\uFF0C\u8F6C\u6210\u6587\u5B57
7535
+
7536
+ \u8BFB\u9644\u4EF6\uFF1A\u6D88\u606F\u5185\u5BB9\u91CC\u7684 \`<file key="file_v3_\u2026" name="\u2026.xlsx"/>\` \u5C31\u662F\u9644\u4EF6\uFF0Ckey \u662F \`--file-key\`\uFF0C\u6D88\u606F\u53F7\u662F \`--message-id\`\uFF08\u7528 \`get-message\`\u3001\`list-chat-messages\`\u3001\`search-messages\` \u62FF\uFF09\u3002\u652F\u6301 Excel\uFF08xlsx\uFF09\u3001Word\uFF08docx\uFF09\u3001PPT\uFF08pptx\uFF09\u3001csv\u3001txt\u3001md\u3001json\u3002\u4E0D\u5E26 \`--sheet\` \u65F6\u8FD4\u56DE\u5DE5\u4F5C\u8868\u6E05\u5355\uFF08\u540D\u79F0\u3001\u884C\u6570\u3001\u5217\u6570\uFF09\u548C\u7B2C\u4E00\u5F20\u8868\u7684\u7B2C\u4E00\u9875\uFF1B\u6BCF\u9875\u6700\u591A 200 \u884C\u6216 100KB\uFF0C\`hasMore\` \u4E3A\u771F\u5C31\u7528 \`nextOffset\` \u4F5C \`--offset\` \u7FFB\u9875\uFF1B\u627E\u67D0\u4E9B\u884C\u7528 \`--grep \u5173\u952E\u8BCD\`\uFF08\u53EA\u8FD4\u56DE\u542B\u5173\u952E\u8BCD\u7684\u884C\uFF0C\`--offset\` \u6309\u547D\u4E2D\u5E8F\u53F7\u7FFB\uFF09\uFF1BExcel \u7684\u6BCF\u4E00\u884C\u5F00\u5934\u662F\u539F\u8868\u884C\u53F7\u3002\u4E0D\u8981\u4E3A\u4E86\u627E\u51E0\u884C\u628A\u6574\u5F20\u5927\u8868\u4E00\u9875\u9875\u7FFB\u5B8C\uFF0C\u5148\u770B\u6E05\u5355\uFF0C\u518D\u7528 \`--grep\`\u3002\u8FD4\u56DE \`unsupported_type\`\uFF08PDF\u3001\u65E7\u7248 xls\u3001doc\u3001ppt\u3001\u56FE\u7247\u7B49\uFF09\uFF1A\u544A\u8BC9\u4ED6\u8FD9\u4E2A\u683C\u5F0F\u8BFB\u4E0D\u4E86\uFF0C\u8BF7\u4ED6\u8F6C\u6210 xlsx\u3001docx\u3001pptx \u6216 csv \u518D\u53D1\uFF1B\`too_large\`\uFF1A\u6587\u4EF6\u8D85\u8FC7 20MB\uFF1B\`unreadable\`\uFF1A\u6587\u4EF6\u635F\u574F\u6216\u592A\u590D\u6742\uFF1B\`busy\`\uFF1A\u7A0D\u540E\u518D\u8BD5\uFF1B\`lark_error\`\uFF1A\u4ED6\u770B\u4E0D\u5230\u8FD9\u6761\u6D88\u606F\u6216\u6587\u4EF6\u3002\u8BFB\u4E0D\u5230\u9644\u4EF6\u65F6\u5982\u5B9E\u8BF4\uFF0C\u522B\u62FF\u7FA4\u91CC\u7684\u7ED3\u8BBA\u5F53\u6210\u9010\u884C\u6838\u5BF9\u8FC7\u7684\u3002
7534
7537
 
7535
7538
  \u8F93\u51FA\u662F JSON\u3002\u53EA\u5728\u56DE\u7B54\u4ED6\u7684\u95EE\u9898\u9700\u8981\u65F6\u8BFB\uFF0C\u8BFB\u5230\u7684\u5185\u5BB9\u53EA\u7528\u6765\u56DE\u7B54\u8FD9\u4E2A\u4EBA\uFF0C\u522B\u8F6C\u8FF0\u5230\u522B\u5904\u3002\u8FD4\u56DE expired \u8BF4\u660E\u8FD9\u4E00\u8F6E\u7684\u6388\u6743\u5DF2\u8FC7\u671F\uFF0C\u544A\u8BC9\u4ED6\u91CD\u65B0\u53D1\u4E00\u6B21\u95EE\u9898\u3002\u8FD4\u56DE need_auth \u8BF4\u660E\u4ED6\u7684\u6388\u6743\u5931\u6548\u4E86\uFF08\u592A\u4E45\u6CA1\u7528\u6216\u5728\u98DE\u4E66\u91CC\u64A4\u9500\u8FC7\uFF09\uFF0C\u7CFB\u7EDF\u5DF2\u7ECF\u7ED9\u4ED6\u91CD\u53D1\u4E86\u4E00\u5F20\u6388\u6743\u5361\u7247\uFF1A\u544A\u8BC9\u4ED6\u70B9\u5361\u7247\u91CD\u65B0\u6388\u6743\uFF0C\u6388\u6743\u540E\u518D\u95EE\u4E00\u6B21\u3002\u8FD4\u56DE auth_failed \u8BF4\u660E\u6388\u6743\u5931\u6548\u3001\u800C\u4E14\u5361\u7247\u6CA1\u53D1\u51FA\u53BB\uFF1A\u544A\u8BC9\u4ED6\u7A0D\u540E\u518D\u95EE\u4E00\u6B21\u3002
7536
7539
 
@@ -17623,13 +17626,14 @@ var generated_default = '<!doctype html>\n<html lang="zh-CN">\n <head>\n <me
17623
17626
  // src/bridge/lark-cli/user-im.ts
17624
17627
  var LIST_CHAT_SCOPES = ["im:chat:read"];
17625
17628
  var ADD_BOT_SCOPES = ["im:chat.members:write_only"];
17626
- var defaultExec = (args, env, timeoutMs) => new Promise((resolve3) => {
17629
+ var defaultExec = (args, env, timeoutMs, cwd) => new Promise((resolve3) => {
17627
17630
  let stdout = "";
17628
17631
  let stderr = "";
17629
17632
  let timedOut = false;
17630
17633
  const child = spawnProcess("lark-cli", args, {
17631
17634
  env: mergeProcessEnv(process.env, env),
17632
- stdio: ["ignore", "pipe", "pipe"]
17635
+ stdio: ["ignore", "pipe", "pipe"],
17636
+ ...cwd ? { cwd } : {}
17633
17637
  });
17634
17638
  child.stdout?.on("data", (b) => stdout += b.toString("utf8"));
17635
17639
  child.stderr?.on("data", (b) => stderr += b.toString("utf8"));
@@ -19881,9 +19885,9 @@ function toResult(r) {
19881
19885
  }
19882
19886
 
19883
19887
  // src/bridge/user-gateway/gateway.ts
19884
- import { randomBytes as randomBytes10 } from "crypto";
19885
- import { existsSync as existsSync10 } from "fs";
19886
- import { mkdir as mkdir19, rm as rm14, writeFile as writeFile9 } from "fs/promises";
19888
+ import { createHash as createHash8, randomBytes as randomBytes10 } from "crypto";
19889
+ import { existsSync as existsSync10, rmSync as rmSync4 } from "fs";
19890
+ import { mkdir as mkdir19, readdir as readdir6, readFile as readFileFs, rm as rm14, stat as stat8, writeFile as writeFile9 } from "fs/promises";
19887
19891
  import { join as join29 } from "path";
19888
19892
 
19889
19893
  // src/bridge/user-gateway/app-token.ts
@@ -19993,6 +19997,367 @@ function realAppTokenFetcher(sourceConfigFile) {
19993
19997
  };
19994
19998
  }
19995
19999
 
20000
+ // src/bridge/user-gateway/file-reader.ts
20001
+ import { readFile as readFile18 } from "fs/promises";
20002
+ import { Readable } from "stream";
20003
+ import { StringDecoder } from "string_decoder";
20004
+ import { createInflateRaw } from "zlib";
20005
+ var PAGE_ROWS = 200;
20006
+ var PAGE_BYTES = 100 * 1024;
20007
+ var MAX_ENTRIES = 5e3;
20008
+ var MAX_UNZIPPED_BYTES = 200 * 1024 * 1024;
20009
+ var MAX_ROW_BYTES = 8 * 1024 * 1024;
20010
+ var Unreadable = class extends Error {
20011
+ };
20012
+ var Budget = class {
20013
+ constructor(max) {
20014
+ this.max = max;
20015
+ }
20016
+ max;
20017
+ used = 0;
20018
+ add(n) {
20019
+ this.used += n;
20020
+ if (this.used > this.max) throw new Unreadable("\u89E3\u538B\u540E\u592A\u5927");
20021
+ }
20022
+ };
20023
+ function listZip(buf) {
20024
+ const tail = Math.max(0, buf.length - 66e3);
20025
+ let eocd = -1;
20026
+ for (let i = buf.length - 22; i >= tail; i--) {
20027
+ if (buf.readUInt32LE(i) === 101010256) {
20028
+ eocd = i;
20029
+ break;
20030
+ }
20031
+ }
20032
+ if (eocd < 0) throw new Unreadable("\u4E0D\u662F zip");
20033
+ const total = buf.readUInt16LE(eocd + 10);
20034
+ const cdOffset = buf.readUInt32LE(eocd + 16);
20035
+ if (total === 65535 || cdOffset === 4294967295) throw new Unreadable("\u4E0D\u652F\u6301 zip64");
20036
+ if (total > MAX_ENTRIES) throw new Unreadable("zip \u6761\u76EE\u592A\u591A");
20037
+ const out = [];
20038
+ let p3 = cdOffset;
20039
+ for (let i = 0; i < total; i++) {
20040
+ if (p3 + 46 > buf.length || buf.readUInt32LE(p3) !== 33639248) throw new Unreadable("zip \u76EE\u5F55\u635F\u574F");
20041
+ const method = buf.readUInt16LE(p3 + 10);
20042
+ const compSize = buf.readUInt32LE(p3 + 20);
20043
+ const nameLen = buf.readUInt16LE(p3 + 28);
20044
+ const extraLen = buf.readUInt16LE(p3 + 30);
20045
+ const commentLen = buf.readUInt16LE(p3 + 32);
20046
+ const localOffset = buf.readUInt32LE(p3 + 42);
20047
+ out.push({ name: buf.toString("utf8", p3 + 46, p3 + 46 + nameLen), method, compSize, localOffset });
20048
+ p3 += 46 + nameLen + extraLen + commentLen;
20049
+ }
20050
+ return out;
20051
+ }
20052
+ async function* entryChunks(buf, e, budget) {
20053
+ const o = e.localOffset;
20054
+ if (o + 30 > buf.length || buf.readUInt32LE(o) !== 67324752) throw new Unreadable("zip \u6761\u76EE\u635F\u574F");
20055
+ const start = o + 30 + buf.readUInt16LE(o + 26) + buf.readUInt16LE(o + 28);
20056
+ const data = buf.subarray(start, start + e.compSize);
20057
+ if (e.method === 0) {
20058
+ budget.add(data.length);
20059
+ yield data;
20060
+ return;
20061
+ }
20062
+ if (e.method !== 8) throw new Unreadable("zip \u538B\u7F29\u65B9\u5F0F\u4E0D\u652F\u6301");
20063
+ const inflater = createInflateRaw();
20064
+ Readable.from([data]).pipe(inflater);
20065
+ try {
20066
+ for await (const chunk of inflater) {
20067
+ budget.add(chunk.length);
20068
+ yield chunk;
20069
+ }
20070
+ } catch (err) {
20071
+ if (err instanceof Unreadable) throw err;
20072
+ throw new Unreadable(`zip \u89E3\u538B\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`);
20073
+ } finally {
20074
+ inflater.destroy();
20075
+ }
20076
+ }
20077
+ async function entryText(buf, e, budget) {
20078
+ const dec = new StringDecoder("utf8");
20079
+ let s = "";
20080
+ for await (const c of entryChunks(buf, e, budget)) s += dec.write(c);
20081
+ return s + dec.end();
20082
+ }
20083
+ var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
20084
+ function unescapeXml(s) {
20085
+ return s.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (_m, g) => {
20086
+ if (g[0] === "#") {
20087
+ const n = g[1] === "x" ? parseInt(g.slice(2), 16) : parseInt(g.slice(1), 10);
20088
+ return Number.isFinite(n) && n > 0 && n < 1114112 ? String.fromCodePoint(n) : "";
20089
+ }
20090
+ return ENTITIES[g] ?? "";
20091
+ });
20092
+ }
20093
+ var flat = (s) => s.replace(/[\t\r\n]+/g, " ");
20094
+ function attr(tag, name) {
20095
+ const m = new RegExp(`\\b${name}="([^"]*)"`).exec(tag);
20096
+ return m ? unescapeXml(m[1] ?? "") : void 0;
20097
+ }
20098
+ function colIndex(ref) {
20099
+ const m = /^([A-Z]+)/.exec(ref);
20100
+ if (!m) return -1;
20101
+ let n = 0;
20102
+ for (const ch of m[1]) n = n * 26 + (ch.charCodeAt(0) - 64);
20103
+ return n - 1;
20104
+ }
20105
+ function textsOf(xml, tag) {
20106
+ const re = new RegExp(`<${tag}(?:\\s[^>]*)?>([\\s\\S]*?)</${tag}>`, "g");
20107
+ let out = "";
20108
+ for (let m = re.exec(xml); m; m = re.exec(xml)) out += unescapeXml(m[1] ?? "");
20109
+ return out;
20110
+ }
20111
+ function sharedStrings(xml) {
20112
+ const out = [];
20113
+ const re = /<si\b[^>]*>([\s\S]*?)<\/si>/g;
20114
+ for (let m = re.exec(xml); m; m = re.exec(xml)) out.push(flat(textsOf((m[1] ?? "").replace(/<rPh\b[\s\S]*?<\/rPh>/g, ""), "t")));
20115
+ return out;
20116
+ }
20117
+ function parseRow(inner, shared) {
20118
+ const cells = [];
20119
+ const re = /<c\b([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g;
20120
+ for (let m = re.exec(inner); m; m = re.exec(inner)) {
20121
+ const a = m[1] ?? "";
20122
+ const body = m[2] ?? "";
20123
+ const ref = attr(a, "r") ?? "";
20124
+ const t = attr(a, "t");
20125
+ let v;
20126
+ if (t === "inlineStr") v = flat(textsOf(body, "t"));
20127
+ else {
20128
+ const raw = /<v>([\s\S]*?)<\/v>/.exec(body)?.[1] ?? "";
20129
+ const val = unescapeXml(raw);
20130
+ if (t === "s") v = shared[Number(val)] ?? "";
20131
+ else if (t === "b") v = val === "1" ? "TRUE" : "FALSE";
20132
+ else v = flat(val);
20133
+ }
20134
+ const ci = colIndex(ref);
20135
+ if (ci >= 0) while (cells.length < ci) cells.push("");
20136
+ cells.push(v);
20137
+ }
20138
+ return cells;
20139
+ }
20140
+ async function openXlsx(buf, entries, budget) {
20141
+ const map = new Map(entries.map((e) => [e.name, e]));
20142
+ const wb = map.get("xl/workbook.xml");
20143
+ if (!wb) throw new Unreadable("\u6CA1\u6709 workbook");
20144
+ const wbXml = await entryText(buf, wb, budget);
20145
+ const relsEntry = map.get("xl/_rels/workbook.xml.rels");
20146
+ const rels = /* @__PURE__ */ new Map();
20147
+ if (relsEntry) {
20148
+ const relsXml = await entryText(buf, relsEntry, budget);
20149
+ for (const m of relsXml.matchAll(/<Relationship\b[^>]*>/g)) {
20150
+ const id = attr(m[0], "Id");
20151
+ const target = attr(m[0], "Target");
20152
+ if (id && target) rels.set(id, target.startsWith("/") ? target.slice(1) : `xl/${target}`);
20153
+ }
20154
+ }
20155
+ const sheets = [];
20156
+ for (const m of wbXml.matchAll(/<sheet\b[^>]*>/g)) {
20157
+ const name = attr(m[0], "name");
20158
+ const rid = attr(m[0], "r:id");
20159
+ const path = rid ? rels.get(rid) : void 0;
20160
+ if (name && path && map.has(path)) sheets.push({ name, path });
20161
+ }
20162
+ if (!sheets.length) throw new Unreadable("\u6CA1\u6709\u5DE5\u4F5C\u8868");
20163
+ const ss = map.get("xl/sharedStrings.xml");
20164
+ const shared = ss ? sharedStrings(await entryText(buf, ss, budget)) : [];
20165
+ return { buf, entries: map, sheets, shared };
20166
+ }
20167
+ async function* sheetRows(book, path, budget, onPending) {
20168
+ const entry = book.entries.get(path);
20169
+ const dec = new StringDecoder("utf8");
20170
+ let pending = "";
20171
+ let seq = 0;
20172
+ const drain = function* (final) {
20173
+ let pos = 0;
20174
+ for (; ; ) {
20175
+ const s = pending.indexOf("<row", pos);
20176
+ if (s < 0) break;
20177
+ const next = pending[s + 4];
20178
+ if (next !== " " && next !== ">" && next !== "/") {
20179
+ pos = s + 4;
20180
+ continue;
20181
+ }
20182
+ const gt = pending.indexOf(">", s);
20183
+ if (gt < 0) break;
20184
+ const tag = pending.slice(s, gt + 1);
20185
+ seq += 1;
20186
+ const n = Number(attr(tag, "r")) || seq;
20187
+ if (pending[gt - 1] === "/") {
20188
+ pos = gt + 1;
20189
+ yield { n, cells: [] };
20190
+ continue;
20191
+ }
20192
+ const e = pending.indexOf("</row>", gt);
20193
+ if (e < 0) break;
20194
+ const inner = pending.slice(gt + 1, e);
20195
+ pos = e + 6;
20196
+ yield { n, cells: parseRow(inner, book.shared) };
20197
+ }
20198
+ pending = final ? "" : pending.slice(pos);
20199
+ if (pending.length > MAX_ROW_BYTES) throw new Unreadable("\u5355\u884C\u592A\u5927");
20200
+ onPending?.(pending.length);
20201
+ };
20202
+ for await (const c of entryChunks(book.buf, entry, budget)) {
20203
+ pending += dec.write(c);
20204
+ yield* drain(false);
20205
+ }
20206
+ pending += dec.end();
20207
+ yield* drain(true);
20208
+ }
20209
+ async function pageLines(lines, opts) {
20210
+ const offset = opts.offset ?? 0;
20211
+ const limit = Math.min(opts.limit ?? PAGE_ROWS, PAGE_ROWS);
20212
+ const out = [];
20213
+ let bytes = 0;
20214
+ let idx = 0;
20215
+ let hasMore = false;
20216
+ for await (const l of lines) {
20217
+ if (opts.grep && !l.line.includes(opts.grep)) continue;
20218
+ if (idx < offset) {
20219
+ idx += 1;
20220
+ continue;
20221
+ }
20222
+ let line = l.line;
20223
+ const size = Buffer.byteLength(line);
20224
+ if (out.length >= limit || out.length > 0 && bytes + size + 1 > PAGE_BYTES) {
20225
+ hasMore = true;
20226
+ break;
20227
+ }
20228
+ if (size > PAGE_BYTES) line = `${line.slice(0, Math.floor(PAGE_BYTES / 4))}\u2026`;
20229
+ out.push(line);
20230
+ bytes += Buffer.byteLength(line) + 1;
20231
+ idx += 1;
20232
+ }
20233
+ return { text: out.join("\n"), hasMore, nextOffset: offset + out.length };
20234
+ }
20235
+ function* toLines(items) {
20236
+ let n = 0;
20237
+ for (const line of items) yield { n: ++n, line };
20238
+ }
20239
+ async function* asyncOf(it) {
20240
+ yield* it;
20241
+ }
20242
+ function decodeText(buf) {
20243
+ try {
20244
+ return new TextDecoder("utf-8", { fatal: true }).decode(buf).replace(/^/, "");
20245
+ } catch {
20246
+ try {
20247
+ return new TextDecoder("gb18030").decode(buf);
20248
+ } catch {
20249
+ return buf.toString("latin1");
20250
+ }
20251
+ }
20252
+ }
20253
+ function detect(buf) {
20254
+ if (buf.length >= 4 && buf.readUInt32LE(0) === 67324752) {
20255
+ let entries;
20256
+ try {
20257
+ entries = listZip(buf);
20258
+ } catch {
20259
+ return { kind: "unsupported", ext: "zip" };
20260
+ }
20261
+ const names = new Set(entries.map((e) => e.name));
20262
+ if (names.has("xl/workbook.xml")) return { kind: "xlsx" };
20263
+ if (names.has("word/document.xml")) return { kind: "docx" };
20264
+ if (names.has("ppt/presentation.xml")) return { kind: "pptx" };
20265
+ return { kind: "unsupported", ext: "zip" };
20266
+ }
20267
+ const head = buf.subarray(0, 8);
20268
+ if (head.subarray(0, 4).toString("latin1") === "%PDF") return { kind: "unsupported", ext: "pdf" };
20269
+ if (head.readUInt32BE(0) === 3503231456) return { kind: "unsupported", ext: "ole" };
20270
+ if (head.subarray(0, 4).equals(Buffer.from([137, 80, 78, 71])) || head[0] === 255 && head[1] === 216 || head.subarray(0, 3).toString("latin1") === "GIF") {
20271
+ return { kind: "unsupported", ext: "image" };
20272
+ }
20273
+ const sample = buf.subarray(0, 8192);
20274
+ if (sample.includes(0)) return { kind: "unsupported", ext: "binary" };
20275
+ return { kind: "text" };
20276
+ }
20277
+ async function xlsxSheetInfo(buf, stats, maxUnzipped = MAX_UNZIPPED_BYTES) {
20278
+ const budget = new Budget(maxUnzipped);
20279
+ const book = await openXlsx(buf, listZip(buf), budget);
20280
+ const out = [];
20281
+ for (const s of book.sheets) {
20282
+ let rows = 0;
20283
+ let cols = 0;
20284
+ for await (const r of sheetRows(book, s.path, budget)) {
20285
+ rows += 1;
20286
+ if (r.cells.length > cols) cols = r.cells.length;
20287
+ }
20288
+ out.push({ name: s.name, rows, cols });
20289
+ }
20290
+ if (stats) stats.inflated = budget.used;
20291
+ return out;
20292
+ }
20293
+ async function readPage(path, kind, opts, deps = {}) {
20294
+ const buf = await readFile18(path);
20295
+ if (kind === "text") {
20296
+ const lines = decodeText(buf).split(/\r?\n/);
20297
+ if (lines.length && lines[lines.length - 1] === "") lines.pop();
20298
+ const p3 = await pageLines(asyncOf(toLines(lines)), opts);
20299
+ return { ext: "text", ...p3 };
20300
+ }
20301
+ const entries = listZip(buf);
20302
+ const budget = new Budget(deps.maxUnzipped ?? MAX_UNZIPPED_BYTES);
20303
+ try {
20304
+ if (kind === "xlsx") {
20305
+ const book = await openXlsx(buf, entries, budget);
20306
+ let sheets;
20307
+ if (!opts.sheet) {
20308
+ sheets = deps.sheetsCache?.get();
20309
+ if (!sheets) {
20310
+ sheets = await xlsxSheetInfo(buf, deps.stats, deps.maxUnzipped);
20311
+ deps.sheetsCache?.set(sheets);
20312
+ }
20313
+ }
20314
+ const target = opts.sheet ? book.sheets.find((s) => s.name === opts.sheet) : book.sheets[0];
20315
+ if (!target) throw new Unreadable(`\u6CA1\u6709\u53EB\u300C${opts.sheet}\u300D\u7684\u5DE5\u4F5C\u8868`);
20316
+ async function* lines() {
20317
+ for await (const r of sheetRows(book, target.path, budget, deps.onPending)) yield { n: r.n, line: `${r.n} ${r.cells.join(" ")}` };
20318
+ }
20319
+ const p4 = await pageLines(lines(), opts);
20320
+ if (deps.stats) deps.stats.inflated = Math.max(deps.stats.inflated, budget.used);
20321
+ return { ext: "xlsx", ...sheets ? { sheets } : {}, sheet: target.name, ...p4 };
20322
+ }
20323
+ if (kind === "docx") {
20324
+ const e = entries.find((x) => x.name === "word/document.xml");
20325
+ if (!e) throw new Unreadable("\u6CA1\u6709\u6B63\u6587");
20326
+ const xml = await entryText(buf, e, budget);
20327
+ const rows2 = [];
20328
+ const re = /<w:tr\b[\s\S]*?<\/w:tr>|<w:p\b[\s\S]*?<\/w:p>/g;
20329
+ for (let m = re.exec(xml); m; m = re.exec(xml)) {
20330
+ const block = m[0];
20331
+ if (block.startsWith("<w:tr")) {
20332
+ const cells = [];
20333
+ for (const c of block.matchAll(/<w:tc\b[\s\S]*?<\/w:tc>/g)) cells.push(flat(textsOf(c[0].replace(/<w:tab\s*\/>/g, "<w:t> </w:t>"), "w:t")));
20334
+ rows2.push(cells.join(" "));
20335
+ } else {
20336
+ const t = textsOf(block.replace(/<w:tab\s*\/>/g, "<w:t> </w:t>").replace(/<w:br\s*\/>/g, "<w:t> </w:t>"), "w:t");
20337
+ if (t.trim()) rows2.push(t);
20338
+ }
20339
+ }
20340
+ const p4 = await pageLines(asyncOf(toLines(rows2)), opts);
20341
+ return { ext: "docx", ...p4 };
20342
+ }
20343
+ const slides = entries.map((x) => ({ x, n: Number(/^ppt\/slides\/slide(\d+)\.xml$/.exec(x.name)?.[1]) })).filter((s) => Number.isFinite(s.n)).sort((a, b) => a.n - b.n);
20344
+ const rows = [];
20345
+ for (const s of slides) {
20346
+ rows.push(`\u7B2C ${s.n} \u9875`);
20347
+ const xml = await entryText(buf, s.x, budget);
20348
+ for (const m of xml.matchAll(/<a:p\b[\s\S]*?<\/a:p>/g)) {
20349
+ const t = flat(textsOf(m[0], "a:t"));
20350
+ if (t.trim()) rows.push(t);
20351
+ }
20352
+ }
20353
+ const p3 = await pageLines(asyncOf(toLines(rows)), opts);
20354
+ return { ext: "pptx", ...p3 };
20355
+ } catch (err) {
20356
+ if (err instanceof Unreadable) throw err;
20357
+ throw new Unreadable(err instanceof Error ? err.message : String(err));
20358
+ }
20359
+ }
20360
+
19996
20361
  // src/bridge/user-gateway/gateway.ts
19997
20362
  var USER_READ_SCOPES = [
19998
20363
  "search:message",
@@ -20005,11 +20370,15 @@ var USER_READ_SCOPES = [
20005
20370
  "drive:drive.metadata:readonly",
20006
20371
  "offline_access"
20007
20372
  ];
20008
- var READ_APIS = ["search-messages", "get-message", "list-chat-messages", "search-docs", "fetch-doc"];
20373
+ var READ_APIS = ["search-messages", "get-message", "list-chat-messages", "search-docs", "fetch-doc", "read-file"];
20009
20374
  var HANDLE_TTL_MS = 5 * 6e4;
20010
20375
  var MESSAGE_MAX_AGE_MS = 2 * 6e4;
20011
20376
  var CLOCK_SKEW_MS = 3e4;
20012
20377
  var MAX_HANDLES_PER_MESSAGE = 5;
20378
+ var MAX_FILE_BYTES = 20 * 1024 * 1024;
20379
+ var MAX_TMP_BYTES = 500 * 1024 * 1024;
20380
+ var DOWNLOAD_TIMEOUT_MS = 6e4;
20381
+ var MAINTENANCE_MS = 6e4;
20013
20382
  var USED_TTL_MS = MESSAGE_MAX_AGE_MS + CLOCK_SKEW_MS + 6e4;
20014
20383
  var AUTH_POLL_MS = 5e3;
20015
20384
  var AUTH_MAX_MS = 10 * 6e4;
@@ -20022,6 +20391,7 @@ var RUN_ID = /^[A-Za-z0-9._:-]{1,200}$/;
20022
20391
  var NONCE = /^[0-9a-f]{32}$/;
20023
20392
  var TASK_GUID = /^[A-Za-z0-9-]{8,100}$/;
20024
20393
  var PAGE_TOKEN = /^[A-Za-z0-9+/=_-]{1,500}$/;
20394
+ var FILE_KEY = /^file_[A-Za-z0-9_-]{1,100}$/;
20025
20395
  var DOC_REF = /^([A-Za-z0-9]{8,64}|https:\/\/[A-Za-z0-9.-]+\.(larksuite|feishu)\.(com|cn)\/[A-Za-z0-9/_?=&#.-]{1,300})$/;
20026
20396
  var tail6 = (id) => id.slice(-6);
20027
20397
  function isRecord6(v) {
@@ -20115,8 +20485,33 @@ function readArgs(api, input) {
20115
20485
  }
20116
20486
  case "fetch-doc":
20117
20487
  return ["docs", "+fetch", "--as", "user", "--json", "--doc", str2(input, "doc", DOC_REF), "--doc-format", "markdown"];
20488
+ case "read-file":
20489
+ readFileParams(input);
20490
+ return [];
20118
20491
  }
20119
20492
  }
20493
+ function intParam(input, key, min, max) {
20494
+ const v = input[key];
20495
+ if (v === void 0) return void 0;
20496
+ if (!Number.isInteger(v) || v < min || v > max) throw new BadRequest(`${key} \u8981\u662F ${min}\u2013${max} \u7684\u6574\u6570`);
20497
+ return v;
20498
+ }
20499
+ function readFileParams(input) {
20500
+ const messageId = str2(input, "messageId", MESSAGE_ID);
20501
+ const fileKey = str2(input, "fileKey", FILE_KEY);
20502
+ const opts = {};
20503
+ for (const key of ["sheet", "grep"]) {
20504
+ const v = input[key];
20505
+ if (v === void 0) continue;
20506
+ if (typeof v !== "string" || !v || v.length > 200) throw new BadRequest(`${key} \u8981 1\u2013200 \u4E2A\u5B57\u7B26`);
20507
+ opts[key] = v;
20508
+ }
20509
+ const offset = intParam(input, "offset", 0, 1e7);
20510
+ const limit = intParam(input, "limit", 1, 200);
20511
+ if (offset !== void 0) opts.offset = offset;
20512
+ if (limit !== void 0) opts.limit = limit;
20513
+ return { messageId, fileKey, opts };
20514
+ }
20120
20515
  function isReadApi(api) {
20121
20516
  return READ_APIS.includes(api);
20122
20517
  }
@@ -20175,9 +20570,55 @@ function createGateway(opts) {
20175
20570
  }
20176
20571
  return r;
20177
20572
  };
20573
+ const tmpRoot = join29(opts.stateDir, "tmp-files");
20574
+ const tmpDirOf = (runId) => join29(tmpRoot, createHash8("sha256").update(runId).digest("hex").slice(0, 32));
20575
+ const downloads = /* @__PURE__ */ new Map();
20576
+ const sheetCache = /* @__PURE__ */ new Map();
20577
+ try {
20578
+ rmSync4(tmpRoot, { recursive: true, force: true });
20579
+ } catch {
20580
+ }
20581
+ async function cleanupTmp() {
20582
+ const live = /* @__PURE__ */ new Set();
20583
+ for (const v of handles.values()) live.add(tmpDirOf(v.runId).slice(tmpRoot.length + 1));
20584
+ let names;
20585
+ try {
20586
+ names = await readdir6(tmpRoot);
20587
+ } catch {
20588
+ return;
20589
+ }
20590
+ for (const n of names) {
20591
+ if (live.has(n)) continue;
20592
+ for (const k of sheetCache.keys()) if (k.startsWith(join29(tmpRoot, n))) sheetCache.delete(k);
20593
+ await rm14(join29(tmpRoot, n), { recursive: true, force: true }).catch(() => {
20594
+ });
20595
+ }
20596
+ }
20597
+ async function tmpBytes() {
20598
+ let total = 0;
20599
+ let dirs;
20600
+ try {
20601
+ dirs = await readdir6(tmpRoot);
20602
+ } catch {
20603
+ return 0;
20604
+ }
20605
+ for (const d of dirs) {
20606
+ try {
20607
+ for (const f of await readdir6(join29(tmpRoot, d))) total += (await stat8(join29(tmpRoot, d, f))).size;
20608
+ } catch {
20609
+ }
20610
+ }
20611
+ return total;
20612
+ }
20178
20613
  function sweep() {
20179
20614
  const t = now();
20180
- for (const [h, v] of handles) if (v.expiresAt <= t) handles.delete(h);
20615
+ let expired = false;
20616
+ for (const [h, v] of handles)
20617
+ if (v.expiresAt <= t) {
20618
+ handles.delete(h);
20619
+ expired = true;
20620
+ }
20621
+ if (expired) void cleanupTmp();
20181
20622
  for (const [m, until] of used) if (until <= t) used.delete(m);
20182
20623
  for (const [m, v] of issuedFor) if (v.until <= t) issuedFor.delete(m);
20183
20624
  }
@@ -20378,6 +20819,99 @@ function createGateway(opts) {
20378
20819
  log.warn("user-gateway", "auth.timeout", { sender: tail6(openId) });
20379
20820
  };
20380
20821
  }
20822
+ setInterval(() => {
20823
+ sweep();
20824
+ void cleanupTmp();
20825
+ }, MAINTENANCE_MS).unref();
20826
+ async function larkFailure(h, fields, r) {
20827
+ const e = larkError(r);
20828
+ if (!r.timedOut && e.type === "authentication") {
20829
+ await rm14(authorizedMark(h.openId), { force: true });
20830
+ for (const [k, v] of handles) if (v.openId === h.openId) handles.delete(k);
20831
+ try {
20832
+ await startAuth(h.openId);
20833
+ } catch (err) {
20834
+ log.warn("user-gateway", "read.reauth-failed", { ...fields, detail: String(err) });
20835
+ return { status: "auth_failed" };
20836
+ }
20837
+ log.info("user-gateway", "read.need-auth", { ...fields, detail: e.detail });
20838
+ return { status: "need_auth" };
20839
+ }
20840
+ log.warn("user-gateway", "read.failed", { ...fields, result: "lark_error", detail: e.detail });
20841
+ return { status: "lark_error", detail: r.timedOut ? "\u547D\u4EE4\u8D85\u65F6" : e.detail };
20842
+ }
20843
+ async function readFile19(h, input, fields) {
20844
+ const started = Date.now();
20845
+ const { messageId, fileKey, opts: ropts } = readFileParams(input);
20846
+ const dir = tmpDirOf(h.runId);
20847
+ const outName = `${fileKey}.bin`;
20848
+ let path = join29(dir, outName);
20849
+ const fail = (result, extra = {}) => log.warn("user-gateway", "read.failed", { ...fields, result, ...extra });
20850
+ if (!existsSync10(path)) {
20851
+ if (await tmpBytes() >= (opts.tmpMaxBytes ?? MAX_TMP_BYTES)) {
20852
+ fail("busy");
20853
+ return { status: "busy" };
20854
+ }
20855
+ const key = `${h.runId}:${fileKey}`;
20856
+ let dl = downloads.get(key);
20857
+ if (!dl) {
20858
+ dl = (async () => {
20859
+ await mkdir19(dir, { recursive: true, mode: 448 });
20860
+ const r2 = await opts.exec(
20861
+ ["im", "+messages-resources-download", "--message-id", messageId, "--file-key", fileKey, "--type", "file", "--as", "user", "--output", outName],
20862
+ env(userDir(h.openId)),
20863
+ DOWNLOAD_TIMEOUT_MS,
20864
+ dir
20865
+ );
20866
+ return { r: r2, path };
20867
+ })().finally(() => downloads.delete(key));
20868
+ downloads.set(key, dl);
20869
+ }
20870
+ const { r } = await dl;
20871
+ if (r.code !== 0) {
20872
+ await rm14(path, { force: true });
20873
+ return larkFailure(h, fields, r);
20874
+ }
20875
+ }
20876
+ if (!existsSync10(path)) {
20877
+ try {
20878
+ const hit = (await readdir6(dir)).filter((n) => n.startsWith(fileKey));
20879
+ if (hit.length === 1) path = join29(dir, hit[0]);
20880
+ } catch {
20881
+ }
20882
+ }
20883
+ let size;
20884
+ try {
20885
+ size = (await stat8(path)).size;
20886
+ } catch {
20887
+ if (![...handles.values()].includes(h)) return { status: "expired" };
20888
+ fail("lark_error", { detail: "\u4E0B\u8F7D\u540E\u627E\u4E0D\u5230\u6587\u4EF6" });
20889
+ return { status: "lark_error", detail: "\u4E0B\u8F7D\u540E\u627E\u4E0D\u5230\u6587\u4EF6" };
20890
+ }
20891
+ if (size > MAX_FILE_BYTES) {
20892
+ await rm14(path, { force: true });
20893
+ fail("too_large", { sizeBytes: size });
20894
+ return { status: "too_large", sizeBytes: size };
20895
+ }
20896
+ try {
20897
+ const kind = detect(await readFileFs(path));
20898
+ if (kind.kind === "unsupported") {
20899
+ fail("unsupported_type", { ext: kind.ext, sizeBytes: size });
20900
+ return { status: "unsupported_type", ext: kind.ext };
20901
+ }
20902
+ const page = await readPage(path, kind.kind, ropts, {
20903
+ sheetsCache: { get: () => sheetCache.get(path), set: (v) => sheetCache.set(path, v) }
20904
+ });
20905
+ log.info("user-gateway", "read.ok", { ...fields, result: "ok", ext: page.ext, sizeBytes: size, durationMs: Date.now() - started });
20906
+ return { status: "ok", data: { ext: page.ext, sizeBytes: size, ...page.sheets ? { sheets: page.sheets } : {}, ...page.sheet !== void 0 ? { sheet: page.sheet } : {}, text: page.text, hasMore: page.hasMore, nextOffset: page.nextOffset } };
20907
+ } catch (err) {
20908
+ if (err instanceof Unreadable) {
20909
+ fail("unreadable", { sizeBytes: size });
20910
+ return { status: "unreadable", detail: err.message };
20911
+ }
20912
+ throw err;
20913
+ }
20914
+ }
20381
20915
  return {
20382
20916
  /** POST /handles:核实提问人(私聊或群里的消息),发句柄;没授权就发卡片并返回 need_auth,查库开着时同一轮仍带只能查库的句柄(intent 0068)。 */
20383
20917
  async requestHandle(input) {
@@ -20426,8 +20960,14 @@ function createGateway(opts) {
20426
20960
  }
20427
20961
  }
20428
20962
  if (n) log.info("user-gateway", "handle.dropped", { runId, count: n });
20963
+ void cleanupTmp();
20429
20964
  return n;
20430
20965
  },
20966
+ /** 每分钟一次:过期的句柄清掉,没有存活句柄的附件临时目录删掉(没有请求进来时也要清,intent 0077 R-09b)。测试里可直接调。 */
20967
+ async maintenance() {
20968
+ sweep();
20969
+ await cleanupTmp();
20970
+ },
20431
20971
  /** POST /read/{api}:凭句柄找到提问人,用他的目录跑 lark-cli。 */
20432
20972
  async read(handle2, api, input) {
20433
20973
  sweep();
@@ -20450,24 +20990,9 @@ function createGateway(opts) {
20450
20990
  log.warn("user-gateway", "read.failed", { ...fields, result: "lark_error" });
20451
20991
  return { status: "lark_error", detail: String(err instanceof Error ? err.message : err) };
20452
20992
  }
20993
+ if (api === "read-file") return readFile19(h, input, fields);
20453
20994
  const r = await opts.exec(args, env(userDir(h.openId)), 6e4);
20454
- if (r.code !== 0) {
20455
- const e = larkError(r);
20456
- if (!r.timedOut && e.type === "authentication") {
20457
- await rm14(authorizedMark(h.openId), { force: true });
20458
- for (const [k, v] of handles) if (v.openId === h.openId) handles.delete(k);
20459
- try {
20460
- await startAuth(h.openId);
20461
- } catch (err) {
20462
- log.warn("user-gateway", "read.reauth-failed", { ...fields, detail: String(err) });
20463
- return { status: "auth_failed" };
20464
- }
20465
- log.info("user-gateway", "read.need-auth", { ...fields, detail: e.detail });
20466
- return { status: "need_auth" };
20467
- }
20468
- log.warn("user-gateway", "read.failed", { ...fields, result: "lark_error", detail: e.detail });
20469
- return { status: "lark_error", detail: r.timedOut ? "\u547D\u4EE4\u8D85\u65F6" : e.detail };
20470
- }
20995
+ if (r.code !== 0) return larkFailure(h, fields, r);
20471
20996
  log.info("user-gateway", "read.ok", { ...fields, result: "ok" });
20472
20997
  return { status: "ok", data: parseJson4(r.stdout) ?? r.stdout };
20473
20998
  },
@@ -20646,13 +21171,13 @@ function createGateway(opts) {
20646
21171
  }
20647
21172
 
20648
21173
  // src/bridge/user-gateway/server.ts
20649
- import { createHash as createHash8, timingSafeEqual as timingSafeEqual3 } from "crypto";
21174
+ import { createHash as createHash9, timingSafeEqual as timingSafeEqual3 } from "crypto";
20650
21175
  import { createServer as createServer2 } from "http";
20651
21176
  var MAX_BODY = 16 * 1024;
20652
21177
  var CLAUDE_ROUTES = /* @__PURE__ */ new Set(["/claude/token", "/claude/task-token", "/claude/ready", "/claude/login-submit", "/claude/logout"]);
20653
21178
  var DB_TASK_HANDLE = "/db/task-handle";
20654
21179
  var DB_QUERY = "/db/query";
20655
- var digest = (s) => createHash8("sha256").update(s).digest();
21180
+ var digest = (s) => createHash9("sha256").update(s).digest();
20656
21181
  function tokenOk(given, expected) {
20657
21182
  if (typeof given !== "string" || !given) return false;
20658
21183
  return timingSafeEqual3(digest(given), expected);