dsh-account-pool 0.1.0

package/lib/accounts.js

@@ -0,0 +1,576 @@
+/**
+ * WorkBuddy 多账号凭据层。
+ *
+ * 职责：
+ *   - 用 OAuth 设备流把多个账号登录进来，凭证落盘到 $DSH_HOME/.account-pool.<region>.json
+ *   - 每个账号独立刷新 token（到期前 5 分钟），刷新结果写回自己的副本
+ *   - 对外只暴露「账号列表 + 取某个账号的可用 token」两个动作
+ *
+ * 设计要点：
+ *   - 按区域（cn / global）分文件存，两个区域的账号互不覆盖，可同时在线
+ *   - 落盘权限 0600；写入先写临时文件再 rename，避免半截文件
+ *   - 刷新按账号去重（single-flight），并发请求不会同时刷同一个账号
+ *   - 刷新失败但原 token 未过期时继续沿用旧 token，不因一次网络抖动踢掉账号
+ */
+
+import { readFile, writeFile, rename, mkdir, rm } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { dirname, join } from 'node:path'
+import { commonHeaders as baseHeaders } from './headers.js'
+
+// ---------------------------------------------------------------------------
+// 上游常量
+// ---------------------------------------------------------------------------
+
+/** 国内版网关。 */
+const CN_BASE = 'https://copilot.tencent.com'
+/** 国际版网关（桌面端登录域）。 */
+const GLOBAL_BASE = 'https://www.workbuddy.ai'
+/** 国际版备用品牌域（CodeBuddy CLI 登录域）。 */
+const GLOBAL_CB_BASE = 'https://www.codebuddy.ai'
+/** 国内版 Origin/Referer。 */
+const CN_ORIGIN = 'https://www.codebuddy.cn'
+
+/** token 到期前多久就提前刷新。 */
+const REFRESH_MARGIN_MS = 5 * 60 * 1000
+
+/** 单次 JSON 请求超时。 */
+const JSON_TIMEOUT_MS = 30_000
+
+/** 凭据文件格式版本；将来结构变了靠它做迁移。 */
+const FILE_VERSION = 1
+
+/** 临时文件名序号：保证并发写入时各自的临时文件互不冲突。 */
+let tmpSeq = 0
+
+// ---------------------------------------------------------------------------
+// 区域与网关选择
+// ---------------------------------------------------------------------------
+
+/**
+ * 登录域属于哪个区域。
+ * workbuddy.ai / codebuddy.ai 都是国际版（同一套网关，两个品牌域）；
+ * 其余（含空）按国内版处理。
+ */
+export function regionOf(domain) {
+  const d = String(domain ?? '').trim().toLowerCase()
+  if (d === 'workbuddy.ai' || d.endsWith('.workbuddy.ai')) return 'global'
+  if (d === 'codebuddy.ai' || d.endsWith('.codebuddy.ai')) return 'global'
+  return 'cn'
+}
+
+/** 该账号的 chat 上游基地址。国际版必须跟随凭据自己的域，两个域不通用。 */
+export function chatBaseOf(domain) {
+  if (regionOf(domain) !== 'global') return CN_BASE
+  return String(domain).trim().toLowerCase().endsWith('codebuddy.ai') ? GLOBAL_CB_BASE : GLOBAL_BASE
+}
+
+/** 该账号请求要带的 Origin/Referer 基地址。 */
+export function originOf(domain) {
+  return regionOf(domain) === 'global' ? chatBaseOf(domain) : CN_ORIGIN
+}
+
+/**
+ * 稳定账号 id：优先 uin（计费身份，重新登录也不变），退化到 uid。
+ * 只取前 24 位十六进制，够用且便于展示。
+ */
+export function accountIdOf(credential) {
+  const stable = credential.uin || credential.uid || credential.nickname || 'unknown'
+  return createHash('sha256').update(`workbuddy\0${stable}`).digest('hex').slice(0, 24)
+}
+
+// ---------------------------------------------------------------------------
+// HTTP 小工具
+// ---------------------------------------------------------------------------
+
+/** 上游统一信封 {code,msg,data}：code!==0 视为业务失败。 */
+async function postJson(url, { headers, body, method = 'POST' } = {}) {
+  const response = await fetch(url, {
+    method,
+    headers: { 'content-type': 'application/json', ...headers },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(JSON_TIMEOUT_MS),
+  })
+  const text = await response.text()
+  let parsed
+  try {
+    parsed = JSON.parse(text)
+  } catch {
+    throw new Error(`上游返回非 JSON（HTTP ${response.status}）：${text.slice(0, 200)}`)
+  }
+  return { status: response.status, envelope: parsed }
+}
+
+/** 上游通用请求头（不含 Authorization）。 */
+/**
+ * 本模块的请求头：在共享头基础上加账号维度。
+ * uid 决定设备头，区域决定 Accept-Language。
+ */
+function commonHeaders(origin, credential) {
+  return baseHeaders({
+    origin,
+    region: credential?.region ?? 'cn',
+    uid: credential?.uid,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// OAuth 设备授权登录
+// ---------------------------------------------------------------------------
+
+/**
+ * 第一步：申请一个授权 URL 与 state。
+ * 用户拿这个 URL 去浏览器登录，插件轮询等待完成。
+ */
+export async function startDeviceLogin(region) {
+  const base = region === 'global' ? GLOBAL_BASE : CN_BASE
+  const origin = region === 'global' ? GLOBAL_BASE : CN_ORIGIN
+  const { envelope } = await postJson(`${base}/v2/plugin/auth/state?platform=CLI`, {
+    headers: commonHeaders(origin),
+    body: {},
+  })
+  if (envelope.code !== 0) throw new Error(`申请授权失败：code=${envelope.code} ${envelope.msg ?? ''}`)
+  const { state, authUrl } = envelope.data ?? {}
+  if (!state || !authUrl) throw new Error('上游未返回 state 或 authUrl')
+  return { state, authUrl }
+}
+
+/**
+ * 第二步：轮询换 token。
+ * 返回 {pending:true} 表示用户还没在浏览器里完成授权；
+ * 完成时返回完整凭证。
+ */
+export async function pollDeviceLogin(region, state) {
+  const base = region === 'global' ? GLOBAL_BASE : CN_BASE
+  const origin = region === 'global' ? GLOBAL_BASE : CN_ORIGIN
+  const headers = commonHeaders(origin, { region })
+
+  const tokenResult = await postJson(`${base}/v2/plugin/auth/token?state=${encodeURIComponent(state)}`, {
+    headers,
+    method: 'GET',
+  })
+  const env = tokenResult.envelope
+
+  // code 11217 = "login ing"，是未完成的正常响应，不是错误。
+  if (env.code === 11217 || env.code !== 0) {
+    if (tokenResult.status === 0 || tokenResult.status >= 500) {
+      throw new Error(`token 端点异常：HTTP ${tokenResult.status} ${env.msg ?? ''}`)
+    }
+    return { pending: true }
+  }
+
+  const tok = env.data ?? {}
+  if (!tok.accessToken) return { pending: true }
+
+  // 拿账号资料（uid / nickname）。失败不阻塞登录——资料只是展示用。
+  let account = {}
+  try {
+    const acct = await postJson(`${base}/v2/plugin/login/account?state=${encodeURIComponent(state)}`, {
+      headers: { ...headers, authorization: `Bearer ${tok.accessToken}` },
+      method: 'GET',
+    })
+    account = acct.envelope.data ?? {}
+  } catch {
+    // 忽略：uid 缺失时下面会退化到用 domain+nickname 做 id
+  }
+
+  return {
+    pending: false,
+    credential: normalizeCredential({
+      accessToken: tok.accessToken,
+      refreshToken: tok.refreshToken,
+      expiresInSec: tok.expiresIn,
+      domain: tok.domain,
+      uid: account.uid,
+      enterpriseId: account.enterpriseId,
+      nickname: account.nickname,
+      issuedAtMs: Date.now(),
+    }),
+  }
+}
+
+/** 把上游登录/刷新返回值归一成内部凭证结构（时间统一为 epoch 毫秒）。 */
+/**
+ * 解析 refresh token 的到期时刻。
+ *
+ * 上游给的是相对秒数 `refreshExpiresIn`（实测约 60 天），所以要用签发时刻
+ * 换算；某些来源可能直接给绝对时间戳，也一并兼容。
+ */
+function refreshExpiresAtOf(raw, issuedAtMs) {
+  const relative = Number(raw.refreshExpiresIn ?? raw.refresh_expires_in)
+  if (Number.isFinite(relative) && relative > 0) {
+    return issuedAtMs + relative * 1000
+  }
+  const absolute = Number(raw.refreshExpiresAtMs ?? raw.refreshExpiresAt)
+  if (Number.isFinite(absolute) && absolute > 0) {
+    return absolute < 1e12 ? absolute * 1000 : absolute
+  }
+  return undefined
+}
+
+export function normalizeCredential(raw) {
+  const expiresInSec = Number(raw.expiresInSec ?? raw.expires_in ?? 3600)
+  const issuedAtMs = Number(raw.issuedAtMs ?? Date.now())
+  const domain = String(raw.domain ?? '')
+  const credential = {
+    accessToken: String(raw.accessToken ?? ''),
+    refreshToken: String(raw.refreshToken ?? ''),
+    domain,
+    uid: String(raw.uid ?? ''),
+    enterpriseId: raw.enterpriseId ? String(raw.enterpriseId) : undefined,
+    nickname: raw.nickname ? String(raw.nickname) : undefined,
+    uin: raw.uin ? String(raw.uin) : undefined,
+    region: regionOf(domain),
+    // 记「签发时刻」，而不是只记到期时刻——上游吊销 token 时不会改 expiresAt，
+    // 所以 expiresAt 不能用来判断新鲜度（参照项目在真机上踩过这个坑）。
+    issuedAtMs,
+    expiresAtMs: issuedAtMs + expiresInSec * 1000,
+    // refresh token 的到期时间。含义是「最晚什么时候还能换新 token」，
+    // 超过它账号就彻底作废、只能重新登录——所以保活必须赶在这之前。
+    // 实测上游给的是相对秒数 refreshExpiresIn（约 60 天），
+    // 不是绝对时间戳；两种形态都兼容。
+    refreshExpiresAtMs: refreshExpiresAtOf(raw, issuedAtMs),
+  }
+  credential.id = accountIdOf(credential)
+  return credential
+}
+
+// ---------------------------------------------------------------------------
+// token 刷新
+// ---------------------------------------------------------------------------
+
+/**
+ * 用 refresh token 换新的 access token。
+ * X-Refresh-Token 只在这里出现，chat 请求绝不带 refresh token（安全红线）。
+ * 该端点不吃 JSON body，凭证完全靠请求头传。
+ */
+export async function refreshCredential(credential) {
+  const base = chatBaseOf(credential.domain)
+  const origin = originOf(credential.domain)
+  const headers = {
+    ...commonHeaders(origin, credential),
+    'x-refresh-token': credential.refreshToken,
+    // 渠道标识对齐官方客户端 refresh 渠道（网关 headers.go 标注为 "plugin"）
+    'x-auth-refresh-source': 'plugin',
+  }
+  if (credential.enterpriseId) headers['x-enterprise-id'] = credential.enterpriseId
+
+  const { envelope } = await postJson(`${base}/v2/plugin/auth/token/refresh`, { headers, method: 'POST' })
+  if (envelope.code !== 0) throw new Error(`刷新失败：code=${envelope.code} ${envelope.msg ?? ''}`)
+
+  const data = envelope.data ?? {}
+  if (!data.accessToken) throw new Error('刷新响应缺少 accessToken')
+
+  return normalizeCredential({
+    accessToken: data.accessToken,
+    // 上游可能轮换 refresh token，没给就沿用旧的。
+    refreshToken: data.refreshToken || credential.refreshToken,
+    // 刷新响应给的是相对秒数 refreshExpiresIn。这里原样透传，
+    // 由 refreshExpiresAtOf 统一换算（不写死字段名，避免又对不上）。
+    refreshExpiresIn: data.refreshExpiresIn ?? data.refresh_expires_in,
+    expiresInSec: data.expiresIn,
+    domain: data.domain || credential.domain,
+    uid: credential.uid,
+    enterpriseId: credential.enterpriseId,
+    nickname: credential.nickname,
+    uin: credential.uin,
+    issuedAtMs: Date.now(),
+  })
+}
+
+// ---------------------------------------------------------------------------
+// 凭据库
+// ---------------------------------------------------------------------------
+
+/**
+ * 一个区域一份的凭据库。
+ * 所有方法都是「读文件 → 改 → 原子写回」，进程内并发由调用方串行化。
+ */
+export class CredentialStore {
+  /**
+   * @param {object} options
+   * @param {string} options.dshHome  DSH 主目录
+   * @param {'cn'|'global'} options.region 本库负责的区域
+   */
+  constructor({ dshHome, region }) {
+    this.dshHome = dshHome
+    this.region = region
+    this.file = join(dshHome, `.account-pool.${region}.json`)
+    /**
+     * 历史位置的只读迁移来源，按优先级排列。
+     *
+     * 1. 旧位置（DSH 主目录的上一级）：更早版本用
+     *    `process.env.DSH_HOME ?? process.cwd()` 取路径，宿主里 DSH_HOME
+     *    常常没设，凭证会落到上一级。
+     * 2. 旧文件名：插件早期叫 workbuddy-pool，凭证是
+     *    `.workbuddy-pool.<region>.json`。改名后必须还能读到，
+     *    否则已登录的账号会"消失"。
+     *
+     * 只读：一旦有写入就落到新路径，旧文件不再更新。
+     */
+    this.legacyFiles = [
+      join(dirname(dshHome), `.account-pool.${region}.json`),
+      join(dshHome, `.workbuddy-pool.${region}.json`),
+      join(dirname(dshHome), `.workbuddy-pool.${region}.json`),
+    ]
+    /** 每个账号一把刷新锁，避免并发重复刷新。 */
+    this.refreshLocks = new Map()
+    /**
+     * 写操作串行队列。
+     *
+     * read→改→write 不是原子操作；并发调用会互相覆盖，而且多个写入
+     * 共用同一个 .tmp 文件名会直接踩踏（实测报 rename ENOENT）。
+     * 这里把写操作排成一队，一个完成再开始下一个。
+     */
+    this.writeQueue = Promise.resolve()
+  }
+
+  /**
+   * 把一次「读-改-写」排进串行队列。
+   * @param {(doc:object) => (void|Promise<void>)} mutate 拿到文档后的修改动作
+   */
+  enqueueWrite(mutate) {
+    const run = this.writeQueue.then(async () => {
+      const doc = await this.read()
+      await mutate(doc)
+      await this.write(doc)
+    })
+    // 队列本身不能因为某次失败而断掉，否则后续写永远卡住
+    this.writeQueue = run.catch(() => {})
+    return run
+  }
+
+  /**
+   * 读整份文件；不存在或损坏时返回空结构（不抛错，避免拖垮插件启动）。
+   * 新位置读不到时依次回落到历史位置与历史文件名——
+   * 见构造函数里 legacyFiles 的说明。
+   */
+  async read() {
+    for (const path of [this.file, ...this.legacyFiles]) {
+      try {
+        const raw = await readFile(path, 'utf8')
+        const doc = JSON.parse(raw)
+        if (doc?.version === FILE_VERSION && typeof doc.accounts === 'object') {
+          return doc
+        }
+      } catch {
+        // 该位置不存在或损坏，试下一个
+      }
+    }
+    return { version: FILE_VERSION, accounts: {} }
+  }
+
+  /** 原子写回：先写 .tmp 再 rename，权限 0600。 */
+  async write(doc) {
+    await mkdir(dirname(this.file), { recursive: true })
+    // 临时文件名加进程内唯一后缀：即使有绕过队列的写入路径，
+    // 也不会互相踩踏（这是实测 rename ENOENT 的直接原因）。
+    const tmp = `${this.file}.${process.pid}.${++tmpSeq}.tmp`
+    await writeFile(tmp, JSON.stringify(doc, null, 2), { encoding: 'utf8', mode: 0o600 })
+    await rename(tmp, this.file)
+  }
+
+  /** 可选账号列表（不含 token，只给界面用）。 */
+  async list() {
+    const doc = await this.read()
+    return Object.values(doc.accounts).map(credential => ({
+      id: credential.id,
+      nickname: credential.nickname ?? credential.uid ?? credential.id.slice(0, 8),
+      uid: credential.uid,
+      domain: credential.domain,
+      region: credential.region,
+      expiresAtMs: credential.expiresAtMs,
+      issuedAtMs: credential.issuedAtMs,
+    }))
+  }
+
+  /** 保存（新增或覆盖）一个账号。经串行队列，避免并发写互相覆盖。 */
+  async save(credential) {
+    await this.enqueueWrite(doc => {
+      doc.accounts[credential.id] = credential
+    })
+    return credential
+  }
+
+  /** 删除一个账号。经串行队列。 */
+  async remove(accountId) {
+    let removed = false
+    await this.enqueueWrite(doc => {
+      if (doc.accounts[accountId] !== undefined) {
+        delete doc.accounts[accountId]
+        removed = true
+      }
+    })
+    return removed
+  }
+
+  /** 读单个账号原始凭证（不刷新）。 */
+  async get(accountId) {
+    const doc = await this.read()
+    return doc.accounts[accountId]
+  }
+
+  /**
+   * 取一个账号「现在能用的」凭证：快到期就刷新，刷新失败但还没过期就沿用旧的。
+   * 刷新按账号去重——同一账号并发调用只发一次刷新请求。
+   *
+   * @throws 当账号不存在、或已过期且刷新失败
+   */
+  async usable(accountId) {
+    const credential = await this.get(accountId)
+    if (credential === undefined) throw new Error(`账号不存在：${accountId}`)
+
+    const now = Date.now()
+    const needsRefresh = credential.expiresAtMs - now < REFRESH_MARGIN_MS
+    if (!needsRefresh) return credential
+
+    // single-flight：同一账号的并发刷新合并成一次。
+    const existing = this.refreshLocks.get(accountId)
+    if (existing !== undefined) return existing
+
+    const task = (async () => {
+      try {
+        const fresh = await refreshCredential(credential)
+        await this.save(fresh)
+        return fresh
+      } catch (error) {
+        // 刷新失败但 token 还没真过期 → 继续用旧的，别因为一次抖动把账号判死。
+        if (credential.expiresAtMs > Date.now()) return credential
+        throw new Error(`账号 ${credential.nickname ?? accountId} 已过期且刷新失败：${error.message}`)
+      } finally {
+        this.refreshLocks.delete(accountId)
+      }
+    })()
+
+    this.refreshLocks.set(accountId, task)
+    return task
+  }
+
+  /**
+   * 保活：把「快要失去刷新能力」的账号提前刷一遍。
+   *
+   * 为什么需要它：插件原先只在**有请求**时才刷新。若长时间没人用，
+   * access token 会过期——这还能靠 refresh token 救回；但如果闲置到
+   * refresh token 也过期，账号就彻底作废，只能重新登录。
+   * 后台定期调用本方法，把两个到期时间都往后推，避免这种情况。
+   *
+   * @param {number} [maxIdleDays] access token 剩余天数低于它才刷（默认 7）
+   * @returns {Promise<{refreshed:number, failed:number, skipped:number}>}
+   */
+  async keepAlive(maxIdleDays = 7) {
+    const thresholdMs = maxIdleDays * 24 * 3600 * 1000
+    const result = { refreshed: 0, failed: 0, skipped: 0 }
+    for (const account of await this.list()) {
+      const record = await this.get(account.id)
+      if (record === undefined) continue
+      // 剩余充足就跳过，避免无谓打上游。
+      if (record.expiresAtMs - Date.now() > thresholdMs) {
+        result.skipped += 1
+        continue
+      }
+      try {
+        const fresh = await refreshCredential(record)
+        await this.save(fresh)
+        result.refreshed += 1
+      } catch {
+        result.failed += 1
+      }
+    }
+    return result
+  }
+}
+
+/** 打开一个区域的凭据库。 */
+export function openStore(dshHome, region) {
+  return new CredentialStore({ dshHome, region })
+}
+
+/** 清空一个区域的凭据（登出全部账号）。 */
+export async function clearStore(dshHome, region) {
+  await rm(join(dshHome, `.account-pool.${region}.json`), { force: true })
+}
+
+// ---------------------------------------------------------------------------
+// auth 文件导入
+// ---------------------------------------------------------------------------
+
+/**
+ * 解析一份 auth 文件（网关 auths/*.json 或手写文件），支持两种形态：
+ *
+ *   嵌套形（网关与官方客户端落盘的格式）：
+ *     { "auth": { "accessToken", "refreshToken", "expiresAt", "domain", "realm" },
+ *       "account": { "uid", "enterpriseId", "nickname" },
+ *       "device_token": "..." }
+ *
+ *   扁平形（手写方便）：
+ *     { "accessToken", "refreshToken", "expiresAt", "domain", "realm",
+ *       "uid", "enterpriseId", "nickname", "device_token" }
+ *
+ * 时间单位要注意：auth 文件的 expiresAt 是 **Unix 秒**，而插件内部统一用毫秒。
+ * 这里做兼容——数值小于 1e12 视为秒（1e12 秒是公元 33658 年，不可能出现）。
+ *
+ * @param {string|object} input JSON 文本或已解析对象
+ * @param {string} [source] 来源说明（文件名），仅用于报错信息
+ * @returns {object} 归一化后的凭证
+ * @throws 缺少 accessToken 时抛错
+ */
+export function parseAuthFile(input, source = '') {
+  let doc
+  if (typeof input === 'string') {
+    try {
+      doc = JSON.parse(input)
+    } catch (error) {
+      throw new Error(`${source ? source + '：' : ''}不是合法 JSON（${error.message}）`)
+    }
+  } else {
+    doc = input
+  }
+  if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) {
+    throw new Error(`${source ? source + '：' : ''}顶层必须是 JSON 对象`)
+  }
+
+  // 嵌套形与扁平形取同一组字段，只是来源层级不同。
+  const nested = doc.auth !== null && typeof doc.auth === 'object' && !Array.isArray(doc.auth)
+  const auth = nested ? doc.auth : doc
+  const account = nested && doc.account !== null && typeof doc.account === 'object' ? doc.account : doc
+
+  const accessToken = String(auth.accessToken ?? '').trim()
+  if (accessToken === '') {
+    throw new Error(`${source ? source + '：' : ''}缺少 accessToken`)
+  }
+
+  const domain = String(auth.domain ?? '').trim()
+
+  // expiresAt：兼容秒与毫秒；都没有就按「从现在起 1 小时」保守估计，
+  // 反正下次使用时会走刷新。
+  const rawExpires = Number(auth.expiresAt ?? auth.expires_at ?? 0)
+  let expiresAtMs
+  if (Number.isFinite(rawExpires) && rawExpires > 0) {
+    expiresAtMs = rawExpires < 1e12 ? rawExpires * 1000 : rawExpires
+  } else {
+    expiresAtMs = Date.now() + 3600_000
+  }
+
+  // realm 显式给了就用；否则按 domain 推断。
+  const explicitRealm = String(auth.realm ?? doc.realm ?? '').trim().toLowerCase()
+  const region = explicitRealm === 'global' || explicitRealm === 'cn'
+    ? explicitRealm
+    : regionOf(domain)
+
+  const credential = {
+    accessToken,
+    refreshToken: String(auth.refreshToken ?? '').trim(),
+    domain,
+    uid: String(account.uid ?? '').trim(),
+    enterpriseId: account.enterpriseId ? String(account.enterpriseId) : undefined,
+    nickname: account.nickname ? String(account.nickname) : undefined,
+    uin: account.uin ? String(account.uin) : undefined,
+    region,
+    // 签发时刻未知：用「到期时刻减去一小时」的保守估计，
+    // 这样紧接着就会被判为需要刷新，拿到真实签发时间。
+    issuedAtMs: Math.min(Date.now(), expiresAtMs - 3600_000),
+    expiresAtMs,
+  }
+  credential.id = accountIdOf(credential)
+  return credential
+}