dsh-reference-anything 0.2.0

package/opencli-plugin/claude.js

@@ -0,0 +1,134 @@
+import { domFallbackScript, registerProvider, sinceGuardSource } from './common.js'
+// OpenCLI discovery marker: registerProvider below performs the cli() calls.
+
+const shared = String.raw`
+  const organization = async () => {
+    const response = await fetch('/api/organizations', { credentials: 'include' })
+    if (response.status === 401 || response.status === 403) throw Object.assign(new Error('login required'), { code: 'AUTH' })
+    if (!response.ok) throw new Error('organizations HTTP ' + response.status)
+    const payload = await response.json()
+    const organizations = Array.isArray(payload) ? payload : payload.organizations || []
+    const item = organizations.find(value => value && (value.uuid || value.id))
+    if (!item) throw Object.assign(new Error('no Claude organization'), { code: 'AUTH' })
+    return String(item.uuid || item.id)
+  }
+`
+
+const historyScript = String.raw`async function (args) {
+  ${shared}
+  const stopEarly = (${sinceGuardSource})(args && args.since)
+  const rows = []
+  try {
+    const org = await organization()
+    let offset = 0
+    for (let page = 0; page < 500; page++) {
+      const response = await fetch('/api/organizations/' + encodeURIComponent(org) + '/chat_conversations?limit=100&offset=' + offset, { credentials: 'include' })
+      if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+      if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+      if (!response.ok) throw new Error('history HTTP ' + response.status)
+      const payload = await response.json()
+      const items = Array.isArray(payload) ? payload : payload.items || payload.chat_conversations || []
+      const pageStart = rows.length
+      for (const item of items) {
+        const id = String(item.uuid || item.id || '')
+        if (!id) continue
+        rows.push({ provider: 'claude', accountScope: '', id,
+          title: String(item.name || item.title || 'Untitled Claude chat'),
+          url: location.origin + '/chat/' + encodeURIComponent(id),
+          createdAt: String(item.created_at || item.createdAt || ''),
+          updatedAt: String(item.updated_at || item.updatedAt || item.created_at || ''),
+          messageCount: Number(item.message_count || item.messageCount || 0),
+          cursor: String(offset + items.length), partial: false })
+      }
+      if (items.length < 100) break
+      if (stopEarly(rows.slice(pageStart))) break
+      offset += items.length
+    }
+    return JSON.stringify({ ok: true, rows })
+  } catch (error) {
+    if (error && error.code === 'AUTH') return JSON.stringify({ ok: false, code: 'AUTH' })
+    const links = Array.from(document.querySelectorAll('a[href*="/chat/"]'))
+    const seen = new Set()
+    for (const link of links) {
+      const match = link.href.match(/\/chat\/([^/?#]+)/)
+      if (!match || seen.has(match[1])) continue
+      seen.add(match[1])
+      rows.push({ provider: 'claude', accountScope: '', id: match[1],
+        title: (link.textContent || '').trim() || 'Untitled Claude chat', url: link.href,
+        createdAt: '', updatedAt: '', messageCount: 0, cursor: '', partial: true })
+    }
+    return JSON.stringify({ ok: rows.length > 0, rows, message: String(error && error.message || error) })
+  }
+}`
+
+const detailScript = String.raw`async function (args) {
+  ${shared}
+  const textOf = value => typeof value === 'string' ? value
+    : Array.isArray(value) ? value.map(textOf).filter(Boolean).join('\n')
+    : value && typeof value === 'object' ? textOf(value.text || value.content || value.value || value.markdown || '') : ''
+  try {
+    const org = await organization()
+    const url = '/api/organizations/' + encodeURIComponent(org) + '/chat_conversations/' + encodeURIComponent(args.id)
+      + '?tree=True&rendering_mode=messages&render_all_tools=true'
+    const response = await fetch(url, { credentials: 'include' })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+    if (!response.ok) throw new Error('detail HTTP ' + response.status)
+    const payload = await response.json()
+    const messages = payload.chat_messages || payload.messages || (payload.conversation && payload.conversation.chat_messages) || []
+    const byId = new Map(messages.map(message => [String(message.uuid || message.id || ''), message]))
+    const childIds = new Set(messages.map(message => String(message.parent_message_uuid || message.parent_uuid || message.parent_id || '')).filter(Boolean))
+    const requestedLeaf = String(payload.current_leaf_message_uuid || payload.current_message_uuid || payload.current_node_uuid || '')
+    let leaf = requestedLeaf && byId.has(requestedLeaf) ? requestedLeaf : ''
+    if (!leaf) {
+      const leaves = messages.filter(message => !childIds.has(String(message.uuid || message.id || '')))
+      leaf = String((leaves[leaves.length - 1] || {}).uuid || (leaves[leaves.length - 1] || {}).id || '')
+    }
+    const active = new Set()
+    for (let id = leaf, guard = 0; id && guard++ < messages.length + 1;) {
+      active.add(id)
+      const message = byId.get(id)
+      id = message ? String(message.parent_message_uuid || message.parent_uuid || message.parent_id || '') : ''
+    }
+    const ordered = messages.slice().sort((a, b) => String(a.created_at || '').localeCompare(String(b.created_at || '')))
+    const rows = ordered.map((message, ordinal) => {
+      const id = String(message.uuid || message.id || ordinal)
+      const sender = String(message.sender || message.role || '').toLowerCase()
+      const content = message.content || message.text || message.content_blocks || ''
+      const attachments = (message.attachments || message.files || []).map((file, index) => {
+        const candidate = String(file.download_url || file.url || '')
+        let locator = ''
+        try { if (candidate) { const url = new URL(candidate, location.origin); if (url.origin === location.origin && url.pathname !== '/') locator = url.pathname + url.search } } catch {}
+        const name = String(file.name || file.file_name || 'attachment')
+        const mimeType = String(file.mime_type || file.mimeType || '')
+        return { attachmentId: String(file.id || file.uuid || index), name: String(file.name || file.file_name || 'attachment'),
+          kind: mimeType.startsWith('image/') || /\.(?:gif|jpe?g|png|webp)$/i.test(name) ? 'image' : 'file',
+          mimeType, size: Number(file.size || 0),
+          locator, status: locator ? 'available' : 'unavailable' }
+      })
+      return { conversationId: args.id, ordinal, messageId: id,
+        parentId: String(message.parent_message_uuid || message.parent_uuid || message.parent_id || ''),
+        branchId: String(message.branch_uuid || ''), activeBranch: active.size ? active.has(id) : true,
+        role: /assistant|claude|model/.test(sender) ? 'assistant' : 'user', text: textOf(content),
+        createdAt: String(message.created_at || message.createdAt || ''), attachmentsJson: JSON.stringify(attachments), partial: false }
+    }).filter(row => row.text || row.attachmentsJson !== '[]')
+    return JSON.stringify({ ok: rows.length > 0, rows })
+  } catch (error) {
+    if (error && error.code === 'AUTH') return JSON.stringify({ ok: false, code: 'AUTH' })
+    return JSON.stringify({ ok: false, message: String(error && error.message || error) })
+  }
+}`
+
+registerProvider({
+  site: 'dsh-claude', provider: 'Claude', domain: 'claude.ai', home: 'https://claude.ai/',
+  conversationUrl: id => `https://claude.ai/chat/${encodeURIComponent(id)}`,
+  whoamiScript: String.raw`async function () {
+    const response = await fetch('/api/organizations', { credentials: 'include' })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (!response.ok) return JSON.stringify({ ok: false, message: 'organizations HTTP ' + response.status })
+    const payload = await response.json(); const values = Array.isArray(payload) ? payload : payload.organizations || []
+    const item = values.find(value => value && (value.uuid || value.id)); const identity = String(item && (item.uuid || item.id) || '')
+    return JSON.stringify({ ok: Boolean(identity), identity, code: identity ? undefined : 'AUTH' })
+  }`,
+  historyScript, detailScript, fallbackScript: domFallbackScript,
+})

