aai-lark-bridge 0.2.38 → 0.2.40

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.38",
7
+ version: "0.2.40",
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",
@@ -7116,6 +7116,7 @@ var LOGOUT_TEXT = "\u9000\u51FA Claude \u767B\u5F55";
7116
7116
  var MIN_TOKEN_LEFT_MS = 2 * 60 * 6e4;
7117
7117
  var MIN_AFTER_REFRESH_MS = 10 * 6e4;
7118
7118
  var REFRESH_COOLDOWN_MS = 30 * 6e4;
7119
+ var REFRESH_RETRY_DELAY_MS = 5e3;
7119
7120
  var READY_NUDGE_MS = 60 * 6e4;
7120
7121
  var LOGIN_MAX_MS = 10 * 6e4;
7121
7122
  var SUBMIT_MAX_MS = 3e4;
@@ -7246,13 +7247,36 @@ function createClaudeSeat(opts) {
7246
7247
  if (!c) return nudge2 ? { status: await startLogin(openId) } : { status: "need_login" };
7247
7248
  const recent = now() - (refreshedAt.get(openId) ?? -Infinity) < REFRESH_COOLDOWN_MS && c.expiresAt - now() >= MIN_AFTER_REFRESH_MS;
7248
7249
  if (c.expiresAt - now() < MIN_TOKEN_LEFT_MS && !recent) {
7249
- const ok = await opts.cli.refresh(dir).catch(() => false);
7250
- c = readCredentials(dir);
7251
- const left = c ? c.expiresAt - now() : 0;
7252
- if (!ok || !c || left < MIN_AFTER_REFRESH_MS) {
7253
- log.warn("user-gateway", "claude.refresh-failed", { sender: tail62(openId), proof, runId });
7254
- return { status: "refresh_failed" };
7250
+ const attempt = async (n) => {
7251
+ const r = normalizeRefresh(await opts.cli.refresh(dir).catch((err) => ({ ok: false, spawnError: scrubOutput(String(err)) })));
7252
+ const cur = readCredentials(dir);
7253
+ const left = cur ? cur.expiresAt - now() : 0;
7254
+ const good = r.ok && !!cur && left >= MIN_AFTER_REFRESH_MS;
7255
+ if (!good) {
7256
+ log.warn("user-gateway", "claude.refresh-failed", {
7257
+ sender: tail62(openId),
7258
+ proof,
7259
+ runId,
7260
+ attempt: n,
7261
+ exitCode: r.exitCode ?? null,
7262
+ signal: r.signal ?? null,
7263
+ timedOut: r.timedOut ?? false,
7264
+ durationMs: r.durationMs ?? null,
7265
+ credentials: cur ? `left-${Math.round(left / 6e4)}min` : "unreadable",
7266
+ stdoutTail: r.stdoutTail ?? "",
7267
+ stderrTail: r.stderrTail ?? "",
7268
+ spawnError: r.spawnError ?? ""
7269
+ });
7270
+ }
7271
+ return { good, cur };
7272
+ };
7273
+ let res = await attempt(1);
7274
+ if (!res.good) {
7275
+ await sleep2(opts.refreshRetryDelayMs ?? REFRESH_RETRY_DELAY_MS);
7276
+ res = await attempt(2);
7255
7277
  }
7278
+ c = res.cur;
7279
+ if (!res.good || !c) return { status: "refresh_failed" };
7256
7280
  refreshedAt.set(openId, now());
7257
7281
  log.info("user-gateway", "claude.refreshed", { sender: tail62(openId), proof, runId });
7258
7282
  }
@@ -7349,21 +7373,48 @@ function scrub(text, code) {
7349
7373
  for (const part of code.trim().split("#")) if (part.length >= 6) t = t.split(part).join("<code>");
7350
7374
  return t.replace(/[A-Za-z0-9_-]{40,}/g, "<long>").replace(/\s+/g, " ").trim().slice(0, 300);
7351
7375
  }
7376
+ var sleep2 = (ms) => ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
7377
+ function normalizeRefresh(r) {
7378
+ return typeof r === "boolean" ? { ok: r } : r;
7379
+ }
7380
+ function scrubOutput(text) {
7381
+ const t = text.replace(/"(access|refresh)_?token"\s*:\s*"[^"]*"/gi, '"$1Token":"<redacted>"').replace(/sk-ant-[A-Za-z0-9_-]+/g, "<token>").replace(/\b(Bearer\s+)[A-Za-z0-9._\-+/=]+/gi, "$1<token>").replace(/[A-Za-z0-9_\-.]{32,}/g, "<long>").replace(/\s+/g, " ").trim();
7382
+ return t.length > 400 ? `\u2026${t.slice(-400)}` : t;
7383
+ }
7352
7384
  function realClaudeCli(binary = process.env.SDLC_REAL_CLAUDE || "claude") {
7353
7385
  const baseEnv = (dir) => {
7354
7386
  const keep = Object.fromEntries(Object.entries(process.env).filter(([k]) => /^(PATH|LANG|https?_proxy|no_proxy|HTTPS?_PROXY|NO_PROXY)$/.test(k)));
7355
7387
  return { ...keep, HOME: dir, CLAUDE_CONFIG_DIR: dir };
7356
7388
  };
7389
+ const OUT_KEEP = 4e3;
7357
7390
  const run2 = (args, dir, timeoutMs) => new Promise((resolve3) => {
7358
7391
  void mkdtemp(join19(tmpdir4(), "claude-seat-")).then((cwd) => {
7359
- const p3 = spawn(binary, args, { cwd, env: baseEnv(dir), stdio: ["ignore", "ignore", "ignore"] });
7360
- const t = setTimeout(() => p3.kill("SIGTERM"), timeoutMs).unref();
7361
- p3.on("close", (code) => {
7362
- clearTimeout(t);
7392
+ const started = Date.now();
7393
+ let stdout = "";
7394
+ let stderr = "";
7395
+ let timedOut = false;
7396
+ let settled = false;
7397
+ const finish = (r) => {
7398
+ if (settled) return;
7399
+ settled = true;
7363
7400
  void rm11(cwd, { recursive: true, force: true });
7364
- resolve3(code ?? 1);
7401
+ resolve3({ ...r, durationMs: Date.now() - started, stdoutTail: scrubOutput(stdout), stderrTail: scrubOutput(stderr) });
7402
+ };
7403
+ const p3 = spawn(binary, args, { cwd, env: baseEnv(dir), stdio: ["ignore", "pipe", "pipe"] });
7404
+ p3.stdout.on("data", (d) => stdout = (stdout + d.toString()).slice(-OUT_KEEP));
7405
+ p3.stderr.on("data", (d) => stderr = (stderr + d.toString()).slice(-OUT_KEEP));
7406
+ const t = setTimeout(() => {
7407
+ timedOut = true;
7408
+ p3.kill("SIGTERM");
7409
+ }, timeoutMs).unref();
7410
+ p3.on("close", (code, signal) => {
7411
+ clearTimeout(t);
7412
+ finish({ ok: code === 0, exitCode: code, signal, timedOut });
7413
+ });
7414
+ p3.on("error", (err) => {
7415
+ clearTimeout(t);
7416
+ finish({ ok: false, exitCode: null, spawnError: scrubOutput(String(err)) });
7365
7417
  });
7366
- p3.on("error", () => resolve3(1));
7367
7418
  });
7368
7419
  });
7369
7420
  return {
@@ -7435,7 +7486,7 @@ function realClaudeCli(binary = process.env.SDLC_REAL_CLAUDE || "claude") {
7435
7486
  };
7436
7487
  },
7437
7488
  async refresh(dir) {
7438
- return await run2(["-p", "\u53EA\u56DE\u590D\u6570\u5B571", "--model", "haiku", "--output-format", "json"], dir, 12e4) === 0;
7489
+ return run2(["-p", "\u53EA\u56DE\u590D\u6570\u5B571", "--model", "haiku", "--output-format", "json"], dir, 12e4);
7439
7490
  },
7440
7491
  async logout(dir) {
7441
7492
  await run2(["auth", "logout"], dir, 3e4);
@@ -7480,6 +7531,9 @@ var PROMPT_TOOL = `## \u7528\u63D0\u95EE\u4EBA\u7684\u8EAB\u4EFD\u53EA\u8BFB\uFF
7480
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
7481
7532
  - \`aai-user-read search-docs --query <\u5173\u952E\u8BCD> [--page-size N] [--page-token T]\`\uFF1A\u641C\u4ED6\u80FD\u770B\u7684\u6587\u6863
7482
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
7483
7537
 
7484
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
7485
7539
 
@@ -15326,7 +15380,7 @@ function installStreamResilience(channel, opts = {}) {
15326
15380
  const s = sender;
15327
15381
  const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
15328
15382
  const baseDelayMs = opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
15329
- const sleep2 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
15383
+ const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
15330
15384
  const tracker = {
15331
15385
  streamOptsByCard: /* @__PURE__ */ new Map(),
15332
15386
  lostStreams: /* @__PURE__ */ new WeakSet(),
@@ -15347,7 +15401,7 @@ function installStreamResilience(channel, opts = {}) {
15347
15401
  status: raw?.response?.status,
15348
15402
  code: raw?.response?.data?.code
15349
15403
  });
15350
- await sleep2(baseDelayMs * 3 ** (attempt - 1));
15404
+ await sleep3(baseDelayMs * 3 ** (attempt - 1));
15351
15405
  }
15352
15406
  }
15353
15407
  }
@@ -17572,13 +17626,14 @@ var generated_default = '<!doctype html>\n<html lang="zh-CN">\n <head>\n <me
17572
17626
  // src/bridge/lark-cli/user-im.ts
17573
17627
  var LIST_CHAT_SCOPES = ["im:chat:read"];
17574
17628
  var ADD_BOT_SCOPES = ["im:chat.members:write_only"];
17575
- var defaultExec = (args, env, timeoutMs) => new Promise((resolve3) => {
17629
+ var defaultExec = (args, env, timeoutMs, cwd) => new Promise((resolve3) => {
17576
17630
  let stdout = "";
17577
17631
  let stderr = "";
17578
17632
  let timedOut = false;
17579
17633
  const child = spawnProcess("lark-cli", args, {
17580
17634
  env: mergeProcessEnv(process.env, env),
17581
- stdio: ["ignore", "pipe", "pipe"]
17635
+ stdio: ["ignore", "pipe", "pipe"],
17636
+ ...cwd ? { cwd } : {}
17582
17637
  });
17583
17638
  child.stdout?.on("data", (b) => stdout += b.toString("utf8"));
17584
17639
  child.stderr?.on("data", (b) => stderr += b.toString("utf8"));
@@ -19830,9 +19885,9 @@ function toResult(r) {
19830
19885
  }
19831
19886
 
19832
19887
  // src/bridge/user-gateway/gateway.ts
19833
- import { randomBytes as randomBytes10 } from "crypto";
19834
- import { existsSync as existsSync10 } from "fs";
19835
- 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";
19836
19891
  import { join as join29 } from "path";
19837
19892
 
19838
19893
  // src/bridge/user-gateway/app-token.ts
@@ -19942,6 +19997,367 @@ function realAppTokenFetcher(sourceConfigFile) {
19942
19997
  };
19943
19998
  }
19944
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
+
19945
20361
  // src/bridge/user-gateway/gateway.ts
19946
20362
  var USER_READ_SCOPES = [
19947
20363
  "search:message",
@@ -19954,10 +20370,15 @@ var USER_READ_SCOPES = [
19954
20370
  "drive:drive.metadata:readonly",
19955
20371
  "offline_access"
19956
20372
  ];
19957
- 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"];
19958
20374
  var HANDLE_TTL_MS = 5 * 6e4;
19959
20375
  var MESSAGE_MAX_AGE_MS = 2 * 6e4;
19960
20376
  var CLOCK_SKEW_MS = 3e4;
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;
19961
20382
  var USED_TTL_MS = MESSAGE_MAX_AGE_MS + CLOCK_SKEW_MS + 6e4;
19962
20383
  var AUTH_POLL_MS = 5e3;
19963
20384
  var AUTH_MAX_MS = 10 * 6e4;
@@ -19970,6 +20391,7 @@ var RUN_ID = /^[A-Za-z0-9._:-]{1,200}$/;
19970
20391
  var NONCE = /^[0-9a-f]{32}$/;
19971
20392
  var TASK_GUID = /^[A-Za-z0-9-]{8,100}$/;
19972
20393
  var PAGE_TOKEN = /^[A-Za-z0-9+/=_-]{1,500}$/;
20394
+ var FILE_KEY = /^file_[A-Za-z0-9_-]{1,100}$/;
19973
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})$/;
19974
20396
  var tail6 = (id) => id.slice(-6);
19975
20397
  function isRecord6(v) {
@@ -20063,16 +20485,42 @@ function readArgs(api, input) {
20063
20485
  }
20064
20486
  case "fetch-doc":
20065
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 [];
20066
20491
  }
20067
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
+ }
20068
20515
  function isReadApi(api) {
20069
20516
  return READ_APIS.includes(api);
20070
20517
  }
20071
20518
  function createGateway(opts) {
20072
20519
  const now = opts.now ?? Date.now;
20073
- const sleep2 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms).unref()));
20520
+ const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms).unref()));
20074
20521
  const handles = /* @__PURE__ */ new Map();
20075
20522
  const used = /* @__PURE__ */ new Map();
20523
+ const issuedFor = /* @__PURE__ */ new Map();
20076
20524
  const inFlight = /* @__PURE__ */ new Set();
20077
20525
  const pendingAuth = /* @__PURE__ */ new Map();
20078
20526
  const tokenRoot = join29(opts.stateDir, "user-tokens", opts.appId);
@@ -20117,15 +20565,62 @@ function createGateway(opts) {
20117
20565
  for (const wait of RATE_LIMIT_BACKOFF_MS) {
20118
20566
  if (r.code === 0 || !isRateLimited(r)) break;
20119
20567
  log.warn("user-gateway", "lark.rate-limited", { api: args.slice(0, 3).join(" "), retryInMs: wait });
20120
- await sleep2(wait);
20568
+ await sleep3(wait);
20121
20569
  r = await opts.exec(args, await appEnv(), timeoutMs);
20122
20570
  }
20123
20571
  return r;
20124
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
+ }
20125
20613
  function sweep() {
20126
20614
  const t = now();
20127
- 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();
20128
20622
  for (const [m, until] of used) if (until <= t) used.delete(m);
20623
+ for (const [m, v] of issuedFor) if (v.until <= t) issuedFor.delete(m);
20129
20624
  }
20130
20625
  async function verify(messageId, purpose, requireP2p = true) {
20131
20626
  sweep();
@@ -20148,6 +20643,31 @@ function createGateway(opts) {
20148
20643
  inFlight.delete(key);
20149
20644
  }
20150
20645
  }
20646
+ async function verifyHandle(messageId) {
20647
+ const v = await verify(messageId, "handle", false);
20648
+ if (typeof v !== "string") {
20649
+ issuedFor.set(messageId, { openId: v.openId, n: 1, until: now() + USED_TTL_MS });
20650
+ return v;
20651
+ }
20652
+ const prev = issuedFor.get(messageId);
20653
+ if (v !== "used" || !prev || prev.n >= MAX_HANDLES_PER_MESSAGE) return v;
20654
+ const key = `handle-again:${messageId}`;
20655
+ if (inFlight.has(key)) return "used";
20656
+ inFlight.add(key);
20657
+ try {
20658
+ const again = await check2(messageId);
20659
+ if (typeof again === "string") return again;
20660
+ if (again.openId !== prev.openId) return "used";
20661
+ prev.n += 1;
20662
+ log.info("user-gateway", "identity.reissue", { messageId, sender: tail6(again.openId), n: prev.n });
20663
+ return again;
20664
+ } catch (err) {
20665
+ log.warn("user-gateway", "verify.failed", { messageId, detail: String(err) });
20666
+ return "lark_error";
20667
+ } finally {
20668
+ inFlight.delete(key);
20669
+ }
20670
+ }
20151
20671
  async function check2(messageId) {
20152
20672
  const msg = await asApp(["api", "GET", `/open-apis/im/v1/messages/${messageId}`, "--as", "bot"]);
20153
20673
  const mjson = parseJson4(msg.stdout);
@@ -20244,7 +20764,8 @@ function createGateway(opts) {
20244
20764
  cli: opts.claudeCli ?? realClaudeCli(),
20245
20765
  sendCard,
20246
20766
  updateCard,
20247
- now
20767
+ now,
20768
+ refreshRetryDelayMs: opts.claudeRefreshRetryDelayMs
20248
20769
  });
20249
20770
  async function startAuth(openId) {
20250
20771
  if (pendingAuth.has(openId)) return;
@@ -20286,7 +20807,7 @@ function createGateway(opts) {
20286
20807
  return async () => {
20287
20808
  const deadline = now() + AUTH_MAX_MS;
20288
20809
  while (now() < deadline) {
20289
- await sleep2(AUTH_POLL_MS);
20810
+ await sleep3(AUTH_POLL_MS);
20290
20811
  const r = await opts.exec(["auth", "login", "--device-code", deviceCode, "--json"], env(dir), 3e4);
20291
20812
  if (r.code === 0) {
20292
20813
  await writeFile9(authorizedMark(openId), `${new Date(now()).toISOString()}
@@ -20298,6 +20819,89 @@ function createGateway(opts) {
20298
20819
  log.warn("user-gateway", "auth.timeout", { sender: tail6(openId) });
20299
20820
  };
20300
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 path = join29(dir, fileKey);
20848
+ const fail = (result, extra = {}) => log.warn("user-gateway", "read.failed", { ...fields, result, ...extra });
20849
+ if (!existsSync10(path)) {
20850
+ if (await tmpBytes() >= (opts.tmpMaxBytes ?? MAX_TMP_BYTES)) {
20851
+ fail("busy");
20852
+ return { status: "busy" };
20853
+ }
20854
+ const key = `${h.runId}:${fileKey}`;
20855
+ let dl = downloads.get(key);
20856
+ if (!dl) {
20857
+ dl = (async () => {
20858
+ await mkdir19(dir, { recursive: true, mode: 448 });
20859
+ const r2 = await opts.exec(
20860
+ ["im", "+messages-resources-download", "--message-id", messageId, "--file-key", fileKey, "--type", "file", "--as", "user", "--output", fileKey],
20861
+ env(userDir(h.openId)),
20862
+ DOWNLOAD_TIMEOUT_MS,
20863
+ dir
20864
+ );
20865
+ return { r: r2, path };
20866
+ })().finally(() => downloads.delete(key));
20867
+ downloads.set(key, dl);
20868
+ }
20869
+ const { r } = await dl;
20870
+ if (r.code !== 0) {
20871
+ await rm14(path, { force: true });
20872
+ return larkFailure(h, fields, r);
20873
+ }
20874
+ }
20875
+ let size;
20876
+ try {
20877
+ size = (await stat8(path)).size;
20878
+ } catch {
20879
+ return { status: "expired" };
20880
+ }
20881
+ if (size > MAX_FILE_BYTES) {
20882
+ await rm14(path, { force: true });
20883
+ fail("too_large", { sizeBytes: size });
20884
+ return { status: "too_large", sizeBytes: size };
20885
+ }
20886
+ try {
20887
+ const kind = detect(await readFileFs(path));
20888
+ if (kind.kind === "unsupported") {
20889
+ fail("unsupported_type", { ext: kind.ext, sizeBytes: size });
20890
+ return { status: "unsupported_type", ext: kind.ext };
20891
+ }
20892
+ const page = await readPage(path, kind.kind, ropts, {
20893
+ sheetsCache: { get: () => sheetCache.get(path), set: (v) => sheetCache.set(path, v) }
20894
+ });
20895
+ log.info("user-gateway", "read.ok", { ...fields, result: "ok", ext: page.ext, sizeBytes: size, durationMs: Date.now() - started });
20896
+ 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 } };
20897
+ } catch (err) {
20898
+ if (err instanceof Unreadable) {
20899
+ fail("unreadable", { sizeBytes: size });
20900
+ return { status: "unreadable", detail: err.message };
20901
+ }
20902
+ throw err;
20903
+ }
20904
+ }
20301
20905
  return {
20302
20906
  /** POST /handles:核实提问人(私聊或群里的消息),发句柄;没授权就发卡片并返回 need_auth,查库开着时同一轮仍带只能查库的句柄(intent 0068)。 */
20303
20907
  async requestHandle(input) {
@@ -20308,7 +20912,7 @@ function createGateway(opts) {
20308
20912
  } catch {
20309
20913
  return { status: "bad_request" };
20310
20914
  }
20311
- const v = await verify(messageId, "handle", false);
20915
+ const v = await verifyHandle(messageId);
20312
20916
  if (typeof v === "string") {
20313
20917
  log.info("user-gateway", "handle.refused", { messageId, runId, result: v });
20314
20918
  return { status: v };
@@ -20346,8 +20950,14 @@ function createGateway(opts) {
20346
20950
  }
20347
20951
  }
20348
20952
  if (n) log.info("user-gateway", "handle.dropped", { runId, count: n });
20953
+ void cleanupTmp();
20349
20954
  return n;
20350
20955
  },
20956
+ /** 每分钟一次:过期的句柄清掉,没有存活句柄的附件临时目录删掉(没有请求进来时也要清,intent 0077 R-09b)。测试里可直接调。 */
20957
+ async maintenance() {
20958
+ sweep();
20959
+ await cleanupTmp();
20960
+ },
20351
20961
  /** POST /read/{api}:凭句柄找到提问人,用他的目录跑 lark-cli。 */
20352
20962
  async read(handle2, api, input) {
20353
20963
  sweep();
@@ -20370,24 +20980,9 @@ function createGateway(opts) {
20370
20980
  log.warn("user-gateway", "read.failed", { ...fields, result: "lark_error" });
20371
20981
  return { status: "lark_error", detail: String(err instanceof Error ? err.message : err) };
20372
20982
  }
20983
+ if (api === "read-file") return readFile19(h, input, fields);
20373
20984
  const r = await opts.exec(args, env(userDir(h.openId)), 6e4);
20374
- if (r.code !== 0) {
20375
- const e = larkError(r);
20376
- if (!r.timedOut && e.type === "authentication") {
20377
- await rm14(authorizedMark(h.openId), { force: true });
20378
- for (const [k, v] of handles) if (v.openId === h.openId) handles.delete(k);
20379
- try {
20380
- await startAuth(h.openId);
20381
- } catch (err) {
20382
- log.warn("user-gateway", "read.reauth-failed", { ...fields, detail: String(err) });
20383
- return { status: "auth_failed" };
20384
- }
20385
- log.info("user-gateway", "read.need-auth", { ...fields, detail: e.detail });
20386
- return { status: "need_auth" };
20387
- }
20388
- log.warn("user-gateway", "read.failed", { ...fields, result: "lark_error", detail: e.detail });
20389
- return { status: "lark_error", detail: r.timedOut ? "\u547D\u4EE4\u8D85\u65F6" : e.detail };
20390
- }
20985
+ if (r.code !== 0) return larkFailure(h, fields, r);
20391
20986
  log.info("user-gateway", "read.ok", { ...fields, result: "ok" });
20392
20987
  return { status: "ok", data: parseJson4(r.stdout) ?? r.stdout };
20393
20988
  },
@@ -20566,13 +21161,13 @@ function createGateway(opts) {
20566
21161
  }
20567
21162
 
20568
21163
  // src/bridge/user-gateway/server.ts
20569
- import { createHash as createHash8, timingSafeEqual as timingSafeEqual3 } from "crypto";
21164
+ import { createHash as createHash9, timingSafeEqual as timingSafeEqual3 } from "crypto";
20570
21165
  import { createServer as createServer2 } from "http";
20571
21166
  var MAX_BODY = 16 * 1024;
20572
21167
  var CLAUDE_ROUTES = /* @__PURE__ */ new Set(["/claude/token", "/claude/task-token", "/claude/ready", "/claude/login-submit", "/claude/logout"]);
20573
21168
  var DB_TASK_HANDLE = "/db/task-handle";
20574
21169
  var DB_QUERY = "/db/query";
20575
- var digest = (s) => createHash8("sha256").update(s).digest();
21170
+ var digest = (s) => createHash9("sha256").update(s).digest();
20576
21171
  function tokenOk(given, expected) {
20577
21172
  if (typeof given !== "string" || !given) return false;
20578
21173
  return timingSafeEqual3(digest(given), expected);