This commit is contained in:
2026-08-25 19:46:38 +08:00
parent e1416994bc
commit 4cf6b1ffbc
15 changed files with 719 additions and 108 deletions
+5
View File
@@ -36,6 +36,11 @@ class ClientSettings(BaseSettings):
# -------------------------------------------------------
TOKEN_FILE: str = "client/.token"
# -------------------------------------------------------
# 心跳(秒):需小于服务端在线窗口(90s)
# -------------------------------------------------------
HEARTBEAT_INTERVAL: int = 30
class Config:
env_file = "client/.env"
env_file_encoding = "utf-8"
+53 -9
View File
@@ -17,6 +17,7 @@ class ServerAPI:
self.base_url = client_settings.SERVER_URL.rstrip("/")
self.token: str | None = None
self.user_id: int | None = None
self.username: str | None = None
self._load_token()
# ------------------------------------------------------------------
@@ -35,42 +36,85 @@ class ServerAPI:
lines = f.read().strip().splitlines()
if lines:
self.token = lines[0]
self.user_id = int(lines[1]) if len(lines) > 1 else None
self.user_id = int(lines[1]) if len(lines) > 1 and lines[1] else None
self.username = lines[2] if len(lines) > 2 else None
logger.info("已加载本地 token")
except Exception as e:
logger.warning(f"读取 token 失败:{e}")
def _save_token(self) -> None:
with open(self._token_path(), "w", encoding="utf-8") as f:
f.write(f"{self.token}\n{self.user_id}")
f.write(f"{self.token}\n{self.user_id}\n{self.username or ''}")
def _headers(self) -> dict:
return {"Authorization": f"Bearer {self.token}"} if self.token else {}
# ------------------------------------------------------------------
# 认证
# 认证(账号密码体系)
# ------------------------------------------------------------------
def register(self, nickname: str | None = None) -> dict:
"""用机器指纹注册/登录,返回 token"""
client_code = generate_client_code()
def register(self, username: str, password: str, nickname: str | None = None) -> dict:
"""注册新账号,返回并保存 token"""
resp = requests.post(
f"{self.base_url}/api/auth/register",
json={"client_code": client_code, "nickname": nickname},
json={"username": username, "password": password, "nickname": nickname},
timeout=15,
)
resp.raise_for_status()
data = resp.json()
return self._store_auth(resp.json())
def login(self, username: str, password: str) -> dict:
"""账号密码登录,返回并保存 token"""
resp = requests.post(
f"{self.base_url}/api/auth/login",
json={
"username": username,
"password": password,
"client_code": generate_client_code(), # 仅作设备审计
},
timeout=15,
)
resp.raise_for_status()
return self._store_auth(resp.json())
def _store_auth(self, data: dict) -> dict:
"""保存认证信息到内存与本地文件"""
self.token = data["token"]
self.user_id = data["user_id"]
self.username = data.get("username")
self._save_token()
logger.info(f"注册/登录成功,user_id={self.user_id},新用户={data.get('is_new')}")
logger.info(f"认证成功,user_id={self.user_id},username={self.username}")
return data
def logout(self) -> None:
"""清除本地 token"""
self.token = None
self.user_id = None
self.username = None
try:
if os.path.exists(self._token_path()):
os.remove(self._token_path())
except Exception:
pass
def get_me(self) -> dict:
resp = requests.get(f"{self.base_url}/api/auth/me", headers=self._headers(), timeout=15)
resp.raise_for_status()
return resp.json()
def heartbeat(self) -> bool:
"""发送心跳,刷新服务端 last_seen_at;失败返回 False(不抛异常)"""
if not self.token:
return False
try:
resp = requests.post(
f"{self.base_url}/api/auth/heartbeat",
headers=self._headers(), timeout=10,
)
return resp.status_code == 200
except Exception as e:
logger.debug(f"心跳发送失败:{e}")
return False
def update_login_status(self, status: str, boss_account: str | None = None) -> dict:
payload = {"login_status": status}
if boss_account:
+130 -21
View File
@@ -3,6 +3,8 @@
FastAPI 应用:提供操作界面 + 编排浏览器自动化流程
"""
import threading
import time
import requests
from pathlib import Path
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import HTMLResponse
@@ -14,7 +16,7 @@ from loguru import logger
from ..config import client_settings
from ..server_api import ServerAPI
from ..ai import AIClient
from ..fingerprint import generate_client_code, get_machine_summary
from ..fingerprint import get_machine_summary
from ..browser.manager import BrowserManager
from ..browser.resume_scraper import ResumeScraper
from ..browser.applicant import Applicant
@@ -37,20 +39,67 @@ class AppState:
self.applicant: Applicant | None = None
self.connected = False # 是否已注册/登录云端
self.login_polling = False
self._heartbeat_started = False
def ensure_applicant(self) -> Applicant:
if self.applicant is None:
self.applicant = Applicant(self.browser, self.server_api, self.ai)
return self.applicant
# ------------------------------------------------------------------
# 心跳:登录成功后启动后台线程,周期性向服务端上报存活
# ------------------------------------------------------------------
def ensure_heartbeat(self) -> None:
if self._heartbeat_started or not self.server_api.token:
return
self._heartbeat_started = True
threading.Thread(target=self._heartbeat_loop, daemon=True).start()
logger.info(f"心跳线程已启动,间隔 {client_settings.HEARTBEAT_INTERVAL}s")
def _heartbeat_loop(self) -> None:
while True:
if not self.server_api.token:
# 已退出登录,停止心跳
self._heartbeat_started = False
logger.info("已退出登录,心跳停止")
break
self.server_api.heartbeat()
time.sleep(client_settings.HEARTBEAT_INTERVAL)
state = AppState()
# =======================================================
# 前置校验(收敛:所有需要已登录云端的路由统一走这里)
# =======================================================
def _require_auth() -> None:
"""未登录云端时统一抛 400,禁止各路由自行散落判断"""
if not state.connected:
raise HTTPException(status_code=400, detail="请先登录系统账号")
def _require_rpa_online() -> None:
"""
关键操作(开始投递)前的在线预检:
先发一次心跳刷新在线状态,再确认服务端判定为在线,
避免心跳链路异常时启动必然失败的操作。
"""
state.server_api.heartbeat()
try:
me = state.server_api.get_me()
if not me.get("is_online"):
raise HTTPException(status_code=409, detail="RPA 在线状态未确认,请检查网络后重试")
except requests.RequestException as e:
raise HTTPException(status_code=503, detail=f"无法确认在线状态:{e}")
# =======================================================
# 请求模型
# =======================================================
class ConnectReq(BaseModel):
class AuthReq(BaseModel):
username: str
password: str
nickname: str | None = None
@@ -78,15 +127,30 @@ def index(request: Request):
# =======================================================
@app.get("/api/status")
def get_status():
"""返回整体状态,供前端轮询"""
"""返回整体状态,供前端轮询(含本地 token 免登录校验)"""
# 若本地存有 token,尝试校验并获取用户信息(实现二次启动免登录)
me = None
if state.server_api.token:
try:
me = state.server_api.get_me()
state.connected = True
state.ensure_heartbeat() # token 有效时确保心跳线程在跑
except Exception:
state.connected = False
state.server_api.logout() # token 失效,清除本地缓存
else:
state.connected = False
result = {
"client_code": generate_client_code()[:16] + "...",
"machine": get_machine_summary(),
"username": state.server_api.username,
"server_connected": state.connected,
"server_reachable": state.server_api.ping(),
"rpa_online": me.get("is_online", False) if me else False,
"adspower_running": state.browser.is_adspower_running(),
"ai_configured": state.ai.available(),
"login_status": "unknown",
"login_status": me.get("login_status", "unknown") if me else "unknown",
"boss_account": me.get("boss_account") if me else None,
"resume_count": 0,
"has_primary": False,
"applying": False,
@@ -94,14 +158,11 @@ def get_status():
}
if state.connected:
try:
me = state.server_api.get_me()
result["login_status"] = me.get("login_status", "unknown")
result["boss_account"] = me.get("boss_account")
resumes = state.server_api.list_resumes()
result["resume_count"] = len(resumes)
result["has_primary"] = any(r.get("is_primary") for r in resumes)
except Exception as e:
logger.debug(f"获取用户状态失败:{e}")
logger.debug(f"获取简历状态失败:{e}")
if state.applicant and state.applicant.is_running:
result["applying"] = True
result["apply_stats"] = state.applicant.stats
@@ -109,16 +170,50 @@ def get_status():
# =======================================================
# Step 0: 连接云端服务端
# Step 0: 登录 / 注册云端账号(账号密码体系)
# =======================================================
@app.post("/api/connect")
def connect(req: ConnectReq):
def _extract_error(e: requests.HTTPError) -> str:
"""从服务端错误响应中提取 detail 信息"""
try:
data = state.server_api.register(req.nickname)
return e.response.json().get("detail", str(e))
except Exception:
return str(e)
@app.post("/api/register")
def register(req: AuthReq):
"""注册新账号"""
try:
data = state.server_api.register(req.username, req.password, req.nickname)
state.connected = True
return {"ok": True, "user_id": data["user_id"], "is_new": data["is_new"]}
state.ensure_heartbeat()
return {"ok": True, "user_id": data["user_id"], "username": data["username"]}
except requests.HTTPError as e:
raise HTTPException(status_code=e.response.status_code, detail=_extract_error(e))
except Exception as e:
raise HTTPException(status_code=500, detail=f"连接服务端失败:{e}")
raise HTTPException(status_code=500, detail=f"注册失败:{e}")
@app.post("/api/login")
def login(req: AuthReq):
"""账号密码登录"""
try:
data = state.server_api.login(req.username, req.password)
state.connected = True
state.ensure_heartbeat()
return {"ok": True, "user_id": data["user_id"], "username": data["username"]}
except requests.HTTPError as e:
raise HTTPException(status_code=e.response.status_code, detail=_extract_error(e))
except Exception as e:
raise HTTPException(status_code=500, detail=f"登录失败:{e}")
@app.post("/api/logout")
def logout():
"""退出登录,清除本地 token"""
state.server_api.logout()
state.connected = False
return {"ok": True}
# =======================================================
@@ -127,8 +222,7 @@ def connect(req: ConnectReq):
@app.post("/api/start-login")
def start_login():
"""打开 AdsPower 浏览器并跳转到 Boss直聘,等待用户手动登录"""
if not state.connected:
raise HTTPException(status_code=400, detail="请先连接服务端")
_require_auth()
try:
state.server_api.update_login_status("logging_in")
page = state.browser.connect()
@@ -158,6 +252,22 @@ def _poll_login():
state.login_polling = False
@app.post("/api/detect-login")
def detect_login():
"""活体检测 Boss直聘 登录状态(进入登录步骤时自动调用)"""
_require_auth()
try:
logged_in = state.browser.check_boss_login()
except Exception as e:
raise HTTPException(status_code=500, detail=f"检测失败:{e}")
if logged_in:
account = state.browser.get_boss_account_name()
state.server_api.update_login_status("logged_in", account)
return {"logged_in": True, "account": account}
state.server_api.update_login_status("not_login")
return {"logged_in": False}
@app.get("/api/login-status")
def login_status():
"""前端轮询登录状态"""
@@ -180,8 +290,7 @@ def login_status():
@app.post("/api/scrape-resumes")
def scrape_resumes():
"""AI 抓取账号内所有简历并上传到云端"""
if not state.connected:
raise HTTPException(status_code=400, detail="请先连接服务端")
_require_auth()
try:
scraper = ResumeScraper(state.browser, state.ai)
resumes = scraper.scrape_all()
@@ -212,8 +321,8 @@ def set_primary(resume_id: int):
# =======================================================
@app.post("/api/start-apply")
def start_apply(req: StartApplyReq):
if not state.connected:
raise HTTPException(status_code=400, detail="请先连接服务端")
_require_auth()
_require_rpa_online() # 在线预检:与服务端 require_online_user 前置校验呼应
if not state.server_api.get_primary_resume():
raise HTTPException(status_code=400, detail="请先设置主简历")
if not state.browser.is_adspower_running():
+93 -15
View File
@@ -24,8 +24,9 @@ function goToStep(step) {
for (let i = 1; i <= 5; i++) {
$(`panel-${i}`).classList.toggle('hidden', i !== step);
}
if (step === 5) loadHistory();
if (step === 2) detectBossLogin(); // 进入 Boss登录 步骤自动活体检测
if (step === 3) loadResumes();
if (step === 5) loadHistory();
}
document.querySelectorAll('.step').forEach(el => {
el.addEventListener('click', () => goToStep(parseInt(el.dataset.step)));
@@ -53,7 +54,6 @@ function badge(text, cls) {
async function refreshStatus() {
try {
const s = await api('/api/status');
$('clientCode').textContent = s.client_code;
$('serverReachable').innerHTML = badge(
s.server_reachable ? '可连接' : '无法连接',
s.server_reachable ? 'ok' : 'err'
@@ -62,13 +62,25 @@ async function refreshStatus() {
s.adspower_running ? '运行中' : '未运行',
s.adspower_running ? 'ok' : 'warn'
);
// 顶部徽章
$('statusBadges').innerHTML =
badge(s.server_connected ? '已连接' : '未连接', s.server_connected ? 'ok' : '') +
badge(s.ai_configured ? 'AI已配置' : 'AI未配置', s.ai_configured ? 'ok' : 'warn');
// 顶部徽章与用户区
let badges = badge(s.server_connected ? '已连接' : '未连接', s.server_connected ? 'ok' : '');
if (s.server_connected) {
badges += badge(s.rpa_online ? 'RPA在线' : 'RPA离线', s.rpa_online ? 'ok' : 'warn');
}
badges += badge(s.ai_configured ? 'AI已配置' : 'AI未配置', s.ai_configured ? 'ok' : 'warn');
$('statusBadges').innerHTML = badges;
const userArea = $('userArea');
if (s.server_connected && s.username) {
userArea.classList.remove('hidden');
$('userName').textContent = s.username;
} else {
userArea.classList.add('hidden');
}
if (s.server_connected) {
updateLoginBadge(s.login_status, s.boss_account);
// 本地 token 免登录:自动跳过账号步骤
if (currentStep === 1) goToStep(2);
}
return s;
} catch (e) {
@@ -88,29 +100,95 @@ function updateLoginBadge(status, account) {
}
// ==========================================================
// Step 1: 连接服务端
// Step 1: 登录 / 注册系统账号
// ==========================================================
$('btnConnect').addEventListener('click', async () => {
const btn = $('btnConnect');
let registerMode = false;
function setAuthMode(isRegister) {
registerMode = isRegister;
$('btnLogin').classList.toggle('hidden', isRegister);
$('btnRegister').classList.toggle('hidden', !isRegister);
$('nicknameGroup').classList.toggle('hidden', !isRegister);
$('authSwitchHint').textContent = isRegister
? '已有账号?点击上方“登 录”切换为登录模式。'
: '没有账号?点击上方“注册新账号”切换为注册模式。';
}
// 登录/注册模式切换:登录模式下“注册新账号”是切换按钮;注册模式下“登 录”是切换按钮
$('btnRegister').addEventListener('click', () => { if (!registerMode) setAuthMode(true); });
$('btnLogin').addEventListener('click', () => { if (registerMode) setAuthMode(false); });
$('authSwitchHint').addEventListener('click', () => setAuthMode(!registerMode));
$('authSwitchHint').style.cursor = 'pointer';
async function submitAuth() {
const username = $('username').value.trim();
const password = $('password').value;
if (!username || !password) { toast('请输入用户名和密码'); return; }
const wasRegister = registerMode;
const btn = wasRegister ? $('btnRegister') : $('btnLogin');
btn.disabled = true;
try {
const data = await api('/api/connect', {
method: 'POST',
body: JSON.stringify({ nickname: $('nickname').value || null }),
});
toast(data.is_new ? '注册成功!' : '登录成功!');
const path = wasRegister ? '/api/register' : '/api/login';
const body = { username, password };
if (wasRegister) body.nickname = $('nickname').value || null;
const data = await api(path, { method: 'POST', body: JSON.stringify(body) });
toast(wasRegister ? '注册成功!' : `欢迎回来,${data.username}!`);
await refreshStatus();
goToStep(2);
} catch (e) {
toast('连接失败:' + e.message, 5000);
toast(e.message, 5000);
setAuthMode(wasRegister); // 失败时保持当前模式
} finally {
btn.disabled = false;
}
}
// 主按钮提交(当前模式下可见的那个)
$('btnLogin').addEventListener('click', () => { if (!registerMode) submitAuth(); });
$('btnRegister').addEventListener('click', () => { if (registerMode) submitAuth(); });
// 回车提交表单
document.addEventListener('keydown', (e) => {
if (e.key === 'Enter' && currentStep === 1) submitAuth();
});
// 退出登录
$('btnLogout').addEventListener('click', async () => {
try {
await api('/api/logout', { method: 'POST' });
toast('已退出登录');
goToStep(1);
refreshStatus();
} catch (e) { toast('退出失败:' + e.message); }
});
// ==========================================================
// Step 2: 登录 Boss直聘
// ==========================================================
// 活体检测:进入本步骤自动调用,判断指纹浏览器中是否已登录
async function detectBossLogin() {
$('detectSpinner').classList.remove('hidden');
try {
const r = await api('/api/detect-login', { method: 'POST' });
if (r.logged_in) {
updateLoginBadge('logged_in', r.account);
$('btnSkipLogin').classList.remove('hidden');
toast(`检测到已登录:${r.account},可直接进入下一步`);
} else {
updateLoginBadge('not_login');
$('btnSkipLogin').classList.add('hidden');
toast('未检测到登录,请点击“打开浏览器登录”');
}
} catch (e) {
toast('登录检测失败:' + e.message, 5000);
} finally {
$('detectSpinner').classList.add('hidden');
}
}
$('btnRedetect').addEventListener('click', detectBossLogin);
$('btnSkipLogin').addEventListener('click', () => goToStep(3));
$('btnStartLogin').addEventListener('click', async () => {
const btn = $('btnStartLogin');
btn.disabled = true;
+20
View File
@@ -38,6 +38,26 @@ body {
.header h1 { font-size: 22px; }
.status-badges { display: flex; gap: 8px; }
/* ===== 用户区 ===== */
.user-area {
display: flex;
align-items: center;
gap: 10px;
}
.user-name {
font-weight: 600;
color: var(--primary);
}
.btn-link {
background: none;
border: none;
color: var(--text-light);
cursor: pointer;
font-size: 13px;
text-decoration: underline;
}
.btn-link:hover { color: var(--danger); }
/* ===== 步骤导航 ===== */
.steps {
display: flex;
+28 -8
View File
@@ -11,42 +11,62 @@
<!-- 顶部标题栏 -->
<header class="header">
<h1>🎯 Boss直聘 AI 智能投递</h1>
<div class="user-area hidden" id="userArea">
<span class="user-name" id="userName"></span>
<button class="btn-link" id="btnLogout">退出</button>
</div>
<div class="status-badges" id="statusBadges"></div>
</header>
<!-- 步骤导航 -->
<nav class="steps">
<div class="step active" data-step="1"><span class="step-num">1</span> 连接</div>
<div class="step" data-step="2"><span class="step-num">2</span> 登录</div>
<div class="step active" data-step="1"><span class="step-num">1</span> 账号</div>
<div class="step" data-step="2"><span class="step-num">2</span> Boss登录</div>
<div class="step" data-step="3"><span class="step-num">3</span> 简历</div>
<div class="step" data-step="4"><span class="step-num">4</span> 投递</div>
<div class="step" data-step="5"><span class="step-num">5</span> 记录</div>
</nav>
<!-- Step 1: 连接服务端 -->
<!-- Step 1: 登录 / 注册系统账号 -->
<section class="panel" id="panel-1">
<h2>连接云端服务端</h2>
<p class="hint">使用本机硬件指纹作为唯一编码注册,数据将隔离存储在你的账号下。</p>
<h2>登录系统账号</h2>
<p class="hint">简历与投递记录都保存在你的账号下,换机器登录同一账号即可延续数据。</p>
<div class="info-box">
<div><strong>机器指纹:</strong><code id="clientCode">加载中...</code></div>
<div><strong>服务端状态:</strong><span id="serverReachable" class="badge">检测中</span></div>
</div>
<div class="form-group">
<label>用户名</label>
<input type="text" id="username" placeholder="请输入用户名" autocomplete="username">
</div>
<div class="form-group">
<label>密码</label>
<input type="password" id="password" placeholder="请输入密码" autocomplete="current-password">
</div>
<div class="form-group hidden" id="nicknameGroup">
<label>昵称(可选)</label>
<input type="text" id="nickname" placeholder="给自己起个名字">
</div>
<button class="btn btn-primary" id="btnConnect">连接并注册</button>
<div class="action-buttons">
<button class="btn btn-primary" id="btnLogin">登 录</button>
<button class="btn hidden" id="btnRegister">注册新账号</button>
</div>
<p class="hint" id="authSwitchHint">没有账号?点击上方“注册新账号”切换为注册模式。</p>
</section>
<!-- Step 2: 登录 Boss直聘 -->
<section class="panel hidden" id="panel-2">
<h2>登录 Boss直聘</h2>
<p class="hint">点击下方按钮,将通过 AdsPower 指纹浏览器打开 Boss直聘,请在弹出的浏览器窗口中手动完成登录(扫码或账号密码)。</p>
<p class="hint">进入本步骤会自动检测指纹浏览器中的登录状态:若已登录可直接跳过;否则点击下方按钮打开 Boss直聘 手动登录(扫码或账号密码)。</p>
<div class="info-box">
<div><strong>AdsPower 状态:</strong><span id="adspowerStatus" class="badge">检测中</span></div>
<div><strong>登录状态:</strong><span id="loginStatus" class="badge">未登录</span></div>
</div>
<div class="spinner hidden" id="detectSpinner">正在检测指纹浏览器中的登录状态...</div>
<div class="action-buttons">
<button class="btn btn-primary" id="btnStartLogin">打开浏览器登录</button>
<button class="btn hidden" id="btnSkipLogin">已登录,直接下一步</button>
<button class="btn" id="btnRedetect">重新检测</button>
</div>
<div class="spinner hidden" id="loginSpinner">正在等待登录,请在浏览器中完成操作...</div>
</section>
+192
View File
@@ -0,0 +1,192 @@
# Boss直聘 AI 投递系统 — 优化方案
> 本文档汇总系统搭建后,通过评审讨论确定的优化项。
> 每个优化项包含:问题来源、现状缺陷、改造方案、涉及文件、验收标准与当前状态。
---
## 一、架构现状(优化前)
- **服务端**:FastAPI + MySQL + JWT,按 `client_code`(机器硬件指纹)识别用户
- **客户端**:本地 Web 控制面板 + AdsPower 指纹浏览器 + Playwright + AI 评分
- **身份模型**:以机器硬件指纹作为唯一编码注册,数据按用户隔离
本轮优化主要围绕**身份体系**与**登录健壮性**展开。
---
## 二、优化项清单
### ⭐ 优化项 1:系统登录改为「账号密码」体系(核心)
**问题来源**
- 「RPA 是不是要有一个登录步骤?要不然怎么知道这个 RPA 要登录到系统的哪一个账号?」
- 「RPA 的编码是不是应该以指纹浏览器为唯一?要不然用户切换了机器也会被认为是新的。」
**现状缺陷**
- 身份绑定在**机器硬件指纹**上:换机器 = 新用户,数据无法延续。
- 无真正的"账号"概念:无用户名、无密码、无法管理、无法找回。
- RPA 与账号无显式关系,无法明确"控制哪个 RPA 启停"。
**改造方案**(已确认:**账号密码登录**)
- 身份从"机器指纹 / Profile 编码"改为**服务端账号(用户名 + 密码)**。
- 账号存于服务端,与机器、与指纹浏览器 Profile 完全解耦。
- 指纹浏览器回归本职:仅作为访问 Boss直聘 的防检测浏览器工具(本地配置)。
- 数据(简历 / 投递记录)全部挂在账号下。
> 说明:此前讨论的"Profile localStorage 编码"方案已被账号密码体系取代,不再实施。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 服务端 | `server/auth.py` | 新增 `hash_password` / `verify_password`(PBKDF2);token payload 用 username |
| 服务端 | `server/models.py` | User 增加 `username`(唯一)、`password_hash`;`client_code` 降为可选设备标记 |
| 服务端 | `server/schemas.py` | 改造注册模型;新增登录请求/响应模型 |
| 服务端 | `server/routers/register.py` | 拆分 `/register`(注册)与 `/login`(登录)接口 |
| 客户端 | `client/server_api.py` | `register/login` 改为账密;保留 token 持久化 |
| 客户端 | `client/web/app.py` | 新增 `/api/register`、`/api/login`;替换指纹连接逻辑 |
| 客户端 | `client/web/templates/index.html` + `static/app.js` | Step1 改为登录/注册表单 |
**验收标准**
- [x] 可通过用户名密码注册新账号,密码以加盐哈希存储(不存明文)
- [x] 可通过用户名密码登录,返回 JWT token
- [x] 客户端保存 token,二次启动免登录;token 失效时引导重新登录
- [x] 换机器登录同一账号,可见原有简历与投递记录
**状态**:✅ 已完成
---
### 优化项 2:Boss直聘登录「活体检测」(重连健壮性)
**问题来源**
- 「如果 RPA 离线后再次登录,但指纹浏览器已经登录了 Boss 该怎么办?是不是应该做一个检查处理?」
**现状缺陷**
- 登录状态只存在服务端字段里(`login_status`),从不与真实浏览器做活体校验。
- 场景 A:Profile 里 Cookie 仍有效(已登录),却仍强制用户手动扫码。
- 场景 B:Cookie 已过期,但服务端仍记 `logged_in`,后续抓简历/投递会失败。
**改造方案**(已确认:**进入登录步骤自动检测**)
- 进入登录步骤时,自动调用 `BrowserManager.check_boss_login()` 做活体校验。
- 已登录 → 自动标记 `logged_in`,跳过手动登录,直接进入简历步骤。
- 未登录 → 展示手动登录引导(扫码/账密)。
- 新增 `/api/detect-login` 接口供前端触发。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 客户端 | `client/web/app.py` | 新增 `/api/detect-login`,内部调用 `check_boss_login` 并回写服务端状态 |
| 客户端 | `client/web/static/app.js` | 进入 Step2 自动触发检测,按结果决定跳过或引导登录 |
**验收标准**
- [x] Profile 已登录时,进入登录步骤自动识别并跳过手动登录
- [x] Cookie 失效时,能正确识别为未登录并引导重新登录
**状态**:✅ 已完成
---
### 优化项 3:单账号模式(范围决策,非编码项)
**问题来源**
- 「RPA 是不是需要与账号有一个关系?要不然怎么控制哪个 RPA 开始、哪个结束?」
**决策**(已确认:**单账号**)
- 一个客户端一次只服务一个账号,投递任务为该账号的全局单例。
- "启停控制"即"启停当前登录账号的投递任务",无需多账号实体。
- 多账号 / 多 Profile 独立启停为后续可扩展方向(届时引入 `RpaProfile` 实体)。
**状态**:已确认范围,本轮不做多账号改造
---
### 优化项 4:RPA 在线判定(心跳机制)
**问题来源**
- 「我们现在是怎么确认 RPA 在线的?」
**现状缺陷**(优化前)
- 无真正的在线判定:`last_seen_at` 只在登录/写操作时被动更新,客户端静默挂着不刷新。
- 前端 8 秒轮询只调只读接口 `/me`,服务端不记录为存活。
- 客户端崩溃/断网后服务端永远不知道离线,`logging_in` 状态会永久卡死。
**改造方案**
- 服务端新增 `/api/auth/heartbeat`,客户端登录后每 30s 上报一次,刷新 `last_seen_at`。
- 在线判定:`last_seen_at` 距今 ≤ 90s(= 3 个心跳周期)为在线。
- `/api/auth/me` 返回 `is_online` 字段;前端顶部展示“RPA在线/离线”徽章。
- 懒清理:客户端已离线却仍停留在 `logging_in` 时,自动重置为 `not_login`。
**涉及改动**
| 端 | 文件 | 改动内容 |
|----|------|---------|
| 服务端 | `server/schemas.py` | `UserInfo` 增加 `is_online` |
| 服务端 | `server/routers/register.py` | 新增 `/heartbeat`、`is_user_online` 判定、`/me` 懒清理 |
| 客户端 | `client/config.py` | 新增 `HEARTBEAT_INTERVAL=30` |
| 客户端 | `client/server_api.py` | 新增 `heartbeat()`(失败不抛异常) |
| 客户端 | `client/web/app.py` | 后台心跳线程(登录启动、退出停止);`/api/status` 返回 `rpa_online` |
| 客户端 | `client/web/static/app.js` | 顶部展示 RPA 在线徽章 |
**验收标准**
- [x] 登录后心跳线程自动启动,每 30s 上报;退出登录自动停止
- [x] 客户端关闭/断网 90s 后,服务端判定离线,前端徽章变为“RPA离线”
- [x] 离线时 `logging_in` 状态自动重置为 `not_login`
**业务底层收敛(重要设计约束)**
在线判定不允许在各路由里各自实现,统一收敛到 `server/online.py`:
| 服务 | 职责 | 使用方 |
|------|------|--------|
| `is_online(user)` | 纯判定,无副作用 | `/me` 返回在线状态 |
| `touch(user, db)` | 刷新活跃时间 | `/heartbeat` |
| `require_online_user` | 前置校验依赖:认证→先验在线→再刷新 | 所有需 RPA 存活的写操作 |
前置校验接入清单:
- ✅ `/api/sessions/start`(开始投递)、`/stats`(上报统计)
- ✅ `/api/auth/login-status`(Boss 登录状态变更)
- ✅ `/api/resumes/batch`(简历上传)、`/api/jobs/report`(投递上报)
- ⚠️ 特例:`/api/sessions/{id}/stop` 故意豁免在线拦截——stop 是安全清理操作,
否则离线前遗留的 running 僵尸会话永远无法关闭
- 只读查询接口(history/stats/list)不强制在线
客户端同步收敛:`client/web/app.py` 的 `_require_auth()` 统一未登录拦截,
`_require_rpa_online()` 在开始投递前先发心跳再确认服务端判定在线。
后续新增任何写操作接口,必须走 `require_online_user`,不得另起炉灶。
**状态**:✅ 已完成
---
## 三、已通过设计决策解决(无需单独实现)
| 讨论点 | 结论 |
|--------|------|
| RPA 编码唯一性(跨机器) | 由服务端账号体系解决:账号与机器/Profile 解耦 |
| RPA 与账号绑定、启停控制 | 单账号下,账号即身份,投递会话已有单实例约束 |
| 账号找回 | 使用服务端账号密码,账号常驻服务端,无需找回机制 |
---
## 四、实施顺序
1. **服务端账号密码体系**(优化项 1)
- auth.py 密码哈希 → models.py → schemas.py → register.py 路由
2. **客户端登录/注册**(优化项 1 客户端部分)
- server_api.py → web/app.py → 前端表单
3. **Boss登录活体检测**(优化项 2)
- web/app.py detect-login → 前端自动检测
4. **RPA 在线判定**(优化项 4)
- 服务端 heartbeat 接口 → 客户端心跳线程 → 前端徽章
---
## 五、决策记录
| 议题 | 选项 | 最终决定 |
|------|------|---------|
| 账号规模 | 单账号 / 多账号多开 | **单账号** |
| Boss登录检测时机 | 自动检测 / 手动按钮 / 两者 | **进入登录步骤自动检测** |
| 系统登录模式 | 纯编码自动 / 账号密码 / 混合 | **账号密码登录** |
| 账号找回 | 需要 / 不需要 | **不需要**(服务端账号密码天然解决) |
+35 -3
View File
@@ -1,6 +1,8 @@
"""
JWT 认证工具
JWT 认证工具 + 密码哈希
"""
import hashlib
import secrets
from datetime import datetime, timedelta
from typing import Optional
@@ -17,12 +19,42 @@ from .models import User
bearer_scheme = HTTPBearer(auto_error=False)
def create_access_token(user_id: int, client_code: str) -> str:
# ------------------------------------------------------------------
# 密码哈希(PBKDF2-SHA256,标准库实现,无需额外依赖)
# ------------------------------------------------------------------
_PBKDF2_ITERATIONS = 120_000
def hash_password(password: str) -> str:
"""生成 '盐$哈希' 格式的密码摘要"""
salt = secrets.token_hex(16)
digest = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt.encode("utf-8"), _PBKDF2_ITERATIONS
).hex()
return f"{salt}${digest}"
def verify_password(password: str, stored: str) -> bool:
"""校验明文密码与存储摘要是否匹配"""
try:
salt, digest = stored.split("$", 1)
except ValueError:
return False
candidate = hashlib.pbkdf2_hmac(
"sha256", password.encode("utf-8"), salt.encode("utf-8"), _PBKDF2_ITERATIONS
).hex()
return secrets.compare_digest(candidate, digest)
# ------------------------------------------------------------------
# JWT
# ------------------------------------------------------------------
def create_access_token(user_id: int, username: str) -> str:
"""生成 JWT token"""
expire = datetime.utcnow() + timedelta(days=settings.ACCESS_TOKEN_EXPIRE_DAYS)
payload = {
"sub": str(user_id),
"client_code": client_code,
"username": username,
"exp": expire,
}
return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM)
+9 -5
View File
@@ -18,17 +18,21 @@ def utcnow() -> datetime:
class User(Base):
"""
客户端用户
以机器硬件指纹(client_code)作为唯一标识
系统用户
以用户名(username)+ 密码哈希作为身份,与机器/指纹浏览器解耦
"""
__tablename__ = "users"
id = Column(Integer, primary_key=True, autoincrement=True)
# 机器硬件指纹哈希(唯一)
client_code = Column(String(128), unique=True, nullable=False, index=True)
# 登录用户名(唯一)
username = Column(String(64), unique=True, nullable=False, index=True)
# 密码加盐哈希(PBKDF2,格式:盐$摘要),不存明文
password_hash = Column(String(255), nullable=False)
# 客户端显示昵称(可选)
nickname = Column(String(64), nullable=True)
# JWT token 存储(服务端无状态校验,这里仅做记录)
# 最近一次登录的客户端设备指纹(仅作审计/展示,非身份标识)
client_code = Column(String(128), nullable=True)
# 账号是否启用
is_active = Column(Boolean, default=True, nullable=False)
# Boss直聘 账号标识(登录成功后回填,用于区分同一 Boss 账号)
boss_account = Column(String(128), nullable=True)
+60
View File
@@ -0,0 +1,60 @@
"""
RPA 在线状态服务(业务底层收敛)
====================================
所有与"客户端在线"相关的判定与刷新必须经由本模块,禁止在路由里各自实现:
- is_online(user) 纯判定:last_seen_at 距今是否在在线窗口内
- touch(user, db) 刷新活跃时间(心跳 / 任何业务请求)
- require_online_user 前置校验依赖:认证 + 刷新活跃 + 在线校验
使用约定:
- 心跳接口 → touch()
- 需要 RPA 存活的写操作(开始/结束投递、登录状态变更、简历上传、
投递上报等)→ require_online_user 前置校验
- 只读查询接口 → 仍用 get_current_user,不做在线强制
"""
from datetime import datetime
from fastapi import Depends, HTTPException, status
from sqlalchemy.orm import Session
from .auth import get_current_user
from .database import get_db
from .models import User
# 客户端心跳间隔 30s;连续 3 个周期(90s)无心跳即判定离线
ONLINE_WINDOW_SECONDS = 90
def is_online(user: User) -> bool:
"""判定客户端是否在线(纯函数,不产生任何写操作)"""
if not user.last_seen_at:
return False
return (datetime.utcnow() - user.last_seen_at).total_seconds() <= ONLINE_WINDOW_SECONDS
def touch(user: User, db: Session) -> None:
"""刷新活跃时间并提交(请求本身即在线信号)"""
user.last_seen_at = datetime.utcnow()
db.commit()
def require_online_user(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
) -> User:
"""
业务操作前置校验依赖(开始/结束投递、登录等必须走这里):
1. 认证(复用 get_current_user)
2. 先校验在线:若客户端已离线(心跳中断),直接拒绝操作
3. 再刷新活跃时间,让业务请求本身也成为在线信号
注意顺序:先校验后刷新。若先刷新,离线校验将永远通过,失去拦截意义。
"""
if not is_online(current_user):
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail="RPA 客户端已离线,请确认客户端正在运行后重试",
)
touch(current_user, db)
return current_user
+3 -2
View File
@@ -10,6 +10,7 @@ from sqlalchemy import func
from ..auth import get_current_user
from ..database import get_db
from ..models import User, JobApplication
from ..online import require_online_user
from ..schemas import ApplicationIn, ApplicationOut, Message, StatsOut
router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
@@ -19,11 +20,11 @@ router = APIRouter(prefix="/api/jobs", tags=["投递记录"])
def report_application(
req: ApplicationIn,
session_id: Optional[int] = Query(None, description="所属会话 ID"),
current_user: User = Depends(get_current_user),
current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""
客户端上报一条投递/跳过记录。
客户端上报一条投递/跳过记录(前置校验:RPA 必须在线)。
同一用户 + 同一职位 ID 去重,已存在则更新。
"""
existing = db.query(JobApplication).filter(
+59 -27
View File
@@ -1,59 +1,91 @@
"""
客户端注册 / 登录状态 / 用户信息路由
账号注册 / 登录 / 用户状态路由
"""
from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from ..auth import create_access_token, get_current_user
from ..auth import (
create_access_token, get_current_user, hash_password, verify_password,
)
from ..database import get_db
from ..models import User
from ..online import is_online, touch, require_online_user
from ..schemas import (
RegisterRequest, RegisterResponse, UserInfo, LoginStatusUpdate, Message,
RegisterRequest, LoginRequest, AuthResponse,
UserInfo, LoginStatusUpdate, Message,
)
router = APIRouter(prefix="/api/auth", tags=["认证与用户"])
@router.post("/register", response_model=RegisterResponse)
@router.post("/register", response_model=AuthResponse)
def register(req: RegisterRequest, db: Session = Depends(get_db)):
"""
客户端注册/登录。
以机器硬件指纹 client_code 作为唯一标识:
- 已存在 → 直接返回 token(视为登录)
- 不存在 → 创建新用户
"""
user = db.query(User).filter(User.client_code == req.client_code).first()
is_new = user is None
"""注册新账号(用户名 + 密码)"""
exists = db.query(User).filter(User.username == req.username).first()
if exists:
raise HTTPException(status_code=409, detail="用户名已存在")
if is_new:
user = User(client_code=req.client_code, nickname=req.nickname)
user = User(
username=req.username,
password_hash=hash_password(req.password),
nickname=req.nickname,
)
db.add(user)
db.commit()
db.refresh(user)
# 更新最后活跃时间
token = create_access_token(user.id, user.username)
return AuthResponse(user_id=user.id, username=user.username, token=token)
@router.post("/login", response_model=AuthResponse)
def login(req: LoginRequest, db: Session = Depends(get_db)):
"""账号密码登录,返回 JWT token"""
user = db.query(User).filter(User.username == req.username).first()
if user is None or not verify_password(req.password, user.password_hash):
raise HTTPException(status_code=401, detail="用户名或密码错误")
if not user.is_active:
raise HTTPException(status_code=403, detail="账号已被禁用")
# 记录登录设备与活跃时间(client_code 仅作审计)
if req.client_code:
user.client_code = req.client_code
user.last_seen_at = datetime.utcnow()
db.commit()
token = create_access_token(user.id, user.client_code)
return RegisterResponse(
user_id=user.id,
token=token,
client_code=user.client_code,
is_new=is_new,
)
token = create_access_token(user.id, user.username)
return AuthResponse(user_id=user.id, username=user.username, token=token)
@router.post("/heartbeat", response_model=Message)
def heartbeat(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""客户端心跳:刷新 last_seen_at,用于在线判定(统一走 online.touch)"""
touch(current_user, db)
return Message(msg="ok")
@router.get("/me", response_model=UserInfo)
def get_me(current_user: User = Depends(get_current_user)):
"""获取当前用户信息"""
def get_me(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""获取当前用户信息(含 RPA 在线状态)"""
online = is_online(current_user)
# 懒清理:客户端已离线却仍停留在“登录中”,说明登录轮询已中断,重置为未登录
if not online and current_user.login_status == "logging_in":
current_user.login_status = "not_login"
db.commit()
return UserInfo(
id=current_user.id,
client_code=current_user.client_code,
username=current_user.username,
nickname=current_user.nickname,
boss_account=current_user.boss_account,
login_status=current_user.login_status,
is_online=online,
created_at=current_user.created_at,
)
@@ -61,10 +93,10 @@ def get_me(current_user: User = Depends(get_current_user)):
@router.put("/login-status", response_model=Message)
def update_login_status(
req: LoginStatusUpdate,
current_user: User = Depends(get_current_user),
current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""更新 Boss直聘 登录状态"""
"""更新 Boss直聘 登录状态(前置校验:RPA 必须在线)"""
valid_status = {"not_login", "logging_in", "logged_in"}
if req.login_status not in valid_status:
raise HTTPException(status_code=400, detail=f"登录状态必须是 {valid_status} 之一")
+3 -2
View File
@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user
from ..database import get_db
from ..models import User, Resume
from ..online import require_online_user
from ..schemas import ResumeIn, ResumeOut, ResumeBatchIn, Message
router = APIRouter(prefix="/api/resumes", tags=["简历管理"])
@@ -40,11 +41,11 @@ def get_primary_resume(
@router.post("/batch", response_model=list[ResumeOut])
def upload_resumes_batch(
req: ResumeBatchIn,
current_user: User = Depends(get_current_user),
current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""
批量上传抓取到的简历。
批量上传抓取到的简历(前置校验:RPA 必须在线)。
以 boss_resume_id 去重:存在则更新,不存在则新增。
第一份简历自动设为主简历(若当前没有主简历)。
"""
+10 -5
View File
@@ -8,6 +8,7 @@ from sqlalchemy.orm import Session
from ..auth import get_current_user
from ..database import get_db
from ..models import User, ApplySession
from ..online import require_online_user
from ..schemas import SessionStartIn, SessionOut, SessionStatsIn, Message
router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@@ -16,10 +17,10 @@ router = APIRouter(prefix="/api/sessions", tags=["投递会话"])
@router.post("/start", response_model=SessionOut)
def start_session(
req: SessionStartIn,
current_user: User = Depends(get_current_user),
current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""开始一次投递会话"""
"""开始一次投递会话(前置校验:RPA 必须在线)"""
# 若已有进行中的会话,先结束它
running = db.query(ApplySession).filter(
ApplySession.user_id == current_user.id,
@@ -64,7 +65,11 @@ def stop_session(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""结束指定会话"""
"""
结束指定会话。
特例:start 需在线前置校验,但 stop 是安全清理操作,故意豁免在线拦截——
否则离线前遗留的 running 僵尸会话将永远无法关闭。
"""
session = db.query(ApplySession).filter(
ApplySession.id == session_id,
ApplySession.user_id == current_user.id,
@@ -82,10 +87,10 @@ def stop_session(
def update_session_stats(
session_id: int,
req: SessionStatsIn,
current_user: User = Depends(get_current_user),
current_user: User = Depends(require_online_user),
db: Session = Depends(get_db),
):
"""增量上报投递/跳过数量"""
"""增量上报投递/跳过数量(前置校验:RPA 必须在线)"""
session = db.query(ApplySession).filter(
ApplySession.id == session_id,
ApplySession.user_id == current_user.id,
+15 -7
View File
@@ -7,23 +7,30 @@ from pydantic import BaseModel, Field
# =======================================================
# 认证相关
# 认证相关(账号密码体系)
# =======================================================
class RegisterRequest(BaseModel):
client_code: str = Field(..., min_length=8, max_length=128, description="机器硬件指纹哈希")
username: str = Field(..., min_length=3, max_length=64, description="登录用户名")
password: str = Field(..., min_length=6, max_length=128, description="登录密码")
nickname: Optional[str] = Field(None, max_length=64)
class RegisterResponse(BaseModel):
class LoginRequest(BaseModel):
username: str = Field(..., min_length=1, max_length=64)
password: str = Field(..., min_length=1, max_length=128)
# 可选:客户端设备指纹(仅作审计记录)
client_code: Optional[str] = Field(None, max_length=128)
class AuthResponse(BaseModel):
user_id: int
username: str
token: str
client_code: str
is_new: bool # 是否为新注册用户
class TokenPayload(BaseModel):
sub: int # user_id
client_code: str
username: str
# =======================================================
@@ -31,10 +38,11 @@ class TokenPayload(BaseModel):
# =======================================================
class UserInfo(BaseModel):
id: int
client_code: str
username: str
nickname: Optional[str]
boss_account: Optional[str]
login_status: str
is_online: bool # RPA 客户端是否在线(心跳判定)
created_at: datetime
class Config: