@2api-store/activate 0.5.1 → 0.6.0

package/lib/api.mjs

@@ -1,184 +0,0 @@
-import https from 'node:https'
-import http from 'node:http'
-
-const USER_AGENT = '@2api-store/activate/0.1.0'
-const DEFAULT_TIMEOUT_MS = 30000
-
-/**
- * 发送 POST /api/v1/cli/activate 请求
- * @param {{credential: string, email?: string, platform?: string, group_id?: number, apiBase: string}} opts
- * @returns {Promise<object>} 解析后的 JSON 响应
- */
-export function cliActivate({ credential, email, platform, groupId, apiBase }) {
-  return new Promise((resolve, reject) => {
-    let url
-    try {
-      url = new URL('/api/v1/cli/activate', apiBase)
-    } catch (err) {
-      reject(new Error(`无效的 apiBase：${apiBase}（${err.message}）`))
-      return
-    }
-
-    const lib = url.protocol === 'https:' ? https : http
-    const payload = {
-      credential,
-      ...(email ? { email } : {}),
-      ...(platform ? { platform } : {}),
-      ...(groupId ? { group_id: groupId } : {}),
-    }
-    const body = JSON.stringify(payload)
-
-    const req = lib.request(
-      url,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body),
-          'User-Agent': USER_AGENT,
-        },
-        timeout: DEFAULT_TIMEOUT_MS,
-      },
-      (res) => {
-        const chunks = []
-        res.on('data', (c) => chunks.push(c))
-        res.on('end', () => {
-          const text = Buffer.concat(chunks).toString('utf8')
-          let json
-          try {
-            json = text ? JSON.parse(text) : {}
-          } catch {
-            const err = new Error(`响应非 JSON（HTTP ${res.statusCode}）：${text.slice(0, 200)}`)
-            err.statusCode = res.statusCode
-            err.raw = text
-            reject(err)
-            return
-          }
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resolve(json)
-          } else {
-            const errObj = json?.error
-            const msg = (errObj && typeof errObj === 'object' ? errObj.message : errObj) || json?.message || `HTTP ${res.statusCode}`
-            const err = new Error(msg)
-            err.statusCode = res.statusCode
-            err.body = json
-            reject(err)
-          }
-        })
-      },
-    )
-
-    req.on('timeout', () => {
-      req.destroy(new Error(`请求超时（${DEFAULT_TIMEOUT_MS / 1000}s）— ${url.href}`))
-    })
-    req.on('error', reject)
-    req.write(body)
-    req.end()
-  })
-}
-
-/**
- * 获取可用分组列表：GET /api/v1/cli/groups
- * 兑换码模式（balance 类型码无 group_id）CLI 选组用。
- * @param {{apiBase: string}} opts
- * @returns {Promise<Array<{id: number, name: string}>>} 分组列表（精简，仅 id+name）
- */
-export function listGroups({ apiBase }) {
-  return new Promise((resolve, reject) => {
-    let url
-    try {
-      url = new URL('/api/v1/cli/groups', apiBase)
-    } catch (err) {
-      reject(new Error(`无效的 apiBase：${apiBase}（${err.message}）`))
-      return
-    }
-
-    const lib = url.protocol === 'https:' ? https : http
-    const req = lib.request(
-      url,
-      {
-        method: 'GET',
-        headers: {
-          'User-Agent': USER_AGENT,
-          Accept: 'application/json',
-        },
-        timeout: DEFAULT_TIMEOUT_MS,
-      },
-      (res) => {
-        const chunks = []
-        res.on('data', (c) => chunks.push(c))
-        res.on('end', () => {
-          const text = Buffer.concat(chunks).toString('utf8')
-          let json
-          try {
-            json = text ? JSON.parse(text) : {}
-          } catch {
-            // 响应非 JSON，退化为空列表（CLI 兜底）
-            resolve([])
-            return
-          }
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            // 后端返回 {groups: [{id,name}]}；兼容直接返回数组的形式
-            const arr = Array.isArray(json) ? json : json?.groups
-            resolve(Array.isArray(arr) ? arr : [])
-          } else {
-            // 失败退化：返回空列表（不阻塞激活主流程，让用户看到「无组可选」提示）
-            resolve([])
-          }
-        })
-      },
-    )
-
-    req.on('timeout', () => {
-      req.destroy(new Error(`请求超时（${DEFAULT_TIMEOUT_MS / 1000}s）— ${url.href}`))
-    })
-    req.on('error', (err) => {
-      // 网络错误同样退化为空列表（CLI 兜底）
-      resolve([])
-    })
-    req.end()
-  })
-}
-
-/**
- * 验证 API Key：GET {baseUrl}/v1/models（Bearer api_key），期望 200
- * @param {{apiKey: string, baseUrl: string}} opts
- * @returns {Promise<{ok: boolean, statusCode?: number, error?: string}>}
- */
-export function verifyApiKey({ apiKey, baseUrl }) {
-  return new Promise((resolve) => {
-    let url
-    try {
-      url = new URL('/v1/models', baseUrl)
-    } catch {
-      resolve({ ok: false, error: `无效的 baseUrl：${baseUrl}` })
-      return
-    }
-    const lib = url.protocol === 'https:' ? https : http
-    const req = lib.request(
-      url,
-      {
-        method: 'GET',
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          'User-Agent': USER_AGENT,
-        },
-        timeout: 15000,
-      },
-      (res) => {
-        const chunks = []
-        res.on('data', (c) => chunks.push(c))
-        res.on('end', () => {
-          const ok = res.statusCode >= 200 && res.statusCode < 300
-          resolve({ ok, statusCode: res.statusCode })
-        })
-      },
-    )
-    req.on('timeout', () => {
-      req.destroy()
-      resolve({ ok: false, error: '验证请求超时（15s）' })
-    })
-    req.on('error', (err) => resolve({ ok: false, error: err.message }))
-    req.end()
-  })
-}

