@jackwener/opencli 1.7.5 → 1.7.7

package/clis/deepseek/utils.js

@@ -38,31 +38,27 @@ export async function getPageState(page) {
 
 export async function selectModel(page, modelName) {
     return page.evaluate(`(() => {
-        const radios = document.querySelectorAll('div[role="radio"]');
-        for (const radio of radios) {
-            const span = radio.querySelector('span');
-            if (span && span.textContent.trim().toLowerCase() === '${modelName}'.toLowerCase()) {
-                const alreadySelected = radio.getAttribute('aria-checked') === 'true';
-                if (!alreadySelected) radio.click();
-                return { ok: true, toggled: !alreadySelected };
-            }
-        }
-        return { ok: false };
+        var radios = document.querySelectorAll('div[role="radio"]');
+        if (radios.length === 0) return { ok: false };
+        var isFirst = '${modelName}'.toLowerCase() === 'instant';
+        if (!isFirst && radios.length < 2) return { ok: false };
+        var target = isFirst ? radios[0] : radios[radios.length - 1];
+        var alreadySelected = target.getAttribute('aria-checked') === 'true';
+        if (!alreadySelected) target.click();
+        return { ok: true, toggled: !alreadySelected };
     })()`);
 }
 
 export async function setFeature(page, featureName, enabled) {
+    // Match by position: DeepThink is the first toggle, Search is the second
+    var index = featureName === 'DeepThink' ? 0 : 1;
     return page.evaluate(`(() => {
-        const btns = document.querySelectorAll('div[role="button"]');
-        for (const btn of btns) {
-            const span = btn.querySelector('span');
-            if (span && span.textContent.trim() === '${featureName}') {
-                const isActive = btn.classList.contains('ds-toggle-button--selected');
-                if (${enabled} !== isActive) btn.click();
-                return { ok: true, toggled: ${enabled} !== isActive };
-            }
-        }
-        return { ok: false };
+        var toggles = Array.from(document.querySelectorAll('.ds-toggle-button'));
+        var btn = toggles[${index}];
+        if (!btn) return { ok: false };
+        var isActive = btn.classList.contains('ds-toggle-button--selected');
+        if (${enabled} !== isActive) btn.click();
+        return { ok: true, toggled: ${enabled} !== isActive };
     })()`);
 }
 
@@ -101,7 +97,35 @@ export async function getBubbleCount(page) {
     return count || 0;
 }
 
-export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
+// Parse thinking response using text as a fallback when DOM-level extraction
+// is not available.  Does NOT split on \n\n — that heuristic silently corrupts
+// multi-paragraph thinking or multi-paragraph answers.  Instead, everything
+// after the header is treated as thinking content, and `response` stays empty
+// until the caller provides a DOM-separated answer.
+export function parseThinkingResponse(rawText) {
+    if (!rawText) return null;
+
+    // Match thinking header patterns: "Thought for X seconds" or "已思考（用时 X 秒）"
+    const thinkHeaderMatch = rawText.match(/^(Thought for ([\d.]+) seconds?|已思考（用时 ([\d.]+) 秒）)\s*/);
+
+    if (!thinkHeaderMatch) {
+        // No thinking section found, return plain response
+        return { response: rawText, thinking: null, thinking_time: null };
+    }
+
+    const thinkingTime = thinkHeaderMatch[2] || thinkHeaderMatch[3];
+    const afterHeader = rawText.slice(thinkHeaderMatch[0].length);
+
+    // Treat everything after the header as thinking.  The response will be
+    // populated by the DOM-level extraction in waitForResponse().
+    return {
+        response: '',
+        thinking: afterHeader.trim(),
+        thinking_time: thinkingTime,
+    };
+}
+
+export async function waitForResponse(page, baselineCount, prompt, timeoutMs, parseThinking = false) {
     const startTime = Date.now();
     let lastText = '';
     let stableCount = 0;
@@ -114,7 +138,51 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
             result = await page.evaluate(`(() => {
                 const bubbles = document.querySelectorAll('${MESSAGE_SELECTOR}');
                 const texts = Array.from(bubbles).map(b => (b.innerText || '').trim()).filter(Boolean);
-                return { count: texts.length, last: texts[texts.length - 1] || '' };
+                var last = texts[texts.length - 1] || '';
+
+                // DOM-level thinking/response separation.
+                // DeepSeek renders thinking in a collapsible container with a
+                // distinct class (e.g. .ds-markdown--think or similar) and the
+                // final answer in the main .ds-markdown region.  By querying
+                // these separately we avoid any text-heuristic split.
+                var thinkEl = null, answerEl = null, thinkTime = null;
+                if (${parseThinking} && bubbles.length > 0) {
+                    var lastBubble = bubbles[bubbles.length - 1];
+                    // Thinking container — DeepSeek uses various class names;
+                    // try common selectors.
+                    thinkEl = lastBubble.querySelector('.ds-markdown--think')
+                           || lastBubble.querySelector('[class*="think"]');
+                    // Final answer container — the main markdown block that is
+                    // NOT the thinking section.
+                    var markdownEls = lastBubble.querySelectorAll('.ds-markdown');
+                    for (var i = 0; i < markdownEls.length; i++) {
+                        if (markdownEls[i] !== thinkEl
+                            && !(thinkEl && thinkEl.contains(markdownEls[i]))
+                            && !markdownEls[i].classList.contains('ds-markdown--think')) {
+                            answerEl = markdownEls[i];
+                        }
+                    }
+                    // Thinking time from the toggle/header element
+                    var timeEl = lastBubble.querySelector('[class*="think"] ~ *')
+                              || lastBubble.querySelector('.ds-thinking-header');
+                    if (!timeEl) {
+                        // Fallback: parse from raw text header
+                        var m = last.match(/^(?:Thought for ([\\d.]+) seconds?|已思考（用时 ([\\d.]+) 秒）)/);
+                        if (m) thinkTime = m[1] || m[2];
+                    } else {
+                        var tm = (timeEl.textContent || '').match(/([\\d.]+)/);
+                        if (tm) thinkTime = tm[1];
+                    }
+                }
+
+                return {
+                    count: texts.length,
+                    last: last,
+                    // DOM-separated fields (null when not available)
+                    thinkText: thinkEl ? (thinkEl.innerText || '').trim() : null,
+                    answerText: answerEl ? (answerEl.innerText || '').trim() : null,
+                    thinkTime: thinkTime,
+                };
             })()`);
         } catch {
             continue;
@@ -126,7 +194,21 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
         if (candidate && result.count > baselineCount && candidate !== prompt.trim()) {
             if (candidate === lastText) {
                 stableCount++;
-                if (stableCount >= 3) return candidate;
+                if (stableCount >= 3) {
+                    if (parseThinking) {
+                        // Prefer DOM-level separation
+                        if (result.thinkText != null || result.answerText != null) {
+                            return {
+                                thinking: result.thinkText || '',
+                                response: result.answerText || '',
+                                thinking_time: result.thinkTime || null,
+                            };
+                        }
+                        // Fallback to text-header parsing (no \n\n split)
+                        return parseThinkingResponse(candidate);
+                    }
+                    return candidate;
+                }
             } else {
                 stableCount = 0;
             }
@@ -134,6 +216,9 @@ export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
         }
     }
 
+    if (parseThinking && lastText) {
+        return parseThinkingResponse(lastText);
+    }
     return lastText || null;
 }
 
