feat(community/og): 抓取加固 + SiteAdapter + LLM 兜底 + 管理员重抓

背景
DC 分享 9 条全部入库但 6 条 og_title 为 NULL，feed 卡片基本空白。
逐条根因不同：mp.weixin.qq.com 反爬+体积超限；arxiv.org/pdf 是 PDF 不是 HTML；
scholar.google.com/scholar_url 是 click-tracking 返 204；其他静默失败。

Phase 1: OgFetchService 加固
- UA 改纯 Chrome 伪装（去 Bot 字样），绕开微信软反爬
- MAX_BODY_BYTES 2MB → 8MB，覆盖微信带 base64 inline 图的臃肿页面
- 流式扫到 </head> 立即停读，绝大多数站点只读几十 KB 就够（早停 + 限流双兜底）
- Content-Type 非 HTML（application/pdf 等）直接软失败 "non-html content-type:..."

Phase 2: SiteAdapter 抽象
- 接口 + UrlNormalizer 链式（最多 5 跳防环）
- ArxivPdfAdapter: arxiv.org/pdf/<id> → arxiv.org/abs/<id>（pdf 二进制无 OG，abs 才有）
- ScholarUrlAdapter: 从 scholar_url?url=<real> 提真实链接（Scholar 是 tracker）
- 链式串联：scholar_url(arxiv pdf) → arxiv abs，一跳通杀

Phase 3: LLM 兜底
- OgFallbackService：抓不到 title 时用 OpenAI/DeepSeek 根据 URL 猜 title/desc
- EnrichmentWorker 在 OG fetch 后插一步：title 为空才调，避免无效消耗 token
- 复用 OpenAiProperties，未配 apiKey 时直接降级返回空（不失败）

Phase 3.5: 管理员重抓 endpoint
- POST /api/admin/community/{id}/refetch-og：单条触发异步 enrichment
- POST /api/admin/community/refetch-og/bulk：body {"ids":[1,2,3]} 或 {"ids":["all"]}
  限流单次最多 100 条，"all" 自动找 og_title IS NULL 的批量重跑
- Repository 加 findIdsMissingOgTitle(limit) 配合上面 bulk all 模式

测试
- 12 个原 OgFetch test 全过（构造器加 UrlNormalizer 参数后修复）
- 16 个新 SiteAdapterTests：arxiv/scholar/链式 全覆盖
- 10 个原 EnrichmentWorker test 全过（@mock 加 OgFallbackService）
- 全 suite 仅剩 2 个 pre-existing seed user 失败（PR #22 时已确认无关）

Spring 注入
- OgFetchService 主 ctor 加 @Autowired，避免 Spring 在 prod ctor + test ctor 之间困惑

Author: longsizhuo

src/main/java/com/involutionhell/backend/community/controller/SharedLinkAdminController.java

@@ -6,6 +6,7 @@
 import com.involutionhell.backend.community.model.SharedLink;
 import com.involutionhell.backend.community.model.SharedLinkStatus;
 import com.involutionhell.backend.community.repository.SharedLinkRepository;
+import com.involutionhell.backend.community.service.SharedLinkEnrichmentWorker;
 import com.involutionhell.backend.community.service.SharedLinkService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -44,11 +45,14 @@ public class SharedLinkAdminController {
 
     private final SharedLinkService service;
     private final SharedLinkRepository linkRepo;
+    private final SharedLinkEnrichmentWorker enrichmentWorker;
 
     public SharedLinkAdminController(SharedLinkService service,
-                                     SharedLinkRepository linkRepo) {
+                                     SharedLinkRepository linkRepo,
+                                     SharedLinkEnrichmentWorker enrichmentWorker) {
         this.service = service;
         this.linkRepo = linkRepo;
+        this.enrichmentWorker = enrichmentWorker;
     }
 
     @GetMapping("/pending")
@@ -91,4 +95,58 @@ public ResponseEntity<ApiResponse<SharedLinkView>> reject(
                 .orElseGet(() -> ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                         .body(new ApiResponse<>(false, "link disappeared after update", null)));
     }
+
+    /**
+     * 重跑 enrichment（OG 抓取 + LLM 兜底 + 分类）。
+     *
+     * 用途：
+     * - OG 抓取规则升级后回填历史链接
+     * - 单条链接首次抓取卡在限流 / 反爬，等过段时间手动重试
+     * - 测试新 SiteAdapter / OgFallback 效果
+     *
+     * 异步触发，不等结果——立即返回 202 Accepted，前端轮询 /pending 看新数据。
+     * status 不变（不会把 APPROVED 推回 PENDING），enrich() 内部会原地覆盖 og_* 字段。
+     */
+    @PostMapping("/{id}/refetch-og")
+    public ResponseEntity<ApiResponse<Map<String, Object>>> refetchOg(@PathVariable Long id) {
+        Optional<SharedLink> maybe = linkRepo.findById(id);
+        if (maybe.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                    .body(new ApiResponse<>(false, "link not found", null));
+        }
+        log.info("admin refetch-og shared-link id={}", id);
+        enrichmentWorker.enrich(id);
+        return ResponseEntity.accepted()
+                .body(ApiResponse.ok(Map.of("id", id, "queued", true)));
+    }
+
+    /**
+     * 批量重跑 enrichment。POST body: {"ids": [1, 2, 3]}。
+     * 用 ids: ["all"] 表示对全表扫描所有 og_title IS NULL 的链接重跑（运维用）。
+     *
+     * 防误操作：单次最多 100 条；"all" 也走相同上限。
+     */
+    @PostMapping("/refetch-og/bulk")
+    public ResponseEntity<ApiResponse<Map<String, Object>>> bulkRefetchOg(
+            @RequestBody Map<String, Object> body) {
+        Object idsRaw = body.get("ids");
+        List<Long> ids;
+        if (idsRaw instanceof List<?> raw && raw.size() == 1 && "all".equals(raw.get(0))) {
+            ids = service.findIdsMissingOg(100);
+        } else if (idsRaw instanceof List<?> raw) {
+            ids = raw.stream()
+                    .map(v -> v instanceof Number n ? n.longValue() : Long.parseLong(v.toString()))
+                    .limit(100)
+                    .toList();
+        } else {
+            return ResponseEntity.badRequest()
+                    .body(new ApiResponse<>(false, "missing or invalid 'ids' field", null));
+        }
+        log.info("admin bulk refetch-og count={}", ids.size());
+        for (Long id : ids) {
+            enrichmentWorker.enrich(id);
+        }
+        return ResponseEntity.accepted()
+                .body(ApiResponse.ok(Map.of("queued", ids.size(), "ids", ids)));
+    }
 }

