linke-cli 0.1.0 → 0.3.0

package/README.md

@@ -10,19 +10,28 @@ 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 包分发可审计）；**提交后在网页内完成教务登录验证**——验证中
+动效 → 结果回显（成功显示姓名与教学周，凭据此时才落盘 0600；密码错
+误页内提示并可重试，含教务锁号警示）。尝试上限 3 次、5 分钟超时，
+任一终结即自动关闭服务。`--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.3.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.3.0
 description: "林课教务查询 CLI（山东财经大学正方教务）：查课表、查成绩、看教务登录状态。当用户问「我这学期课表」「今天有什么课」「我的成绩/绩点」「挂了什么课」「教务登录状态」等教务只读信息时使用。登录全自动（验证码云端识别），无需用户介入。"
 metadata:
   requires:
@@ -20,8 +20,10 @@ linke status
 ```
 
 - `configured: false` → 用户还没配置凭据。**引导用户本人**在终端运行
-  `linke config`（交互式录入学号密码，输入不回显）。**你不代输密码、
-  不把密码写进任何命令**——凭据只经用户本人的终端进入 `~/.linke-cli/`。
+  `linke login`（本机起登录页并自动打开浏览器，手机填写加 `--qr` 出
+  局域网二维码；验证在网页内完成——通过才保存，失败页内重试，全程
+  无需看终端；凭据只存本机 `~/.linke-cli/`）。**你不代输密码、
+  不把密码写进任何命令**——凭据只经用户本人的网页/终端进入本机。
 - `configured: true` 即可用，无需关心登录：每个命令内置鉴权状态机，
   session 过期自动重登，只有凭据失效才需要人介入。
 