package/lib/backup.mjs

@@ -1,109 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-/**
- * 备份目标文件到同目录 .bak.<ISO时间戳>（非覆盖，保留多次）。
- *
- * 行为（spec §5.4）：
- *   - 文件不存在 → 返回 null（跳过备份）
- *   - 文件存在且备份成功 → 返回备份路径
- *   - 文件存在但备份失败 → 抛错（调用方应中止写入，避免无备份覆盖）
- *
- * @param {string} targetPath 目标文件绝对路径
- * @returns {string|null} 备份路径，或 null（文件不存在）
- * @throws {Error} 文件存在但 copyFileSync 失败
- */
-export function backupFile(targetPath) {
-  let exists = false
-  try {
-    exists = fs.existsSync(targetPath)
-  } catch {
-    // 无法检查存在性（权限等）— 视为不存在，best effort
-    return null
-  }
-  if (!exists) return null
-
-  // ISO 时间戳，文件名安全化（: 和 . 替换为 -）
-  const ts = new Date().toISOString().replace(/[:.]/g, '-')
-  const backupPath = `${targetPath}.bak.${ts}`
-
-  // copyFileSync 失败会抛出 — 调用方知道文件存在且备份失败
-  fs.copyFileSync(targetPath, backupPath)
-  return backupPath
-}
-
-/**
- * 扫描多个目录下所有 .bak.<timestamp> 备份文件，按修改时间倒序排列。
- *
- * 文件名格式约定：<original>.bak.<ISO时间戳>（backupFile 写入）。
- *
- * @param {string[]} dirs 要扫描的目录绝对路径列表
- * @returns {Array<{bakPath: string, origPath: string, mtime: number, dir: string, file: string, origName: string, size: number}>}
- *   按修改时间倒序（最新在前）
- */
-export function listBackups(dirs) {
-  const backups = []
-  for (const dir of dirs) {
-    if (!dir) continue
-    let entries
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true })
-    } catch {
-      // 目录不存在或权限不足 — 跳过
-      continue
-    }
-    for (const entry of entries) {
-      if (!entry.isFile()) continue
-      // 匹配 <filename>.bak.<timestamp>（timestamp 含 T Z - 数字）
-      const match = entry.name.match(/^(.+)\.bak\.[\dTZ:-]+$/)
-      if (!match) continue
-      const origName = match[1]
-      const bakPath = path.join(dir, entry.name)
-      const origPath = path.join(dir, origName)
-      try {
-        const stat = fs.statSync(bakPath)
-        backups.push({
-          bakPath,
-          origPath,
-          mtime: stat.mtimeMs,
-          dir,
-          file: entry.name,
-          origName,
-          size: stat.size,
-        })
-      } catch {
-        // stat 失败 — 跳过
-      }
-    }
-  }
-  // 修改时间倒序（最新在前）
-  backups.sort((a, b) => b.mtime - a.mtime)
-  return backups
-}
-
-/**
- * 从备份恢复（复制回原文件，覆盖当前）。
- *
- * 行为：
- *   - 备份文件不存在 → 抛错（调用方应预先校验）
- *   - 目标父目录不存在 → 自动 mkdir
- *   - 恢复后保留备份文件（不删，多次恢复可用）
- *
- * @param {string} bakPath 备份文件绝对路径
- * @param {string} origPath 原文件目标绝对路径
- * @returns {string} origPath（恢复后的路径）
- * @throws {Error} 备份文件不存在或复制失败
- */
-export function restoreBackup(bakPath, origPath) {
-  if (!fs.existsSync(bakPath)) {
-    throw new Error(`备份文件不存在：${bakPath}`)
-  }
-  const dir = path.dirname(origPath)
-  try {
-    fs.mkdirSync(dir, { recursive: true })
-  } catch {
-    // 父目录已存在或创建失败忽略（copyFileSync 会再报）
-  }
-  fs.copyFileSync(bakPath, origPath)
-  return origPath
-}