linke-cli 0.1.0 → 0.2.0

package/README.md

@@ -10,19 +10,25 @@ skill 说明书（`skills/linke/SKILL.md`），一条命令装入 agent 的 skil
 
 ```bash
 npm install -g linke-cli   # 或 npx linke-cli <命令>
-linke config               # 交互式录入学号/密码（输入不回显）
+linke login                # 首选配置：本机起登录页，自动打开浏览器（手机填写加 --qr）
 linke schedule             # 直接用，登录全自动
 ```
 
 要求 Node.js ≥ 18.14，零运行时依赖。
 
+`linke login` 的登录页由本机 CLI 提供（仅绑 127.0.0.1 随机端口，页面
+随 npm 包分发可审计）；`--qr` 模式额外在终端展示局域网 URL 二维码
+（含一次性令牌，用后即失效），手机同 Wi-Fi 扫码填写。凭据只落本机，
+不经任何云端。`linke config` 保留为非 TTY / SSH 场景的终端兜底。
+
 ## 命令
 
 | 命令 | 说明 |
 |---|---|
-| `linke config [--clear]` | 录入/清除教务凭据（存 `~/.linke-cli/config.json`，权限 600） |
+| `linke login [--qr]` | 网页配置凭据（首选）；`--qr` 出局域网二维码供手机填写 |
+| `linke config [--clear]` | 终端录入/清除凭据（非 TTY 兜底；存 `~/.linke-cli/`，权限 600） |
+| `linke verify` | 验证已存凭据（自动登录教务并显示身份） |
 | `linke status` | 配置与会话状态（JSON） |