@@ -29,13 +31,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 +57,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 +72,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,131 @@ 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
+}
+
+function pickPrimaryLanUrl(urls) {
+  // 主网卡取舍：192.168.x 优先（家用路由常态），其次 10.x / 172.16-31.x
+  const score = (url) => {
+    if (url.includes('//192.168.')) return 0
+    if (url.includes('//10.')) return 1
+    if (/\/\/172\.(1[6-9]|2\d|3[01])\./.test(url)) return 2
+    return 3
+  }
+  return [...urls].sort((a, b) => score(a) - score(b))[0] || null
+}
+
+/**
+ * 验证回调工厂（T7 验收 8：复用 session 状态机的登录实现，不另写
+ * 登录路径）。凭据仅在验证通过后才落盘（0600 不变式），失败不留
+ * 半成品文件。导出供测试注入 fake 适配器验证分类与落盘纪律。
+ */
+export function createVerifyCredentials({ school = DEFAULT_SCHOOL, apiBase = DEFAULT_API_BASE } = {}) {
+  return async function verifyCredentials(userId, password) {
+    const config = { school, userId, password, apiBase }
+    const adapter = getAdapter(school)
+    try {
+      const session = await forceLogin(adapter, config) // 内部含 saveSession
+      saveConfig(config) // 验证通过才落盘
+      const info = session.userInfo || {}
+      return {
+        ok: true,
+        summary: {
+          name: info.name || '',
+          unit: info.unit || '',
+          weekNow: info.week ? info.week.now : '',
+          weekAll: info.week ? info.week.all : '',
+        },
+      }
+    } catch (err) {
+      if (err instanceof LinkeError && err.code === 'CREDENTIAL_INVALID') {
+        return { ok: false, kind: 'credential', message: err.message }
+      }
+      return { ok: false, kind: 'service', message: err.message || String(err) }
+    }
+  }
+}
+
+async function cmdLogin(flags) {
+  const qr = flags.qr === true
+  const verifyCredentials = createVerifyCredentials()
+
+  let terminalOutcome = 'closed'
+  const onEvent = (event) => {
+    switch (event.type) {
+      case 'submitted':
+        progress(`收到网页提交（第 ${event.attempts}/3 次尝试），正在验证教务登录...`)
+        break
+      case 'success': {
+        const s = event.summary || {}
+        const bits = [s.name, s.weekNow ? `第 ${s.weekNow} 周` : ''].filter(Boolean).join(' · ')
+        progress(`验证通过${bits ? `（${bits}）` : ''}`)
+        progress(`凭据已保存到 ~/.linke-cli/config.json（权限 600），session 已就绪`)
+        break
+      }
+      case 'credential-error':
+        progress(`教务返回密码错误${event.remaining > 0 ? `（剩余 ${event.remaining} 次尝试）` : ''}`)
+        break
+      case 'service-error':
+        progress(`验证服务异常：${event.message}${event.remaining > 0 ? `（剩余 ${event.remaining} 次尝试）` : ''}`)
+        break
+      case 'attempts-exhausted':
+        progress('已达尝试上限（3 次），登录服务关闭；请确认凭据后重新运行 linke login')
+        break
+      case 'timeout':
+        progress('超时未完成验证，凭据未保存；可重新运行 linke login')
+        break
+      default:
+        break
+    }
+    if (event.type === 'success') terminalOutcome = 'success'
+    if (event.type === 'timeout') terminalOutcome = 'timeout'
+    if (event.type === 'attempts-exhausted') terminalOutcome = 'exhausted'
+  }
+
+  const handle = await startLoginServer({ qr, verify: verifyCredentials, onEvent })
+  progress('登录页已就绪（提交后网页内完成验证；5 分钟超时，成功或达尝试上限后自动关闭）')
+  progress(`本机访问: ${handle.urls.local}`)
+  if (qr && handle.urls.lan.length > 0) {
+    progress('局域网访问（含会话令牌，勿转发他人）:')
+    for (const lan of handle.urls.lan) progress(`  ${lan}`)
+    const primary = pickPrimaryLanUrl(handle.urls.lan)
+    if (primary) {
+      const { modules } = buildQr(Buffer.from(primary, '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)
+  })
+
+  await handle.done
+  if (terminalOutcome === 'success') {
+    emitJson({ ok: true, outcome: 'success' })
+    return 0
+  }
+  if (terminalOutcome === 'exhausted') return 3 // 对齐 LOGIN_RETRY_EXHAUSTED 契约
+  if (terminalOutcome === 'timeout') return 1
+  // closed：页面未完成验证即被关闭（如令牌取走失败后的兜底收摊）
+  progress('登录服务已结束，凭据未保存；可重新运行 linke login')
+  return 1
+}
+
+async function cmdVerify() {
   const config = requireConfig()
   const adapter = getAdapter(config.school)
   const session = await forceLogin(adapter, config)
@@ -198,7 +327,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,293 @@
+/**
+ * 本地登录服务（T7：网页内验证闭环）：
+ *
+ * 流程：页面提交凭据 → 服务立即应答并进入「验证中」→ CLI 侧执行
+ * 完整教务登录验证（由 verify 回调注入，复用 session 状态机的登录
+ * 实现）→ 页面轮询 GET /result 获取结果 → 成功才由 verify 回调落盘。
+ *
+ * 令牌语义（T7 验收 3，会话化折中）：URL 令牌在会话内有效——
+ * 成功 / 超时 / 达尝试上限即失效。尝试上限默认 3 次（保守值：
+ * 教务锁定阈值无档案记录，按卡文口径取 3），既防本机令牌爆破，
+ * 更防教务系统因连续错密码锁定账号。
+ *
+ * 安全口径（T6 不回归）：Host 必须 IP 字面量（防 DNS rebinding）、
+ * Origin 存在须同源（防跨站）、POST/结果内容零日志；页面随包分发。
+ */
+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'
+
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000
+const MAX_BODY_BYTES = 64 * 1024
+const DEFAULT_MAX_ATTEMPTS = 3
+// 终结性结果（成功/上限耗尽）发出后留给页面的收尾窗口
+const RESULT_LINGER_MS = 10 * 1000
+
+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 {number} options.timeoutMs 超时自动关闭（会话最长时长）
+ * @param {number} options.maxAttempts 提交尝试上限（默认 3）
+ * @param {(userId: string, password: string) => Promise<{ok: true, summary: object} | {ok: false, kind: 'credential'|'service', message: string}>} options.verify
+ *   验证回调：执行完整教务登录验证；成功路径内完成凭据落盘（0600），
+ *   失败路径不得写任何凭据文件。kind 区分「凭据错误」（页内重试）
+ *   与「网络/识别服务失败」（稍后再试）。
+ * @param {(event: {type: string, [k: string]: any}) => void} options.onEvent
+ *   终端汇报事件：submitted / success / credential-error / service-error /
+ *   attempts-exhausted / timeout
+ * @returns {Promise<{server, port, token, urls, close: () => void, done: Promise<{type: string}>, attempts: () => number}>}
+ */
+export function startLoginServer({
+  qr = false,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  maxAttempts = DEFAULT_MAX_ATTEMPTS,
+  verify,
+  onEvent = () => {},
+} = {}) {
+  return new Promise((resolve, reject) => {
+    const token = crypto.randomBytes(16).toString('hex')
+    const pageHtml = loginPageHtml()
+    let sessionOpen = true // 令牌会话有效性：成功/超时/上限耗尽即 false
+    let attempts = 0
+    let verifying = false
+    let lastResult = null // {type:'success'|'credential'|'service', ...}
+    let resultAcked = false
+    let closed = false
+    let doneResolve
+    const done = new Promise((r) => {
+      doneResolve = r
+    })
+
+    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))
+      }
+
+      if (!isIpLiteralHost(req.headers.host)) {
+        sendJson(403, { ok: false, error: '非法 Host' })
+        return
+      }
+
+      const tokenOk = () => sessionOpen && url.searchParams.get('t') === token
+
+      if (req.method === 'GET' && url.pathname === '/') {
+        if (!tokenOk()) {
+          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 === 'GET' && url.pathname === '/result') {
+        // 结果轮询只校验令牌匹配：成功/上限后令牌会话已结束，但结果
+        // 仍须让页面取走（提交路径此时已被 sessionOpen 拒绝，无重放面）
+        if (url.searchParams.get('t') !== token) {
+          sendJson(403, { ok: false, error: '令牌错误' })
+          return
+        }
+        if (lastResult) {
+          const terminal =
+            lastResult.type === 'success' ||
+            (lastResult.type !== 'success' && lastResult.final)
+          const payload = { status: 'done', ...lastResult }
+          if (terminal && !resultAcked) {
+            resultAcked = true
+            // 页面已收到终结性结果：短暂延迟后收摊
+            setTimeout(closeServer, 1000)
+          }
+          sendJson(200, payload)
+          return
+        }
+        sendJson(200, { status: verifying ? 'verifying' : 'idle' })
+        return
+      }
+
+      if (req.method === 'POST' && url.pathname === '/submit') {
+        const origin = req.headers.origin
+        if (origin && origin !== `http://${req.headers.host}`) {
+          sendJson(403, { ok: false, error: '非法来源' })
+          return
+        }
+        // 令牌经请求体传递（页面为相对路径提交，URL 无 query），
+        // 此处只先校验会话有效性，令牌匹配在解析 body 后校验
+        if (!sessionOpen) {
+          sendJson(403, { ok: false, error: '会话已结束，请重新运行 linke login' })
+          return
+        }
+        if (verifying) {
+          sendJson(409, { ok: false, error: '正在验证上一次提交，请稍候' })
+          return
+        }
+        if (attempts >= maxAttempts) {
+          sendJson(429, { ok: false, error: `已达尝试上限（${maxAttempts} 次）` })
+          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', () => {
+          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
+          }
+          // 计数在任何验证发生前完成：提交即视为一次教务尝试（保守口径）
+          attempts += 1
+          const remaining = maxAttempts - attempts
+          verifying = true
+          lastResult = null
+          resultAcked = false
+          sendJson(200, { ok: true, attempts, remaining })
+          onEvent({ type: 'submitted', attempts, remaining, userId })
+          // 注意：此处不打印/记录凭据（红线）
+          Promise.resolve()
+            .then(() => verify(userId, password))
+            .then((outcome) => {
+              verifying = false
+              if (outcome && outcome.ok) {
+                sessionOpen = false // 令牌会话结束（验收 3）
+                lastResult = {
+                  type: 'success',
+                  summary: outcome.summary || {},
+                  maxAttempts,
+                }
+                onEvent({ type: 'success', summary: outcome.summary, userId })
+              } else {
+                const kind = outcome && outcome.kind === 'credential' ? 'credential' : 'service'
+                const final = remaining <= 0
+                lastResult = {
+                  type: kind,
+                  message: (outcome && outcome.message) || '验证失败',
+                  remaining,
+                  final,
+                  maxAttempts,
+                }
+                onEvent({ type: kind === 'credential' ? 'credential-error' : 'service-error', message: lastResult.message, remaining, final, userId })
+                if (final) {
+                  sessionOpen = false
+                  scheduleForceClose()
+                  onEvent({ type: 'attempts-exhausted', attempts })
+                }
+              }
+            })
+            .catch((err) => {
+              verifying = false
+              const final = remaining <= 0
+              lastResult = {
+                type: 'service',
+                message: (err && err.message) || '验证过程异常',
+                remaining,
+                final,
+                maxAttempts,
+              }
+              onEvent({ type: 'service-error', message: lastResult.message, remaining, final, userId })
+              if (final) {
+                sessionOpen = false
+                scheduleForceClose()
+                onEvent({ type: 'attempts-exhausted', attempts })
+              }
+            })
+        })
+        return
+      }
+
+      sendJson(404, { ok: false, error: 'Not Found' })
+    })
+
+    let lingerHandle = null
+    let timeoutHandle = null
+
+    const closeServer = () => {
+      if (closed) return
+      closed = true
+      clearTimeout(timeoutHandle)
+      clearTimeout(lingerHandle)
+      if (typeof server.closeAllConnections === 'function') server.closeAllConnections()
+      server.close()
+      sessionOpen = false
+      doneResolve({ type: 'closed' })
+    }
+
+    // 终结性失败结果若始终无人来取（页面已关等），超窗强制收摊
+    const scheduleForceClose = () => {
+      clearTimeout(lingerHandle)
+      lingerHandle = setTimeout(closeServer, RESULT_LINGER_MS)
+    }
+
+    timeoutHandle = setTimeout(() => {
+      onEvent({ type: 'timeout' })
+      sessionOpen = false
+      closeServer()
+    }, 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,
+        done,
+        attempts: () => attempts,
+      })
+    })
+  })
+}

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/schools/sdufe/parsers.js

