feat: 完善 OAuth 认证流程与模型导入系统

新增功能：
- 实现完整的 OAuth 认证流程，支持多种 issuer（ZCode、BigModel、ZAI 等）
- 添加 OAuth loopback 服务器实现，支持授权码回调
- 扩展模型导入功能，支持预设导入和模型绑定
- 新增 Ollama 模型供应商支持
- 增强会话报告系统，支持 subagent 报告展示

改进项：
- 改进模型列表获取逻辑，支持 OAuth 认证的上游模型
- 完善导入对话界面，支持选择导入源
- 增强模型绑定和预设管理功能
- 扩展国际化支持

测试：
- 新增 OAuth 流程、registry、loopback 等单元测试
- 扩展模型列表和导入相关测试
- 新增 thinking adapter 测试

Author: 239573049

src/main/db/repo.ts

@@ -3009,6 +3009,104 @@ export function putImportMapping(mapping: ImportMappingRow): void {
   )
 }
 
+/**
+ * 扫描缓存的一行。★ 这不是「导入过什么」的记录(那是 `import_mappings`),
+ * 而是「上次扫描时从这个文件里读出了什么」—— 没导入的文件也有。
+ */
+export interface ImportScanCacheRow {
+  sourceId: string
+  sourcePath: string
+  changeToken: string
+  sessionId: string
+  /** '' = 只读了头部,没算过全文哈希。 */
+  contentHash: string
+  cwd: string
+  title: string
+  model: string
+  modelProvider: string
+  /** partial 为真时是下界。 */
+  messages: number
+  partial: boolean
+  sourceUpdatedAt: number
+  scannedAt: number
+}
+
+function importScanCacheFromRow(row: Record<string, unknown>): ImportScanCacheRow {
+  return {
+    sourceId: String(row['source_id'] ?? ''),
+    sourcePath: String(row['source_path'] ?? ''),
+    changeToken: String(row['change_token'] ?? ''),
+    sessionId: String(row['session_id'] ?? ''),
+    contentHash: String(row['content_hash'] ?? ''),
+    cwd: String(row['cwd'] ?? ''),
+    title: String(row['title'] ?? ''),
+    model: String(row['model'] ?? ''),
+    modelProvider: String(row['model_provider'] ?? ''),
+    messages: Number(row['messages'] ?? 0),
+    partial: Number(row['partial'] ?? 0) === 1,
+    sourceUpdatedAt: Number(row['source_updated_at'] ?? 0),
+    scannedAt: Number(row['scanned_at'] ?? 0)
+  }
+}
+
+/** 一个来源的全部缓存行,按 `source_path` 建索引供扫描循环查。 */
+export function listImportScanCache(sourceId: string): Map<string, ImportScanCacheRow> {
+  const rows = stmt('SELECT * FROM import_scan_cache WHERE source_id = ?').all(sourceId)
+  const map = new Map<string, ImportScanCacheRow>()
+  for (const row of rows) {
+    const parsed = importScanCacheFromRow(row as Record<string, unknown>)
+    map.set(parsed.sourcePath, parsed)
+  }
+  return map
+}
+
+/**
+ * 整批写回。★ 一次事务,不是一行一个 —— 一轮扫描上千行,逐行提交在 WAL 上
+ * 是上千次写放大,那正是这套缓存要省掉的开销。
+ */
+export function putImportScanCache(rows: readonly ImportScanCacheRow[]): void {
+  if (rows.length === 0) return
+  tx(() => {
+    const write = stmt(
+      `INSERT INTO import_scan_cache (
+         source_id, source_path, change_token, session_id, content_hash, cwd, title,
+         model, model_provider, messages, partial, source_updated_at, scanned_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (source_id, source_path) DO UPDATE SET
+         change_token = excluded.change_token,
+         session_id = excluded.session_id,
+         content_hash = excluded.content_hash,
+         cwd = excluded.cwd,
+         title = excluded.title,
+         model = excluded.model,
+         model_provider = excluded.model_provider,
+         messages = excluded.messages,
+         partial = excluded.partial,
+         source_updated_at = excluded.source_updated_at,
+         scanned_at = excluded.scanned_at`
+    )
+    for (const row of rows) {
+      write.run(
+        row.sourceId, row.sourcePath, row.changeToken, row.sessionId, row.contentHash,
+        row.cwd, row.title, row.model, row.modelProvider, row.messages,
+        row.partial ? 1 : 0, row.sourceUpdatedAt, row.scannedAt
+      )
+    }
+  })
+}
+
+/**
+ * 清掉本轮没再见到的行 —— 源侧文件删了,缓存不该无限长大。
+ *
+ * ★ 按 `scanned_at` 判定而不是传一份「见过的路径」清单:一轮扫描上千条路径,
+ * 拼进 `NOT IN (...)` 会撞上 SQLite 的变量上限,而时间戳比较没有这个问题。
+ */
+export function pruneImportScanCache(sourceId: string, scannedAt: number): number {
+  const result = stmt('DELETE FROM import_scan_cache WHERE source_id = ? AND scanned_at < ?')
+    .run(sourceId, scannedAt)
+  return Number(result.changes ?? 0)
+}
+
 /**
  * 把某个本地目标对应的全部映射切到新状态。
  *

src/main/db/schema.ts

@@ -834,6 +834,48 @@ CREATE TABLE usage_daily (
 CREATE INDEX usage_daily_by_day ON usage_daily (day);
 `
 
+/**
+ * 扫描缓存 —— 让「扫过但**没导入**」的转录也能跳过重读。
+ *
+ * ★ 存在的理由:changeToken 原先挂在 `import_mappings.meta` 上,而映射只有
+ * 导入过的会话才有。实测一台机器上 1063 个转录只有 47 条映射 —— 96% 的文件
+ * 每次扫描都要完整重读(Codex 那 1.6GB 读一遍约 5 秒,全程堵在主进程里)。
+ * 换句话说那个缓存对绝大多数人是不生效的。
+ *
+ * ★ 主键用**文件路径**不用 sessionId:sessionId 要解析完文件才知道
+ * (Codex 的文件名是 `rollout-*`,与会话 id 无关),而缓存的全部意义
+ * 就是在读文件之前决定「要不要读」。
+ *
+ * ★ `content_hash = ''` 表示这一行是**只读头部**得来的 —— 那种情况下
+ * `messages` 是下界而不是精确值。判据见 `service.ts` 的 `readChatMeta`:
+ * 没有映射的条目状态必然是 new,而 new 不需要哈希,所以那一趟全文读是白读的。
+ */
+const V21_IMPORT_SCAN_CACHE = `
+CREATE TABLE import_scan_cache (
+  source_id      TEXT NOT NULL,
+  -- 绝对路径。OpenCode 这类库内会话用 \`opencode.db#<id>\` 这种合成路径。
+  source_path    TEXT NOT NULL,
+  -- size:mtime。和源文件一比就知道整行能不能复用。
+  change_token   TEXT NOT NULL,
+  -- 解析出来的会话 id(去重与映射键都要用它)。
+  session_id     TEXT NOT NULL DEFAULT '',
+  -- '' = 只读了头部,没算过全文哈希。
+  content_hash   TEXT NOT NULL DEFAULT '',
+  cwd            TEXT NOT NULL DEFAULT '',
+  title          TEXT NOT NULL DEFAULT '',
+  model          TEXT NOT NULL DEFAULT '',
+  model_provider TEXT NOT NULL DEFAULT '',
+  -- partial = 1 时这是下界。
+  messages       INTEGER NOT NULL DEFAULT 0,
+  partial        INTEGER NOT NULL DEFAULT 0,
+  source_updated_at INTEGER NOT NULL DEFAULT 0,
+  scanned_at     INTEGER NOT NULL,
+  PRIMARY KEY (source_id, source_path)
+);
+-- 扫完一轮要按来源清掉本轮没再见到的行(源侧文件已删)
+CREATE INDEX import_scan_cache_by_source ON import_scan_cache (source_id, scanned_at);
+`
+
 export const MIGRATIONS: readonly Migration[] = [
   { version: 1, name: 'core', sql: V1_CORE },
   { version: 2, name: 'connections', sql: V2_CONNECTIONS },
@@ -857,4 +899,5 @@ export const MIGRATIONS: readonly Migration[] = [
   { version: 18, name: 'scheduled-tasks', sql: V18_SCHEDULED_TASKS }
   ,{ version: 19, name: 'plans-v2', sql: V19_PLANS_V2 }
   ,{ version: 20, name: 'usage-daily', sql: V20_USAGE_DAILY }
+  ,{ version: 21, name: 'import-scan-cache', sql: V21_IMPORT_SCAN_CACHE }
 ]

src/main/imports/__tests__/scan-head.test.ts

@@ -0,0 +1,124 @@
+/**
+ * 预览只读头部 —— **省下的必须只是时间,不能是结论**。
+ *
+ * 这套用例守的是一条很容易被优化顺手破坏的性质:扫描从「全文读」改成
+ * 「读前 1MiB」之后,一份**前 1MiB 全被单条巨型工具输出占满**的转录会解析出
+ * 0 条消息。而 0 条消息在两个扫描循环里都是终局判决 ——
+ * Claude 那边 `continue` 直接把它丢出预览,Codex 那边标成 incompatible。
+ * 两者都不抛异常、不记诊断,用户唯一能观察到的现象是「我那个会话不见了」。
+ *
+ * 实测语料里这种文件真实存在(单个 115MB 的 Codex 转录,前若干 MB 是一条
+ * 工具输出),所以这不是假想的边界。
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { IMPORT_LIMITS } from '../../../shared/domain/import'
+import { closeDatabase, openDatabase } from '../../db/index'
+import { store } from '../../state/store'
+import * as service from '../service'
+
+vi.mock('../../ipc/attachment', () => ({
+  uploadAttachment: (req: { mime: string }) => ({
+    id: 'att', scope: 'session', displayName: 'x', mime: req.mime,
+    size: 1, checksum: 'c', createdAt: 0, url: 'ncw://attachments/session/x/att.png'
+  })
+}))
+
+let dbDir = ''
+let sourceDir = ''
+let projectDir = ''
+
+beforeEach(() => {
+  closeDatabase()
+  dbDir = mkdtempSync(join(tmpdir(), 'ncw-head-db-'))
+  openDatabase(dbDir)
+  sourceDir = mkdtempSync(join(tmpdir(), 'ncw-head-cc-'))
+  projectDir = mkdtempSync(join(tmpdir(), 'ncw-head-proj-'))
+  mkdirSync(join(sourceDir, 'projects', 'encoded-proj'), { recursive: true })
+})
+
+afterEach(() => {
+  closeDatabase()
+  for (const dir of [dbDir, sourceDir, projectDir]) rmSync(dir, { recursive: true, force: true })
+})
+
+/**
+ * 一份「头重脚轻」的转录:第一条就是撑满头部预算的工具结果,
+ * 真正的对话记录全在它后面。
+ */
+function headHeavyTranscript(sessionId: string): string {
+  const filler = 'x'.repeat(IMPORT_LIMITS.scanHeadBytes + 512 * 1024)
+  return [
+    {
+      uuid: 'u0', parentUuid: null, type: 'user', cwd: projectDir, sessionId,
+      timestamp: '2025-01-01T00:00:00.000Z',
+      message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't0', content: filler, is_error: false }] }
+    },
+    {
+      uuid: 'u1', parentUuid: 'u0', type: 'user', cwd: projectDir, sessionId,
+      timestamp: '2025-01-01T00:00:01.000Z',
+      message: { role: 'user', content: '这条在头部预算之外' }
+    },
+    {
+      uuid: 'a1', parentUuid: 'u1', type: 'assistant',
+      timestamp: '2025-01-01T00:00:02.000Z',
+      message: { role: 'assistant', model: 'claude-sonnet-4-5', content: [{ type: 'text', text: '收到。' }] }
+    }
+  ].map((r) => JSON.stringify(r)).join('\n') + '\n'
+}
+
+function seed(sessionId: string, body: string): string {
+  writeFileSync(join(sourceDir, 'projects', 'encoded-proj', `${sessionId}.jsonl`), body)
+  const now = Date.now()
+  store.putImportSource({
+    sourceId: 'src-head', kind: 'claude-code', configDir: sourceDir, origin: 'user-picked',
+    syncEnabled: false, categories: ['chat', 'project'], projectKeys: [projectDir],
+    status: 'off', diagnostics: [], createdAt: now, updatedAt: now
+  })
+  return 'src-head'
+}
+
+async function chatItems(sourceId: string, requestId: string) {
+  const preview = await service.buildPreview(sourceId, requestId)
+  return service.previewItems({ previewId: preview.previewId, category: 'chat', offset: 0, limit: 50 }).items
+}
+
+describe('预览的头部读取', () => {
+  it('★★ 前 1MiB 全是一条巨型工具输出时,会话依然出现在预览里', async () => {
+    const sourceId = seed('sess-head-heavy', headHeavyTranscript('sess-head-heavy'))
+    const items = await chatItems(sourceId, 'head-heavy')
+
+    /*
+      没有那条回退的话,这里拿到的是空数组 —— 而且整个流程一声不吭。
+      断言写成「至少一条」而不是精确条数,是因为这里要守的是
+      「不会被静默丢掉」,不是编码器的具体产出。
+    */
+    expect(items).toHaveLength(1)
+    expect(items[0]?.count).toBeGreaterThan(0)
+  })
+
+  it('★ 回退读的是全文,所以条数是准的,不标近似', async () => {
+    const sourceId = seed('sess-exact', headHeavyTranscript('sess-exact'))
+    const items = await chatItems(sourceId, 'exact')
+
+    /*
+      ★ 先断言长度。少了这一句,下面那条在 items 为空时会**真空通过**
+      (`items[0]?.x` 对空数组同样是 undefined)—— 摘掉回退跑一遍就会发现
+      它照样是绿的,那种用例什么都守不住。
+    */
+    expect(items).toHaveLength(1)
+    // 头部没解析出消息 → 回退 parseAll → partial 为假 → 不该打近似标记。
+    expect(items[0]?.countApproximate).toBeUndefined()
+  })
+
+  it('★ 真正的空会话仍然被挡在预览之外 —— 回退不是「什么都放进来」', async () => {
+    const empty = JSON.stringify({
+      uuid: 'm1', parentUuid: null, type: 'summary', cwd: projectDir,
+      sessionId: 'sess-empty', timestamp: '2025-01-01T00:00:00.000Z', summary: '只有摘要没有对话'
+    }) + '\n'
+    const sourceId = seed('sess-empty', empty)
+    expect(await chatItems(sourceId, 'empty')).toHaveLength(0)
+  })
+})