package/opencli-plugin/common.js

@@ -0,0 +1,307 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { dirname, resolve } from 'node:path'
+import { cli, Strategy } from '@jackwener/opencli/registry'
+import { sinceGuardSource } from './since-guard.js'
+import {
+  ArgumentError,
+  AuthRequiredError,
+  CommandExecutionError,
+  EmptyResultError,
+} from '@jackwener/opencli/errors'
+
+export { sinceGuardSource }
+
+const HISTORY_COLUMNS = [
+  'provider', 'accountScope', 'id', 'title', 'url', 'createdAt', 'updatedAt',
+  'messageCount', 'cursor', 'partial',
+]
+
+const SYNC_INDEX_COLUMNS = ['kind', 'identity', 'sinceApplied', ...HISTORY_COLUMNS]
+
+const DETAIL_COLUMNS = [
+  'conversationId', 'ordinal', 'messageId', 'parentId', 'branchId',
+  'activeBranch', 'role', 'text', 'createdAt', 'attachmentsJson', 'partial',
+]
+
+function parseEvaluate(value, operation) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value)
+  try {
+    return JSON.parse(raw)
+  } catch (error) {
+    throw new CommandExecutionError(`${operation}: provider page returned malformed JSON: ${String(error)}`)
+  }
+}
+
+async function evaluate(page, script, args, operation) {
+  const source = `(() => { const __args = ${JSON.stringify(args)}; return (${script})(__args); })()`
+  return parseEvaluate(await page.evaluate(source), operation)
+}
+
+function assertResult(result, domain, operation) {
+  if (result?.code === 'AUTH') throw new AuthRequiredError(domain, result.message || `${operation} requires login`)
+  if (result?.code === 'RATE_LIMIT') {
+    throw new CommandExecutionError(`${operation}: ${result.message || 'provider rate limit reached'}`)
+  }
+  if (result?.ok !== true || !Array.isArray(result.rows)) {
+    throw new CommandExecutionError(`${operation}: ${result?.message || 'provider adapter did not return rows'}`)
+  }
+  return result.rows
+}
+
+/**
+ * Release only the one-shot task tab. Browser Bridge deliberately keeps its
+ * empty adapter container alive so the next sync can reuse it; if the user
+ * closes that container, Browser Bridge recreates it on demand.
+ */
+async function inTemporaryTab(page, task) {
+  try {
+    return await task()
+  } finally {
+    try {
+      await page.closeTab?.()
+    } catch {
+      // Preserve the provider result/error if the browser closed first.
+    }
+  }
+}
+
+export function registerProvider(config) {
+  const browserSession = SYNC_BROWSER_SESSION
+
+  cli({
+    site: config.site,
+    name: 'whoami',
+    access: 'read',
+    description: `Resolve the stable ${config.provider} account identity for local scoping`,
+    domain: config.domain,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    ...browserSession,
+    navigateBefore: false,
+    args: [],
+    columns: ['identity'],
+    func: async (page) => inTemporaryTab(page, async () => {
+      await page.goto(config.home, { settleMs: 500 })
+      const result = await evaluate(page, config.whoamiScript, {}, `${config.site} whoami`)
+      if (result?.code === 'AUTH') throw new AuthRequiredError(config.domain)
+      if (result?.ok !== true || typeof result.identity !== 'string' || !result.identity) {
+        throw new CommandExecutionError(`${config.site} whoami: ${result?.message || 'stable account identity unavailable'}`)
+      }
+      return [{ identity: result.identity }]
+    }),
+  })
+
+  cli({
+    site: config.site,
+    name: 'sync-index',
+    access: 'read',
+    description: `Resolve the ${config.provider} account and list its conversation history in one browser session`,
+    domain: config.domain,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    ...browserSession,
+    navigateBefore: false,
+    args: [{
+      name: 'since',
+      help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
+    }, { name: 'accountScope', help: 'Previously observed hashed account scope; mismatch forces a full listing' }],
+    columns: SYNC_INDEX_COLUMNS,
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+      const since = String(kwargs.since || '').trim()
+      if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
+      await page.goto(config.home, { settleMs: 1200 })
+      const identity = await evaluate(page, config.whoamiScript, {}, `${config.site} sync-index identity`)
+      if (identity?.code === 'AUTH') throw new AuthRequiredError(config.domain)
+      if (identity?.ok !== true || typeof identity.identity !== 'string' || !identity.identity) {
+        throw new CommandExecutionError(`${config.site} sync-index: ${identity?.message || 'stable account identity unavailable'}`)
+      }
+      const accountScope = createHash('sha256').update(`${config.provider.toLocaleLowerCase()}\0${identity.identity}`).digest('hex')
+      const effectiveSince = String(kwargs.accountScope || '') === accountScope ? since : ''
+      const rows = assertResult(
+        await evaluate(page, config.historyScript, { since: effectiveSince }, `${config.site} sync-index history`),
+        config.domain,
+        `${config.site} sync-index`,
+      )
+      return [
+        { kind: 'identity', identity: identity.identity, sinceApplied: effectiveSince },
+        ...rows.map(row => ({ kind: 'conversation', identity: '', sinceApplied: '', ...row })),
+      ]
+    }),
+  })
+
+  cli({
+    site: config.site,
+    name: 'history-all',
+    access: 'read',
+    description: `List the ${config.provider} web conversation history, whole or since an instant`,
+    domain: config.domain,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    ...browserSession,
+    navigateBefore: false,
+    args: [{
+      name: 'since',
+      help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
+    }],
+    columns: HISTORY_COLUMNS,
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+      const since = String(kwargs.since || '').trim()
+      if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
+      await page.goto(config.home, { settleMs: 1200 })
+      const rows = assertResult(
+        await evaluate(page, config.historyScript, { since }, `${config.site} history-all`),
+        config.domain,
+        `${config.site} history-all`,
+      )
+      return rows
+    }),
+  })
+
+  cli({
+    site: config.site,
+    name: 'detail',
+    access: 'read',
+    description: `Read one complete ${config.provider} conversation`,
+    domain: config.domain,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    ...browserSession,
+    navigateBefore: false,
+    args: [
+      { name: 'id', positional: true, required: true, help: 'Provider conversation id' },
+      { name: 'accountScope', help: 'Expected hashed account scope; mismatch refuses the read' },
+    ],
+    columns: DETAIL_COLUMNS,
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+      const id = String(kwargs.id || '').trim()
+      if (!id) throw new ArgumentError('id must be a non-empty conversation id')
+      await page.goto(config.home, { settleMs: 600 })
+      const expectedScope = String(kwargs.accountScope || '').trim()
+      if (expectedScope) {
+        const identity = await evaluate(page, config.whoamiScript, {}, `${config.site} detail identity`)
+        if (identity?.code === 'AUTH') throw new AuthRequiredError(config.domain)
+        if (identity?.ok !== true || typeof identity.identity !== 'string' || !identity.identity) {
+          throw new CommandExecutionError(`${config.site} detail: stable account identity unavailable`)
+        }
+        const actualScope = createHash('sha256').update(`${config.provider.toLocaleLowerCase()}\0${identity.identity}`).digest('hex')
+        if (actualScope !== expectedScope) {
+          throw new CommandExecutionError(`DSH_ACCOUNT_SCOPE_MISMATCH: ${config.site} detail: conversation belongs to a different logged-in account`)
+        }
+      }
+      let result = await evaluate(page, config.detailScript, { id }, `${config.site} detail`)
+      if (result?.ok !== true && result?.code !== 'AUTH' && result?.code !== 'RATE_LIMIT' && config.fallbackScript) {
+        await page.goto(config.conversationUrl(id), { settleMs: 1800 })
+        result = await evaluate(page, config.fallbackScript, { id }, `${config.site} detail fallback`)
+      }
+      const rows = assertResult(result, config.domain, `${config.site} detail`)
+      if (rows.length === 0) throw new EmptyResultError(`${config.site} detail`, `No messages found for ${id}`)
+      return rows
+    }),
+  })
+
+  cli({
+    site: config.site,
+    name: 'attachment',
+    access: 'read',
+    description: `Materialize one authorized ${config.provider} attachment`,
+    domain: config.domain,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    ...browserSession,
+    navigateBefore: false,
+    args: [
+      { name: 'locator', positional: true, required: true, help: 'Stable same-origin attachment locator' },
+      { name: 'output', required: true, help: 'Absolute output file path' },
+      { name: 'maxBytes', type: 'int', default: 26214400, help: 'Maximum decoded bytes' },
+    ],
+    columns: ['attachmentId', 'name', 'mimeType', 'size', 'status', 'localPath'],
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+      const locator = String(kwargs.locator || '').trim()
+      const output = resolve(String(kwargs.output || ''))
+      const maxBytes = Number(kwargs.maxBytes ?? 26_214_400)
+      if (!locator) throw new ArgumentError('locator must not be empty')
+      if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 26_214_400) {
+        throw new ArgumentError('maxBytes must be between 1 and 26214400')
+      }
+      await page.goto(config.home, { settleMs: 500 })
+      const result = await evaluate(page, ATTACHMENT_SCRIPT, {
+        locator,
+        origin: new URL(config.home).origin,
+        maxBytes,
+      }, `${config.site} attachment`)
+      if (result?.code === 'AUTH') throw new AuthRequiredError(config.domain)
+      if (result?.ok !== true || typeof result.base64 !== 'string') {
+        throw new CommandExecutionError(`${config.site} attachment: ${result?.message || 'attachment unavailable'}`)
+      }
+      const bytes = Buffer.from(result.base64, 'base64')
+      if (bytes.byteLength > maxBytes) throw new CommandExecutionError(`${config.site} attachment exceeds maxBytes`)
+      await mkdir(dirname(output), { recursive: true })
+      await writeFile(output, bytes)
+      return [{
+        attachmentId: locator,
+        name: result.name || output.split(/[\\/]/).pop() || 'attachment',
+        mimeType: result.mimeType || 'application/octet-stream',
+        size: bytes.byteLength,
+        status: 'available',
+        localPath: output,
+      }]
+    }),
+  })
+}
+
+/** Browser Bridge lifecycle contract shared by every web-chat sync command. */
+export const SYNC_BROWSER_SESSION = Object.freeze({
+  siteSession: 'ephemeral',
+  defaultWindowMode: 'background',
+})
+
+const ATTACHMENT_SCRIPT = String.raw`async function (args) {
+  try {
+    const target = new URL(args.locator, args.origin)
+    if (target.origin !== args.origin) return JSON.stringify({ ok: false, message: 'cross-origin locator refused' })
+    const response = await fetch(target.href, { credentials: 'include' })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (!response.ok) return JSON.stringify({ ok: false, message: 'attachment HTTP ' + response.status })
+    const length = Number(response.headers.get('content-length') || 0)
+    if (length > args.maxBytes) return JSON.stringify({ ok: false, message: 'attachment exceeds maxBytes' })
+    const bytes = new Uint8Array(await response.arrayBuffer())
+    if (bytes.byteLength > args.maxBytes) return JSON.stringify({ ok: false, message: 'attachment exceeds maxBytes' })
+    let binary = ''
+    for (let at = 0; at < bytes.length; at += 0x8000) {
+      binary += String.fromCharCode(...bytes.subarray(at, Math.min(bytes.length, at + 0x8000)))
+    }
+    return JSON.stringify({
+      ok: true,
+      base64: btoa(binary),
+      mimeType: response.headers.get('content-type') || 'application/octet-stream',
+      name: target.pathname.split('/').pop() || 'attachment',
+    })
+  } catch (error) {
+    return JSON.stringify({ ok: false, message: String(error && error.message || error) })
+  }
+}`
+
+export const domFallbackScript = String.raw`async function (args) {
+  const nodes = Array.from(document.querySelectorAll('[data-message-author-role], user-query, model-response, [class*="message"]'))
+  const rows = []
+  let ordinal = 0
+  for (const node of nodes) {
+    if (node.parentElement && node.parentElement.closest('[data-message-author-role], user-query, model-response') !== node) continue
+    const attr = (node.getAttribute('data-message-author-role') || '').toLowerCase()
+    const tag = node.tagName.toLowerCase()
+    const role = attr === 'user' || tag === 'user-query' || /user|human/i.test(node.className || '') ? 'user'
+      : attr === 'assistant' || tag === 'model-response' || /assistant|model-response|claude/i.test(node.className || '') ? 'assistant'
+      : null
+    const text = (node.innerText || node.textContent || '').trim()
+    if (!role || !text) continue
+    rows.push({
+      conversationId: args.id,
+      ordinal: ordinal++,
+      messageId: node.getAttribute('data-message-id') || '',
+      parentId: '', branchId: '', activeBranch: true,
+      role, text, createdAt: '', attachmentsJson: '[]', partial: true,
+    })
+  }
+  return JSON.stringify({ ok: rows.length > 0, rows, message: rows.length ? '' : 'DOM fallback found no messages' })
+}`