@@ -161,7 +246,6 @@ export async function getConversationList(page) {
             if (btn) btn.click();
         }
     })()`);
-    // Poll for sidebar history links to render
     for (let attempt = 0; attempt < 5; attempt++) {
         await page.wait(2);
         const items = await page.evaluate(`(() => {
@@ -186,6 +270,90 @@ export async function getConversationList(page) {
     return [];
 }
 
+async function waitForFilePreview(page, fileName) {
+    for (let attempt = 0; attempt < 8; attempt++) {
+        await page.wait(2);
+        const ready = await page.evaluate(`(() => {
+            const name = ${JSON.stringify(fileName)};
+            return Array.from(document.querySelectorAll('div'))
+                .some((el) => el.children.length === 0 && (el.textContent || '').trim() === name);
+        })()`);
+        if (ready) return true;
+    }
+    return false;
+}
+
+export async function sendWithFile(page, filePath, prompt) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const absPath = path.default.resolve(filePath);
+
+    if (!fs.default.existsSync(absPath)) {
+        return { ok: false, reason: `File not found: ${absPath}` };
+    }
+
+    const stats = fs.default.statSync(absPath);
+    if (stats.size > 100 * 1024 * 1024) {
+        return { ok: false, reason: `File too large (${(stats.size / 1024 / 1024).toFixed(1)} MB). Max: 100 MB` };
+    }
+
+    const fileName = path.default.basename(absPath);
+
+    // Collapse sidebar to keep DOM simple for send button matching
+    await page.evaluate(`(() => {
+        if (document.querySelectorAll('a[href*="/a/chat/s/"]').length > 0) {
+            const btn = document.querySelector('div[tabindex="0"][role="button"]');
+            if (btn) btn.click();
+        }
+    })()`);
+    await page.wait(0.5);
+
+    let uploaded = false;
+    if (page.setFileInput) {
+        try {
+            await page.setFileInput([absPath], 'input[type="file"]');
+            uploaded = true;
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
+                throw err;
+            }
+        }
+    }
+
+    if (!uploaded) {
+        const content = fs.default.readFileSync(absPath);
+        const base64 = content.toString('base64');
+        const fallbackResult = await page.evaluate(`(async () => {
+            var binary = atob('${base64}');
+            var bytes = new Uint8Array(binary.length);
+            for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+
+            var file = new File([bytes], ${JSON.stringify(fileName)});
+            var dt = new DataTransfer();
+            dt.items.add(file);
+
+            var inp = document.querySelector('input[type="file"]');
+            if (!inp) return { ok: false, reason: 'file input not found' };
+
+            var propsKey = Object.keys(inp).find(function(k) { return k.startsWith('__reactProps$'); });
+            if (!propsKey || typeof inp[propsKey].onChange !== 'function') {
+                return { ok: false, reason: 'React onChange not found' };
+            }
+
+            inp.files = dt.files;
+            inp[propsKey].onChange({ target: { files: dt.files } });
+            return { ok: true };
+        })()`);
+        if (fallbackResult && !fallbackResult.ok) return fallbackResult;
+    }
+
+    const ready = await waitForFilePreview(page, fileName);
+    if (!ready) return { ok: false, reason: 'file preview did not appear' };
+
+    return sendMessage(page, prompt);
+}
+
 // Retries on CDP "Promise was collected" errors caused by DeepSeek's SPA router transitions.
 export async function withRetry(fn, retries = 2) {
     for (let i = 0; i <= retries; i++) {

package/clis/deepseek/utils.test.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { selectModel, sendWithFile, parseThinkingResponse } from './utils.js';
+
+describe('deepseek parseThinkingResponse', () => {
+  it('returns plain response when no thinking header is present', () => {
+    const rawText = 'This is a regular response without thinking.';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: rawText,
+      thinking: null,
+      thinking_time: null,
+    });
+  });
+
+  it('parses English thinking header — all content after header is thinking', () => {
+    const rawText = 'Thought for 3.5 seconds\n\nLet me analyze this problem...\nFirst, I need to consider X.\nThen, Y.\n\nThe answer is 42.';
+    const result = parseThinkingResponse(rawText);
+
+    // Text-level parser no longer splits on \n\n; everything after header is thinking.
+    // DOM-level extraction in waitForResponse() handles the actual separation.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'Let me analyze this problem...\nFirst, I need to consider X.\nThen, Y.\n\nThe answer is 42.',
+      thinking_time: '3.5',
+    });
+  });
+
+  it('parses Chinese thinking header — all content after header is thinking', () => {
+    const rawText = '已思考（用时 2.3 秒）\n\n让我分析这个问题...\n首先需要考虑X。\n然后是Y。\n\n答案是42。';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: '',
+      thinking: '让我分析这个问题...\n首先需要考虑X。\n然后是Y。\n\n答案是42。',
+      thinking_time: '2.3',
+    });
+  });
+
+  it('multi-paragraph thinking without final answer is not corrupted', () => {
+    const rawText = 'Thought for 1.2 seconds\n\nFirst paragraph.\n\nSecond paragraph.';
+    const result = parseThinkingResponse(rawText);
+
+    // Both paragraphs must stay in thinking; response is empty.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'First paragraph.\n\nSecond paragraph.',
+      thinking_time: '1.2',
+    });
+  });
+
+  it('multi-paragraph final answer is not split by text parser', () => {
+    const rawText = 'Thought for 3 seconds\n\nreasoning\n\nAnswer para 1.\n\nAnswer para 2.';
+    const result = parseThinkingResponse(rawText);
+
+    // Text parser treats everything as thinking; DOM handles separation.
+    expect(result).toEqual({
+      response: '',
+      thinking: 'reasoning\n\nAnswer para 1.\n\nAnswer para 2.',
+      thinking_time: '3',
+    });
+  });
+
+  it('handles thinking without final response', () => {
+    const rawText = 'Thought for 1.2 seconds\n\nThinking process here...';
+    const result = parseThinkingResponse(rawText);
+
+    expect(result).toEqual({
+      response: '',
+      thinking: 'Thinking process here...',
+      thinking_time: '1.2',
+    });
+  });
+
+  it('returns null for empty input', () => {
+    const result = parseThinkingResponse('');
+    expect(result).toBeNull();
+  });
+
+  it('returns null for null input', () => {
+    const result = parseThinkingResponse(null);
+    expect(result).toBeNull();
+  });
+});
+
+
+describe('deepseek sendWithFile', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  it('prefers page.setFileInput over base64-in-evaluate when supported', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-deepseek-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, 'report.txt');
+    fs.writeFileSync(filePath, 'hello');
+
+    const page = {
+      setFileInput: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce(undefined)
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce({ ok: true }),
+    };
+
+    const result = await sendWithFile(page, filePath, 'summarize this');
+
+    expect(result).toEqual({ ok: true });
+    expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[type="file"]');
+  });
+});
+
+describe('deepseek selectModel', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete global.document;
+  });
+
+  it('fails expert selection when only one radio is present', async () => {
+    const instantRadio = {
+      getAttribute: vi.fn(() => 'true'),
+      click: vi.fn(),
+    };
+    global.document = {
+      querySelectorAll: vi.fn(() => [instantRadio]),
+    };
+    const page = {
+      evaluate: vi.fn(async (script) => eval(script)),
+    };
+
+    const result = await selectModel(page, 'expert');
+
+    expect(result).toEqual({ ok: false });
+    expect(instantRadio.click).not.toHaveBeenCalled();
+  });
+});

