@jackwener/opencli 1.7.11 → 1.7.13

package/clis/dblp/utils.js

@@ -0,0 +1,290 @@
+/**
+ * DBLP adapter utilities.
+ *
+ * dblp serves a public, unauthenticated API:
+ *   - Publication search (JSON):
+ *     `https://dblp.org/search/publ/api?q=<query>&format=json&h=<limit>`
+ *   - Per-record metadata (XML):
+ *     `https://dblp.org/rec/<key>.xml`
+ *
+ * The search response is well-shaped JSON, but the per-record endpoint is
+ * XML. We parse it with conservative regexes (same pattern as the arxiv
+ * adapter) to avoid pulling in an XML lib for this single endpoint.
+ */
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const DBLP_ORIGIN = 'https://dblp.org';
+
+/**
+ * dblp record keys look like `<type>/<venue>/<short>` (e.g.
+ * `conf/nips/VaswaniSPUJGKP17`, `journals/corr/abs-2509-05821`,
+ * `phd/Smith20`). Allow lowercase letter prefixes plus 1+ slash-segments
+ * containing letters / digits / `_` / `.` / `-`.
+ */
+const KEY_PATTERN = /^[a-z]+(?:\/[A-Za-z0-9_.-]+)+$/;
+
+/**
+ * Wraps `fetch` with typed errors. We always set a UA per dblp's
+ * polite-fetch guidance (https://dblp.org/faq/How+to+use+the+dblp+search+API.html).
+ */
+async function dblpFetch(url, label, accept) {
+    let res;
+    try {
+        res = await fetch(url, {
+            headers: {
+                accept,
+                'user-agent': 'opencli-dblp/1.0 (+https://github.com/jackwener/opencli)',
+            },
+        });
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} request failed: ${err?.message ?? err}`, 'Check that dblp.org is reachable from this network.');
+    }
+    if (!res.ok) {
+        if (res.status === 429) {
+            throw new CommandExecutionError(`${label} returned HTTP 429 (rate limited)`, 'dblp throttles clients that fetch too aggressively. Wait a few seconds and retry, or lower --limit.');
+        }
+        if (res.status === 404) {
+            throw new EmptyResultError(label, 'dblp returned 404 — the requested record may not exist.');
+        }
+        throw new CommandExecutionError(`${label} returned HTTP ${res.status}`, 'Inspect the response in a browser at the same URL for more context.');
+    }
+    return res;
+}
+
+export async function dblpFetchJson(path, label) {
+    const res = await dblpFetch(`${DBLP_ORIGIN}${path}`, label, 'application/json');
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    const statusCode = String(body?.result?.status?.['@code'] ?? '').trim();
+    if (!statusCode) {
+        throw new CommandExecutionError(
+            `${label} returned JSON without result.status.@code`,
+            'dblp changed its JSON envelope or returned a partial error payload; inspect the raw response in a browser.',
+        );
+    }
+    if (statusCode !== '200') {
+        const statusText = String(body?.result?.status?.text ?? '').trim();
+        throw new CommandExecutionError(
+            `${label} returned API status ${statusCode}${statusText ? ` (${statusText})` : ''}`,
+            'dblp accepted the HTTP request but reported an API-level failure. Retry later or inspect the same query in a browser.',
+        );
+    }
+    return body;
+}
+
+export async function dblpFetchXml(path, label) {
+    const res = await dblpFetch(`${DBLP_ORIGIN}${path}`, label, 'application/xml');
+    return res.text();
+}
+
+export function coerceInt(value) {
+    if (value === undefined || value === null || value === '') return NaN;
+    const n = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(n) && Number.isInteger(n) ? n : NaN;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = coerceInt(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`dblp ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`dblp ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requireQuery(value, label = 'query') {
+    const q = String(value ?? '').trim();
+    if (!q) {
+        throw new ArgumentError(`dblp ${label} cannot be empty`);
+    }
+    return q;
+}
+
+export function requireRecordKey(value) {
+    const key = String(value ?? '').trim();
+    if (!key) {
+        throw new ArgumentError('dblp paper key is required');
+    }
+    if (!KEY_PATTERN.test(key)) {
+        throw new ArgumentError(`dblp paper key "${value}" is not a valid record key`, 'Expected something like "conf/nips/VaswaniSPUJGKP17" — copy the `key` column from `dblp search`.');
+    }
+    return key;
+}
+
+/** Decode the small set of XML entities dblp emits in record bodies. */
+export function decodeXmlEntities(text) {
+    if (!text) return '';
+    return String(text)
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)));
+}
+
+/** Strip dblp's per-author homonym suffixes (`Smith 0001`) → `Smith`. */
+function trimAuthorHomonym(name) {
+    return String(name || '').replace(/\s+\d{4,}$/, '').trim();
+}
+
+/**
+ * Normalize the `info.authors.author` field from a dblp search hit. dblp
+ * collapses single authors into one object instead of a 1-element array.
+ */
+export function normalizeAuthors(authorsField) {
+    if (!authorsField) return [];
+    const raw = authorsField?.author;
+    if (!raw) return [];
+    const list = Array.isArray(raw) ? raw : [raw];
+    return list.map((a) => {
+        if (a && typeof a === 'object') return trimAuthorHomonym(a.text || a['#text'] || '');
+        return trimAuthorHomonym(String(a));
+    }).filter(Boolean);
+}
+
+/**
+ * Project a dblp publication search hit into one row. Drops only the most
+ * volatile fields (e.g. abstract, which dblp does not expose) and keeps
+ * the canonical key as the round-trip handle.
+ */
+export function searchHitToRow(hit, rank) {
+    const info = hit?.info ?? {};
+    const authors = normalizeAuthors(info.authors);
+    const key = String(info.key ?? '').trim();
+    return {
+        rank,
+        key,
+        title: stripTrailingDot(decodeXmlEntities(info.title ?? '')).trim(),
+        authors: authors.join(', '),
+        venue: decodeXmlEntities(info.venue ?? ''),
+        year: String(info.year ?? '').trim(),
+        type: simplifyHitType(info.type),
+        doi: String(info.doi ?? '').trim(),
+        url: String(info.ee ?? info.url ?? '').trim(),
+    };
+}
+
+/** Title strings from dblp end with a period — strip it for cleaner display. */
+function stripTrailingDot(s) {
+    return String(s || '').replace(/\.\s*$/, '');
+}
+
+/** Compress dblp's verbose `type` strings into single-token tags. */
+function simplifyHitType(type) {
+    if (!type) return '';
+    const t = String(type);
+    if (/Conference and Workshop/i.test(t)) return 'conf';
+    if (/Journal Articles/i.test(t)) return 'journal';
+    if (/Books and Theses/i.test(t)) return 'book';
+    if (/Editorship/i.test(t)) return 'editorship';
+    if (/Reference Works/i.test(t)) return 'reference';
+    if (/Informal/i.test(t)) return 'preprint';
+    return t.toLowerCase().split(/\s+/)[0];
+}
+
+/**
+ * Extract a single tag from a dblp record XML blob (regex-based, same
+ * approach as arxiv/utils.js — keeps the dependency surface flat).
+ */
+export function extractFirst(xml, tag) {
+    const m = String(xml || '').match(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return m ? m[1] : '';
+}
+
+export function extractAll(xml, tag) {
+    const out = [];
+    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g');
+    let m;
+    while ((m = re.exec(String(xml || ''))) !== null) out.push(m[1]);
+    return out;
+}
+
+/**
+ * Pick the first `<ee type="oa">` (open-access link) if present, otherwise
+ * fall back to the first `<ee>`.
+ */
+export function extractOpenAccessLink(xml) {
+    const oa = String(xml || '').match(/<ee\b[^>]*type=["']oa["'][^>]*>([\s\S]*?)<\/ee>/);
+    if (oa) return oa[1].trim();
+    const any = String(xml || '').match(/<ee\b[^>]*>([\s\S]*?)<\/ee>/);
+    return any ? any[1].trim() : '';
+}
+
+/** Pull the `key` attribute off the wrapper element regardless of record type. */
+export function extractRecordKey(xml) {
+    const m = String(xml || '').match(/<(?:article|inproceedings|incollection|proceedings|book|phdthesis|mastersthesis)\b[^>]*\bkey="([^"]+)"/);
+    return m ? m[1] : '';
+}
+
+/**
+ * Identify the record type from the wrapper element name. Maps to the
+ * same simplified tag set the search rows use.
+ */
+export function extractRecordType(xml) {
+    const m = String(xml || '').match(/<(article|inproceedings|incollection|proceedings|book|phdthesis|mastersthesis)\b/);
+    if (!m) return '';
+    switch (m[1]) {
+        case 'inproceedings': return 'conf';
+        case 'article': return 'journal';
+        case 'incollection': return 'incollection';
+        case 'proceedings': return 'editorship';
+        case 'book': return 'book';
+        case 'phdthesis': return 'phdthesis';
+        case 'mastersthesis': return 'mastersthesis';
+        default: return m[1];
+    }
+}
+
+/**
+ * Parse a single dblp record XML into the row shape used by `dblp paper`.
+ * Treats every field as optional; throws upstream when the record body
+ * is missing entirely (404 already handled at fetch level).
+ */
+export function recordXmlToRow(xml) {
+    const key = extractRecordKey(xml);
+    const type = extractRecordType(xml);
+    const title = stripTrailingDot(decodeXmlEntities(extractFirst(xml, 'title')));
+    const authors = extractAll(xml, 'author').map((a) => trimAuthorHomonym(decodeXmlEntities(a)));
+    const year = decodeXmlEntities(extractFirst(xml, 'year'));
+    const pages = decodeXmlEntities(extractFirst(xml, 'pages'));
+    const venueRaw = type === 'conf'
+        ? decodeXmlEntities(extractFirst(xml, 'booktitle'))
+        : decodeXmlEntities(extractFirst(xml, 'journal'));
+    const doi = (() => {
+        const m = String(xml || '').match(/<ee\b[^>]*>([^<]*?(?:doi\.org\/|10\.[^"<]+))<\/ee>/i);
+        if (!m) return '';
+        const v = m[1].replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, '');
+        return v.startsWith('10.') ? v : '';
+    })();
+    return {
+        key,
+        type,
+        title,
+        authors: authors.join(', '),
+        venue: venueRaw,
+        year,
+        pages,
+        doi,
+        open_access_url: extractOpenAccessLink(xml),
+        dblp_url: key ? `${DBLP_ORIGIN}/rec/${key}.html` : '',
+    };
+}
+
+export const SEARCH_COLUMNS = [
+    'rank', 'key', 'title', 'authors', 'venue', 'year', 'type', 'doi', 'url',
+];
+
+export const PAPER_COLUMNS = [
+    'key', 'type', 'title', 'authors', 'venue', 'year', 'pages', 'doi', 'open_access_url', '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,17 +3,19 @@ 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({
     site: 'deepseek',
     name: 'ask',
+    access: 'write',
     description: 'Send a prompt to DeepSeek and get the response',
     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' },
@@ -37,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

@@ -4,10 +4,12 @@ import { DEEPSEEK_DOMAIN, getConversationList } from './utils.js';
 export const historyCommand = cli({
     site: 'deepseek',
     name: 'history',
+    access: 'read',
     description: 'List conversation history from DeepSeek sidebar',
     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

@@ -4,10 +4,12 @@ import { DEEPSEEK_DOMAIN, DEEPSEEK_URL } from './utils.js';
 export const newCommand = cli({
     site: 'deepseek',
     name: 'new',
+    access: 'read',
     description: 'Start a new conversation in DeepSeek',
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status'],

package/clis/deepseek/read.js

@@ -4,10 +4,12 @@ import { DEEPSEEK_DOMAIN, ensureOnDeepSeek, getVisibleMessages } from './utils.j
 export const readCommand = cli({
     site: 'deepseek',
     name: 'read',
+    access: 'read',
     description: 'Read the current DeepSeek conversation',
     domain: DEEPSEEK_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Role', 'Text'],