package/opencli-plugin/deepseek.js

@@ -0,0 +1,152 @@
+import { domFallbackScript, registerProvider, sinceGuardSource } from './common.js'
+// OpenCLI discovery marker: registerProvider below performs the cli() calls.
+
+const historyScript = String.raw`async function (args) {
+  const stopEarly = (${sinceGuardSource})(args && args.since)
+  const normalize = value => Array.isArray(value) ? value : []
+  const headers = (() => {
+    try {
+      const stored = JSON.parse(localStorage.getItem('userToken') || 'null')
+      const token = typeof stored === 'string' ? stored : stored && (stored.value || stored.token)
+      return token ? { Accept: 'application/json', Authorization: 'Bearer ' + token } : { Accept: 'application/json' }
+    } catch { return { Accept: 'application/json' } }
+  })()
+  const toDate = value => {
+    if (typeof value === 'number' && Number.isFinite(value)) return new Date(value < 1e12 ? value * 1000 : value).toISOString()
+    return String(value || '')
+  }
+  const rows = []
+  let cursorPinned = false
+  let cursorUpdatedAt = ''
+  let guard = 0
+  try {
+    do {
+      const query = new URLSearchParams({ count: '100', 'lte_cursor.pinned': String(cursorPinned) })
+      if (cursorUpdatedAt) query.set('lte_cursor.updated_at', cursorUpdatedAt)
+      const response = await fetch('/api/v0/chat_session/fetch_page?' + query, { credentials: 'include', headers })
+      if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+      if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+      if (!response.ok) throw new Error('history HTTP ' + response.status)
+      const payload = await response.json()
+      if (payload && (payload.code === 40002 || /missing token|unauth/i.test(String(payload.msg || payload.message || '')))) {
+        return JSON.stringify({ ok: false, code: 'AUTH' })
+      }
+      const data = payload.data && payload.data.biz_data || payload.biz_data || payload.data || payload
+      const items = normalize(data.chat_sessions || data.sessions || data.items || data.conversations)
+      const pageStart = rows.length
+      for (const item of items) {
+        const id = String(item.id || item.chat_session_id || item.uuid || '')
+        if (!id) continue
+        rows.push({
+          provider: 'deepseek', accountScope: '', id,
+          title: String(item.title || item.name || 'Untitled DeepSeek chat'),
+          url: location.origin + '/a/chat/s/' + encodeURIComponent(id),
+          createdAt: toDate(item.inserted_at || item.created_at || item.createdAt || ''),
+          updatedAt: toDate(item.updated_at || item.updatedAt || item.inserted_at || item.created_at || ''),
+          messageCount: Number(item.message_count || item.messageCount || 0),
+          cursor: String(item.updated_at || item.updatedAt || ''), partial: false,
+        })
+      }
+      const last = items[items.length - 1]
+      const nextUpdatedAt = String(last && (last.updated_at || last.updatedAt) || '')
+      const nextPinned = Boolean(last && last.pinned)
+      if (!data.has_more || !nextUpdatedAt || (nextUpdatedAt === cursorUpdatedAt && nextPinned === cursorPinned)) break
+      if (stopEarly(rows.slice(pageStart))) break
+      cursorUpdatedAt = nextUpdatedAt
+      cursorPinned = nextPinned
+    } while (++guard < 500)
+    return JSON.stringify({ ok: true, rows })
+  } catch (error) {
+    const links = Array.from(document.querySelectorAll('a[href*="/a/chat/s/"]'))
+    const seen = new Set()
+    for (const link of links) {
+      const match = link.href.match(/\/a\/chat\/s\/([^/?#]+)/)
+      if (!match || seen.has(match[1])) continue
+      seen.add(match[1])
+      rows.push({ provider: 'deepseek', accountScope: '', id: match[1],
+        title: (link.textContent || '').trim() || 'Untitled DeepSeek chat', url: link.href,
+        createdAt: '', updatedAt: '', messageCount: 0, cursor: '', partial: true })
+    }
+    return JSON.stringify({ ok: rows.length > 0, rows, message: String(error && error.message || error) })
+  }
+}`
+
+const detailScript = String.raw`async function (args) {
+  const headers = (() => {
+    try {
+      const stored = JSON.parse(localStorage.getItem('userToken') || 'null')
+      const token = typeof stored === 'string' ? stored : stored && (stored.value || stored.token)
+      return token ? { Accept: 'application/json', Authorization: 'Bearer ' + token } : { Accept: 'application/json' }
+    } catch { return { Accept: 'application/json' } }
+  })()
+  const toText = value => typeof value === 'string' ? value
+    : Array.isArray(value) ? value.map(toText).filter(Boolean).join('\n')
+    : value && typeof value === 'object' ? toText(value.text || value.content || value.value || '') : ''
+  try {
+    const response = await fetch('/api/v0/chat/history_messages?chat_session_id=' + encodeURIComponent(args.id), { credentials: 'include', headers })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+    if (!response.ok) throw new Error('detail HTTP ' + response.status)
+    const payload = await response.json()
+    if (payload && (payload.code === 40002 || /missing token|unauth/i.test(String(payload.msg || payload.message || '')))) {
+      return JSON.stringify({ ok: false, code: 'AUTH' })
+    }
+    const data = payload.data && payload.data.biz_data || payload.biz_data || payload.data || payload
+    const messages = data.chat_messages || data.messages || data.items || []
+    const rows = messages.map((message, ordinal) => {
+      const roleRaw = String(message.role || message.message_role || message.sender || '').toLowerCase()
+      const role = /assistant|bot|model/.test(roleRaw) ? 'assistant' : 'user'
+      const files = message.attachments || message.files || message.file_infos || []
+      const attachments = (Array.isArray(files) ? files : []).map((file, index) => {
+        const candidate = String(file.download_url || file.url || file.path || '')
+        let locator = ''
+        try { if (candidate) { const url = new URL(candidate, location.origin); if (url.origin === location.origin && url.pathname !== '/') locator = url.pathname + url.search } } catch {}
+        const name = String(file.name || file.file_name || 'attachment')
+        const mimeType = String(file.mime_type || file.mimeType || '')
+        return { attachmentId: String(file.id || file.file_id || index),
+          kind: mimeType.startsWith('image/') || /\.(?:gif|jpe?g|png|webp)$/i.test(name) ? 'image' : 'file',
+          name, mimeType,
+          size: Number(file.size || file.file_size || 0), locator, status: locator ? 'available' : 'unavailable' }
+      })
+      return { conversationId: args.id, ordinal,
+        messageId: String(message.id || message.message_id || ordinal),
+        parentId: String(message.parent_id || message.parentId || ''), branchId: '', activeBranch: true,
+        role, text: toText(message.content || message.text || message.fragments || ''),
+        createdAt: String(message.created_at || message.createdAt || ''),
+        attachmentsJson: JSON.stringify(attachments), partial: false }
+    }).filter(row => row.text || row.attachmentsJson !== '[]')
+    return JSON.stringify({ ok: rows.length > 0, rows })
+  } catch (error) {
+    return JSON.stringify({ ok: false, message: String(error && error.message || error) })
+  }
+}`
+
+registerProvider({
+  site: 'dsh-deepseek', provider: 'DeepSeek', domain: 'chat.deepseek.com',
+  home: 'https://chat.deepseek.com/', conversationUrl: id => `https://chat.deepseek.com/a/chat/s/${encodeURIComponent(id)}`,
+  whoamiScript: String.raw`async function () {
+    const headers = (() => {
+      try {
+        const stored = JSON.parse(localStorage.getItem('userToken') || 'null')
+        const token = typeof stored === 'string' ? stored : stored && (stored.value || stored.token)
+        return token ? { Accept: 'application/json', Authorization: 'Bearer ' + token } : { Accept: 'application/json' }
+      } catch { return { Accept: 'application/json' } }
+    })()
+    for (const url of ['/api/v0/users/current', '/api/v0/user/profile']) {
+      const response = await fetch(url, { credentials: 'include', headers })
+      if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+      if (!response.ok) continue
+      const contentType = response.headers.get('content-type') || ''
+      if (!contentType.includes('application/json')) continue
+      const payload = await response.json()
+      if (payload && (payload.code === 40002 || /missing token|unauth/i.test(String(payload.msg || payload.message || '')))) {
+        return JSON.stringify({ ok: false, code: 'AUTH' })
+      }
+      const user = payload.data && payload.data.biz_data || payload.biz_data || payload.data || payload
+      const identity = String(user.id || user.user_id || user.uuid || user.email || '')
+      if (identity) return JSON.stringify({ ok: true, identity })
+    }
+    return JSON.stringify({ ok: false, code: 'AUTH' })
+  }`,
+  historyScript, detailScript, fallbackScript: domFallbackScript,
+})