-| `linke login` | 强制重登（平时自动，排障用） |
 | `linke scores [--term 2025-2026-1]` | 成绩（缺省全部学期，JSON） |
 | `linke schedule [--term ...] [--week 3]` | 课表（缺省当前学期全部周，JSON） |
 | `linke schools` | 列出学校适配器 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linke-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "林课 CLI：把山财教务能力（课表/成绩只读查询）封装为本机命令行工具，供用户 agent 通过 shell 调用。登录请求从本机直发教务系统，验证码识别调用林课云端无状态 OCR 接口。",
   "type": "module",
   "bin": {

package/skills/linke/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: linke
-version: 0.1.0
+version: 0.2.0
 description: "林课教务查询 CLI（山东财经大学正方教务）：查课表、查成绩、看教务登录状态。当用户问「我这学期课表」「今天有什么课」「我的成绩/绩点」「挂了什么课」「教务登录状态」等教务只读信息时使用。登录全自动（验证码云端识别），无需用户介入。"
 metadata:
   requires:
@@ -20,8 +20,9 @@ linke status
 ```
 
 - `configured: false` → 用户还没配置凭据。**引导用户本人**在终端运行
-  `linke config`（交互式录入学号密码，输入不回显）。**你不代输密码、
-  不把密码写进任何命令**——凭据只经用户本人的终端进入 `~/.linke-cli/`。
+  `linke login`（本机起登录页并自动打开浏览器，手机填写加 `--qr` 出
+  局域网二维码；凭据只存本机 `~/.linke-cli/`）。**你不代输密码、
+  不把密码写进任何命令**——凭据只经用户本人的网页/终端进入本机。
 - `configured: true` 即可用，无需关心登录：每个命令内置鉴权状态机，
   session 过期自动重登，只有凭据失效才需要人介入。
 
@@ -29,13 +30,15 @@ linke status
 
 | 需求 | 命令 |
 |---|---|
+| 配置凭据（用户本人执行） | `linke login`（网页输入；`--qr` 手机扫码填写） |
+| 终端配置（非 TTY / SSH 兜底） | `linke config` |
+| 验证已存凭据 | `linke verify` |
 | 本学期课表（全部周） | `linke schedule` |
 | 指定学期课表 | `linke schedule --term 2025-2026-1` |
 | 单周课表 | `linke schedule --week 3` |
 | 全部成绩 | `linke scores` |
 | 指定学期成绩 | `linke scores --term 2025-2026-1` |
 | 登录/配置状态 | `linke status` |
-| 强制重登（排障用） | `linke login` |
 
 ## 输出契约
 
@@ -53,11 +56,11 @@ linke status
 | exit code | 含义 | 你的动作 |
 |---|---|---|
 | 0 | 成功 | 解析 stdout |
-| 2 | 凭据失效（教务报密码错误） | 引导用户本人重新运行 `linke config`，不要自行重试 |
+| 2 | 凭据失效（教务报密码错误） | 引导用户本人重新运行 `linke login`，不要自行重试 |
 | 3 | 验证码自动识别连续未通过 | 直接重试一次同一命令；仍失败告知用户稍后再试 |
 | 4 | 网络不可达（教务或云端识别） | 告知用户检查网络后重试 |
 | 5 | 解析失败（教务页面改版） | 告知用户到 linke-cli 仓库提 issue，不要反复重试 |
-| 6 | 未配置凭据 | 引导用户本人运行 `linke config` |
+| 6 | 未配置凭据 | 引导用户本人运行 `linke login`（网页输入；SSH 场景 `linke config`） |
 
 stderr 末行「提示:」是面向用户的自救说明，可直接转述。
 
@@ -68,7 +71,8 @@ stderr 末行「提示:」是面向用户的自救说明，可直接转述。
    不要尝试用任何方式绕过。
 2. **凭据纪律**：密码只存在于用户本机 `~/.linke-cli/`（权限 600）。
    不询问、不存储、不转发用户密码；需要录入时只引导用户本人跑
-   `linke config`。
+   `linke login`（或 SSH 场景 `linke config`）。`linke login` 起的
+   网页服务只绑本机/局域网且带一次性令牌，凭据不经过任何云端。
 3. **频次纪律**：教务系统对高频请求有风控，连续查询之间保持间隔，
    不做轮询；一次问答内同一命令不重复执行超过 2 次。
 4. 数据口径：成绩/课表数据实时来自教务系统，如与预期不符先用

package/src/bin.js

@@ -15,20 +15,25 @@ import {
 import { installSkill, skillSourceDir } from './skill.js'
 import { ask, askPassword } from './prompt.js'
 import { emitJson, progress } from './util.js'
+import { startLoginServer } from './loginserver.js'
+import { buildQr, renderTerminal } from './qr.js'
+import { exec } from 'node:child_process'
 
 const USAGE = `linke —— 林课教务 CLI（只读查询，供 agent / 人类使用）
 
 用法:
-  linke config [--school sdufe] [--api-base URL]   交互式录入学号/密码（存 ~/.linke-cli/，权限 600）
-  linke config --clear                             清除本机凭据
-  linke status                                     配置与教务会话状态（JSON）
-  linke login                                      强制重新登录（状态机平时自动做）
-  linke scores [--term 2025-2026-1]                成绩查询（缺省=全部学期）
-  linke schedule [--term 2025-2026-1] [--week 3]   课表查询（缺省=当前学期全部周）
-  linke schools                                    列出可用学校适配器
-  linke skill install [--path ~/.agents/skills]    安装 agent skill 说明书
-  linke logout                                     清除本机教务 session（保留凭据）
-  linke help                                       本帮助
+  linke login [--qr]                                   网页配置凭据（首选）：本机起登录页自动开浏览器；
+                                                       --qr 额外展示局域网二维码，手机同 Wi-Fi 填写
+  linke config [--school sdufe] [--api-base URL]       终端录入凭据（非 TTY / SSH 兜底）
+  linke config --clear                                 清除本机凭据
+  linke verify                                         验证已存凭据（自动登录教务并显示身份）
+  linke status                                         配置与教务会话状态（JSON）
+  linke scores [--term 2025-2026-1]                    成绩查询（缺省=全部学期）
+  linke schedule [--term 2025-2026-1] [--week 3]       课表查询（缺省=当前学期全部周）
+  linke schools                                        列出可用学校适配器
+  linke skill install [--path ~/.agents/skills]        安装 agent skill 说明书
+  linke logout                                         清除本机教务 session（保留凭据）
+  linke help                                           本帮助
 
 说明:
   登录请求从本机直发教务系统；验证码图片仅用于云端识别（传图返文字）。
@@ -90,7 +95,7 @@ async function cmdConfig(flags) {
   }
   saveConfig({ school, userId, password, apiBase })
   clearSession() // 凭据变更后旧 session 一律作废
-  progress(`已保存到 ~/.linke-cli/config.json（权限 600）。运行 linke login 验证，或直接运行任意查询命令。`)
+  progress(`已保存到 ~/.linke-cli/config.json（权限 600）。建议运行 linke verify 验证凭据，或直接运行任意查询命令。`)
   return 0
 }
 
@@ -112,7 +117,62 @@ async function cmdStatus() {
   return 0
 }
 
