jowork 0.2.4 → 0.3.0

package/dist/chunk-DQW74UCN.js

@@ -0,0 +1,671 @@
+import {
+  formatApproval,
+  formatCalendarEvent,
+  formatDocument
+} from "./chunk-RO3KK5RC.js";
+import {
+  logError,
+  logInfo
+} from "./chunk-MYDK7MWB.js";
+import {
+  contentHash
+} from "./chunk-OXWWOKC7.js";
+
+// src/sync/feishu.ts
+var defaultLogger = {
+  info: (msg, ctx) => logInfo("sync", msg, ctx),
+  warn: (msg, ctx) => logError("sync", msg, ctx),
+  error: (msg, ctx) => logError("sync", msg, ctx)
+};
+async function getFeishuToken(appId, appSecret) {
+  const res = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret })
+  });
+  const data = await res.json();
+  if (data.code !== 0) throw new Error(`Feishu auth failed: code ${data.code}`);
+  return data.tenant_access_token;
+}
+async function syncFeishu(ctx, data, logger = defaultLogger) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const token = await getFeishuToken(appId, appSecret);
+  const chats = [];
+  let chatPageToken;
+  let hasMoreChats = true;
+  while (hasMoreChats) {
+    const chatUrl = new URL("https://open.feishu.cn/open-apis/im/v1/chats");
+    chatUrl.searchParams.set("page_size", "100");
+    if (chatPageToken) chatUrl.searchParams.set("page_token", chatPageToken);
+    const chatsRes = await fetch(chatUrl.toString(), {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const chatsData = await chatsRes.json();
+    if (chatsData.code !== 0) throw new Error(`Failed to list chats: code ${chatsData.code}`);
+    chats.push(...chatsData.data?.items ?? []);
+    hasMoreChats = chatsData.data?.has_more ?? false;
+    chatPageToken = chatsData.data?.page_token;
+  }
+  let totalMessages = 0;
+  let newMessages = 0;
+  const sqlite = ctx.getSqlite();
+  const fileWriter = ctx.writer;
+  const dayMessages = /* @__PURE__ */ new Map();
+  for (const chat of chats) {
+    const cursor = ctx.getCursor(`feishu:${chat.chat_id}`);
+    let pageToken = cursor?.pageToken;
+    let hasMore = true;
+    while (hasMore) {
+      const url = new URL("https://open.feishu.cn/open-apis/im/v1/messages");
+      url.searchParams.set("container_id_type", "chat");
+      url.searchParams.set("container_id", chat.chat_id);
+      url.searchParams.set("page_size", "50");
+      url.searchParams.set("sort_type", "ByCreateTimeAsc");
+      if (pageToken) url.searchParams.set("page_token", pageToken);
+      const msgRes = await fetch(url.toString(), {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const msgData = await msgRes.json();
+      if (msgData.code !== 0) {
+        if (msgData.code === 99991400) {
+          logger.warn(`Rate limited on ${chat.name}, waiting 5s`);
+          await new Promise((r) => setTimeout(r, 5e3));
+          continue;
+        }
+        logger.warn(`Failed to get messages from "${chat.name}": code ${msgData.code}`);
+        break;
+      }
+      const messages = msgData.data?.items ?? [];
+      for (let i = 0; i < messages.length; i += 100) {
+        const batch = messages.slice(i, i + 100);
+        const items = [];
+        for (const msg of batch) {
+          if (msg.msg_type !== "text" && msg.msg_type !== "post") continue;
+          let content = "";
+          try {
+            const bodyContent = JSON.parse(msg.body?.content ?? "{}");
+            const raw = bodyContent.text ?? bodyContent.content ?? bodyContent;
+            content = typeof raw === "string" ? raw : JSON.stringify(raw);
+          } catch {
+            content = msg.body?.content ?? "";
+          }
+          if (!content || typeof content !== "string") continue;
+          const uri = `feishu://message/${msg.message_id}`;
+          const createTime = msg.create_time ? parseInt(msg.create_time) : Date.now();
+          items.push({
+            source: "feishu",
+            sourceType: "message",
+            uri,
+            title: chat.name,
+            content,
+            contentType: "text/plain",
+            createdAt: createTime,
+            tags: ["feishu", "message"]
+          });
+          if (fileWriter) {
+            const date = new Date(createTime).toISOString().slice(0, 10);
+            const time = new Date(createTime).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" });
+            const key = `${chat.chat_id}:${date}`;
+            let group = dayMessages.get(key);
+            if (!group) {
+              group = { chatName: chat.name, chatId: chat.chat_id, date, messages: [] };
+              dayMessages.set(key, group);
+            }
+            group.messages.push({ time, sender: msg.sender?.id ?? "unknown", content });
+          }
+        }
+        const result = ctx.batchUpsert(items);
+        newMessages += result.inserted;
+      }
+      totalMessages += messages.length;
+      hasMore = msgData.data.has_more;
+      pageToken = msgData.data.page_token;
+      if (pageToken) {
+        ctx.saveCursor(`feishu:${chat.chat_id}`, { pageToken });
+      }
+    }
+  }
+  if (fileWriter && dayMessages.size > 0) {
+    for (const group of dayMessages.values()) {
+      try {
+        const filePath = fileWriter.appendMessages(
+          "feishu",
+          group.chatName,
+          group.chatId,
+          group.date,
+          group.messages
+        );
+        sqlite.prepare(
+          `UPDATE objects SET file_path = ? WHERE source = 'feishu' AND source_type = 'message' AND title = ? AND file_path IS NULL`
+        ).run(filePath, group.chatName);
+      } catch (err) {
+        logger.warn(`Failed to write messages file for ${group.chatName}/${group.date}: ${err}`);
+      }
+    }
+  }
+  logger.info("Feishu sync complete", { totalMessages, newMessages, chats: chats.length });
+  return { totalMessages, newMessages, chats: chats.length };
+}
+async function syncFeishuMeetings(ctx, data, logger = defaultLogger) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const token = await getFeishuToken(appId, appSecret);
+  let meetings = 0, newObjects = 0;
+  const fileWriter = ctx.writer;
+  try {
+    const now = Math.floor(Date.now() / 1e3);
+    const weekAgo = now - 30 * 24 * 60 * 60;
+    const calRes = await fetch("https://open.feishu.cn/open-apis/calendar/v4/calendars?page_size=50", {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    const calData = await calRes.json();
+    if (calData.code !== 0 || !calData.data?.calendar_list?.length) {
+      if (calData.code === 99992402) {
+        logger.warn("Calendar sync requires calendar:calendar:readonly scope. Add it at https://open.feishu.cn/app \u2192 Permissions");
+      } else if (calData.code !== 0) {
+        logger.warn(`Calendar API returned code ${calData.code}`);
+      }
+      return { meetings, newObjects };
+    }
+    for (const cal of calData.data.calendar_list) {
+      const eventsRes = await fetch(
+        `https://open.feishu.cn/open-apis/calendar/v4/calendars/${cal.calendar_id}/events?start_time=${weekAgo}&end_time=${now}&page_size=50`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      const eventsData = await eventsRes.json();
+      if (eventsData.code !== 0 || !eventsData.data?.items) continue;
+      const items = [];
+      for (const event of eventsData.data.items) {
+        const uri = `feishu://calendar/${cal.calendar_id}/event/${event.event_id}`;
+        const attendees = event.attendees?.map((a) => a.display_name).join(", ") ?? "";
+        const startTs = parseInt(event.start_time?.timestamp ?? "0") * 1e3;
+        const startTime = new Date(startTs).toLocaleString("zh-CN");
+        const summary = `${event.summary} (${startTime}, ${attendees || "no attendees"})`;
+        const body = [
+          `Meeting: ${event.summary}`,
+          `Time: ${startTime}`,
+          `Attendees: ${attendees}`,
+          `Description: ${event.description || "(none)"}`
+        ].join("\n");
+        const attendeeNames = event.attendees?.map((a) => a.display_name) ?? [];
+        const endTs = parseInt(event.end_time?.timestamp ?? "0") * 1e3;
+        const endTime = new Date(endTs).toLocaleString("zh-CN");
+        const date = new Date(startTs).toISOString().slice(0, 10);
+        const fileContent = formatCalendarEvent({
+          source: "feishu",
+          title: event.summary || "Untitled meeting",
+          startTime,
+          endTime,
+          attendees: attendeeNames,
+          description: event.description || "",
+          uri
+        });
+        items.push({
+          source: "feishu",
+          sourceType: "calendar_event",
+          uri,
+          title: event.summary || "Untitled meeting",
+          summary,
+          tags: ["feishu", "calendar", "meeting"],
+          content: body,
+          contentType: "text/plain",
+          createdAt: startTs,
+          fileContent,
+          fileMeta: { date }
+        });
+      }
+      const result = ctx.batchUpsert(items);
+      meetings += result.inserted;
+      newObjects += result.inserted;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+  } catch (err) {
+    logger.error(`Meeting sync error: ${err}`);
+  }
+  logger.info("Meeting sync complete", { meetings, newObjects });
+  return { meetings, newObjects };
+}
+async function syncFeishuApprovals(ctx, data, logger = defaultLogger) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const token = await getFeishuToken(appId, appSecret);
+  let approvals = 0, newObjects = 0;
+  try {
+    const res = await fetch("https://open.feishu.cn/open-apis/approval/v4/instances?page_size=50", {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok || res.status === 400) {
+      logger.warn("Approval sync requires approval:approval:readonly scope. Add it at https://open.feishu.cn/app \u2192 Permissions");
+      return { approvals, newObjects };
+    }
+    const resData = await res.json();
+    if (resData.code !== 0 || !resData.data?.items) {
+      logger.warn(`Approval list returned code ${resData.code}`);
+      return { approvals, newObjects };
+    }
+    const items = [];
+    for (const approval of resData.data.items) {
+      const uri = `feishu://approval/${approval.instance_id}`;
+      const summary = `${approval.approval_name} [${approval.status}]`;
+      let formText = "";
+      try {
+        const formData = JSON.parse(approval.form || "[]");
+        formText = Array.isArray(formData) ? formData.map((f) => `${f.name}: ${f.value}`).join("\n") : JSON.stringify(formData);
+      } catch {
+        formText = approval.form || "";
+      }
+      const body = [
+        `Approval: ${approval.approval_name}`,
+        `Status: ${approval.status}`,
+        `Submitted: ${approval.start_time}`,
+        `Completed: ${approval.end_time || "pending"}`,
+        "",
+        formText
+      ].join("\n");
+      const startTime = approval.start_time ? new Date(approval.start_time).getTime() : Date.now();
+      let formFields = [];
+      try {
+        const fd = JSON.parse(approval.form || "[]");
+        if (Array.isArray(fd)) formFields = fd;
+      } catch {
+      }
+      const fileContent = formatApproval({
+        source: "feishu",
+        name: approval.approval_name,
+        status: approval.status,
+        submitter: approval.user_id || "unknown",
+        fields: formFields,
+        uri
+      });
+      items.push({
+        source: "feishu",
+        sourceType: "approval",
+        uri,
+        title: approval.approval_name,
+        summary,
+        tags: ["feishu", "approval", approval.status],
+        content: body,
+        contentType: "text/plain",
+        createdAt: startTime,
+        fileContent
+      });
+    }
+    const result = ctx.batchUpsert(items);
+    approvals += result.inserted;
+    newObjects += result.inserted;
+  } catch (err) {
+    logger.error(`Approval sync error: ${err}`);
+  }
+  logger.info("Approval sync complete", { approvals, newObjects });
+  return { approvals, newObjects };
+}
+async function syncFeishuDocs(ctx, data, logger = defaultLogger) {
+  const { appId, appSecret } = data;
+  if (!appId || !appSecret) throw new Error("Missing Feishu credentials");
+  const token = await getFeishuToken(appId, appSecret);
+  let docs = 0, newObjects = 0;
+  const sqlite = ctx.getSqlite();
+  async function fetchDocContent(docToken) {
+    try {
+      const res = await fetch(
+        `https://open.feishu.cn/open-apis/docx/v1/documents/${docToken}/raw_content`,
+        { headers: { Authorization: `Bearer ${token}` } }
+      );
+      if (!res.ok) return null;
+      const d = await res.json();
+      return d.data?.content ?? null;
+    } catch {
+      return null;
+    }
+  }
+  function insertDoc(uri, title, docBody, objType, createdTs) {
+    if (ctx.exists(uri)) return false;
+    const fileContent = formatDocument({ source: "feishu", title, uri, body: docBody });
+    const result = ctx.upsertObject({
+      source: "feishu",
+      sourceType: "document",
+      uri,
+      title,
+      tags: ["feishu", "document", objType],
+      content: docBody,
+      contentType: "text/plain",
+      createdAt: createdTs,
+      fileContent
+    });
+    if (result.action === "inserted") {
+      docs++;
+      newObjects++;
+      return true;
+    }
+    return false;
+  }
+  try {
+    let wikiFound = 0;
+    try {
+      const spacesRes = await fetch("https://open.feishu.cn/open-apis/wiki/v2/spaces?page_size=50", {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const spacesData = await spacesRes.json();
+      if (spacesData.code === 0 && spacesData.data?.items?.length) {
+        for (const space of spacesData.data.items) {
+          let nodePageToken;
+          let hasMoreNodes = true;
+          while (hasMoreNodes) {
+            const url = new URL(`https://open.feishu.cn/open-apis/wiki/v2/spaces/${space.space_id}/nodes`);
+            url.searchParams.set("page_size", "50");
+            if (nodePageToken) url.searchParams.set("page_token", nodePageToken);
+            const nodesRes = await fetch(url.toString(), { headers: { Authorization: `Bearer ${token}` } });
+            const nodesData = await nodesRes.json();
+            if (nodesData.code !== 0 || !nodesData.data?.items) break;
+            for (const node of nodesData.data.items) {
+              const uri = `feishu://wiki/${space.space_id}/${node.node_token}`;
+              let docBody = `Wiki: ${node.title} (${node.obj_type}, space: ${space.name})`;
+              if (node.obj_type === "docx" || node.obj_type === "doc") {
+                const content = await fetchDocContent(node.obj_token);
+                if (content) docBody = content;
+              }
+              if (insertDoc(uri, node.title, docBody, node.obj_type)) wikiFound++;
+              await new Promise((r) => setTimeout(r, 100));
+            }
+            hasMoreNodes = nodesData.data?.has_more ?? false;
+            nodePageToken = nodesData.data?.page_token;
+          }
+        }
+      }
+    } catch (err) {
+      logger.warn(`Wiki sync error (non-fatal): ${err}`);
+    }
+    let driveFound = 0;
+    try {
+      let drivePageToken;
+      let hasMoreFiles = true;
+      while (hasMoreFiles) {
+        const url = new URL("https://open.feishu.cn/open-apis/drive/v1/files");
+        url.searchParams.set("page_size", "50");
+        if (drivePageToken) url.searchParams.set("page_token", drivePageToken);
+        const driveRes = await fetch(url.toString(), { headers: { Authorization: `Bearer ${token}` } });
+        const driveData = await driveRes.json();
+        if (driveData.code !== 0) {
+          if (driveData.code === 99992402) {
+            logger.warn("Drive sync requires drive:drive:readonly scope. Add it at https://open.feishu.cn/app \u2192 Permissions");
+          }
+          break;
+        }
+        for (const file of driveData.data?.files ?? []) {
+          const uri = `feishu://drive/${file.token}`;
+          let docBody = `Drive: ${file.name} (${file.type})`;
+          if (file.type === "docx" || file.type === "doc") {
+            const content = await fetchDocContent(file.token);
+            if (content) docBody = content;
+          }
+          const createdTs = file.created_time ? parseInt(file.created_time) * 1e3 : void 0;
+          if (insertDoc(uri, file.name, docBody, file.type, createdTs)) driveFound++;
+          await new Promise((r) => setTimeout(r, 100));
+        }
+        hasMoreFiles = driveData.data?.has_more ?? false;
+        drivePageToken = driveData.data?.next_page_token;
+      }
+    } catch (err) {
+      logger.warn(`Drive sync error (non-fatal): ${err}`);
+    }
+    let msgDocFound = 0;
+    try {
+      const msgObjs = sqlite.prepare(`
+        SELECT o.id, o.file_path FROM objects o
+        WHERE o.source = 'feishu' AND o.source_type = 'message'
+        AND o.summary LIKE '%feishu.cn%'
+      `).all();
+      const { readObjectContents } = await import("./content-reader-VPGTR2SF.js");
+      const contentMap = readObjectContents(
+        sqlite,
+        msgObjs.map((o) => ({ id: o.id, filePath: o.file_path }))
+      );
+      const msgRows = [...contentMap.values()].filter((c) => c.includes("feishu.cn")).map((c) => ({ content: c }));
+      const docTokens = /* @__PURE__ */ new Map();
+      const feishuUrlPattern = /https?:\/\/[a-z0-9]+\.feishu\.cn\/(docx|doc|wiki|sheets|bitable|mindnote)\/([A-Za-z0-9]+)/g;
+      for (const row of msgRows) {
+        for (const match of row.content.matchAll(feishuUrlPattern)) {
+          const docType = match[1];
+          const docToken = match[2];
+          if (!docTokens.has(docToken)) {
+            docTokens.set(docToken, docType);
+          }
+        }
+      }
+      if (docTokens.size > 0) {
+        logger.info(`Found ${docTokens.size} feishu doc links in messages`);
+      }
+      for (const [docToken, docType] of docTokens) {
+        const uri = `feishu://doc/${docToken}`;
+        if (ctx.exists(uri)) continue;
+        let title = `Feishu ${docType} (${docToken})`;
+        let docBody = "";
+        if (docType === "docx" || docType === "doc") {
+          try {
+            const metaRes = await fetch(
+              `https://open.feishu.cn/open-apis/docx/v1/documents/${docToken}`,
+              { headers: { Authorization: `Bearer ${token}` } }
+            );
+            if (metaRes.ok) {
+              const metaData = await metaRes.json();
+              if (metaData.data?.document?.title) title = metaData.data.document.title;
+            }
+          } catch {
+          }
+          const content = await fetchDocContent(docToken);
+          if (content) {
+            docBody = content;
+          } else {
+            docBody = `(Content not accessible \u2014 doc may not be shared with the app)`;
+          }
+        } else if (docType === "wiki") {
+          try {
+            const nodeRes = await fetch(
+              `https://open.feishu.cn/open-apis/wiki/v2/spaces/get_node?token=${docToken}`,
+              { headers: { Authorization: `Bearer ${token}` } }
+            );
+            if (nodeRes.ok) {
+              const nodeData = await nodeRes.json();
+              if (nodeData.data?.node?.title) title = nodeData.data.node.title;
+              if (nodeData.data?.node?.obj_token && (nodeData.data.node.obj_type === "docx" || nodeData.data.node.obj_type === "doc")) {
+                const content = await fetchDocContent(nodeData.data.node.obj_token);
+                if (content) docBody = content;
+              }
+            }
+          } catch {
+          }
+          if (!docBody) docBody = `Wiki: ${title}`;
+        } else {
+          docBody = `Feishu ${docType}: ${title} (non-docx format, content extraction not supported)`;
+        }
+        if (insertDoc(uri, title, docBody, docType)) msgDocFound++;
+        await new Promise((r) => setTimeout(r, 200));
+      }
+      if (msgDocFound > 0) {
+        logger.info(`Extracted ${msgDocFound} docs from message links`);
+      }
+    } catch (err) {
+      logger.warn(`Message doc extraction error (non-fatal): ${err}`);
+    }
+    if (wikiFound === 0 && driveFound === 0 && msgDocFound === 0) {
+      const existingDocs = sqlite.prepare("SELECT COUNT(*) as cnt FROM objects WHERE source='feishu' AND source_type='document'").get().cnt;
+      if (existingDocs === 0) {
+        logger.warn("No documents found. Ensure docs are shared with the app, or wiki spaces include the bot as member.");
+      }
+    }
+  } catch (err) {
+    logger.error(`Document sync error: ${err}`);
+  }
+  logger.info("Document sync complete", { docs, newObjects });
+  return { docs, newObjects };
+}
+var SKIP_URL_PATTERNS = [
+  /email\.quail-mail\.com/,
+  // Newsletter tracking redirects
+  /\.feishu\.cn\//,
+  // Feishu internal links (handled by doc sync)
+  /mp\.weixin\.qq\.com/,
+  // WeChat articles (need cookies)
+  /open\.weixin\.qq\.com/,
+  // WeChat OAuth
+  /xhslink\.com/,
+  // Xiaohongshu short links (need app)
+  /b23\.tv/,
+  // Bilibili short links
+  /t\.co\//,
+  // Twitter short links
+  /luma\.com\/event/
+  // Luma events (dynamic SPA)
+];
+function extractUrlsFromContent(content) {
+  const urls = [];
+  try {
+    const parsed = JSON.parse(content);
+    const rows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const row of rows) {
+      if (!Array.isArray(row)) continue;
+      for (const element of row) {
+        if (element?.tag === "a" && element?.href) {
+          const href = String(element.href);
+          if (/\.(png|jpg|jpeg|gif|webp|svg|mp4|mp3|pdf|zip|rar)(\?|$)/i.test(href)) continue;
+          if (href.includes("/file/") || href.includes("/image/")) continue;
+          if (SKIP_URL_PATTERNS.some((p) => p.test(href))) continue;
+          urls.push({ url: href, text: element.text ?? href });
+        }
+      }
+    }
+  } catch {
+  }
+  if (urls.length === 0) {
+    const matches = content.match(/https?:\/\/[^\s"'<>\]]+/g);
+    if (matches) {
+      for (const url of matches) {
+        if (/\.(png|jpg|jpeg|gif|webp|svg|mp4|mp3|pdf|zip|rar)(\?|$)/i.test(url)) continue;
+        if (SKIP_URL_PATTERNS.some((p) => p.test(url))) continue;
+        urls.push({ url, text: url });
+      }
+    }
+  }
+  return urls;
+}
+async function fetchUrlContent(url) {
+  try {
+    const res = await fetch(`https://r.jina.ai/${url}`, {
+      headers: {
+        "Accept": "text/markdown",
+        "X-No-Cache": "true"
+      },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!res.ok) return null;
+    const text = await res.text();
+    if (!text || text.length < 50) return null;
+    const titleMatch = text.match(/^Title:\s*(.+)/m);
+    let fallbackHost = url;
+    try {
+      fallbackHost = new URL(url).hostname;
+    } catch {
+    }
+    const title = titleMatch?.[1]?.trim() ?? fallbackHost;
+    return { title, content: text };
+  } catch {
+    return null;
+  }
+}
+async function syncFeishuLinks(ctx, _data, logger = defaultLogger) {
+  let extracted = 0, fetched = 0, failed = 0;
+  const sqlite = ctx.getSqlite();
+  try {
+    const { readObjectContents } = await import("./content-reader-VPGTR2SF.js");
+    const msgObjs = sqlite.prepare(`
+      SELECT o.id, o.file_path FROM objects o
+      WHERE o.source = 'feishu' AND o.source_type = 'message'
+      AND o.summary LIKE '%http%'
+    `).all();
+    const contentMap = readObjectContents(
+      sqlite,
+      msgObjs.map((o) => ({ id: o.id, filePath: o.file_path }))
+    );
+    const messageRows = [...contentMap.values()].filter((c) => c.includes("http")).map((c) => ({ content: c }));
+    const urlSet = /* @__PURE__ */ new Map();
+    for (const row of messageRows) {
+      const urls = extractUrlsFromContent(row.content);
+      for (const { url, text } of urls) {
+        if (!urlSet.has(url)) urlSet.set(url, text);
+      }
+    }
+    extracted = urlSet.size;
+    if (extracted === 0) {
+      logger.info("No URLs found in messages");
+      return { extracted, fetched, failed };
+    }
+    logger.info(`Found ${extracted} unique URLs in messages`);
+    let i = 0;
+    for (const [url, linkText] of urlSet) {
+      i++;
+      try {
+        new URL(url);
+      } catch {
+        failed++;
+        continue;
+      }
+      const uri = `feishu://link/${contentHash(url)}`;
+      if (ctx.exists(uri)) continue;
+      const result = await fetchUrlContent(url);
+      if (!result) {
+        failed++;
+        continue;
+      }
+      const title = result.title || linkText;
+      let hostname = "unknown";
+      try {
+        hostname = new URL(url).hostname;
+      } catch {
+      }
+      const fileContent = [
+        "---",
+        `source: feishu`,
+        `type: link`,
+        `url: ${url}`,
+        `title: "${title.replace(/"/g, '\\"')}"`,
+        `fetched: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        "---",
+        "",
+        result.content,
+        ""
+      ].join("\n");
+      const upsertResult = ctx.upsertObject({
+        source: "feishu",
+        sourceType: "link",
+        uri,
+        title,
+        tags: ["feishu", "link", hostname],
+        content: result.content,
+        contentType: "text/markdown",
+        fileContent,
+        fileMeta: { url }
+      });
+      if (upsertResult.action === "inserted") {
+        fetched++;
+      }
+      if (i % 10 === 0) {
+        logger.info(`Links progress: ${i}/${extracted} (${fetched} fetched, ${failed} failed)`);
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  } catch (err) {
+    logger.error(`Link sync error: ${err}`);
+  }
+  logger.info("Link sync complete", { extracted, fetched, failed });
+  return { extracted, fetched, failed };
+}
+
+export {
+  getFeishuToken,
+  syncFeishu,
+  syncFeishuMeetings,
+  syncFeishuApprovals,
+  syncFeishuDocs,
+  syncFeishuLinks
+};