src/main/imports/claude-code.ts

@@ -23,7 +23,7 @@
  * 里那张 projects 表),目录名只当**索引键**用。
  */
 import { createReadStream } from 'node:fs'
-import { readdir, readFile, realpath, stat } from 'node:fs/promises'
+import { open, readdir, readFile, realpath, stat } from 'node:fs/promises'
 import { createInterface } from 'node:readline'
 import { createHash } from 'node:crypto'
 import { homedir } from 'node:os'
@@ -179,6 +179,43 @@ export async function readTranscriptLines(
   return { lines, diagnostics }
 }
 
+/**
+ * 只读一份转录的**开头**。
+ *
+ * ★ 为什么够用:扫描要的是 `cwd` / `title` / `model` / `sessionId`,它们都在
+ * 转录的头几条记录里;而全文读一遍只多产出两样东西 —— 精确的消息数和
+ * `contentHash`。哈希**只在这个会话已经导入过**时才有人看(`statusOfChat`
+ * 里没有映射直接就是 new),那是少数。实测一台机器上 1063 个转录里
+ * 只有 47 个导入过,为另外 96% 读满 2GB 是白读。
+ *
+ * ★ 末尾那一行**必须丢掉**:按字节截断几乎总会把最后一行切在半中间,
+ * 而半条 JSON 喂给 `JSON.parse` 会变成一条「文件损坏」诊断 —— 答非所问。
+ * 整个文件都读完了(`complete`)时它是完整的,那时才留。
+ */
+export async function readTranscriptHead(
+  path: string,
+  maxBytes: number
+): Promise<{ lines: string[]; complete: boolean }> {
+  const info = await stat(path)
+  const want = Math.min(maxBytes, info.size)
+  const handle = await open(path, 'r')
+  try {
+    const buffer = Buffer.alloc(want)
+    let filled = 0
+    while (filled < want) {
+      const { bytesRead } = await handle.read(buffer, filled, want - filled, filled)
+      if (bytesRead === 0) break
+      filled += bytesRead
+    }
+    const complete = filled >= info.size
+    const lines = buffer.subarray(0, filled).toString('utf8').split('\n')
+    if (!complete) lines.pop()
+    return { lines: lines.filter((line) => line !== ''), complete }
+  } finally {
+    await handle.close()
+  }
+}
+
 // ─── 项目与转录枚举 ───────────────────────────────────────────────────────
 
 export interface TranscriptFile {