@jackwener/opencli 1.7.12 → 1.7.13

package/clis/ctrip/utils.js

@@ -0,0 +1,175 @@
+/**
+ * Shared helpers for ctrip public destination/hotel suggestion endpoints.
+ *
+ * The single backing endpoint `https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine`
+ * accepts a `searchType` discriminator:
+ *   - `D` → destination suggest (cities, scenic spots, railway stations, landmarks)
+ *   - `H` → hotel-context suggest (cities, business areas, individual hotels)
+ *
+ * Response shape is identical; we surface every field the endpoint emits as a
+ * stable column so callers do not silently lose geo / English / id metadata.
+ */
+import { ArgumentError, CliError } from '@jackwener/opencli/errors';
+
+const ENDPOINT = 'https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine';
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 50;
+
+export function parseLimit(raw, fallback = 15) {
+    if (raw === undefined || raw === null || raw === '') return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < MIN_LIMIT || parsed > MAX_LIMIT) {
+        throw new ArgumentError(`--limit must be between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${parsed}`);
+    }
+    return parsed;
+}
+
+export async function fetchSuggest(query, searchType) {
+    let response;
+    try {
+        response = await fetch(ENDPOINT, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                keyword: query,
+                searchType,
+                platform: 'online',
+                pageID: '102001',
+                head: {
+                    Locale: 'zh-CN',
+                    LocaleController: 'zh_cn',
+                    Currency: 'CNY',
+                    PageId: '102001',
+                    clientID: 'opencli-ctrip',
+                    group: 'ctrip',
+                    Frontend: { sessionID: 1, pvid: 1 },
+                    HotelExtension: { group: 'CTRIP', WebpSupport: false },
+                },
+            }),
+        });
+    } catch (err) {
+        throw new CliError(
+            'FETCH_ERROR',
+            `ctrip suggest fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+            'Check your network connection and retry',
+        );
+    }
+    if (!response.ok) {
+        throw new CliError(
+            'FETCH_ERROR',
+            `ctrip suggest failed with status ${response.status}`,
+            'Retry the command or verify ctrip.com is reachable',
+        );
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    } catch (err) {
+        throw new CliError(
+            'COMMAND_EXEC',
+            `ctrip suggest returned invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            'Ctrip may have changed the endpoint response format; retry later',
+        );
+    }
+    if (payload && payload.Result === false) {
+        const code = payload.ErrorCode ?? 'unknown';
+        throw new CliError(
+            'COMMAND_EXEC',
+            `ctrip suggest API returned Result=false (ErrorCode=${code})`,
+            'Verify keyword and retry; this typically means upstream rejected the query envelope',
+        );
+    }
+    return Array.isArray(payload?.Response?.searchResults) ? payload.Response.searchResults : [];
+}
+
+/**
+ * Pick the best lat/lon pair available.
+ *
+ * Domestic Mainland China rows ship `gdLat`/`gdLon` (gaode); international rows
+ * ship `gLat`/`gLon` (google/wgs84). `lat`/`lon` is the legacy flat field — fall
+ * through to it last. Zero values are treated as "missing" since the endpoint
+ * uses 0.0 as a sentinel for unknown coords.
+ */
+export function pickCoords(item) {
+    const candidates = [
+        [item.gdLat, item.gdLon],
+        [item.gLat, item.gLon],
+        [item.lat, item.lon],
+    ];
+    for (const [la, lo] of candidates) {
+        if (Number.isFinite(la) && Number.isFinite(lo) && (la !== 0 || lo !== 0)) {
+            return { lat: la, lon: lo };
+        }
+    }
+    return { lat: null, lon: null };
+}
+
+/**
+ * Build a canonical user-facing URL from the suggest item type + ids.
+ * Unknown types return null (do not silently fabricate URLs).
+ */
+export function buildUrl(item) {
+    const id = item?.id ? String(item.id) : '';
+    const cityId = item?.cityId ?? '';
+    const cityName = item?.cityName ? String(item.cityName) : '';
+    switch (item?.type) {
+        case 'City':
+            return cityId ? `https://you.ctrip.com/place/${encodeURIComponent(cityName)}${cityId}.html` : null;
+        case 'Markland':
+            return id && cityId
+                ? `https://you.ctrip.com/sight/${encodeURIComponent(cityName)}${cityId}/${id}.html`
+                : null;
+        case 'Hotel':
+            return id ? `https://hotels.ctrip.com/hotels/detail/?hotelid=${id}` : null;
+        case 'BusinessArea':
+        case 'Zone':
+            return cityId && id
+                ? `https://hotels.ctrip.com/hotels/list?city=${cityId}&zone=${id}`
+                : null;
+        case 'RailwayStation':
+            return id ? `https://trains.ctrip.com/trainstation/${id}.html` : null;
+        default:
+            return null;
+    }
+}
+
+function nz(v) {
+    return Number.isFinite(v) && v !== 0 ? v : null;
+}
+
+function firstNonZero(...values) {
+    for (const v of values) {
+        const n = Number(v);
+        if (Number.isFinite(n) && n !== 0) return n;
+    }
+    return null;
+}
+
+/**
+ * Project a raw suggest row into the stable adapter column shape.
+ * No silent fallbacks: every column has a deterministic value (string|number|null).
+ */
+export function mapSuggestRow(item, index) {
+    const { lat, lon } = pickCoords(item);
+    return {
+        rank: index + 1,
+        id: item?.id ? String(item.id) : null,
+        type: item?.type ? String(item.type) : null,
+        displayType: item?.displayType ? String(item.displayType).trim() : null,
+        name: String(item?.displayName || item?.word || item?.cityName || '').replace(/\s+/g, ' ').trim() || null,
+        eName: item?.eName ? String(item.eName).trim() : null,
+        cityId: Number.isFinite(item?.cityId) && item.cityId !== 0 ? item.cityId : null,
+        cityName: item?.cityName ? String(item.cityName).trim() : null,
+        provinceName: item?.provinceName ? String(item.provinceName).trim() : null,
+        countryName: item?.countryName ? String(item.countryName).trim() : null,
+        lat,
+        lon,
+        score: firstNonZero(item?.commentScore, item?.cStar),
+        url: buildUrl(item),
+    };
+}
+
+export const __test__ = { ENDPOINT, MIN_LIMIT, MAX_LIMIT };