-async function cmdLogin() {
+function openBrowser(url) {
+  const platform = process.platform
+  const cmd =
+    platform === 'darwin' ? `open ${JSON.stringify(url)}` :
+    platform === 'win32' ? `start "" ${JSON.stringify(url)}` :
+    `xdg-open ${JSON.stringify(url)}`
+  exec(cmd, () => {}) // 打开失败不致命：终端已打印 URL
+}
+
+async function cmdLogin(flags) {
+  const qr = flags.qr === true
+  let settle
+  const submitted = new Promise((resolve) => {
+    settle = resolve
+  })
+  const handle = await startLoginServer({ qr, onSubmit: settle })
+  progress('登录页已就绪（5 分钟内有效，成功或超时后自动关闭）')
+  progress(`本机访问: ${handle.urls.local}`)
+  if (qr && handle.urls.lan.length > 0) {
+    progress('局域网访问（含一次性令牌，勿转发他人）:')
+    for (const lan of handle.urls.lan) {
+      progress(`  ${lan}`)
+      const { modules } = buildQr(Buffer.from(lan, 'utf8'))
+      process.stderr.write('\n' + renderTerminal(modules, 2) + '\n\n')
+    }
+  } else if (qr) {
+    progress('未探测到局域网 IPv4 地址，二维码不可用（本机访问不受影响）')
+  } else {
+    progress('提示：手机填写请改用 linke login --qr（展示局域网二维码）')
+  }
+  progress('正在打开浏览器...')
+  openBrowser(handle.urls.local)
+  process.on('SIGINT', () => {
+    handle.close()
+    progress('已取消，凭据未保存')
+    process.exit(130)
+  })
+
+  const result = await submitted
+  if (!result.ok) {
+    progress('超时未提交，凭据未保存；可重新运行 linke login')
+    return 1
+  }
+  progress(`凭据已保存（学号 ${result.userId}），正在验证教务登录...`)
+  // 复用 verify 逻辑：网页配置后立即做一次真实登录验证。
+  // 验证失败不影响已保存的凭据（多为验证码偶发），提示后以非零码退出。
+  try {
+    return await cmdVerify()
+  } catch (err) {
+    progress(`凭据已保存，但本次自动验证未通过：${err.message || err}`)
+    progress('稍后运行任意查询命令（如 linke scores）会自动重试登录')
+    return err instanceof LinkeError ? err.exitCode : 1
+  }
+}
+
+async function cmdVerify() {
   const config = requireConfig()
   const adapter = getAdapter(config.school)
   const session = await forceLogin(adapter, config)
@@ -198,7 +258,9 @@ async function dispatch(argv) {
     case 'status':
       return cmdStatus()
     case 'login':
-      return cmdLogin()
+      return cmdLogin(flags)
+    case 'verify':
+      return cmdVerify()
     case 'scores':
       return cmdScores(flags)
     case 'schedule':

package/src/loginserver.js

@@ -0,0 +1,182 @@
+/**
+ * 本地登录服务（T6）：`linke login` 在用户本机起内置登录页。
+ *
+ * 安全口径（T6 验收 1-4）：
+ * - 本地模式仅绑 127.0.0.1 随机端口；二维码模式（--qr）绑 0.0.0.0
+ *   供局域网手机访问，URL 强制携带一次性令牌；
+ * - 令牌一次性：提交成功（无论凭据是否有效）立即失效；
+ * - 凭据只经 POST /submit 进入本进程 → saveConfig 落盘（0600），
+ *   不写任何日志、不打印；
+ * - Host 头必须是 IP 字面量（防 DNS rebinding）；Origin 头存在时
+ *   必须同源（防跨站提交）；页面为随包分发的静态文件（可审计），
+ *   不从云端拉取任何内容；
+ * - 服务在提交成功或超时（默认 5 分钟）后自动关闭。
+ */
+import http from 'node:http'
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { saveConfig, DEFAULT_SCHOOL, DEFAULT_API_BASE } from './config.js'
+import { clearSession } from './session.js'
+
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000
+const MAX_BODY_BYTES = 64 * 1024
+
+function loginPageHtml() {
+  const here = path.dirname(fileURLToPath(import.meta.url))
+  return fs.readFileSync(path.join(here, 'web', 'login.html'), 'utf8')
+}
+
+/** 枚举本机局域网 IPv4（排除回环/内网虚拟网段由调用方展示时全列） */
+export function lanAddresses() {
+  const result = []
+  const interfaces = os.networkInterfaces()
+  for (const name of Object.keys(interfaces)) {
+    for (const info of interfaces[name] || []) {
+      if (info.family !== 'IPv4' || info.internal) continue
+      result.push({ name, address: info.address })
+    }
+  }
+  return result
+}
+
+function isIpLiteralHost(host) {
+  const hostname = String(host || '').split(':')[0]
+  if (!hostname) return false
+  return /^(\d{1,3}\.){3}\d{1,3}$/.test(hostname) || hostname === '[::1]' || hostname === '::1'
+}
+
+/**
+ * 起本地登录服务。
+ * @param {object} options
+ * @param {boolean} options.qr 二维码模式：绑 0.0.0.0（含 127.0.0.1）；默认仅 127.0.0.1
+ * @param {(result: {ok: boolean, userId?: string, error?: string}) => void} options.onSubmit 凭据落盘回调
+ * @param {number} options.timeoutMs 超时自动关闭
+ * @returns {Promise<{server, port, token, urls: {local: string, lan: string[]}, close: () => void}>}
+ */
+export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, onSubmit } = {}) {
+  return new Promise((resolve, reject) => {
+    const token = crypto.randomBytes(16).toString('hex')
+    const pageHtml = loginPageHtml()
+    let tokenUsed = false
+    let closed = false
+
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, 'http://placeholder')
+      const sendJson = (status, payload) => {
+        res.writeHead(status, { 'Content-Type': 'application/json;charset=utf-8' })
+        res.end(JSON.stringify(payload))
+      }
+
+      // 防 DNS rebinding：Host 必须是 IP 字面量
+      if (!isIpLiteralHost(req.headers.host)) {
+        sendJson(403, { ok: false, error: '非法 Host' })
+        return
+      }
+
+      if (req.method === 'GET' && url.pathname === '/') {
+        if (tokenUsed || url.searchParams.get('t') !== token) {
+          res.writeHead(403, { 'Content-Type': 'text/html;charset=utf-8' })
+          res.end('<meta charset="utf-8"><p>链接无效或已使用：请回到终端重新运行 linke login。</p>')
+          return
+        }
+        res.writeHead(200, { 'Content-Type': 'text/html;charset=utf-8' })
+        res.end(pageHtml)
+        return
+      }
+
+      if (req.method === 'POST' && url.pathname === '/submit') {
+        // 防 CSRF：浏览器提交必带 Origin，存在则必须同源
+        const origin = req.headers.origin
+        if (origin) {
+          const host = req.headers.host
+          if (origin !== `http://${host}`) {
+            sendJson(403, { ok: false, error: '非法来源' })
+            return
+          }
+        }
+        const chunks = []
+        let size = 0
+        req.on('data', (chunk) => {
+          size += chunk.length
+          if (size > MAX_BODY_BYTES) {
+            req.destroy()
+            return
+          }
+          chunks.push(chunk)
+        })
+        req.on('end', () => {
+          if (tokenUsed) {
+            sendJson(403, { ok: false, error: '令牌已使用，请重新运行 linke login' })
+            return
+          }
+          let body
+          try {
+            body = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+          } catch {
+            sendJson(400, { ok: false, error: '请求体不是合法 JSON' })
+            return
+          }
+          if (body.token !== token) {
+            sendJson(403, { ok: false, error: '令牌错误' })
+            return
+          }
+          const userId = String(body.userId || '').trim()
+          const password = String(body.password || '')
+          if (!userId || !password) {
+            sendJson(400, { ok: false, error: '学号与密码均不能为空' })
+            return
+          }
+          // 令牌一次性：无论后续结果如何，本令牌立即作废
+          tokenUsed = true
+          saveConfig({
+            school: DEFAULT_SCHOOL,
+            userId,
+            password,
+            apiBase: DEFAULT_API_BASE,
+          })
+          clearSession() // 凭据变更后旧 session 作废
+          // 注意：此处不打印/记录 body 任何内容（凭据红线）
+          sendJson(200, { ok: true })
+          onSubmit && onSubmit({ ok: true, userId })
+          closeServer()
+        })
+        return
+      }
+
+      sendJson(404, { ok: false, error: 'Not Found' })
+    })
+
+    const closeServer = () => {
+      if (closed) return
+      closed = true
+      clearTimeout(timeoutHandle)
+      // keep-alive 空闲连接会阻止 close 生效，强制断开
+      if (typeof server.closeAllConnections === 'function') server.closeAllConnections()
+      server.close()
+    }
+
+    const timeoutHandle = setTimeout(() => {
+      closeServer()
+      onSubmit && onSubmit({ ok: false, error: 'timeout' })
+    }, timeoutMs)
+
+    server.on('error', reject)
+    server.listen(0, qr ? '0.0.0.0' : '127.0.0.1', () => {
+      const port = server.address().port
+      const urls = {
+        local: `http://127.0.0.1:${port}/?t=${token}`,
+        lan: qr ? lanAddresses().map((i) => `http://${i.address}:${port}/?t=${token}`) : [],
+      }
+      resolve({
+        server,
+        port,
+        token,
+        urls,
+        close: closeServer,
+      })
+    })
+  })
+}