src/main/java/com/involutionhell/backend/community/repository/JdbcSharedLinkRepository.java

@@ -248,6 +248,17 @@ public void touchProbeLastAt(Long id) {
         jdbc.update("UPDATE shared_links SET probe_last_at = NOW() WHERE id = ?", id);
     }
 
+    @Override
+    public List<Long> findIdsMissingOgTitle(int limit) {
+        // 用 LIMIT 防止运维误调动了几万条全量重跑把 LLM 兜底配额炸了。
+        // 排序按 id ASC，先补老的（更可能是历史抓取规则不完善）。
+        return jdbc.queryForList(
+                "SELECT id FROM shared_links WHERE og_title IS NULL ORDER BY id ASC LIMIT ?",
+                Long.class,
+                limit
+        );
+    }
+
     private String serializeFlags(Map<String, Boolean> flags) {
         try {
             return objectMapper.writeValueAsString(flags == null ? new HashMap<>() : flags);

src/main/java/com/involutionhell/backend/community/repository/SharedLinkRepository.java

@@ -70,4 +70,7 @@ void updateEnrichment(Long id,
 
     /** 探活扫描需要的最小字段集合。 */
     record ProbeTarget(Long id, String url, int probeFailCount) {}
+
+    /** 找出 og_title IS NULL 的 link id，用于管理员批量重抓 OG。 */
+    List<Long> findIdsMissingOgTitle(int limit);
 }

src/main/java/com/involutionhell/backend/community/service/OgFallbackService.java

@@ -0,0 +1,164 @@
+package com.involutionhell.backend.community.service;
+
+import com.involutionhell.backend.openai.config.OpenAiProperties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Service;
+import tools.jackson.databind.JsonNode;
+import tools.jackson.databind.ObjectMapper;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * OG 抓取失败时的 LLM 兜底：用 LLM 根据 URL 本身（host + path）猜个 title/description。
+ *
+ * 何时触发：{@link OgFetchService} 返回的 errorMessage 非 null（PDF / 反爬 / 限流 等）。
+ * 不能保证准确，但能避免 feed 卡片完全空白 ——
+ * 用户看到 "<arxiv 论文 id> — 摘要：暂不可用" 也比一行 URL 强。
+ *
+ * 复用 {@link OpenAiProperties}（model/apiUrl/apiKey），跟 ClassificationService 同一套 LLM。
+ * 失败降级：返回空结果（title/description 都 null），调用方自己决定显示策略。
+ */
+@Service
+public class OgFallbackService {
+
+    private static final Logger log = LoggerFactory.getLogger(OgFallbackService.class);
+    private static final Duration TIMEOUT = Duration.ofSeconds(20);
+
+    /**
+     * Prompt 设计原则：
+     * - 强约束只返回 JSON，禁止 markdown / 解释，跟 ClassificationService 一致
+     * - 明确"不能编造内容"——只根据 URL 本身可推断的信息给标题
+     * - 失败标识：所有字段为空时返回 {"title":null,"description":null}
+     */
+    private static final String SYSTEM_PROMPT = """
+            你是一个网页元数据猜测助手。用户会给你一条无法直接抓取 OG meta 的 URL，
+            请根据 URL 的 host、path、query 推断出最可能的标题和一句简短描述。
+
+            约束：
+            - 只能基于 URL 本身可推断的事实，**不要编造文章内容**
+            - 标题尽量贴近真实页面标题的风格（如 arxiv 论文用 "[Paper] <id>"，
+              微信公众号用 "<公众号> · <推断主题>"，github repo 用 "<owner>/<repo>" 等）
+            - 描述一句话说明这是什么类型的资源（论文、技术博客、新闻报道、代码仓库、视频、PDF 文档...）
+            - 中文输出
+            - 完全无法推断时返回 {"title":null,"description":null}
+
+            严格只返回 JSON，不要任何解释、代码块标记（不要 ```json）或其他文字：
+            {"title":"<推断标题>", "description":"<一句话描述>"}
+            """;
+
+    private final HttpClient httpClient;
+    private final ObjectMapper objectMapper;
+    private final OpenAiProperties properties;
+
+    public OgFallbackService(HttpClient httpClient,
+                             ObjectMapper objectMapper,
+                             OpenAiProperties properties) {
+        this.httpClient = httpClient;
+        this.objectMapper = objectMapper;
+        this.properties = properties;
+    }
+
+    /**
+     * 给 URL 猜个 OG。失败返回 (null, null)，让调用方决定是否回填。
+     */
+    public Guess guess(String url, String host) {
+        if (url == null || url.isBlank()) {
+            return Guess.empty();
+        }
+        // 没配 apiKey 时直接降级，避免发空请求被 LLM 服务拒绝
+        if (properties.apiKey() == null || properties.apiKey().isBlank()) {
+            log.debug("og-fallback 跳过：未配置 OPENAI_API_KEY");
+            return Guess.empty();
+        }
+        try {
+            String userContent = "URL: " + url + "\nHost: " + (host == null ? "(unknown)" : host);
+            String requestBody = buildRequestBody(SYSTEM_PROMPT, userContent);
+            HttpRequest request = HttpRequest.newBuilder(URI.create(properties.apiUrl() + "/chat/completions"))
+                    .header("Content-Type", "application/json")
+                    .header("Authorization", "Bearer " + properties.apiKey())
+                    .timeout(TIMEOUT)
+                    .POST(HttpRequest.BodyPublishers.ofString(requestBody, StandardCharsets.UTF_8))
+                    .build();
+
+            HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+            if (response.statusCode() < 200 || response.statusCode() >= 300) {
+                log.warn("og-fallback LLM 失败（HTTP 非 2xx）: host={} status={}", host, response.statusCode());
+                return Guess.empty();
+            }
+            return parseLlmResponse(response.body(), host);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return Guess.empty();
+        } catch (Exception e) {
+            log.warn("og-fallback 异常: host={} error={}", host, e.getMessage());
+            return Guess.empty();
+        }
+    }
+
+    private String buildRequestBody(String systemContent, String userContent) {
+        try {
+            Map<String, Object> body = new LinkedHashMap<>();
+            body.put("model", properties.model());
+            body.put("temperature", 0);
+            body.put("messages", List.of(
+                    Map.of("role", "system", "content", systemContent),
+                    Map.of("role", "user", "content", userContent)
+            ));
+            return objectMapper.writeValueAsString(body);
+        } catch (Exception e) {
+            // ObjectMapper 写 LinkedHashMap 不会抛 checked exception，但兜底以防万一
+            throw new IllegalStateException("og-fallback 构造请求体失败", e);
+        }
+    }
+
+    private Guess parseLlmResponse(String body, String host) {
+        try {
+            JsonNode root = objectMapper.readTree(body);
+            String content = root.path("choices").path(0).path("message").path("content").asString(null);
+            if (content == null || content.isBlank()) return Guess.empty();
+            // LLM 偶尔会带 ```json ... ``` 包装，剥一下
+            String stripped = content.trim();
+            if (stripped.startsWith("```")) {
+                int firstNewline = stripped.indexOf('\n');
+                if (firstNewline > 0) stripped = stripped.substring(firstNewline + 1);
+                if (stripped.endsWith("```")) stripped = stripped.substring(0, stripped.length() - 3);
+                stripped = stripped.trim();
+            }
+            JsonNode payload = objectMapper.readTree(stripped);
+            String title = nullableText(payload.path("title"));
+            String description = nullableText(payload.path("description"));
+            if (title == null && description == null) {
+                return Guess.empty();
+            }
+            return new Guess(title, description);
+        } catch (Exception e) {
+            log.warn("og-fallback LLM 响应解析失败: host={} error={}", host, e.getMessage());
+            return Guess.empty();
+        }
+    }
+
+    private static String nullableText(JsonNode node) {
+        if (node == null || node.isMissingNode() || node.isNull()) return null;
+        String s = node.asString(null);
+        if (s == null) return null;
+        s = s.trim();
+        return s.isEmpty() ? null : s;
+    }
+
+    /**
+     * 兜底猜测结果。两个字段都为 null 表示无可用猜测。
+     */
+    public record Guess(String title, String description) {
+        public static Guess empty() { return new Guess(null, null); }
+        public boolean isEmpty() { return title == null && description == null; }
+    }
+}