weaver-work-cli 0.1.28 → 0.1.31

package/dist/chunks/chunk-AC7KJWC5.js

@@ -0,0 +1,358 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  cacheScopeSuffix,
+  readCache,
+  writeCache
+} from "./chunk-CVZ2JOSW.js";
+import {
+  EB_BASE,
+  SCHEMA_DATETIME_MINUTE,
+  ebBusinessSuccess,
+  extractEbRows,
+  meetingSuccess,
+  queryBody,
+  schemaOf
+} from "./chunk-H6XSTSLM.js";
+
+// src/shortcuts/meeting/operations/eb/room-recommend.ts
+var ROOMS_TTL_MS = 24 * 60 * 60 * 1e3;
+var FREQUENT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var FREQUENT_WINDOW_DAYS = 180;
+var PAGE_SIZE = 100;
+var MAX_PAGES = 20;
+var STATUS_TEXT = { "0": "\u6B63\u5E38", "1": "\u5C01\u5B58" };
+var ATTR_TEXT = { "0": "\u5B9E\u4F53", "1": "\u865A\u62DF", "2": "\u7EC4\u5408" };
+function toText(value) {
+  if (value === void 0 || value === null) return "";
+  if (Array.isArray(value)) {
+    return value.map((item) => item && typeof item === "object" ? String(item.name ?? item.id ?? "") : String(item ?? "")).filter((item) => item !== "").join(",");
+  }
+  if (typeof value === "object") {
+    const item = value;
+    return String(item.name ?? item.id ?? "");
+  }
+  return String(value);
+}
+function toNumber(value) {
+  const text = toText(value).trim();
+  if (text === "") return 0;
+  const parsed = Number(text);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+async function fetchRoomsPage(env, pageNo) {
+  const session = await env.host.getSession();
+  const response = await env.host.request({
+    method: "POST",
+    path: `${EB_BASE}/getFormDataList/query_meeting_room_list`,
+    operation: "meeting.eb.room.recommend",
+    body: queryBody(session.userId, { pageNo, pageSize: PAGE_SIZE }),
+    acceptBusiness: ebBusinessSuccess
+  });
+  const { rows } = extractEbRows(response);
+  return { rows, requests: 1 };
+}
+function normalizeRoom(row) {
+  const main = row?.mainTable ?? row ?? {};
+  const status = toText(main.status).trim();
+  const roomAttr = toText(main.room_attr).trim();
+  return {
+    id: toText(main.id).trim(),
+    name: toText(main.room_name).trim(),
+    status,
+    statusText: STATUS_TEXT[status] ?? (status === "" ? "\u672A\u8BBE\u7F6E" : status),
+    roomAttr,
+    roomAttrText: ATTR_TEXT[roomAttr] ?? roomAttr,
+    minNum: toNumber(main.allow_minnum),
+    maxNum: toNumber(main.allow_maxnum),
+    place: toText(main.place).trim(),
+    equipments: toText(main.equipments).trim(),
+    mrType: toText(main.mr_type).trim()
+  };
+}
+async function loadRooms(env, options = {}) {
+  const key = `rooms-${await cacheScopeSuffix(env)}`;
+  const warnings = [];
+  if (!options.refresh) {
+    const cached = await readCache(env, key, { ttlMs: ROOMS_TTL_MS });
+    if (cached?.data?.length) {
+      return {
+        rooms: cached.data,
+        fromCache: true,
+        ageSeconds: Math.floor(cached.ageMs / 1e3),
+        requests: 0,
+        warnings
+      };
+    }
+  }
+  const rooms = [];
+  let requests = 0;
+  for (let pageNo = 1; pageNo <= MAX_PAGES; pageNo += 1) {
+    const page = await fetchRoomsPage(env, pageNo);
+    requests += page.requests;
+    rooms.push(...page.rows.map(normalizeRoom).filter((room) => room.id !== ""));
+    if (page.rows.length < PAGE_SIZE) break;
+  }
+  if (rooms.length === 0) {
+    warnings.push("\u4F1A\u8BAE\u5BA4\u5217\u8868\u4E3A\u7A7A\uFF08\u6216\u5F53\u524D\u8D26\u53F7\u65E0\u4F1A\u8BAE\u5BA4\u8BFB\u53D6\u6743\u9650\uFF09\u2014\u2014\u65E0\u6CD5\u63A8\u8350\uFF0C\u8BF7\u6539\u4E3A\u624B\u5DE5\u6307\u5B9A\u4F1A\u8BAE\u5BA4");
+  } else {
+    await writeCache(env, key, rooms);
+  }
+  return { rooms, fromCache: false, ageSeconds: 0, requests, warnings };
+}
+async function loadFrequentRooms(env, options = {}) {
+  const session = await env.host.getSession();
+  const userId = String(session?.userId ?? "").trim();
+  const key = `frequent-rooms-${await cacheScopeSuffix(env)}-${userId}`;
+  const warnings = [];
+  if (!options.refresh) {
+    const cached = await readCache(env, key, { ttlMs: FREQUENT_TTL_MS });
+    if (cached?.data) {
+      return { order: cached.data, fromCache: true, requests: 0, warnings };
+    }
+  }
+  if (!userId) {
+    return { order: [], fromCache: false, requests: 0, warnings: ["\u53D6\u4E0D\u5230\u5F53\u524D\u7528\u6237 id\uFF0C\u8DF3\u8FC7\u300C\u5E38\u7528\u4F1A\u8BAE\u5BA4\u300D\u7EDF\u8BA1"] };
+  }
+  const since = new Date(Date.now() - FREQUENT_WINDOW_DAYS * 24 * 60 * 60 * 1e3);
+  const pad = (n) => String(n).padStart(2, "0");
+  const sinceText = `${since.getFullYear()}-${pad(since.getMonth() + 1)}-${pad(since.getDate())} 00:00`;
+  const counts = /* @__PURE__ */ new Map();
+  let requests = 0;
+  try {
+    const { getMeetingOperation } = await import("./registry-ZJMJVWFA.js");
+    const listOp = getMeetingOperation("meeting.eb.meeting.list");
+    for (let pageNo = 1; pageNo <= 5; pageNo += 1) {
+      const page = await listOp.handler(
+        { creator: userId, begindatetime: sinceText, pageNo, pageSize: PAGE_SIZE },
+        env
+      );
+      requests += 1;
+      const rows = page?.data?.rows ?? [];
+      for (const row of rows) {
+        const main = row?.mainTable ?? row ?? {};
+        const name = toText(main.address).trim();
+        if (!name) continue;
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+      }
+      if (rows.length < PAGE_SIZE) break;
+    }
+  } catch (error) {
+    warnings.push(`\u5E38\u7528\u4F1A\u8BAE\u5BA4\u7EDF\u8BA1\u5931\u8D25\uFF08${String(error?.message ?? error).slice(0, 80)}\uFF09\uFF1A\u672C\u6B21\u6309\u5168\u91CF\u4F1A\u8BAE\u5BA4\u6392\u5E8F\u63A8\u8350`);
+  }
+  const order = [...counts.entries()].map(([name, count]) => ({ name, count })).sort((left, right) => right.count - left.count).slice(0, 10);
+  if (order.length > 0) await writeCache(env, key, order);
+  return { order, fromCache: false, requests, warnings };
+}
+async function fetchBusyRoomIds(env, begin, end) {
+  const session = await env.host.getSession();
+  const ids = /* @__PURE__ */ new Set();
+  let requests = 0;
+  const usageQuery = { enddatetime: end, begindatetime: begin };
+  for (let pageNo = 1; pageNo <= MAX_PAGES; pageNo += 1) {
+    const response = await env.host.request({
+      method: "POST",
+      path: `${EB_BASE}/getFormDataList/query_roomusage_list`,
+      operation: "meeting.eb.room.recommend",
+      query: usageQuery,
+      body: queryBody(session.userId, { pageNo, pageSize: PAGE_SIZE }),
+      acceptBusiness: ebBusinessSuccess
+    });
+    requests += 1;
+    const { rows } = extractEbRows(response);
+    for (const row of rows) {
+      const main = row?.mainTable ?? row ?? {};
+      const roomId = toText(main.address ?? main.room_id).trim();
+      if (roomId) ids.add(roomId);
+    }
+    if (rows.length < PAGE_SIZE) break;
+  }
+  return { ids, requests };
+}
+async function recommendRooms(env, input) {
+  const warnings = [];
+  const topN = Math.max(1, Math.min(10, input.topN ?? 3));
+  const roomData = await loadRooms(env, { refresh: input.refreshRooms === true });
+  warnings.push(...roomData.warnings);
+  const frequent = await loadFrequentRooms(env, { refresh: input.refreshFrequent === true });
+  warnings.push(...frequent.warnings);
+  const busy = await fetchBusyRoomIds(env, input.beginDatetime, input.endDatetime);
+  const frequentRank = /* @__PURE__ */ new Map();
+  frequent.order.forEach((item, index) => {
+    frequentRank.set(item.name, { rank: index, count: item.count });
+  });
+  const memberCount = input.memberCount && input.memberCount > 0 ? input.memberCount : null;
+  const requirement = input.requirement ?? {};
+  const usable = roomData.rooms.filter((room) => room.status === "0");
+  let busyCount = 0;
+  const candidates = [];
+  for (const room of usable) {
+    const isBusy = busy.ids.has(room.id);
+    if (isBusy) {
+      busyCount += 1;
+      if (!input.includeBusy) continue;
+    }
+    if (memberCount !== null) {
+      if (room.maxNum > 0 && room.maxNum < memberCount) continue;
+      if (room.minNum > 0 && room.minNum > memberCount) continue;
+    }
+    if (requirement.roomAttr && room.roomAttr !== requirement.roomAttr) continue;
+    if (requirement.mrType && room.mrType !== requirement.mrType) continue;
+    if (requirement.placeKeyword && !room.place.includes(requirement.placeKeyword)) continue;
+    if (requirement.nameKeyword && !room.name.includes(requirement.nameKeyword)) continue;
+    if (requirement.equipmentsKeyword && !room.equipments.includes(requirement.equipmentsKeyword)) continue;
+    const reasons = [];
+    let score = 0;
+    const freq = frequentRank.get(room.name);
+    if (freq) {
+      reasons.push(`\u4F60\u8FD1 ${FREQUENT_WINDOW_DAYS} \u5929\u7528\u8FC7 ${freq.count} \u6B21`);
+      score += 40 - Math.min(30, freq.rank * 5);
+    }
+    if (memberCount !== null && room.maxNum > 0) {
+      const waste = room.maxNum - memberCount;
+      reasons.push(`\u5BB9\u91CF ${room.maxNum} \u4EBA\uFF0C\u5BB9\u7EB3 ${memberCount} \u4EBA`);
+      score += Math.max(0, 20 - Math.min(20, waste));
+    } else if (room.maxNum > 0) {
+      reasons.push(`\u5BB9\u91CF ${room.maxNum} \u4EBA`);
+      score += 5;
+    }
+    if (requirement.placeKeyword) {
+      reasons.push(`\u5730\u70B9\u5339\u914D\u300C${requirement.placeKeyword}\u300D`);
+      score += 10;
+    }
+    if (requirement.equipmentsKeyword) {
+      reasons.push(`\u8BBE\u5907\u542B\u300C${requirement.equipmentsKeyword}\u300D`);
+      score += 10;
+    }
+    if (isBusy) {
+      reasons.push("\u8BE5\u65F6\u6BB5\u5DF2\u88AB\u5360\u7528\uFF08\u6309 includeBusy \u4E00\u5E76\u8FD4\u56DE\uFF09");
+      score -= 100;
+    } else {
+      reasons.push("\u8BE5\u65F6\u6BB5\u7A7A\u95F2");
+    }
+    candidates.push({
+      id: room.id,
+      name: room.name,
+      capacity: { min: room.minNum, max: room.maxNum },
+      place: room.place,
+      equipments: room.equipments,
+      roomAttrText: room.roomAttrText,
+      frequentCount: freq?.count ?? 0,
+      score,
+      reasons
+    });
+  }
+  candidates.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    const leftCap = left.capacity.max > 0 ? left.capacity.max : Number.MAX_SAFE_INTEGER;
+    const rightCap = right.capacity.max > 0 ? right.capacity.max : Number.MAX_SAFE_INTEGER;
+    if (leftCap !== rightCap) return leftCap - rightCap;
+    return left.name.localeCompare(right.name, "zh-Hans-CN");
+  });
+  if (candidates.length === 0) {
+    warnings.push(
+      `\u6CA1\u6709\u6EE1\u8DB3\u6761\u4EF6\u7684\u7A7A\u95F2\u4F1A\u8BAE\u5BA4\uFF08\u5171 ${roomData.rooms.length} \u95F4\uFF0C\u53EF\u7528 ${usable.length} \u95F4\uFF0C\u8BE5\u65F6\u6BB5\u88AB\u5360\u7528 ${busyCount} \u95F4${memberCount ? `\uFF0C\u4EBA\u6570 ${memberCount}` : ""}\uFF09\u2014\u2014\u8BF7\u653E\u5BBD\u4EBA\u6570/\u5730\u70B9/\u8BBE\u5907\u8981\u6C42\uFF0C\u6216\u6539\u4E3A\u7EBF\u4E0A\u4F1A\u8BAE\u3002`
+    );
+  }
+  return {
+    best: candidates[0] ?? null,
+    candidates: candidates.slice(0, topN),
+    meta: {
+      roomsTotal: roomData.rooms.length,
+      roomsUsable: usable.length,
+      roomsMatched: candidates.length,
+      roomsBusy: busyCount,
+      memberCount,
+      roomsFromCache: roomData.fromCache,
+      roomsCacheAgeSeconds: roomData.ageSeconds,
+      frequentFromCache: frequent.fromCache,
+      requests: roomData.requests + frequent.requests + busy.requests
+    },
+    warnings
+  };
+}
+var ebRoomRecommendOperation = {
+  name: "meeting.eb.room.recommend",
+  resource: "eb",
+  method: "meeting.eb.room.recommend",
+  action: "meeting.eb.room.recommend",
+  summary: "\u4F1A\u8BAE\u5BA4\u63A8\u8350\uFF1A\u6309\u4EBA\u6570 + \u5730\u70B9/\u8BBE\u5907/\u7C7B\u578B\u8981\u6C42 + \u4E2A\u4EBA\u5E38\u7528\uFF08\u8FD1 180 \u5929\uFF09+ \u65F6\u6BB5\u5360\u7528\uFF0C\u7ED9\u51FA\u6392\u5E8F\u5019\u9009\uFF1B\u4F1A\u8BAE\u5BA4\u4E0E\u5E38\u7528\u8BB0\u5F55\u8D70\u672C\u5730\u7F13\u5B58\uFF08\u5206\u522B 24h / 7d\uFF09\uFF0C\u5360\u7528\u5B9E\u65F6\u67E5 1 \u6B21",
+  capability: "eb.room",
+  risk: "read",
+  inputSchema: schemaOf(
+    {
+      beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: "\u5F00\u59CB\u65F6\u95F4\uFF08\u5FC5\u586B\uFF0Cyyyy-MM-dd HH:mm\uFF09" },
+      endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: "\u7ED3\u675F\u65F6\u95F4\uFF08\u5FC5\u586B\uFF0Cyyyy-MM-dd HH:mm\uFF09" },
+      memberCount: { type: "number", description: "\u53C2\u4F1A\u4EBA\u6570\uFF08\u53EF\u9009\uFF1B\u7528\u4E8E\u5BB9\u91CF\u8FC7\u6EE4\uFF0C0 \u6216\u4E0D\u4F20 = \u4E0D\u6309\u4EBA\u6570\u8FC7\u6EE4\uFF09" },
+      hrmMembers: {
+        type: "string",
+        description: "\u53C2\u4F1A\u4EBA id \u9017\u53F7\u5206\u9694\uFF08\u53EF\u9009\uFF09\uFF1A\u4E0D\u4F20 memberCount \u65F6\u6309\u5B83\u7684\u4EBA\u6570\u63A8\u7B97"
+      },
+      placeKeyword: { type: "string", description: "\u5730\u70B9/\u697C\u5C42\u5173\u952E\u8BCD\uFF08\u6A21\u7CCA\u5339\u914D\u4F1A\u8BAE\u5BA4 place\uFF09" },
+      nameKeyword: { type: "string", description: "\u4F1A\u8BAE\u5BA4\u540D\u79F0\u5173\u952E\u8BCD" },
+      mrType: { type: "string", description: "\u4F1A\u8BAE\u5BA4\u7C7B\u578B id\uFF08mr_type\uFF09" },
+      roomAttr: { type: "string", enum: ["0", "1", "2"], description: "\u4F1A\u8BAE\u5BA4\u5C5E\u6027\uFF1A0 \u5B9E\u4F53 / 1 \u865A\u62DF / 2 \u7EC4\u5408" },
+      equipmentsKeyword: { type: "string", description: "\u8BBE\u5907\u5173\u952E\u8BCD\uFF08\u6A21\u7CCA\u5339\u914D equipments\uFF0C\u5982 \u6295\u5F71/\u89C6\u9891\uFF09" },
+      topN: { type: "number", description: "\u8FD4\u56DE\u5019\u9009\u6570\u91CF\uFF08\u9ED8\u8BA4 3\uFF0C\u6700\u591A 10\uFF09" },
+      refresh: { type: "boolean", description: "true=\u5237\u65B0\u4F1A\u8BAE\u5BA4\u5168\u91CF\u4E0E\u5E38\u7528\u8BB0\u5F55\u7F13\u5B58" },
+      includeBusy: { type: "boolean", description: "true=\u628A\u8BE5\u65F6\u6BB5\u5DF2\u88AB\u5360\u7528\u7684\u4F1A\u8BAE\u5BA4\u4E5F\u8FD4\u56DE\uFF08\u6392\u5728\u6700\u540E\uFF0C\u5E26\u8BF4\u660E\uFF09" }
+    },
+    { required: ["beginDatetime", "endDatetime"] }
+  ),
+  handler: async (args, env) => {
+    const hrmCount = String(args.hrmMembers ?? "").split(/[,;，；\s]+/).map((item) => item.trim()).filter((item) => item !== "").length;
+    const memberCount = args.memberCount !== void 0 ? Number(args.memberCount) : hrmCount;
+    const result = await recommendRooms(env, {
+      beginDatetime: String(args.beginDatetime),
+      endDatetime: String(args.endDatetime),
+      ...Number.isFinite(memberCount) && memberCount > 0 ? { memberCount } : {},
+      requirement: {
+        ...args.placeKeyword ? { placeKeyword: String(args.placeKeyword) } : {},
+        ...args.nameKeyword ? { nameKeyword: String(args.nameKeyword) } : {},
+        ...args.mrType ? { mrType: String(args.mrType) } : {},
+        ...args.roomAttr ? { roomAttr: String(args.roomAttr) } : {},
+        ...args.equipmentsKeyword ? { equipmentsKeyword: String(args.equipmentsKeyword) } : {}
+      },
+      ...args.topN !== void 0 ? { topN: Number(args.topN) } : {},
+      ...args.refresh === true ? { refreshRooms: true, refreshFrequent: true } : {},
+      ...args.includeBusy === true ? { includeBusy: true } : {}
+    });
+    return meetingSuccess(
+      "meeting.eb.room.recommend",
+      {
+        best: result.best,
+        candidates: result.candidates,
+        meta: result.meta
+      },
+      result.warnings.length > 0 ? { warnings: result.warnings } : {}
+    );
+  }
+};
+async function rememberFrequentRoom(env, roomId) {
+  const id = String(roomId ?? "").trim();
+  if (!id) return false;
+  const scope = await cacheScopeSuffix(env);
+  const roomsCached = await readCache(env, `rooms-${scope}`, { ttlMs: ROOMS_TTL_MS });
+  const name = roomsCached?.data?.find((room) => room.id === id)?.name ?? "";
+  if (!name) return false;
+  const session = await env.host.getSession().catch(() => null);
+  const userId = String(session?.userId ?? "").trim();
+  if (!userId) return false;
+  const key = `frequent-rooms-${scope}-${userId}`;
+  const cached = await readCache(env, key, { ttlMs: FREQUENT_TTL_MS });
+  const order = cached?.data ?? [];
+  const existing = order.find((item) => item.name === name);
+  if (existing) existing.count += 1;
+  else order.push({ name, count: 1 });
+  order.sort((left, right) => right.count - left.count);
+  await writeCache(env, key, order.slice(0, 10));
+  return true;
+}
+
+export {
+  loadRooms,
+  loadFrequentRooms,
+  recommendRooms,
+  ebRoomRecommendOperation,
+  rememberFrequentRoom
+};