package/src/qr.js

@@ -0,0 +1,390 @@
+/**
+ * 精简 QR Code 编码器（Model 2，byte mode，纠错级 L，version 1-6）。
+ * 为守住「零依赖」架构决策（T3）手写实现：局域网 URL ≈ 60-100 字节，
+ * v6-L 容量 136 字节已覆盖；version ≤ 6 无需 version info 块，复杂度可控。
+ *
+ * 结构：
+ *   buildQr(bytes) → { size, modules }（布尔矩阵，true=黑）
+ *   renderTerminal(matrix, quietZone) → 终端半块字符文本
+ *
+ * 正确性由 test/qr.test.mjs 与系统 qrencode 逐模块对拍保障。
+ */
+
+// ---- version 参数表（L 级）----
+// blocks: [ [totalCodewords, dataCodewords], ... ] 每块
+const VERSION_PARAMS = {
+  1: { size: 21, blocks: [[26, 19]] },
+  2: { size: 25, blocks: [[44, 34]] },
+  3: { size: 29, blocks: [[70, 55]] },
+  4: { size: 33, blocks: [[100, 80]] },
+  5: { size: 37, blocks: [[134, 108]] },
+  6: { size: 41, blocks: [[86, 68], [86, 68]] },
+}
+
+// alignment pattern 中心坐标候选（仅右下角组合不与 finder 重叠，v2-6）
+const ALIGN_POS = { 1: [], 2: [6, 18], 3: [6, 22], 4: [6, 26], 5: [6, 30], 6: [6, 34] }
+
+// ---- GF(256)，本原多项式 0x11d ----
+const GF_EXP = new Uint8Array(512)
+const GF_LOG = new Uint8Array(256)
+;(function buildGf() {
+  let x = 1
+  for (let i = 0; i < 255; i++) {
+    GF_EXP[i] = x
+    GF_LOG[x] = i
+    x <<= 1
+    if (x & 0x100) x ^= 0x11d
+  }
+  for (let i = 255; i < 512; i++) GF_EXP[i] = GF_EXP[i - 255]
+})()
+
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]]
+}
+
+/** RS 生成多项式 g(x) = ∏(x - α^i)，系数最高次在前 */
+function rsGeneratorPoly(degree) {
+  let poly = [1]
+  for (let i = 0; i < degree; i++) {
+    const next = new Array(poly.length + 1).fill(0)
+    for (let j = 0; j < poly.length; j++) {
+      next[j] ^= poly[j]
+      next[j + 1] ^= gfMul(poly[j], GF_EXP[i])
+    }
+    poly = next
+  }
+  return poly
+}
+
+/** 求数据多项式的 RS 纠错码字（systematic 编码） */
+function rsEncode(data, ecLen) {
+  const gen = rsGeneratorPoly(ecLen)
+  const rem = new Array(data.length + ecLen).fill(0)
+  for (let i = 0; i < data.length; i++) rem[i] = data[i]
+  for (let i = 0; i < data.length; i++) {
+    const factor = rem[i]
+    if (factor === 0) continue
+    for (let j = 0; j < gen.length; j++) {
+      rem[i + j] ^= gfMul(gen[j], factor)
+    }
+  }
+  return rem.slice(data.length)
+}
+
+// ---- 数据位流 ----
+
+/** 按最小可用 version 编码为总码字流（含块交织）；导出供测试分层验证 */
+export function encodeCodewords(bytes) {
+  const len = bytes.length
+  let version = 0
+  for (let v = 1; v <= 6; v++) {
+    const dataCap = VERSION_PARAMS[v].blocks.reduce((sum, [t, d]) => sum + d, 0)
+    // byte mode 头部开销：mode 4bit + 计数 8bit
+    if (len + 2 <= dataCap) {
+      version = v
+      break
+    }
+  }
+  if (!version) {
+    throw new Error(`内容过长（${len} 字节），超出 v6-L 容量`)
+  }
+  const { blocks } = VERSION_PARAMS[version]
+  const dataCap = blocks.reduce((sum, [t, d]) => sum + d, 0)
+
+  // 位流：mode(0100) + 8bit 计数 + 数据 + 终止符 + 填充
+  const bits = []
+  const push = (value, count) => {
+    for (let i = count - 1; i >= 0; i--) bits.push((value >> i) & 1)
+  }
+  push(0b0100, 4)
+  push(len, 8)
+  for (const byte of bytes) push(byte, 8)
+  const capacityBits = dataCap * 8
+  push(0, Math.min(4, capacityBits - bits.length))
+  while (bits.length % 8 !== 0) bits.push(0)
+  const stream = []
+  for (let i = 0; i < bits.length; i += 8) {
+    let byte = 0
+    for (let j = 0; j < 8; j++) byte = (byte << 1) | bits[i + j]
+    stream.push(byte)
+  }
+  const padBytes = [0xec, 0x11]
+  let padIdx = 0
+  while (stream.length < dataCap) stream.push(padBytes[padIdx++ % 2])
+
+  // 分块 + 各块纠错 + 交织（数据列优先，纠错随后）
+  const dataBlocks = []
+  const ecBlocks = []
+  let offset = 0
+  for (const [, dataLen] of blocks) {
+    const chunk = stream.slice(offset, offset + dataLen)
+    offset += dataLen
+    dataBlocks.push(chunk)
+    ecBlocks.push(rsEncode(chunk, blocks[0][0] - blocks[0][1]))
+  }
+  const maxData = Math.max(...dataBlocks.map((b) => b.length))
+  const maxEc = Math.max(...ecBlocks.map((b) => b.length))
+  const codewords = []
+  for (let i = 0; i < maxData; i++) {
+    for (const block of dataBlocks) if (i < block.length) codewords.push(block[i])
+  }
+  for (let i = 0; i < maxEc; i++) {
+    for (const block of ecBlocks) if (i < block.length) codewords.push(block[i])
+  }
+  return { version, codewords }
+}
+
+// ---- 矩阵 ----
+
+function makeMatrices(size) {
+  const modules = Array.from({ length: size }, () => new Array(size).fill(false))
+  const reserved = Array.from({ length: size }, () => new Array(size).fill(false))
+  return { modules, reserved }
+}
+
+function reserveFinder(modules, reserved, row, col) {
+  for (let r = -1; r <= 7; r++) {
+    for (let c = -1; c <= 7; c++) {
+      const rr = row + r
+      const cc = col + c
+      if (rr < 0 || rr >= modules.length || cc < 0 || cc >= modules.length) continue
+      const inRing =
+        (r >= 0 && r <= 6 && (c === 0 || c === 6)) ||
+        (c >= 0 && c <= 6 && (r === 0 || r === 6)) ||
+        (r >= 2 && r <= 4 && c >= 2 && c <= 4)
+      modules[rr][cc] = inRing
+      reserved[rr][cc] = true
+    }
+  }
+}
+
+function reserveAlignment(modules, reserved, centers, size) {
+  for (const [row, col] of centers) {
+    for (let r = -2; r <= 2; r++) {
+      for (let c = -2; c <= 2; c++) {
+        const rr = row + r
+        const cc = col + c
+        if (rr < 0 || rr >= size || cc < 0 || cc >= size) continue
+        if (reserved[rr][cc]) continue
+        const isRing = Math.max(Math.abs(r), Math.abs(c)) !== 1
+        modules[rr][cc] = isRing
+        reserved[rr][cc] = true
+      }
+    }
+  }
+}
+
+/** format info 的两份副本共 30 个固定位置（值由 placeFormat 填充） */
+function formatPositions(size) {
+  return [
+    [8, 0], [8, 1], [8, 2], [8, 3], [8, 4], [8, 5], [8, 7], [8, 8],
+    [7, 8], [5, 8], [4, 8], [3, 8], [2, 8], [1, 8], [0, 8],
+    [size - 1, 8], [size - 2, 8], [size - 3, 8], [size - 4, 8],
+    [size - 5, 8], [size - 6, 8], [size - 7, 8],
+    [8, size - 8], [8, size - 7], [8, size - 6], [8, size - 5], [8, size - 4],
+    [8, size - 3], [8, size - 2], [8, size - 1],
+  ]
+}
+
+function buildFunctionPatterns(version) {
+  const { size } = VERSION_PARAMS[version]
+  const { modules, reserved } = makeMatrices(size)
+  // finder + separator（三个角）
+  reserveFinder(modules, reserved, 0, 0)
+  reserveFinder(modules, reserved, 0, size - 7)
+  reserveFinder(modules, reserved, size - 7, 0)
+  // timing
+  for (let i = 8; i < size - 8; i++) {
+    modules[6][i] = i % 2 === 0
+    reserved[6][i] = true
+    modules[i][6] = i % 2 === 0
+    reserved[i][6] = true
+  }
+  // alignment（跳过与 finder 保留区重叠的组合——v2-6 实际仅右下一个）
+  const centers = []
+  const pos = ALIGN_POS[version]
+  for (const r of pos) {
+    for (const c of pos) {
+      if (reserved[r] && reserved[r][c]) continue
+      centers.push([r, c])
+    }
+  }
+  reserveAlignment(modules, reserved, centers, size)
+  // format info 区预留（数据放置须跳过，值由 placeFormat 填充）
+  for (const [r, c] of formatPositions(size)) reserved[r][c] = true
+  // dark module
+  modules[4 * version + 9][8] = true
+  reserved[4 * version + 9][8] = true
+  return { modules, reserved }
+}
+
+const MASK_FUNCS = [
+  (r, c) => (r + c) % 2 === 0,
+  (r) => r % 2 === 0,
+  (r, c) => c % 3 === 0,
+  (r, c) => (r + c) % 3 === 0,
+  (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+  (r, c) => ((r * c) % 2) + ((r * c) % 3) === 0,
+  (r, c) => (((r * c) % 2) + ((r * c) % 3)) % 2 === 0,
+  (r, c) => (((r + c) % 2) + ((r * c) % 3)) % 2 === 0,
+]
+
+/** 把码字按蛇形顺序放置并用 mask 翻转（功能模块不动） */
+function placeData(modules, reserved, codewords, maskFn) {
+  const size = modules.length
+  const bits = []
+  for (const byte of codewords) {
+    for (let i = 7; i >= 0; i--) bits.push((byte >> i) & 1)
+  }
+  let bitIdx = 0
+  const takeBit = () => (bitIdx < bits.length ? bits[bitIdx++] : 0)
+  let col = size - 1
+  let upward = true
+  while (col > 0) {
+    if (col === 6) col -= 1
+    for (let i = 0; i < size; i++) {
+      const row = upward ? size - 1 - i : i
+      for (const cc of [col, col - 1]) {
+        if (reserved[row][cc]) continue
+        let bit = takeBit()
+        if (maskFn(row, cc)) bit ^= 1
+        modules[row][cc] = bit === 1
+      }
+    }
+    col -= 2
+    upward = !upward
+  }
+  return modules
+}
+
+/** BCH(15,5) 计算 format 信息（未异或 mask 前的 15 bit） */
+function formatBits(mask) {
+  const data = (0b01 << 3) | mask // L = 01
+  let rem = data
+  for (let i = 0; i < 10; i++) {
+    rem = (rem << 1) ^ ((rem >> 9) * 0x537)
+  }
+  return ((data << 10) | (rem & 0x3ff)) ^ 0x5412
+}
+
+function placeFormat(modules, mask) {
+  const size = modules.length
+  const bits = formatBits(mask)
+  const bitAt = (i) => ((bits >> i) & 1) === 1 // i: 14..0
+  const seq = formatPositions(size)
+  seq.forEach(([r, c], idx) => {
+    modules[r][c] = bitAt(idx < 15 ? 14 - idx : 14 - (idx - 15))
+  })
+}
+
+// ---- penalty（标准 4 规则，用于选最优掩码）----
+
+function penaltyFor(modules) {
+  const size = modules.length
+  let penalty = 0
+
+  // N1/N3：行、列两个方向
+  for (const horizontal of [true, false]) {
+    for (let i = 0; i < size; i++) {
+      let run = 1
+      const cells = []
+      for (let j = 0; j < size; j++) {
+        cells.push(horizontal ? modules[i][j] : modules[j][i])
+      }
+      for (let j = 1; j < size; j++) {
+        if (cells[j] === cells[j - 1]) run++
+        else {
+          if (run >= 5) penalty += 3 + (run - 5)
+          run = 1
+        }
+      }
+      if (run >= 5) penalty += 3 + (run - 5)
+      const line = cells.map((v) => (v ? '1' : '0')).join('')
+      let from = 0
+      while (true) {
+        const idx1 = line.indexOf('10111010000', from)
+        const idx2 = line.indexOf('00001011101', from)
+        if (idx1 === -1 && idx2 === -1) break
+        penalty += 40
+        from = (idx1 === -1 ? idx2 : idx1) + 1
+      }
+    }
+  }
+
+  // N2：2×2 同色块
+  for (let r = 0; r < size - 1; r++) {
+    for (let c = 0; c < size - 1; c++) {
+      if (
+        modules[r][c] === modules[r][c + 1] &&
+        modules[r][c] === modules[r + 1][c] &&
+        modules[r][c] === modules[r + 1][c + 1]
+      ) {
+        penalty += 3
+      }
+    }
+  }
+
+  // N4：暗模块比例偏离 50%
+  let dark = 0
+  for (const row of modules) for (const v of row) if (v) dark++
+  const percent = (dark * 100) / (size * size)
+  penalty += Math.floor(Math.abs(percent - 50) / 5) * 10
+  return penalty
+}
+
+/**
+ * 编码入口：返回带掩码的完整矩阵。
+ * @param {Uint8Array|number[]} bytes byte mode 内容
+ */
+export function buildQr(bytes) {
+  const { version, codewords } = encodeCodewords(Array.from(bytes))
+  let best = null
+  let bestPenalty = Infinity
+  let bestMask = 0
+  for (let mask = 0; mask < 8; mask++) {
+    const { modules, reserved } = buildFunctionPatterns(version)
+    placeData(modules, reserved, codewords, MASK_FUNCS[mask])
+    placeFormat(modules, mask)
+    const penalty = penaltyFor(modules)
+    if (penalty < bestPenalty) {
+      bestPenalty = penalty
+      best = modules
+      bestMask = mask
+    }
+  }
+  return { size: best.length, modules: best, mask: bestMask, version }
+}
+
+/** 按指定掩码构建（测试对拍用） */
+export function buildQrWithMask(bytes, mask) {
+  const { version, codewords } = encodeCodewords(Array.from(bytes))
+  const { modules, reserved } = buildFunctionPatterns(version)
+  placeData(modules, reserved, codewords, MASK_FUNCS[mask])
+  placeFormat(modules, mask)
+  return { size: modules.length, modules, mask, version }
+}
+
+/** 终端渲染：半块字符，每字符 1 模块宽 × 2 模块高，含 quiet zone */
+export function renderTerminal(matrix, quietZone = 4) {
+  const size = matrix.length
+  const total = size + quietZone * 2
+  const grid = Array.from({ length: total }, () => new Array(total).fill(false))
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) grid[r + quietZone][c + quietZone] = matrix[r][c]
+  }
+  const lines = []
+  for (let r = 0; r < total; r += 2) {
+    let line = ''
+    for (let c = 0; c < total; c++) {
+      const top = grid[r][c]
+      const bottom = grid[r + 1] ? grid[r + 1][c] : false
+      if (top && bottom) line += '█'
+      else if (top) line += '▀'
+      else if (bottom) line += '▄'
+      else line += ' '
+    }
+    lines.push(line)
+  }
+  return lines.join('\n')
+}

