linke-cli 0.2.0 → 0.3.0

package/README.md

@@ -17,9 +17,12 @@ linke schedule             # 直接用，登录全自动
 要求 Node.js ≥ 18.14，零运行时依赖。
 
 `linke login` 的登录页由本机 CLI 提供（仅绑 127.0.0.1 随机端口，页面
-随 npm 包分发可审计）；`--qr` 模式额外在终端展示局域网 URL 二维码
-（含一次性令牌，用后即失效），手机同 Wi-Fi 扫码填写。凭据只落本机，
-不经任何云端。`linke config` 保留为非 TTY / SSH 场景的终端兜底。
+随 npm 包分发可审计）；**提交后在网页内完成教务登录验证**——验证中
+动效 → 结果回显（成功显示姓名与教学周，凭据此时才落盘 0600；密码错
+误页内提示并可重试，含教务锁号警示）。尝试上限 3 次、5 分钟超时，
+任一终结即自动关闭服务。`--qr` 模式额外在终端展示局域网 URL 二维码
+（含会话令牌），手机同 Wi-Fi 扫码填写、全程手机端闭环，凭据不经任
+何云端。`linke config` 保留为非 TTY / SSH 场景的终端兜底。
 
 ## 命令
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linke-cli",
-  "version": "0.2.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.2.0
+version: 0.3.0
 description: "林课教务查询 CLI（山东财经大学正方教务）：查课表、查成绩、看教务登录状态。当用户问「我这学期课表」「今天有什么课」「我的成绩/绩点」「挂了什么课」「教务登录状态」等教务只读信息时使用。登录全自动（验证码云端识别），无需用户介入。"
 metadata:
   requires:
@@ -21,7 +21,8 @@ linke status
 
 - `configured: false` → 用户还没配置凭据。**引导用户本人**在终端运行
   `linke login`（本机起登录页并自动打开浏览器，手机填写加 `--qr` 出
-  局域网二维码；凭据只存本机 `~/.linke-cli/`）。**你不代输密码、
+  局域网二维码；验证在网页内完成——通过才保存，失败页内重试，全程
+  无需看终端；凭据只存本机 `~/.linke-cli/`）。**你不代输密码、
   不把密码写进任何命令**——凭据只经用户本人的网页/终端进入本机。
 - `configured: true` 即可用，无需关心登录：每个命令内置鉴权状态机，
   session 过期自动重登，只有凭据失效才需要人介入。

package/src/bin.js