package/clis/cursor/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { selectorError } from '@jackwener/opencli/errors';
+import { ArgumentError, selectorError } from '@jackwener/opencli/errors';
 export const askCommand = cli({
     site: 'cursor',
     name: 'ask',
@@ -10,12 +10,15 @@ export const askCommand = cli({
     browser: true,
     args: [
         { name: 'text', required: true, positional: true, help: 'Prompt to send' },
-        { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for response (default: 30)', default: 30 },
     ],
     columns: ['Role', 'Text'],
     func: async (page, kwargs) => {
         const text = kwargs.text;
-        const timeout = parseInt(kwargs.timeout, 10) || 30;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
         // Count existing messages before sending
         const beforeCount = await page.evaluate(`
       document.querySelectorAll('[data-message-role]').length

package/clis/dblp/author.js

@@ -0,0 +1,133 @@
+// dblp author — resolve an author name to a PID and list their publications
+// newest first.
+//
+// Two-step lookup against dblp's public API:
+//   1. `search/author/api?q=<name>` returns candidate authors (each with a
+//      stable PID URL like `https://dblp.org/pid/56/953`).
+//   2. `pid/<pid>.xml` returns every publication under that PID, ordered
+//      newest first.
+//
+// We auto-resolve to the top hit. dblp's author search returns a single
+// best-match for unique names; for ambiguous names (e.g. "Wei Wang") it
+// returns multiple PIDs — we pick the highest-scored one and surface the
+// resolved name + PID in the row metadata so the caller can refine.
+//
+// To bypass author search entirely, pass `--pid <prefix>/<id>` (e.g.
+// `--pid 56/953`). This is the canonical disambiguator.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    DBLP_ORIGIN,
+    decodeXmlEntities,
+    dblpFetchJson,
+    dblpFetchXml,
+    extractRecordKey,
+    recordXmlToRow,
+    requireBoundedInt,
+    requireQuery,
+} from './utils.js';
+
+const PID_PATTERN = /^[0-9a-z]+(?:\/[0-9a-z-]+)+$/i;
+
+function extractPidFromAuthorHit(hit) {
+    const url = String(hit?.info?.url ?? '').trim();
+    const m = url.match(/\/pid\/([^/]+(?:\/[^/]+)+)$/);
+    return m ? m[1] : '';
+}
+
+function pickTopAuthor(hits) {
+    // dblp returns hits sorted by score desc; we just take the head.
+    return hits[0];
+}
+
+function splitRecords(xml) {
+    // Each publication is wrapped in <r>…</r> directly under <dblpperson>.
+    const out = [];
+    const re = /<r>\s*([\s\S]*?)\s*<\/r>/g;
+    let m;
+    while ((m = re.exec(String(xml || ''))) !== null) {
+        const inner = m[1];
+        // Skip cross-references that have no concrete record (rare).
+        if (/^<crossref/.test(inner)) continue;
+        out.push(inner);
+    }
+    return out;
+}
+
+cli({
+    site: 'dblp',
+    name: 'author',
+    access: 'read',
+    description: 'List dblp publications by a given author (newest first; resolves to top PID match)',
+    domain: 'dblp.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'author', positional: true, required: false, help: 'Author name (e.g. "Yoshua Bengio"). Optional when --pid is given.' },
+        { name: 'pid', help: 'Canonical dblp PID (e.g. "56/953"). Bypasses author search.' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max publications (1-200)' },
+    ],
+    columns: ['rank', 'key', 'title', 'authors', 'venue', 'year', 'type', 'doi', 'pid', 'url'],
+    func: async (args) => {
+        const limit = requireBoundedInt(args.limit, 20, 200);
+        const pidArg = args.pid != null ? String(args.pid).trim() : '';
+        let pid = '';
+        let resolvedName = '';
+        if (pidArg) {
+            if (!PID_PATTERN.test(pidArg)) {
+                throw new ArgumentError(
+                    `dblp pid "${pidArg}" is not a valid PID`,
+                    'Expected something like "56/953" — visit the author page on dblp.org to find it.',
+                );
+            }
+            pid = pidArg;
+        }
+        else {
+            const name = requireQuery(args.author, 'author');
+            const json = await dblpFetchJson(
+                `/search/author/api?q=${encodeURIComponent(name)}&format=json&h=20`,
+                'dblp author search',
+            );
+            const raw = json?.result?.hits?.hit;
+            const hits = Array.isArray(raw) ? raw : (raw ? [raw] : []);
+            if (!hits.length) {
+                throw new EmptyResultError(
+                    'dblp author',
+                    `No dblp author matched "${name}". Try a different spelling, or pass --pid to bypass author search.`,
+                );
+            }
+            const top = pickTopAuthor(hits);
+            pid = extractPidFromAuthorHit(top);
+            if (!pid) {
+                throw new CommandExecutionError(
+                    `dblp author search for "${name}" returned a hit without a PID URL`,
+                    'dblp may have changed its author-search response shape; retry or pass --pid manually.',
+                );
+            }
+            resolvedName = decodeXmlEntities(String(top?.info?.author ?? '')).trim();
+        }
+        const xml = await dblpFetchXml(`/pid/${pid}.xml`, `dblp pid ${pid}`);
+        const records = splitRecords(xml);
+        if (!records.length) {
+            throw new EmptyResultError(
+                'dblp author',
+                `dblp PID ${pid}${resolvedName ? ` (${resolvedName})` : ''} has no publications.`,
+            );
+        }
+        return records.slice(0, limit).map((recordXml, i) => {
+            const row = recordXmlToRow(`<root>${recordXml}</root>`);
+            return {
+                rank: i + 1,
+                key: row.key || extractRecordKey(recordXml),
+                title: row.title,
+                authors: row.authors,
+                venue: row.venue,
+                year: row.year,
+                type: row.type,
+                doi: row.doi,
+                pid,
+                url: row.open_access_url || row.dblp_url,
+            };
+        });
+    },
+});

package/clis/dblp/venue.js

@@ -0,0 +1,64 @@
+// dblp venue — search dblp's venue (conference / journal) registry.
+//
+// Hits `https://dblp.org/search/venue/api?q=…&format=json&h=…`. Returns a
+// row per matched venue. Useful for resolving an acronym (e.g. "ICLR" →
+// dblp's canonical venue page) and for browsing venues that match a topic.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    DBLP_ORIGIN,
+    decodeXmlEntities,
+    dblpFetchJson,
+    requireBoundedInt,
+    requireQuery,
+} from './utils.js';
+
+function simplifyVenueType(type) {
+    const t = String(type ?? '').trim();
+    if (!t) return '';
+    if (/Conference or Workshop/i.test(t)) return 'conf';
+    if (/Journal/i.test(t)) return 'journal';
+    if (/Series/i.test(t)) return 'series';
+    if (/Book/i.test(t)) return 'book';
+    if (/Reference/i.test(t)) return 'reference';
+    return t.toLowerCase().split(/\s+/)[0];
+}
+
+function venueHitToRow(hit, rank) {
+    const info = hit?.info ?? {};
+    const url = String(info.url ?? '').trim();
+    return {
+        rank,
+        acronym: String(info.acronym ?? '').trim(),
+        venue: decodeXmlEntities(info.venue ?? ''),
+        type: simplifyVenueType(info.type),
+        url: url.startsWith('http') ? url : url ? `${DBLP_ORIGIN}${url.startsWith('/') ? '' : '/'}${url}` : '',
+    };
+}
+
+cli({
+    site: 'dblp',
+    name: 'venue',
+    access: 'read',
+    description: 'Search dblp venue registry (conferences / journals) by name or acronym',
+    domain: 'dblp.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Venue name or acronym (e.g. "ICLR", "neural networks")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max venues (1-100, single dblp page)' },
+    ],
+    columns: ['rank', 'acronym', 'venue', 'type', 'url'],
+    func: async (args) => {
+        const query = requireQuery(args.query);
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const path = `/search/venue/api?q=${encodeURIComponent(query)}&format=json&h=${limit}`;
+        const json = await dblpFetchJson(path, 'dblp venue');
+        const hits = json?.result?.hits?.hit;
+        const list = Array.isArray(hits) ? hits : [];
+        if (list.length === 0) {
+            throw new EmptyResultError('dblp venue', `No dblp venues matched "${query}".`);
+        }
+        return list.slice(0, limit).map((hit, i) => venueHitToRow(hit, i + 1));
+    },
+});

package/clis/deepseek/ask.js

@@ -3,6 +3,7 @@ import { CliError, CommandExecutionError, EXIT_CODES } from '@jackwener/opencli/
 import {
     DEEPSEEK_DOMAIN, DEEPSEEK_URL, ensureOnDeepSeek, selectModel, setFeature,
     sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
+    pickResumeUrl,
 } from './utils.js';
 
 export const askCommand = cli({
@@ -13,8 +14,8 @@ export const askCommand = cli({
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
-    timeoutSeconds: 180,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
         { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },
@@ -38,12 +39,16 @@ export const askCommand = cli({
         } else {
             const navigated = await ensureOnDeepSeek(page);
             if (navigated) {
-                // Workspace was recycled; try to resume the most recent
-                // conversation instead of starting a new one.
-                await page.evaluate(`(() => {
-                    var link = document.querySelector('a[href*="/a/chat/s/"]');
-                    if (link) link.click();
-                })()`);
+                // Pinned conversations sit in their own DOM section and are
+                // skipped so the resume never lands on a topped chat.
+                const resumeUrl = await pickResumeUrl(page);
+                if (!resumeUrl) {
+                    throw new CommandExecutionError(
+                        'Workspace was recycled but no prior conversation could be loaded',
+                        'Pass --new to start a fresh chat, or wait for the sidebar to populate before retrying.',
+                    );
+                }
+                await page.goto(resumeUrl);
                 await page.wait(2);
             }
         }

package/clis/deepseek/ask.test.js

@@ -11,6 +11,7 @@ const {
   mockWaitForResponse,
   mockParseBoolFlag,
   mockWithRetry,
+  mockPickResumeUrl,
 } = vi.hoisted(() => ({
   mockEnsureOnDeepSeek: vi.fn(),
   mockSelectModel: vi.fn(),
@@ -21,6 +22,7 @@ const {
   mockWaitForResponse: vi.fn(),
   mockParseBoolFlag: vi.fn((v) => v === true || v === 'true'),
   mockWithRetry: vi.fn(async (fn) => fn()),
+  mockPickResumeUrl: vi.fn(),
 }));
 
 vi.mock('./utils.js', () => ({
@@ -35,6 +37,7 @@ vi.mock('./utils.js', () => ({
   waitForResponse: mockWaitForResponse,
   parseBoolFlag: mockParseBoolFlag,
   withRetry: mockWithRetry,
+  pickResumeUrl: mockPickResumeUrl,
 }));
 
 import { askCommand } from './ask.js';
@@ -185,9 +188,8 @@ describe('deepseek ask conversation resume', () => {
 
   it('resumes the most recent conversation and skips model selection', async () => {
     mockEnsureOnDeepSeek.mockResolvedValue(true);
-    // first evaluate: sidebar resume click (returns undefined)
-    page.evaluate.mockResolvedValueOnce(undefined);
-    // second evaluate: URL check (now inside a conversation)
+    mockPickResumeUrl.mockResolvedValue('https://chat.deepseek.com/a/chat/s/abc-123');
+    // URL check after resume navigation: now inside a conversation.
     page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/a/chat/s/abc-123');
 
     const rows = await askCommand.func(page, {
@@ -200,6 +202,7 @@ describe('deepseek ask conversation resume', () => {
     });
 
     expect(rows).toEqual([{ response: 'follow-up reply' }]);
+    expect(page.goto).toHaveBeenCalledWith('https://chat.deepseek.com/a/chat/s/abc-123');
     expect(mockSelectModel).not.toHaveBeenCalled();
     expect(mockSendMessage).toHaveBeenCalled();
   });
@@ -243,25 +246,22 @@ describe('deepseek ask conversation resume', () => {
     expect(mockSelectModel).not.toHaveBeenCalled();
   });
 
-  it('still selects model when no conversation to resume', async () => {
+  it('fails fast when the workspace was recycled but no conversation surfaces in time', async () => {
     mockEnsureOnDeepSeek.mockResolvedValue(true);
-    mockSelectModel.mockResolvedValue({ ok: true, toggled: false });
-    // first evaluate: sidebar resume click (no link found)
-    page.evaluate.mockResolvedValueOnce(undefined);
-    // second evaluate: URL check (still on root page)
-    page.evaluate.mockResolvedValueOnce('https://chat.deepseek.com/');
+    mockPickResumeUrl.mockResolvedValue(null);
 
-    const rows = await askCommand.func(page, {
+    await expect(askCommand.func(page, {
       prompt: 'hello',
       timeout: 120,
       new: false,
       model: 'instant',
       think: false,
       search: false,
-    });
+    })).rejects.toBeInstanceOf(CommandExecutionError);
 
-    expect(rows).toEqual([{ response: 'follow-up reply' }]);
-    expect(mockSelectModel).toHaveBeenCalled();
+    expect(page.goto).not.toHaveBeenCalled();
+    expect(mockSelectModel).not.toHaveBeenCalled();
+    expect(mockSendMessage).not.toHaveBeenCalled();
   });
 
   it('skips search toggle in vision mode when search is not requested', async () => {

package/clis/deepseek/detail.js

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    DEEPSEEK_DOMAIN,
+    ensureOnDeepSeek,
+    getVisibleMessages,
+    parseDeepSeekConversationId,
+} from './utils.js';
+
+export const detailCommand = cli({
+    site: 'deepseek',
+    name: 'detail',
+    access: 'read',
+    description: 'Read a specific DeepSeek conversation by ID',
+    domain: DEEPSEEK_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Conversation ID (UUID) or full /a/chat/s/<id> URL' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const id = parseDeepSeekConversationId(kwargs.id);
+        await ensureOnDeepSeek(page);
+        await page.goto(`https://chat.deepseek.com/a/chat/s/${id}`);
+        await page.wait(5);
+        const messages = await getVisibleMessages(page);
+        if (messages.length === 0) {
+            throw new EmptyResultError(
+                'deepseek detail',
+                `No visible messages found for conversation ${id}. Verify the ID is correct and that you are logged in.`,
+            );
+        }
+        return messages;
+    },
+});

package/clis/deepseek/detail.test.js

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+
+const {
+  mockEnsureOnDeepSeek,
+  mockGetVisibleMessages,
+} = vi.hoisted(() => ({
+  mockEnsureOnDeepSeek: vi.fn(),
+  mockGetVisibleMessages: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual('./utils.js');
+  return {
+    ...actual,
+    ensureOnDeepSeek: mockEnsureOnDeepSeek,
+    getVisibleMessages: mockGetVisibleMessages,
+  };
+});
+
+import './detail.js';
+
+describe('deepseek detail', () => {
+  const command = getRegistry().get('deepseek/detail');
+  const id = '749e6bbd-6a45-4440-beaa-ae5238bf06d8';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEnsureOnDeepSeek.mockResolvedValue(false);
+  });
+
+  it('registers as a cookie-browser read command', () => {
+    expect(command).toBeDefined();
+    expect(command.browser).toBe(true);
+    expect(command.strategy).toBe('cookie');
+    expect(command.access).toBe('read');
+    expect(command.columns).toEqual(['Role', 'Text']);
+  });
+
+  it('navigates to the conversation URL and returns visible messages', async () => {
+    mockGetVisibleMessages.mockResolvedValue([
+      { Role: 'user', Text: 'hello' },
+      { Role: 'assistant', Text: 'hi' },
+    ]);
+    const page = { wait: vi.fn().mockResolvedValue(undefined), goto: vi.fn().mockResolvedValue(undefined) };
+
+    const rows = await command.func(page, { id });
+
+    expect(rows).toEqual([
+      { Role: 'user', Text: 'hello' },
+      { Role: 'assistant', Text: 'hi' },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith(`https://chat.deepseek.com/a/chat/s/${id}`);
+    expect(mockGetVisibleMessages).toHaveBeenCalledWith(page);
+  });
+
+  it('accepts a full chat URL and normalises it before navigation', async () => {
+    mockGetVisibleMessages.mockResolvedValue([{ Role: 'user', Text: 'hi' }]);
+    const page = { wait: vi.fn().mockResolvedValue(undefined), goto: vi.fn().mockResolvedValue(undefined) };
+
+    await command.func(page, { id: `https://chat.deepseek.com/a/chat/s/${id.toUpperCase()}?ref=foo` });
+
+    expect(page.goto).toHaveBeenCalledWith(`https://chat.deepseek.com/a/chat/s/${id}`);
+  });
+
+  it('rejects malformed IDs before browser navigation', async () => {
+    const page = { wait: vi.fn(), goto: vi.fn() };
+
+    await expect(command.func(page, { id: 'not-a-uuid' })).rejects.toThrow(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+    expect(mockEnsureOnDeepSeek).not.toHaveBeenCalled();
+  });
+
+  it('throws EmptyResultError when the conversation has no visible messages', async () => {
+    mockGetVisibleMessages.mockResolvedValue([]);
+    const page = { wait: vi.fn().mockResolvedValue(undefined), goto: vi.fn().mockResolvedValue(undefined) };
+
+    await expect(command.func(page, { id })).rejects.toThrow(EmptyResultError);
+  });
+});

package/clis/deepseek/history.js

@@ -9,6 +9,7 @@ export const historyCommand = cli({
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },

package/clis/deepseek/new.js

@@ -9,6 +9,7 @@ export const newCommand = cli({
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status'],

package/clis/deepseek/read.js

@@ -9,6 +9,7 @@ export const readCommand = cli({
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Role', 'Text'],