@web-auto/webauto 0.1.4 → 0.1.6

package/modules/camo-runtime/src/container/runtime-core/operations/tab-pool.mjs

@@ -205,6 +205,71 @@ async function tryOpenTabWithShortcut(profileId, timeoutMs) {
   return { ok: false, error: lastError };
 }
 
+async function waitForTabCountIncrease({
+  profileId,
+  beforeCount,
+  apiTimeoutMs,
+  maxWaitMs,
+  pollMs = 250,
+}) {
+  const startedAt = Date.now();
+  const effectivePollMs = Math.max(80, Number(pollMs) || 250);
+  const waitMs = Math.max(400, Number(maxWaitMs) || 4000);
+  const listTimeoutMs = Math.max(500, Math.min(resolveTimeoutMs(apiTimeoutMs, DEFAULT_API_TIMEOUT_MS), 2500));
+  let lastError = null;
+
+  while (Date.now() - startedAt <= waitMs) {
+    try {
+      const listed = await callApiWithTimeout('page:list', { profileId }, listTimeoutMs);
+      const { pages } = extractPageList(listed);
+      if (pages.length > beforeCount) {
+        return {
+          ok: true,
+          elapsedMs: Date.now() - startedAt,
+          afterCount: pages.length,
+        };
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    await sleep(effectivePollMs);
+  }
+
+  return {
+    ok: false,
+    elapsedMs: Date.now() - startedAt,
+    error: lastError,
+  };
+}
+
+async function tryOpenTabWithAnchor(profileId, seedUrl, timeoutMs) {
+  try {
+    const popupResult = await callApiWithTimeout('evaluate', {
+      profileId,
+      script: `(() => {
+        const href = ${JSON.stringify(seedUrl || 'about:blank')};
+        const anchor = document.createElement('a');
+        anchor.href = href;
+        anchor.target = '_blank';
+        anchor.rel = 'noopener noreferrer';
+        anchor.style.position = 'fixed';
+        anchor.style.left = '-9999px';
+        anchor.style.top = '-9999px';
+        document.body.appendChild(anchor);
+        const evt = new MouseEvent('click', { bubbles: true, cancelable: true, view: window });
+        const dispatched = anchor.dispatchEvent(evt);
+        anchor.click();
+        anchor.remove();
+        return { opened: true, dispatched };
+      })()`,
+    }, timeoutMs);
+    const popupData = popupResult?.result || popupResult || {};
+    return { ok: Boolean(popupData?.opened || popupData?.ok), error: null };
+  } catch (err) {
+    return { ok: false, error: err };
+  }
+}
+
 async function openTabBestEffort({
   profileId,
   seedUrl,
@@ -213,13 +278,15 @@ async function openTabBestEffort({
   apiTimeoutMs,
   navigationTimeoutMs,
   shortcutTimeoutMs,
+  tabAppearTimeoutMs,
   syncConfig,
 }) {
-  const hasNewTab = async () => {
-    const listed = await callApiWithTimeout('page:list', { profileId }, apiTimeoutMs);
-    const { pages } = extractPageList(listed);
-    return pages.length > beforeCount;
-  };
+  const waitForTab = async () => waitForTabCountIncrease({
+    profileId,
+    beforeCount,
+    apiTimeoutMs,
+    maxWaitMs: tabAppearTimeoutMs,
+  });
   const settle = async () => {
     if (openDelayMs > 0) {
       await new Promise((resolve) => setTimeout(resolve, openDelayMs));
@@ -230,7 +297,8 @@ async function openTabBestEffort({
   const shortcutResult = await tryOpenTabWithShortcut(profileId, shortcutTimeoutMs);
   if (shortcutResult.ok) {
     await settle();
-    if (await hasNewTab()) {
+    const shortcutOpened = await waitForTab();
+    if (shortcutOpened.ok) {
       await seedNewestTabIfNeeded({
         profileId,
         seedUrl,
@@ -249,9 +317,10 @@ async function openTabBestEffort({
     ? { profileId, url: seedUrl }
     : { profileId };
   try {
-    await callApiWithTimeout('newPage', payload, apiTimeoutMs);
+    await callApiWithTimeout('newPage', payload, Math.max(1200, Math.min(apiTimeoutMs, 6000)));
     await settle();
-    if (await hasNewTab()) {
+    const newPageOpened = await waitForTab();
+    if (newPageOpened.ok) {
       await seedNewestTabIfNeeded({
         profileId,
         seedUrl,
@@ -277,7 +346,8 @@ async function openTabBestEffort({
     const popupData = popupResult?.result || popupResult || {};
     if (Boolean(popupData?.opened || popupData?.ok)) {
       await settle();
-      if (await hasNewTab()) {
+      const popupOpened = await waitForTab();
+      if (popupOpened.ok) {
         await seedNewestTabIfNeeded({
           profileId,
           seedUrl,
@@ -293,6 +363,29 @@ async function openTabBestEffort({
     openError = err;
   }
 
+  const anchorResult = await tryOpenTabWithAnchor(
+    profileId,
+    seedUrl,
+    Math.max(1200, Math.min(apiTimeoutMs, 5000)),
+  );
+  if (anchorResult.ok) {
+    await settle();
+    const anchorOpened = await waitForTab();
+    if (anchorOpened.ok) {
+      await seedNewestTabIfNeeded({
+        profileId,
+        seedUrl,
+        openDelayMs,
+        apiTimeoutMs,
+        navigationTimeoutMs,
+        syncConfig,
+      });
+      return { ok: true, mode: 'anchor_click', error: null };
+    }
+  } else {
+    openError = anchorResult.error || openError;
+  }
+
   return { ok: false, mode: null, error: openError };
 }
 
@@ -306,6 +399,10 @@ export async function executeTabPoolOperation({ profileId, action, params = {},
     const apiTimeoutMs = resolveTimeoutMs(params.apiTimeoutMs, DEFAULT_API_TIMEOUT_MS);
     const navigationTimeoutMs = resolveTimeoutMs(params.navigationTimeoutMs ?? params.gotoTimeoutMs, DEFAULT_NAV_TIMEOUT_MS);
     const shortcutTimeoutMs = resolveTimeoutMs(params.shortcutTimeoutMs, SHORTCUT_OPEN_TIMEOUT_MS);
+    const tabAppearTimeoutMs = resolveTimeoutMs(
+      params.tabAppearTimeoutMs,
+      Math.max(3000, openDelayMs + 2200),
+    );
     const syncConfig = resolveViewportSyncConfig({ params });
     const configuredSeedUrl = normalizeSeedUrl(String(params.url || '').trim());
 
@@ -334,6 +431,7 @@ export async function executeTabPoolOperation({ profileId, action, params = {},
         apiTimeoutMs,
         navigationTimeoutMs,
         shortcutTimeoutMs,
+        tabAppearTimeoutMs,
         syncConfig,
       });
       listed = await callApiWithTimeout('page:list', { profileId }, apiTimeoutMs);
@@ -364,17 +462,48 @@ export async function executeTabPoolOperation({ profileId, action, params = {},
       for (const page of selected) {
         const pageIndex = Number(page.index);
         if (!Number.isFinite(pageIndex)) continue;
-        await callApiWithTimeout('page:switch', { profileId, index: pageIndex }, apiTimeoutMs);
-        if (shouldNavigateToSeed(page.url, fallbackSeedUrl)) {
-          await callApiWithTimeout('goto', { profileId, url: fallbackSeedUrl }, navigationTimeoutMs);
-          if (openDelayMs > 0) await sleep(Math.min(openDelayMs, 1200));
-        }
-        const syncResult = await syncTabViewportIfNeeded({ profileId, syncConfig });
-        if (!syncResult?.ok) {
-          return asErrorPayload('OPERATION_FAILED', 'tab viewport sync failed', {
-            pageIndex,
-            syncResult,
-          });
+        try {
+          await callApiWithTimeout('page:switch', { profileId, index: pageIndex }, apiTimeoutMs);
+          if (shouldNavigateToSeed(page.url, fallbackSeedUrl)) {
+            await callApiWithTimeout('goto', { profileId, url: fallbackSeedUrl }, navigationTimeoutMs);
+            if (openDelayMs > 0) await sleep(Math.min(openDelayMs, 1200));
+          }
+          const syncResult = await syncTabViewportIfNeeded({ profileId, syncConfig });
+          if (!syncResult?.ok) {
+            throw new Error(syncResult?.message || 'tab viewport sync failed');
+          }
+        } catch (err) {
+          const activePage = selected.find((item) => Number(item.index) === Number(activeIndex)) || selected[0] || null;
+          const slots = activePage
+            ? [{
+              slotIndex: 1,
+              tabRealIndex: Number(activePage.index),
+              url: String(activePage.url || ''),
+            }]
+            : [];
+          if (runtimeState) {
+            runtimeState.tabPool = {
+              slots,
+              cursor: 0,
+              count: slots.length,
+              syncConfig,
+              apiTimeoutMs,
+              initializedAt: new Date().toISOString(),
+            };
+          }
+          return {
+            ok: true,
+            code: 'OPERATION_DEGRADED',
+            message: 'ensure_tab_pool degraded to active tab',
+            data: {
+              tabCount: slots.length,
+              normalized: false,
+              degraded: true,
+              reason: err?.message || 'page switch failed',
+              slots,
+              pages: activePage ? [activePage] : [],
+            },
+          };
         }
       }
       listed = await callApiWithTimeout('page:list', { profileId }, apiTimeoutMs);
@@ -391,13 +520,40 @@ export async function executeTabPoolOperation({ profileId, action, params = {},
     }));
 
     if (slots.length > 0) {
-      await callApiWithTimeout('page:switch', {
-        profileId,
-        index: Number(slots[0].tabRealIndex),
-      }, apiTimeoutMs);
-      const syncResult = await syncTabViewportIfNeeded({ profileId, syncConfig });
-      if (!syncResult?.ok) {
-        return asErrorPayload('OPERATION_FAILED', 'tab viewport sync failed', { slotIndex: 1, syncResult });
+      try {
+        await callApiWithTimeout('page:switch', {
+          profileId,
+          index: Number(slots[0].tabRealIndex),
+        }, apiTimeoutMs);
+        const syncResult = await syncTabViewportIfNeeded({ profileId, syncConfig });
+        if (!syncResult?.ok) {
+          throw new Error(syncResult?.message || 'tab viewport sync failed');
+        }
+      } catch (err) {
+        const activePage = slots[0];
+        if (runtimeState) {
+          runtimeState.tabPool = {
+            slots: activePage ? [activePage] : [],
+            cursor: 0,
+            count: activePage ? 1 : 0,
+            syncConfig,
+            apiTimeoutMs,
+            initializedAt: new Date().toISOString(),
+          };
+        }
+        return {
+          ok: true,
+          code: 'OPERATION_DEGRADED',
+          message: 'ensure_tab_pool degraded on final switch',
+          data: {
+            tabCount: activePage ? 1 : 0,
+            normalized: false,
+            degraded: true,
+            reason: err?.message || 'page switch failed',
+            slots: activePage ? [activePage] : [],
+            pages: activePage ? [activePage] : [],
+          },
+        };
       }
     }
 

package/modules/collection-manager/bloom-filter.ts

@@ -0,0 +1,112 @@
+/**
+ * Simple Bloom Filter for memory-efficient deduplication
+ * Uses non-cryptographic hash functions for speed
+ */
+
+export class BloomFilter {
+  private bitmap: Uint8Array;
+  private size: number;
+  private hashCount: number;
+  private count: number = 0;
+
+  constructor(expectedItems: number = 500000, falsePositiveRate: number = 0.001) {
+    // Calculate optimal size and hash count
+    this.size = Math.ceil(-expectedItems * Math.log(falsePositiveRate) / Math.pow(Math.LN2, 2));
+    this.hashCount = Math.ceil((this.size / expectedItems) * Math.LN2);
+    this.bitmap = new Uint8Array(Math.ceil(this.size / 8));
+  }
+
+  private hash(str: string, seed: number): number {
+    // FNV-1a variant with seed
+    let hash = 2166136261 ^ seed;
+    for (let i = 0; i < str.length; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return Math.abs(hash) % this.size;
+  }
+
+  add(item: string): void {
+    for (let i = 0; i < this.hashCount; i++) {
+      const bit = this.hash(item, i);
+      const byteIndex = Math.floor(bit / 8);
+      const bitIndex = bit % 8;
+      this.bitmap[byteIndex] |= (1 << bitIndex);
+    }
+    this.count++;
+  }
+
+  mightContain(item: string): boolean {
+    for (let i = 0; i < this.hashCount; i++) {
+      const bit = this.hash(item, i);
+      const byteIndex = Math.floor(bit / 8);
+      const bitIndex = bit % 8;
+      if ((this.bitmap[byteIndex] & (1 << bitIndex)) === 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  getCount(): number {
+    return this.count;
+  }
+
+  /**
+   * Export to base64 string for persistence
+   */
+  export(): string {
+    // Header: hashCount (4), count (4), size (4) = 12 bytes
+    const header = Buffer.alloc(12);
+    header.writeUInt32LE(this.hashCount, 0);
+    header.writeUInt32LE(this.count, 4);
+    header.writeUInt32LE(this.size, 8);
+    const buffer = Buffer.concat([header, Buffer.from(this.bitmap)]);
+    return buffer.toString('base64');
+  }
+
+  /**
+   * Import from base64 string
+   */
+  static import(base64: string, expectedItems: number = 100000): BloomFilter {
+    const buffer = Buffer.from(base64, 'base64');
+    
+    // Read header (12 bytes)
+    const hashCount = buffer.readUInt32LE(0);
+    const count = buffer.readUInt32LE(4);
+    const size = buffer.readUInt32LE(8);
+    const bitmapBuffer = buffer.slice(12);
+    
+    const filter = Object.create(BloomFilter.prototype);
+    filter.bitmap = new Uint8Array(bitmapBuffer);
+    filter.size = size;
+    filter.hashCount = hashCount;
+    filter.count = count;
+    
+    return filter;
+  }
+
+  /**
+   * Serialize to JSON
+   */
+  toJSON(): { bitmap: string; size: number; hashCount: number; count: number } {
+    return {
+      bitmap: this.export(),
+      size: this.size,
+      hashCount: this.hashCount,
+      count: this.count
+    };
+  }
+
+  /**
+   * Deserialize from JSON
+   */
+  static fromJSON(json: { bitmap: string; size: number; hashCount: number; count: number }): BloomFilter {
+    const filter = new BloomFilter(1000); // Dummy, will be overwritten
+    filter.bitmap = new Uint8Array(Buffer.from(json.bitmap, 'base64'));
+    filter.size = json.size;
+    filter.hashCount = json.hashCount;
+    filter.count = json.count;
+    return filter;
+  }
+}

package/modules/collection-manager/date-utils.ts

@@ -0,0 +1,316 @@
+/**
+ * Date extraction utilities for social media posts
+ * Handles various time formats from platforms like Weibo, Xiaohongshu
+ */
+
+/**
+ * Parse relative time strings to absolute date
+ * 
+ * Supported formats:
+ * - "刚刚" / "刚刚来自..." → now
+ * - "5分钟前" / "30秒前" → relative to now
+ * - "今天 08:30" / "今天08:30" → today
+ * - "昨天 14:20" / "昨天14:20" → yesterday
+ * - "前天 10:00" → 2 days ago
+ * - "01-15" / "1月15日" → this year
+ * - "2025-12-01" / "2025年12月01日" → exact date
+ * - "12-01 15:30" → this year with time
+ */
+export function parsePlatformDate(
+  text: string,
+  options: {
+    now?: Date;
+    timezone?: string;
+  } = {}
+): { date: string; time: string; fullText: string } | null {
+  const { now = new Date(), timezone = 'Asia/Shanghai' } = options;
+  const trimmed = text.trim();
+  
+  if (!trimmed) return null;
+  
+  // Get current date in specified timezone
+  const currentDate = new Date(now.toLocaleString('en-US', { timeZone: timezone }));
+  const currentYear = currentDate.getFullYear();
+  
+  // "刚刚" / "刚刚来自..."
+  if (trimmed.includes('刚刚')) {
+    return {
+      date: formatDate(currentDate),
+      time: formatTime(currentDate),
+      fullText: formatDateTime(currentDate)
+    };
+  }
+  
+  // "X分钟前" / "X秒前" / "X小时前"
+  const relativeMatch = trimmed.match(/(\d+)\s*(秒|分钟|小时)前/);
+  if (relativeMatch) {
+    const amount = parseInt(relativeMatch[1], 10);
+    const unit = relativeMatch[2];
+    const result = new Date(currentDate);
+    
+    if (unit === '秒') result.setSeconds(result.getSeconds() - amount);
+    else if (unit === '分钟') result.setMinutes(result.getMinutes() - amount);
+    else if (unit === '小时') result.setHours(result.getHours() - amount);
+    
+    return {
+      date: formatDate(result),
+      time: formatTime(result),
+      fullText: formatDateTime(result)
+    };
+  }
+  
+  // "今天 08:30" / "今天08:30"
+  const todayMatch = trimmed.match(/今天\s*(\d{1,2}):(\d{2})/);
+  if (todayMatch) {
+    const hour = parseInt(todayMatch[1], 10);
+    const minute = parseInt(todayMatch[2], 10);
+    const result = new Date(currentDate);
+    result.setHours(hour, minute, 0, 0);
+    
+    return {
+      date: formatDate(result),
+      time: formatTime(result),
+      fullText: formatDateTime(result)
+    };
+  }
+  
+  // "昨天 14:20" / "昨天14:20"
+  const yesterdayMatch = trimmed.match(/昨天\s*(\d{1,2}):(\d{2})/);
+  if (yesterdayMatch) {
+    const hour = parseInt(yesterdayMatch[1], 10);
+    const minute = parseInt(yesterdayMatch[2], 10);
+    const result = new Date(currentDate);
+    result.setDate(result.getDate() - 1);
+    result.setHours(hour, minute, 0, 0);
+    
+    return {
+      date: formatDate(result),
+      time: formatTime(result),
+      fullText: formatDateTime(result)
+    };
+  }
+  
+  // "前天 10:00"
+  const dayBeforeYesterdayMatch = trimmed.match(/前天\s*(\d{1,2}):(\d{2})/);
+  if (dayBeforeYesterdayMatch) {
+    const hour = parseInt(dayBeforeYesterdayMatch[1], 10);
+    const minute = parseInt(dayBeforeYesterdayMatch[2], 10);
+    const result = new Date(currentDate);
+    result.setDate(result.getDate() - 2);
+    result.setHours(hour, minute, 0, 0);
+    
+    return {
+      date: formatDate(result),
+      time: formatTime(result),
+      fullText: formatDateTime(result)
+    };
+  }
+  
+ // "2天前" / "3天前"
+ const daysAgoMatch = trimmed.match(/(\d+)\s*天前/);
+ if (daysAgoMatch) {
+   const days = parseInt(daysAgoMatch[1], 10);
+   const result = new Date(currentDate);
+   result.setDate(result.getDate() - days);
+   
+   return {
+     date: formatDate(result),
+     time: '',
+     fullText: formatDate(result)
+   };
+ }
+ 
+  // "2025-12-01" / "2025年12月01日" - Full date (must match before MM-DD)
+  const fullDateMatch = trimmed.match(/(\d{4})[-年](\d{1,2})[-月](\d{1,2})/);
+  if (fullDateMatch) {
+    const year = parseInt(fullDateMatch[1], 10);
+    const month = parseInt(fullDateMatch[2], 10);
+    const day = parseInt(fullDateMatch[3], 10);
+    const result = new Date(year, month - 1, day);
+    
+    // Check if there's time info
+    const timeMatch = trimmed.match(/(\d{1,2}):(\d{2})/);
+    if (timeMatch) {
+      result.setHours(parseInt(timeMatch[1], 10), parseInt(timeMatch[2], 10), 0, 0);
+      if (result.getTime() > currentDate.getTime()) {
+        result.setFullYear(currentYear - 1);
+      }
+      return {
+        date: formatDate(result),
+        time: formatTime(result),
+        fullText: formatDateTime(result)
+      };
+    }
+    
+    return {
+      date: formatDate(result),
+      time: '',
+      fullText: formatDate(result)
+    };
+  }
+  
+ // "01-15" / "1月15日" (this year, fallback to previous year when parsed date is in future)
+ const monthDayMatch = trimmed.match(/(\d{1,2})[-月](\d{1,2})日?/);
+ if (monthDayMatch && !trimmed.includes('年')) {
+    const month = parseInt(monthDayMatch[1], 10);
+    const day = parseInt(monthDayMatch[2], 10);
+    const result = new Date(currentYear, month - 1, day);
+    
+    // Check if there's time info
+    const timeMatch = trimmed.match(/(\d{1,2}):(\d{2})/);
+    if (timeMatch) {
+      result.setHours(parseInt(timeMatch[1], 10), parseInt(timeMatch[2], 10), 0, 0);
+      if (result.getTime() > currentDate.getTime()) {
+        result.setFullYear(currentYear - 1);
+      }
+      return {
+        date: formatDate(result),
+        time: formatTime(result),
+        fullText: formatDateTime(result)
+      };
+    }
+    if (result.getTime() > currentDate.getTime()) {
+      result.setFullYear(currentYear - 1);
+    }
+    
+   return {
+     date: formatDate(result),
+     time: '',
+     fullText: formatDate(result)
+   };
+ }
+ 
+ 
+ return null;
+}
+
+/**
+ * Format date as YYYY-MM-DD
+ */
+function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Format time as HH:MM
+ */
+function formatTime(date: Date): string {
+  const hour = String(date.getHours()).padStart(2, '0');
+  const minute = String(date.getMinutes()).padStart(2, '0');
+  return `${hour}:${minute}`;
+}
+
+/**
+ * Format datetime as YYYY-MM-DD HH:MM
+ */
+function formatDateTime(date: Date): string {
+  return `${formatDate(date)} ${formatTime(date)}`;
+}
+
+/**
+ * Get current timestamp in ISO format with timezone
+ */
+export function getCurrentTimestamp(timezone: string = 'Asia/Shanghai'): {
+  collectedAt: string;      // ISO 8601 UTC: 2026-02-20T14:58:44.494Z
+  collectedAtLocal: string; // Local with TZ: 2026-02-20 22:58:44.494 +08:00
+  collectedDate: string;    // Date only: 2026-02-20
+} {
+  const now = new Date();
+  
+  // UTC ISO string
+  const collectedAt = now.toISOString();
+  
+  // Local time with timezone
+  const formatter = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    fractionalSecondDigits: 3,
+    hour12: false
+  });
+  
+  const parts = formatter.formatToParts(now);
+  const get = (type: string) => parts.find(p => p.type === type)?.value || '00';
+  
+  const year = get('year');
+  const month = get('month');
+  const day = get('day');
+  const hour = get('hour');
+  const minute = get('minute');
+  const second = get('second');
+  const ms = get('fractionalSecond');
+  
+  // Get timezone offset
+  const tzOffset = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    timeZoneName: 'shortOffset'
+  }).format(now).split(' ').pop() || '+08:00';
+  
+  const collectedAtLocal = `${year}-${month}-${day} ${hour}:${minute}:${second}.${ms} ${tzOffset}`;
+  const collectedDate = `${year}-${month}-${day}`;
+  
+  return {
+    collectedAt,
+    collectedAtLocal,
+    collectedDate
+  };
+}
+
+/**
+ * Weibo-specific date extraction from post element
+ */
+export function extractWeiboPostDate(
+  postElement: Element,
+  now: Date = new Date()
+): { date: string; time: string; fullText: string } | null {
+  // Weibo post time is usually in:
+  // - <a class="head-info_time_..."> or similar
+  // - Element with from, time info
+  
+  const timeSelectors = [
+    'a[class*="time"]',
+    'a[class*="date"]',
+    'span[class*="time"]',
+    '.from a',
+    'a[href*="weibo.com"]'
+  ];
+  
+  for (const selector of timeSelectors) {
+    const timeEl = postElement.querySelector(selector);
+    if (timeEl) {
+      const text = timeEl.textContent?.trim();
+      if (text) {
+        const parsed = parsePlatformDate(text, { now });
+        if (parsed) return parsed;
+      }
+    }
+  }
+  
+  // Fallback: search all text content for date patterns
+  const allText = postElement.textContent || '';
+  const datePatterns = [
+    /刚刚/,
+    /\d+\s*(秒|分钟|小时)前/,
+    /今天\s*\d{1,2}:\d{2}/,
+    /昨天\s*\d{1,2}:\d{2}/,
+    /\d{1,2}-\d{1,2}/,
+    /\d{4}-\d{1,2}-\d{1,2}/
+  ];
+  
+  for (const pattern of datePatterns) {
+    const match = allText.match(pattern);
+    if (match) {
+      const parsed = parsePlatformDate(match[0], { now });
+      if (parsed) return parsed;
+    }
+  }
+  
+  return null;
+}