@@ -126,20 +126,94 @@ function openBrowser(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
-  let settle
-  const submitted = new Promise((resolve) => {
-    settle = resolve
-  })
-  const handle = await startLoginServer({ qr, onSubmit: settle })
-  progress('登录页已就绪（5 分钟内有效，成功或超时后自动关闭）')
+  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 { modules } = buildQr(Buffer.from(lan, 'utf8'))
+    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) {
@@ -155,21 +229,16 @@ async function cmdLogin(flags) {
     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
+  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() {

package/src/loginserver.js

@@ -1,16 +1,17 @@
 /**
- * 本地登录服务（T6）：`linke login` 在用户本机起内置登录页。
+ * 本地登录服务（T7：网页内验证闭环）：
  *
- * 安全口径（T6 验收 1-4）：
- * - 本地模式仅绑 127.0.0.1 随机端口；二维码模式（--qr）绑 0.0.0.0
- *   供局域网手机访问，URL 强制携带一次性令牌；
- * - 令牌一次性：提交成功（无论凭据是否有效）立即失效；
- * - 凭据只经 POST /submit 进入本进程 → saveConfig 落盘（0600），
- *   不写任何日志、不打印；
- * - Host 头必须是 IP 字面量（防 DNS rebinding）；Origin 头存在时
- *   必须同源（防跨站提交）；页面为随包分发的静态文件（可审计），
- *   不从云端拉取任何内容；
- * - 服务在提交成功或超时（默认 5 分钟）后自动关闭。
+ * 流程：页面提交凭据 → 服务立即应答并进入「验证中」→ 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'
@@ -18,18 +19,19 @@ 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
+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（排除回环/内网虚拟网段由调用方展示时全列） */
+/** 枚举本机局域网 IPv4（虚拟网段在内，展示侧由调用方取舍） */
 export function lanAddresses() {
   const result = []
   const interfaces = os.networkInterfaces()
@@ -52,16 +54,37 @@ function isIpLiteralHost(host) {
  * 起本地登录服务。
  * @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}>}
+ * @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, onSubmit } = {}) {
+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 tokenUsed = false
+    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')
@@ -70,16 +93,17 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
         res.end(JSON.stringify(payload))
       }
 
-      // 防 DNS rebinding：Host 必须是 IP 字面量
       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 (tokenUsed || url.searchParams.get('t') !== token) {
+        if (!tokenOk()) {
           res.writeHead(403, { 'Content-Type': 'text/html;charset=utf-8' })
-          res.end('<meta charset="utf-8"><p>链接无效或已使用：请回到终端重新运行 linke login。</p>')
+          res.end('<meta charset="utf-8"><p>链接无效或已失效：请回到终端重新运行 linke login。</p>')
           return
         }
         res.writeHead(200, { 'Content-Type': 'text/html;charset=utf-8' })
@@ -87,15 +111,49 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
         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') {
-        // 防 CSRF：浏览器提交必带 Origin，存在则必须同源
         const origin = req.headers.origin
-        if (origin) {
-          const host = req.headers.host
-          if (origin !== `http://${host}`) {
-            sendJson(403, { ok: false, error: '非法来源' })
-            return
-          }
+        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
@@ -108,10 +166,6 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
           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'))
@@ -129,19 +183,62 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
             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()
+          // 计数在任何验证发生前完成：提交即视为一次教务尝试（保守口径）
+          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
       }
@@ -149,18 +246,30 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
       sendJson(404, { ok: false, error: 'Not Found' })
     })
 
+    let lingerHandle = null
+    let timeoutHandle = null
+
     const closeServer = () => {
       if (closed) return
       closed = true
       clearTimeout(timeoutHandle)
-      // keep-alive 空闲连接会阻止 close 生效，强制断开
+      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)
     }
 
-    const timeoutHandle = setTimeout(() => {
+    timeoutHandle = setTimeout(() => {
+      onEvent({ type: 'timeout' })
+      sessionOpen = false
       closeServer()
-      onSubmit && onSubmit({ ok: false, error: 'timeout' })
     }, timeoutMs)
 
     server.on('error', reject)
@@ -176,6 +285,8 @@ export function startLoginServer({ qr = false, timeoutMs = DEFAULT_TIMEOUT_MS, o
         token,
         urls,
         close: closeServer,
+        done,
+        attempts: () => attempts,
       })
     })
   })

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

@@ -33,9 +33,32 @@
     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; }
+  .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>
@@ -43,14 +66,31 @@
     <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>
+      <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)
@@ -58,35 +98,110 @@
   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 = '保存中...'
+    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
+          userId: userIdInput.value.trim(),
+          password: passwordInput.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 || '保存失败')
-      }
+      if (!data.ok) throw new Error(data.error || '提交失败')
+      showVerifying()
+      passwordInput.value = '' // 提交后即清空，避免长期驻留输入框
+      stopPoll()
+      polling = setInterval(pollResult, 800)
+      pollResult()
     } catch (err) {
-      msg.className = 'msg err'
-      msg.textContent = '保存失败：' + err.message + '。请回终端重新运行 linke login 后重试。'
+      msg.className = 'msg svc'
+      msg.textContent = '提交失败：' + err.message
       btn.disabled = false
-      btn.textContent = '保存到本机'
+      btn.textContent = '验证并保存'
     }
   })
 </script>