@@ -10,23 +10,27 @@
 import { stripSpaces, isJwLoginExpired } from '../../util.js'
 import { parseError } from '../../errors.js'
 
-/** 解析个人主页：姓名/单位/专业/班级（用于登录确认与 status 展示） */
+/** 解析个人主页：姓名/单位/专业/班级 + 当前教学周（用于登录确认与 status/成功页展示） */
 export function parseUserData(html) {
   if (!html || typeof html !== 'string') {
-    return { name: '', unit: '', discipline: '', class: '' }
+    return { name: '', unit: '', discipline: '', class: '', week: null }
   }
   const nameMatch = html.match(/<span class="blue f16 b">(.*?)<\/span>/)
   const name = nameMatch ? nameMatch[1] : ''
   const userMatches = html.matchAll(/middletopdwxxcont">(.*?)<\/div>/g)
   const userData = Array.from(userMatches).map((m) => m[1])
+  // 周次（教务主页 xsMain_new.jsp 口径，交互文档 1.6）
+  const weekMatch = html.match(/<span class="main_text main_color">第(.*?)周<\/span>\/(.*?)周/)
+  const week = weekMatch ? { now: weekMatch[1] || '', all: weekMatch[2] || '' } : null
   if (userData.length < 3) {
-    return { name: name || '', unit: '', discipline: '', class: '' }
+    return { name: name || '', unit: '', discipline: '', class: '', week }
   }
   return {
     name: name || '',
     unit: userData[0] || '',
     discipline: userData[1] || '',
     class: userData[2] || '',
+    week,
   }
 }
 

package/src/web/login.html

@@ -0,0 +1,209 @@
+<!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; white-space: pre-line; }
+  .msg.cred { display: block; color: #cf222e; }
+  .msg.svc { display: block; color: #9a6700; }
+  /* 验证中 */
+  .verifying { display: none; text-align: center; padding: 18px 0 8px; }
+  .verifying .spinner {
+    width: 34px; height: 34px; margin: 0 auto 14px; border-radius: 50%;
+    border: 3px solid #d0d7de; border-top-color: #2da44e;
+    animation: spin 0.9s linear infinite;
+  }
+  @media (prefers-color-scheme: dark) { .verifying .spinner { border-color: #3a4149; border-top-color: #2da44e; } }
+  @keyframes spin { to { transform: rotate(360deg); } }
+  .verifying p { font-size: 14px; color: #6a737d; line-height: 1.7; }
+  @media (prefers-color-scheme: dark) { .verifying p { color: #9aa4af; } }
+  /* 成功 */
+  .success { display: none; text-align: center; padding: 10px 0 0; }
+  .success .mark { font-size: 40px; line-height: 1; }
+  .success h2 { font-size: 17px; margin: 10px 0 6px; }
+  .success .info { font-size: 14px; color: #6a737d; line-height: 1.8; }
+  @media (prefers-color-scheme: dark) { .success .info { color: #9aa4af; } }
+  .success .next {
+    margin-top: 16px; padding: 12px; border-radius: 8px; background: #f0f6ff;
+    font-size: 13px; line-height: 1.8; text-align: left;
+  }
+  @media (prefers-color-scheme: dark) { .success .next { background: #1b2635; } }
+  .success .next code { background: rgba(175,184,193,.25); padding: 1px 6px; border-radius: 4px; }
+</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>
+
+    <div id="verifying" class="verifying">
+      <div class="spinner"></div>
+      <p id="verifyText">正在验证教务登录…<br>（自动获取并识别验证码，约需数秒，请勿关闭本页）</p>
+    </div>
+
+    <div id="success" class="success">
+      <div class="mark">✅</div>
+      <h2 id="okTitle">验证成功</h2>
+      <p class="info" id="okInfo"></p>
+      <div class="next">凭据已保存到本机（权限 600）。<br>
+        现在可以直接问你的 AI：<br>
+        <code>「我这周有什么课」「我的成绩怎么样」</code><br>
+        也可以在终端运行 <code>linke schedule</code> 查看。
+      </div>
+    </div>
+  </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')
+  const verifying = document.getElementById('verifying')
+  const success = document.getElementById('success')
+  const userIdInput = document.getElementById('userId')
+  const passwordInput = document.getElementById('password')
+  let polling = null
+
+  function showForm() {
+    form.style.display = ''
+    verifying.style.display = 'none'
+    success.style.display = 'none'
+    btn.disabled = false
+    btn.textContent = '验证并保存'
+  }
+  function showVerifying() {
+    form.style.display = 'none'
+    msg.className = 'msg'
+    verifying.style.display = 'block'
+  }
+  function showSuccess(info) {
+    form.style.display = 'none'
+    verifying.style.display = 'none'
+    msg.className = 'msg'
+    success.style.display = 'block'
+    document.getElementById('okInfo').textContent = info
+  }
+
+  async function pollResult() {
+    try {
+      const res = await fetch('/result?t=' + encodeURIComponent(token), {
+        headers: { 'Accept': 'application/json' }
+      })
+      if (res.status === 403) {
+        stopPoll()
+        msg.className = 'msg svc'
+        msg.textContent = '会话已结束（成功或超时）。请回终端查看结果；如需重新配置请重新运行 linke login。'
+        showForm()
+        return
+      }
+      const data = await res.json()
+      if (data.status === 'verifying' || data.status === 'idle') return
+      stopPoll()
+      if (data.type === 'success') {
+        const s = data.summary || {}
+        const lines = []
+        if (s.name) lines.push('姓名：' + s.name)
+        if (s.unit) lines.push(s.unit)
+        if (s.weekNow) lines.push('当前教学周：第 ' + s.weekNow + ' 周' + (s.weekAll ? ' / 共 ' + s.weekAll + ' 周' : ''))
+        showSuccess(lines.length ? lines.join('\n') : '教务登录验证通过，凭据已保存。')
+        return
+      }
+      // 失败：回到表单
+      showForm()
+      if (data.type === 'credential') {
+        msg.className = 'msg cred'
+        msg.textContent = '教务返回：' + (data.message || '账号或密码错误') + '。\n' +
+          '⚠️ 连续输错密码可能导致教务账号被锁定，请确认后重试' +
+          (data.remaining > 0 ? '（剩余 ' + data.remaining + ' 次尝试机会）。' : '。')
+      } else {
+        msg.className = 'msg svc'
+        msg.textContent = (data.message || '网络或验证码识别服务异常') + '。\n' +
+          '这通常与账号密码无关，稍后重试即可' +
+          (data.remaining > 0 ? '（剩余 ' + data.remaining + ' 次）' : '') +
+          '。'
+      }
+      if (data.final) {
+        btn.disabled = true
+        btn.textContent = '已达尝试上限'
+        msg.textContent += '\n已达尝试上限（' + data.maxAttempts + ' 次），本服务即将关闭；请回终端重新运行 linke login。'
+      }
+    } catch {
+      /* 网络瞬断继续轮询 */
+    }
+  }
+  function stopPoll() {
+    if (polling) { clearInterval(polling); polling = null }
+  }
+
+  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: userIdInput.value.trim(),
+          password: passwordInput.value
+        })
+      })
+      const data = await res.json()
+      if (!data.ok) throw new Error(data.error || '提交失败')
+      showVerifying()
+      passwordInput.value = '' // 提交后即清空，避免长期驻留输入框
+      stopPoll()
+      polling = setInterval(pollResult, 800)
+      pollResult()
+    } catch (err) {
+      msg.className = 'msg svc'
+      msg.textContent = '提交失败：' + err.message
+      btn.disabled = false
+      btn.textContent = '验证并保存'
+    }
+  })
+</script>
+</body>
+</html>