package/clis/gemini/image.js

@@ -57,7 +57,7 @@ export const imageCommand = cli({
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to Gemini' },
         { name: 'rt', default: '1:1', help: 'Ratio shorthand for aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3)' },
         { name: 'st', default: '', help: 'Style shorthand, e.g. anime, icon, watercolor' },
-        { name: 'op', default: path.join(os.homedir(), 'tmp', 'gemini-images'), help: 'Output directory shorthand' },
+        { name: 'op', default: '~/tmp/gemini-images', help: 'Output directory shorthand' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show Gemini page link' },
     ],
     columns: ['status', 'file', 'link'],

package/clis/instagram/download.js

@@ -202,7 +202,7 @@ cli({
     navigateBefore: false,
     args: [
         { name: 'url', positional: true, required: true, help: 'Instagram post / reel / tv URL' },
-        { name: 'path', default: path.join(os.homedir(), 'Downloads', 'Instagram'), help: 'Download directory' },
+        { name: 'path', default: '~/Downloads/Instagram', help: 'Download directory' },
     ],
     func: async (page, kwargs) => {
         const browserPage = ensurePage(page);

package/clis/jianyu/search.js

@@ -35,6 +35,10 @@ const NAVIGATION_PATH_PREFIXES = [
     '/exhibition/',
     '/swordfish/page_big_pc/search/',
 ];
+const BLOCKED_DETAIL_PATH_PREFIXES = [
+    '/nologin/content/',
+    '/article/bdprivate/',
+];
 const JIANYU_API_TYPES = ['fType', 'eType', 'vType', 'mType'];
 export function buildSearchUrl(query) {
     const url = new URL(SEARCH_ENTRY);
@@ -74,6 +78,86 @@ function isLikelyNavigationUrl(rawUrl) {
         return true;
     }
 }
+function classifyDetailStatus(rawUrl) {
+    const urlText = cleanText(rawUrl);
+    if (!urlText) {
+        return {
+            detail_status: 'blocked',
+            detail_reason: 'missing_url',
+        };
+    }
+    try {
+        const parsed = new URL(urlText);
+        const path = cleanText(parsed.pathname).toLowerCase().replace(/\/+$/, '/') || '/';
+        if (BLOCKED_DETAIL_PATH_PREFIXES.some((prefix) => path.includes(prefix))) {
+            return {
+                detail_status: 'blocked',
+                detail_reason: 'verification_or_paid_wall',
+            };
+        }
+        if (isLikelyNavigationUrl(urlText)) {
+            return {
+                detail_status: 'entry_only',
+                detail_reason: 'navigation_or_profile_entry',
+            };
+        }
+        return {
+            detail_status: 'ok',
+            detail_reason: path.includes('/jybx/') ? 'jybx_detail' : 'detail_candidate',
+        };
+    }
+    catch {
+        return {
+            detail_status: 'blocked',
+            detail_reason: 'invalid_url',
+        };
+    }
+}
+function extractNoticeId(rawUrl) {
+    const value = cleanText(rawUrl);
+    if (!value)
+        return '';
+    try {
+        const parsed = new URL(value);
+        const path = cleanText(parsed.pathname);
+        const jybxMatched = path.match(/\/jybx\/([^/?#]+)\.html$/i);
+        if (jybxMatched?.[1])
+            return cleanText(jybxMatched[1]);
+        const segments = path.split('/').filter(Boolean);
+        const tail = cleanText(segments[segments.length - 1] || '');
+        return cleanText(tail.replace(/\.html?$/i, ''));
+    }
+    catch {
+        return '';
+    }
+}
+function isWithinSinceDays(dateText, sinceDays, now = new Date()) {
+    const normalized = normalizeDate(dateText);
+    if (!normalized)
+        return false;
+    const timestamp = Date.parse(`${normalized}T00:00:00Z`);
+    if (!Number.isFinite(timestamp))
+        return false;
+    const today = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    const deltaDays = Math.floor((today - timestamp) / (24 * 3600 * 1000));
+    return deltaDays >= 0 && deltaDays <= sinceDays;
+}
+function dedupeByNoticeKey(items) {
+    const deduped = [];
+    const seen = new Set();
+    for (const item of items) {
+        const source = cleanText(item.source_id || '');
+        const notice = cleanText(item.notice_id || '');
+        const key = source && notice
+            ? `${source}\t${notice}`
+            : `${cleanText(item.title)}\t${cleanText(item.url)}`;
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}
 function filterNavigationRows(query, items) {
     const queryTokens = cleanText(query).split(/\s+/).filter(Boolean).map((token) => token.toLowerCase());
     return items
@@ -86,6 +170,9 @@ function filterNavigationRows(query, items) {
         .filter((item) => {
         if (!item.title || !item.url)
             return false;
+        const detailSignal = classifyDetailStatus(item.url);
+        if (detailSignal.detail_status !== 'ok')
+            return false;
         const haystack = `${item.title} ${item.contextText}`.toLowerCase();
         const hasQuery = queryTokens.length === 0 || queryTokens.some((token) => haystack.includes(token));
         const hasProcurementHint = PROCUREMENT_TITLE_HINT.test(`${item.title} ${item.contextText}`);
@@ -446,11 +533,16 @@ cli({
     args: [
         { name: 'query', required: true, positional: true, help: 'Search keyword, e.g. "procurement"' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+        { name: 'since_days', type: 'int', help: 'Only keep rows published within N days' },
     ],
-    columns: ['rank', 'content_type', 'title', 'publish_time', 'project_code', 'budget_or_limit', 'url'],
+    columns: ['rank', 'content_type', 'title', 'published_at', 'detail_status', 'project_code', 'budget_or_limit', 'url'],
     func: async (page, kwargs) => {
         const query = cleanText(kwargs.query);
         const limit = Math.max(1, Math.min(Number(kwargs.limit) || 20, 50));
+        const rawSinceDays = Number(kwargs.since_days);
+        const sinceDays = Number.isFinite(rawSinceDays) && rawSinceDays > 0
+            ? Math.max(1, Math.min(rawSinceDays, 3650))
+            : null;
         const apiResult = await fetchJianyuApiRows(page, query, limit);
         const mergedRows = dedupeCandidates(filterNavigationRows(query, apiResult.rows));
         const extractedRows = await searchRowsFromEntries(page, {
@@ -465,21 +557,61 @@ cli({
             const indexedRows = await fetchDuckDuckGoIndexRows(query, limit);
             const filteredIndexedRows = dedupeCandidates(filterNavigationRows(query, indexedRows));
             if (filteredIndexedRows.length > 0) {
-                return toProcurementSearchRecords(filteredIndexedRows, {
+                const records = toProcurementSearchRecords(filteredIndexedRows, {
                     site: SITE,
                     query,
                     limit,
                 });
+                const enriched = dedupeByNoticeKey(records.map((row) => {
+                    const detailSignal = classifyDetailStatus(row.url);
+                    const publishedAt = normalizeDate(row.publish_time || row.date);
+                    return {
+                        ...row,
+                        source_id: SITE,
+                        notice_id: extractNoticeId(row.url),
+                        published_at: publishedAt,
+                        detail_status: detailSignal.detail_status,
+                        detail_reason: detailSignal.detail_reason,
+                    };
+                }))
+                    .filter((row) => row.detail_status === 'ok')
+                    .filter((row) => sinceDays == null || isWithinSinceDays(row.published_at, sinceDays))
+                    .slice(0, limit)
+                    .map((row, index) => ({
+                    ...row,
+                    rank: index + 1,
+                }));
+                return enriched;
             }
             if (apiResult.challenge || await isAuthRequired(page)) {
                 throw new AuthRequiredError(DOMAIN, '[taxonomy=selector_drift] site=jianyu command=search blocked by human verification / access challenge');
             }
         }
-        return toProcurementSearchRecords(rows, {
+        const records = toProcurementSearchRecords(rows, {
             site: SITE,
             query,
             limit,
         });
+        const enriched = dedupeByNoticeKey(records.map((row) => {
+            const detailSignal = classifyDetailStatus(row.url);
+            const publishedAt = normalizeDate(row.publish_time || row.date);
+            return {
+                ...row,
+                source_id: SITE,
+                notice_id: extractNoticeId(row.url),
+                published_at: publishedAt,
+                detail_status: detailSignal.detail_status,
+                detail_reason: detailSignal.detail_reason,
+            };
+        }))
+            .filter((row) => row.detail_status === 'ok')
+            .filter((row) => sinceDays == null || isWithinSinceDays(row.published_at, sinceDays))
+            .slice(0, limit)
+            .map((row, index) => ({
+            ...row,
+            rank: index + 1,
+        }));
+        return enriched;
     },
 });
 export const __test__ = {
@@ -494,4 +626,8 @@ export const __test__ = {
     normalizeApiRow,
     fetchJianyuApiRows,
     collectApiRowsFromResponses,
+    classifyDetailStatus,
+    extractNoticeId,
+    isWithinSinceDays,
+    dedupeByNoticeKey,
 };

package/clis/jianyu/search.test.js

@@ -125,4 +125,29 @@ describe('jianyu search helpers', () => {
         expect(result.rows[0].title).toContain('电梯采购公告');
         expect(result.rows[1].title).toContain('另一条电梯采购公告');
     });
+    it('classifies nologin links as blocked detail targets', () => {
+        const signal = __test__.classifyDetailStatus('https://www.jianyu360.cn/nologin/content/ABC.html');
+        expect(signal.detail_status).toBe('blocked');
+    });
+    it('classifies accessible detail urls as ok even when they are not jybx paths', () => {
+        const signal = __test__.classifyDetailStatus('https://www.jianyu360.cn/notice/detail/123');
+        expect(signal.detail_status).toBe('ok');
+        expect(signal.detail_reason).toBe('detail_candidate');
+    });
+    it('classifies list pages as entry_only', () => {
+        const signal = __test__.classifyDetailStatus('https://www.jianyu360.cn/list/stype/ZBGG.html');
+        expect(signal.detail_status).toBe('entry_only');
+    });
+    it('extracts stable notice id from jybx urls', () => {
+        const id = __test__.extractNoticeId('https://shandong.jianyu360.cn/jybx/20260310_26030938267551.html');
+        expect(id).toBe('20260310_26030938267551');
+    });
+    it('keeps only rows inside recency window', () => {
+        const within = __test__.isWithinSinceDays('2026-03-20', 30, new Date('2026-04-09T00:00:00Z'));
+        const stale = __test__.isWithinSinceDays('2026-02-01', 30, new Date('2026-04-09T00:00:00Z'));
+        const missing = __test__.isWithinSinceDays('', 30, new Date('2026-04-09T00:00:00Z'));
+        expect(within).toBe(true);
+        expect(stale).toBe(false);
+        expect(missing).toBe(false);
+    });
 });