package/dist/chunks/chunk-AJ62BGAW.js

@@ -0,0 +1,29 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+
+// src/core/state.ts
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function stateRoot(ctx) {
+  const home = process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), ".weaver-work-cli");
+  if (ctx?.getGlobalOptions?.().config) return resolve(home);
+  const configured = ctx?.config?.path?.();
+  if (configured) return dirname(resolve(configured));
+  return resolve(home);
+}
+function stateDir(ctx) {
+  return join(stateRoot(ctx), "state");
+}
+function refsDir(ctx) {
+  return join(stateDir(ctx), "refs");
+}
+function refsIndexPath(ctx) {
+  return join(refsDir(ctx), "index.jsonl");
+}
+
+export {
+  stateRoot,
+  stateDir,
+  refsDir,
+  refsIndexPath
+};

package/dist/chunks/chunk-BUSC6UAE.js

@@ -0,0 +1,43 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunks/chunk-CVZ2JOSW.js

@@ -0,0 +1,62 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  meetingStateDir
+} from "./chunk-H6XSTSLM.js";
+
+// src/shortcuts/meeting/operations/eb/cache.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+function cacheDir(env) {
+  return join(meetingStateDir(env.ctx), "cache");
+}
+function cacheFile(env, key) {
+  return join(cacheDir(env), `${key}.json`);
+}
+async function identity(env) {
+  try {
+    const session = await env.host.getSession();
+    return {
+      baseUrl: String(session?.baseUrl ?? ""),
+      tenantKey: String(session?.tenantKey ?? "")
+    };
+  } catch {
+    return { baseUrl: "", tenantKey: "" };
+  }
+}
+async function readCache(env, key, options = {}) {
+  try {
+    const raw = await readFile(cacheFile(env, key), "utf8");
+    const parsed = JSON.parse(raw);
+    const current = await identity(env);
+    if (parsed.baseUrl !== current.baseUrl || parsed.tenantKey !== current.tenantKey) return null;
+    const ageMs = Date.now() - Number(parsed.savedAt || 0);
+    const ttl = options.ttlMs ?? DEFAULT_TTL_MS;
+    if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > ttl) return null;
+    return { data: parsed.data, savedAt: parsed.savedAt, ageMs };
+  } catch {
+    return null;
+  }
+}
+async function writeCache(env, key, data) {
+  try {
+    const current = await identity(env);
+    const payload = { savedAt: Date.now(), baseUrl: current.baseUrl, tenantKey: current.tenantKey, data };
+    const file = cacheFile(env, key);
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(payload), "utf8");
+  } catch {
+  }
+}
+async function cacheScopeSuffix(env) {
+  const { baseUrl, tenantKey } = await identity(env);
+  const host = baseUrl.replace(/^https?:\/\//, "").replace(/[^0-9a-zA-Z]+/g, "-");
+  return `${host || "local"}-${tenantKey || "unknown"}`;
+}
+
+export {
+  readCache,
+  writeCache,
+  cacheScopeSuffix
+};