dsh-reference-anything 0.3.1 → 0.3.2

package/opencli-plugin/common.js

@@ -1,5 +1,5 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import { createHash } from 'node:crypto'
+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'
@@ -12,12 +12,12 @@ import {
 
 export { sinceGuardSource }
 
-const HISTORY_COLUMNS = [
+const HISTORY_COLUMNS = [
   'provider', 'accountScope', 'id', 'title', 'url', 'createdAt', 'updatedAt',
   'messageCount', 'cursor', 'partial',
-]
-
-const SYNC_INDEX_COLUMNS = ['kind', 'identity', 'sinceApplied', ...HISTORY_COLUMNS]
+]
+
+const SYNC_INDEX_COLUMNS = ['kind', 'identity', 'sinceApplied', ...HISTORY_COLUMNS]
 
 const DETAIL_COLUMNS = [
   'conversationId', 'ordinal', 'messageId', 'parentId', 'branchId',
@@ -38,7 +38,24 @@ async function evaluate(page, script, args, operation) {
   return parseEvaluate(await page.evaluate(source), operation)
 }
 
-function assertResult(result, domain, operation) {
+/** Refuse an identity that does not match the account scope captured by sync. */
+export function verifyAccountScope(provider, site, expectedScope, identity) {
+  if (!expectedScope) return
+  const actualScope = createHash('sha256').update(`${provider.toLocaleLowerCase()}\0${identity}`).digest('hex')
+  if (actualScope !== expectedScope) {
+    throw new CommandExecutionError(`DSH_ACCOUNT_SCOPE_MISMATCH: ${site} attachment: attachment belongs to a different logged-in account`)
+  }
+}
+
+/** Preserve omission compatibility while rejecting malformed supplied scopes. */
+export function parseExpectedAccountScope(value) {
+  if (value === undefined || value === null) return ''
+  const scope = String(value).trim()
+  if (!/^[a-f0-9]{64}$/.test(scope)) throw new ArgumentError('accountScope must be a 64-character lowercase hexadecimal hash')
+  return scope
+}
+
+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'}`)
@@ -46,74 +63,85 @@ function assertResult(result, domain, operation) {
   if (result?.ok !== true || !Array.isArray(result.rows)) {
     throw new CommandExecutionError(`${operation}: ${result?.message || 'provider adapter did not return rows'}`)
   }
-  return result.rows
-}
-
-const PROVIDER_READY_TIMEOUT_MS = 1200
-const PROVIDER_READY_INITIAL_DELAY_MS = 50
-const PROVIDER_READY_MAX_DELAY_MS = 400
-
-function terminalProviderResult(result) {
-  return result?.ok === true || result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
-}
-
-function terminalIdentityResult(result) {
-  return result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
-    || (result?.ok === true && typeof result.identity === 'string' && result.identity.length > 0)
-}
-
-/**
- * Run the provider API as the readiness probe. The happy path performs one
- * evaluate immediately after navigation; transient bootstrap failures retry
- * with bounded exponential backoff instead of waiting for the whole SPA DOM
- * to become quiet first.
- */
-export async function evaluateWhenProviderReady(page, script, args, operation, options = {}) {
-  const timeoutMs = options.timeoutMs ?? PROVIDER_READY_TIMEOUT_MS
-  const maxDelayMs = options.maxDelayMs ?? PROVIDER_READY_MAX_DELAY_MS
-  const accepts = options.accepts ?? terminalProviderResult
-  const deadline = Date.now() + timeoutMs
-  let delayMs = options.initialDelayMs ?? PROVIDER_READY_INITIAL_DELAY_MS
-  let lastResult
-  let lastError
-  for (;;) {
-    try {
-      lastResult = await evaluate(page, script, args, operation)
-      lastError = undefined
-      if (accepts(lastResult)) return lastResult
-    } catch (error) {
-      lastError = error
-    }
-    const remaining = deadline - Date.now()
-    if (remaining <= 0) {
-      if (lastError) throw lastError
-      return lastResult
-    }
-    await new Promise(resolve => setTimeout(resolve, Math.min(delayMs, remaining)))
-    delayMs = Math.min(Math.max(delayMs * 2, 1), maxDelayMs)
-  }
-}
-
-/**
- * Each command owns an ephemeral Browser Bridge tab. Close that tab after the
- * command finishes while preserving the provider result or failure.
- */
-async function inTemporaryTab(page, task) {
-  try {
-    return await task()
-  } finally {
-    try {
-      await page.closeTab?.()
-    } catch {
-      // Preserve the provider result/error if the tab or browser closed first.
-    }
-  }
-}
-
-export function registerProvider(config) {
-  const browserSession = SYNC_BROWSER_SESSION
+  return result.rows
+}
+
+function assertIdentityResult(result, domain, operation) {
+  if (result?.code === 'AUTH') throw new AuthRequiredError(domain, result.message)
+  if (result?.code === 'RATE_LIMIT') {
+    throw new CommandExecutionError(`DSH_PROVIDER_RATE_LIMIT: ${operation}: ${result.message || 'provider rate limit reached'}`)
+  }
+  if (result?.ok !== true || typeof result.identity !== 'string' || !result.identity) {
+    throw new CommandExecutionError(`${operation}: ${result?.message || 'stable account identity unavailable'}`)
+  }
+  return result.identity
+}
+
+const PROVIDER_READY_TIMEOUT_MS = 1200
+const PROVIDER_READY_INITIAL_DELAY_MS = 50
+const PROVIDER_READY_MAX_DELAY_MS = 400
+
+function terminalProviderResult(result) {
+  return result?.ok === true || result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
+}
+
+function terminalIdentityResult(result) {
+  return result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
+    || (result?.ok === true && typeof result.identity === 'string' && result.identity.length > 0)
+}
+
+/**
+ * Run the provider API as the readiness probe. The happy path performs one
+ * evaluate immediately after navigation; transient bootstrap failures retry
+ * with bounded exponential backoff instead of waiting for the whole SPA DOM
+ * to become quiet first.
+ */
+export async function evaluateWhenProviderReady(page, script, args, operation, options = {}) {
+  const timeoutMs = options.timeoutMs ?? PROVIDER_READY_TIMEOUT_MS
+  const maxDelayMs = options.maxDelayMs ?? PROVIDER_READY_MAX_DELAY_MS
+  const accepts = options.accepts ?? terminalProviderResult
+  const deadline = Date.now() + timeoutMs
+  let delayMs = options.initialDelayMs ?? PROVIDER_READY_INITIAL_DELAY_MS
+  let lastResult
+  let lastError
+  for (;;) {
+    try {
+      lastResult = await evaluate(page, script, args, operation)
+      lastError = undefined
+      if (accepts(lastResult)) return lastResult
+    } catch (error) {
+      lastError = error
+    }
+    const remaining = deadline - Date.now()
+    if (remaining <= 0) {
+      if (lastError) throw lastError
+      return lastResult
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.min(delayMs, remaining)))
+    delayMs = Math.min(Math.max(delayMs * 2, 1), maxDelayMs)
+  }
+}
+
+/**
+ * Each command owns an ephemeral Browser Bridge tab. Close that tab after the
+ * command finishes while preserving the provider result or failure.
+ */
+async function inTemporaryTab(page, task) {
+  try {
+    return await task()
+  } finally {
+    try {
+      await page.closeTab?.()
+    } catch {
+      // Preserve the provider result/error if the tab or browser closed first.
+    }
+  }
+}
 
-  cli({
+export function registerProvider(config) {
+  const browserSession = SYNC_BROWSER_SESSION
+
+  cli({
     site: config.site,
     name: 'whoami',
     access: 'read',
@@ -124,61 +152,54 @@ export function registerProvider(config) {
     ...browserSession,
     navigateBefore: false,
     args: [],
-    columns: ['identity'],
-    func: async (page) => inTemporaryTab(page, async () => {
-      await page.goto(config.home, { waitUntil: 'none' })
-      const result = await evaluateWhenProviderReady(
-        page, config.whoamiScript, {}, `${config.site} whoami`, { accepts: terminalIdentityResult },
-      )
-      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, { waitUntil: 'none' })
-      const identity = await evaluateWhenProviderReady(
-        page, config.whoamiScript, {}, `${config.site} sync-index identity`, { accepts: terminalIdentityResult },
-      )
-      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({
+    columns: ['identity'],
+    func: async (page) => inTemporaryTab(page, async () => {
+      await page.goto(config.home, { waitUntil: 'none' })
+      const result = await evaluateWhenProviderReady(
+        page, config.whoamiScript, {}, `${config.site} whoami`, { accepts: terminalIdentityResult },
+      )
+      return [{ identity: assertIdentityResult(result, config.domain, `${config.site} whoami`) }]
+    }),
+  })
+
+  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, { waitUntil: 'none' })
+      const identity = await evaluateWhenProviderReady(
+        page, config.whoamiScript, {}, `${config.site} sync-index identity`, { accepts: terminalIdentityResult },
+      )
+      const stableIdentity = assertIdentityResult(identity, config.domain, `${config.site} sync-index`)
+      const accountScope = createHash('sha256').update(`${config.provider.toLocaleLowerCase()}\0${stableIdentity}`).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: stableIdentity, sinceApplied: effectiveSince },
+        ...rows.map(row => ({ kind: 'conversation', identity: '', sinceApplied: '', ...row })),
+      ]
+    }),
+  })
+
+  cli({
     site: config.site,
     name: 'history-all',
     access: 'read',
@@ -193,17 +214,17 @@ export function registerProvider(config) {
       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, { waitUntil: 'none' })
-      const rows = assertResult(
-        await evaluateWhenProviderReady(page, config.historyScript, { since }, `${config.site} history-all`),
-        config.domain,
-        `${config.site} history-all`,
-      )
-      return rows
-    }),
+    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, { waitUntil: 'none' })
+      const rows = assertResult(
+        await evaluateWhenProviderReady(page, config.historyScript, { since }, `${config.site} history-all`),
+        config.domain,
+        `${config.site} history-all`,
+      )
+      return rows
+    }),
   })
 
   cli({
@@ -216,36 +237,33 @@ export function registerProvider(config) {
     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' },
-    ],
+    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`)
+    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 = parseExpectedAccountScope(kwargs.accountScope)
+      if (expectedScope) {
+        const identity = await evaluate(page, config.whoamiScript, {}, `${config.site} detail identity`)
+        const stableIdentity = assertIdentityResult(identity, config.domain, `${config.site} detail`)
+        const actualScope = createHash('sha256').update(`${config.provider.toLocaleLowerCase()}\0${stableIdentity}`).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
-    }),
+      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({
@@ -262,10 +280,11 @@ export function registerProvider(config) {
       { 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' },
+      { name: 'accountScope', help: 'Expected hashed account scope; mismatch refuses the download' },
     ],
     columns: ['attachmentId', 'name', 'mimeType', 'size', 'status', 'localPath'],
-    func: async (page, kwargs) => inTemporaryTab(page, async () => {
-      const locator = String(kwargs.locator || '').trim()
+    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')
@@ -273,17 +292,30 @@ export function registerProvider(config) {
         throw new ArgumentError('maxBytes must be between 1 and 26214400')
       }
       await page.goto(config.home, { settleMs: 500 })
+      const expectedScope = parseExpectedAccountScope(kwargs.accountScope)
+      if (expectedScope) {
+        const identity = await evaluateWhenProviderReady(
+          page, config.whoamiScript, {}, `${config.site} attachment identity`, { accepts: terminalIdentityResult },
+        )
+        const stableIdentity = assertIdentityResult(identity, config.domain, `${config.site} attachment`)
+        verifyAccountScope(config.provider, config.site, expectedScope, stableIdentity)
+      }
       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?.code === 'TOO_LARGE') {
+        throw new CommandExecutionError(`DSH_ATTACHMENT_TOO_LARGE: ${config.site} attachment exceeds maxBytes`)
+      }
       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`)
+      if (bytes.byteLength > maxBytes) {
+        throw new CommandExecutionError(`DSH_ATTACHMENT_TOO_LARGE: ${config.site} attachment exceeds maxBytes`)
+      }
       await mkdir(dirname(output), { recursive: true })
       await writeFile(output, bytes)
       return [{
@@ -291,30 +323,77 @@ export function registerProvider(config) {
         name: result.name || output.split(/[\\/]/).pop() || 'attachment',
         mimeType: result.mimeType || 'application/octet-stream',
         size: bytes.byteLength,
-        status: 'available',
-        localPath: output,
-      }]
-    }),
-  })
-}
-
-/** Browser Bridge lifecycle shared by every web-chat command. */
-export const SYNC_BROWSER_SESSION = Object.freeze({
-  siteSession: 'ephemeral',
-  defaultWindowMode: 'background',
-})
+        status: 'available',
+        localPath: output,
+      }]
+    }),
+  })
+}
 