package/src/web/login.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>linke · 教务账号配置</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0; min-height: 100vh; display: flex; align-items: center; justify-content: center;
+    font-family: -apple-system, "PingFang SC", "Microsoft YaHei", sans-serif;
+    background: #f5f6f8; color: #1f2328; padding: 24px;
+  }
+  @media (prefers-color-scheme: dark) { body { background: #14171a; color: #e2e6ea; } }
+  .card {
+    width: 100%; max-width: 380px; background: #fff; border-radius: 12px;
+    padding: 28px 24px; box-shadow: 0 4px 24px rgba(0,0,0,.08);
+  }
+  @media (prefers-color-scheme: dark) { .card { background: #1d2126; } }
+  h1 { font-size: 18px; margin: 0 0 4px; }
+  .sub { font-size: 13px; color: #6a737d; margin-bottom: 20px; line-height: 1.6; }
+  @media (prefers-color-scheme: dark) { .sub { color: #9aa4af; } }
+  label { display: block; font-size: 13px; margin: 14px 0 6px; }
+  input {
+    width: 100%; padding: 10px 12px; font-size: 16px; border: 1px solid #d0d7de;
+    border-radius: 8px; background: transparent; color: inherit;
+  }
+  @media (prefers-color-scheme: dark) { input { border-color: #3a4149; } }
+  input:focus { outline: 2px solid #4c8dff; border-color: transparent; }
+  button {
+    width: 100%; margin-top: 22px; padding: 11px; font-size: 15px; border: 0;
+    border-radius: 8px; background: #2da44e; color: #fff; cursor: pointer;
+  }
+  button:disabled { opacity: .6; cursor: default; }
+  .msg { margin-top: 16px; font-size: 13px; line-height: 1.7; display: none; }
+  .msg.ok { display: block; color: #1a7f37; }
+  .msg.err { display: block; color: #cf222e; }
+</style>
+</head>
+<body>
+  <main class="card">
+    <h1>林课 linke · 教务账号配置</h1>
+    <p class="sub">此页面由<strong>你本机的 linke CLI</strong> 提供，密码只保存在本机
+    （~/.linke-cli/，权限 600），不会发送到任何服务器。</p>
+    <form id="form">
+      <label for="userId">学号</label>
+      <input id="userId" name="userId" autocomplete="username" inputmode="numeric" required>
+      <label for="password">教务密码</label>
+      <input id="password" name="password" type="password" autocomplete="current-password" required>
+      <button id="btn" type="submit">保存到本机</button>
+    </form>
+    <p id="msg" class="msg"></p>
+  </main>
+<script>
+  const params = new URLSearchParams(location.search)
+  const token = params.get('t') || ''
+  const form = document.getElementById('form')
+  const btn = document.getElementById('btn')
+  const msg = document.getElementById('msg')
+  form.addEventListener('submit', async (e) => {
+    e.preventDefault()
+    msg.className = 'msg'
+    btn.disabled = true
+    btn.textContent = '保存中...'
+    try {
+      const res = await fetch('/submit', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          token,
+          userId: document.getElementById('userId').value.trim(),
+          password: document.getElementById('password').value
+        })
+      })
+      const data = await res.json()
+      if (data.ok) {
+        msg.className = 'msg ok'
+        msg.textContent = '已保存到本机 ~/.linke-cli/config.json（权限 600）。' +
+          '本页面服务已自动关闭，可以关闭此标签页；回到终端查看验证结果。'
+        form.style.display = 'none'
+      } else {
+        throw new Error(data.error || '保存失败')
+      }
+    } catch (err) {
+      msg.className = 'msg err'
+      msg.textContent = '保存失败：' + err.message + '。请回终端重新运行 linke login 后重试。'
+      btn.disabled = false
+      btn.textContent = '保存到本机'
+    }
+  })
+</script>
+</body>
+</html>