-const ATTACHMENT_SCRIPT = String.raw`async function (args) {
+/** Browser Bridge lifecycle shared by every web-chat command. */
+export const SYNC_BROWSER_SESSION = Object.freeze({
+  siteSession: 'ephemeral',
+  defaultWindowMode: 'background',
+})
+
+export const ATTACHMENT_SCRIPT = String.raw`async function (args) {
   try {
+    const cancelBody = async body => {
+      try { await body?.cancel?.() } catch {}
+    }
     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 response = await fetch(target.href, { credentials: 'include', redirect: 'error' })
+    if (response.url && new URL(response.url).origin !== args.origin) {
+      await cancelBody(response.body)
+      return JSON.stringify({ ok: false, message: 'cross-origin redirect refused' })
+    }
+    if (response.status === 401 || response.status === 403) {
+      await cancelBody(response.body)
+      return JSON.stringify({ ok: false, code: 'AUTH' })
+    }
+    if (!response.ok) {
+      await cancelBody(response.body)
+      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' })
+    const declaredLength = Number.isFinite(length) && length > 0 ? length : 0
+    if (declaredLength > args.maxBytes) {
+      await cancelBody(response.body)
+      return JSON.stringify({ ok: false, code: 'TOO_LARGE', message: 'attachment exceeds maxBytes' })
+    }
+    const chunks = []
+    let total = 0
+    if (response.body) {
+      const reader = response.body.getReader()
+      try {
+        for (;;) {
+          const { done, value } = await reader.read()
+          if (done) break
+          const chunk = value instanceof Uint8Array ? value : new Uint8Array(value)
+          if (total + chunk.byteLength > args.maxBytes) {
+            try { await reader.cancel() } catch {}
+            return JSON.stringify({ ok: false, code: 'TOO_LARGE', message: 'attachment exceeds maxBytes' })
+          }
+          chunks.push(chunk)
+          total += chunk.byteLength
+        }
+      } catch (error) {
+        try { await reader.cancel() } catch {}
+        throw error
+      } finally {
+        try { reader.releaseLock?.() } catch {}
+      }
+    }
+    if (declaredLength && total < declaredLength) {
+      return JSON.stringify({ ok: false, message: 'attachment download was truncated' })
+    }
+    const bytes = new Uint8Array(total)
+    let offset = 0
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset)
+      offset += chunk.byteLength
+    }
     let binary = ''
     for (let at = 0; at < bytes.length; at += 0x8000) {
       binary += String.fromCharCode(...bytes.subarray(at, Math.min(bytes.length, at + 0x8000)))

package/opencli-plugin/deepseek.js

@@ -121,10 +121,7 @@ const detailScript = String.raw`async function (args) {
   }
 }`
 
-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 () {
+export const whoamiScript = String.raw`async function () {
     const headers = (() => {
       try {
         const stored = JSON.parse(localStorage.getItem('userToken') || 'null')
@@ -135,6 +132,7 @@ registerProvider({
     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.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
       if (!response.ok) continue
       const contentType = response.headers.get('content-type') || ''
       if (!contentType.includes('application/json')) continue
@@ -147,6 +145,11 @@ registerProvider({
       if (identity) return JSON.stringify({ ok: true, identity })
     }
     return JSON.stringify({ ok: false, code: 'AUTH' })
-  }`,
+  }`
+
+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,
   historyScript, detailScript, fallbackScript: domFallbackScript,
 })