Repository navigation
Expand file tree
/
Copy pathopencode_usage.py
More file actions
618 lines (556 loc) · 27.8 KB
/
Copy pathopencode_usage.py
File metadata and controls
618 lines (556 loc) · 27.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
# -*- coding: utf-8 -*-
"""
OpenCode Usage Console · 一体化本地工具(前后端绑定)
一条命令启动:服务常驻 9901 端口,前端按需手动访问 http://127.0.0.1:9901/
(默认不再自动打开浏览器;如需启动后自动打开页面,设置环境变量 OPEN_BROWSER=1)。
前端可:点击更新(运行 scrape_usage.py,纯 HTTP 直调 opencode Console API 翻页爬取,速度快)、
管理多个账号(凭据/登录态/org 按账号各自保存,一次更新可遍历全部账号)、
选择下载时间段(全部/指定/固定周期)、开启自动更新(后台定时线程按设置周期自动爬取,
即使前端页面关闭也持续生效)、一键导出 Excel 报表。
数据存储只有一份:本地 SQLite 库 opencode_usage.db。爬虫只写库,页面只读库;
需要表格时从库里现生成下载文件,不再维护第二份存储(老安装的遗留表格只做一次性迁移)。
用法:
python opencode_usage.py
python OPEN_BROWSER=1 opencode_usage.py # 想自动打开浏览器时
API:
GET /index.html 前端页面(根路径 / 亦返回)
GET /api/status 本地库状态(条数、最新记录时间、文件时间戳)
GET /api/agg 本地库按 分钟×账号×模型 的聚合结果
GET /api/export.xlsx 从本地库现生成一份 Excel 报表(按需产出,不是第二份存储)
GET /api/autofetch 自动更新配置(不含任何凭据)
POST /api/autofetch {enabled, interval, unit, timeMode, start, end, months, incremental}
GET /api/accounts 账号列表(不含密码)+ activeId
POST /api/accounts {id?, email, password, loginMethod, label} 新增或修改账号
POST /api/accounts/select {id} 切换当前账号
POST /api/accounts/delete {id} 删除账号(连同它的登录态文件)
POST /api/update {accountId, start, end, months, incremental, workspace}
accountId 为注册表条目 id,或 "all" 遍历全部账号
运行爬虫更新数据(SSE 流式返回爬虫进度)
"""
import json
import os as _os
import re
import subprocess
import sys as _sys
import tempfile as _tempfile
import accounts # 多账号注册表(凭据/登录态/身份/org),与爬虫共用同一份
# Windows 子进程隐藏控制台窗口(CREATE_NO_WINDOW = 0x08000000),pythonw 路径避免 cmd 弹窗
IS_WIN = _sys.platform.startswith("win")
NO_WINDOW = 0x08000000 if IS_WIN else 0
def resolve_python_bin() -> str:
"""爬虫子进程解释器 = 运行本服务的那个解释器。裸名 pythonw 会按 PATH 命中另一个
没装依赖的 Python,子进程直接失败退出(前端只见 rc=1,看不到原因)。"""
exe = _sys.executable
if getattr(_sys, "frozen", False) or not exe:
return "pythonw" if IS_WIN else "python"
if IS_WIN and exe.lower().endswith("python.exe") and _os.path.exists(exe[:-len("python.exe")] + "pythonw.exe"):
return exe[:-len("python.exe")] + "pythonw.exe"
return exe
PYTHON_BIN = resolve_python_bin()
import threading
import time
import webbrowser # 仅在显式传入 OPEN_BROWSER=1 环境变量时自动打开页面,避免后台启动每次弹浏览器
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
import usage_db # 本地 SQLite:唯一数据存储(前端只读它的聚合结果)
BASE = Path(__file__).parent
HTML_FILE = BASE / "index.html"
# 只用于"老安装首次升级"的一次性迁移:库里没数据时把这份历史表格灌进去,之后不再读写
LEGACY_XLSX = BASE / "opencode_usage_history.xlsx"
SCRAPE_SCRIPT = BASE / "scrape_usage.py"
CONFIG_FILE = BASE / "autofetch_config.json"
AUTOFETCH_LOG = BASE / "autofetch.log"
PORT = 9901
_update_lock = threading.Lock()
_next_run_ts = 0.0 # 后台线程排定的下次执行时间戳(0=未排期),供前端展示
def append_run_log(msg: str) -> None:
"""每次更新的真实子进程输出统一落盘:手动更新过去只把日志 SSE 推给前端,
前端一关就查不到任何痕迹,失败原因无法复盘。"""
line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}"
try:
with AUTOFETCH_LOG.open("a", encoding="utf-8") as f:
f.write(line + "\n")
except Exception:
pass
# 凭据不在此列:账号邮箱/密码/登录方式属于账号注册表(accounts.py),一个账号一份登录态
DEFAULT_AUTOFETCH = {
"enabled": False,
"interval": 30,
"unit": "min",
"timeMode": "all",
"start": "",
"end": "",
"months": 0,
"incremental": False,
}
def build_scrape_cmd(account="all", workspace="", start="", end="", months=0,
incremental=False, force_login=False, email="", password="",
login_method=""):
"""构造爬虫命令行(手动更新与后台自动更新共用)。
账号由 `--account` 指定:注册表条目 id 更新单个账号,"all" 一次遍历全部账号
(爬虫内部串行跑完每个账号,Excel/库只重写一次,不会互相覆盖)。
默认优先复用该账号的缓存登录态(storage_state),不强制重新登录;仅当需要换账号或
缓存失效需用账号密码重登时 force_login=True。workspace 留空则交给爬虫自动获取。
"""
cmd = [PYTHON_BIN, "-u", str(SCRAPE_SCRIPT)] # -u: 无缓冲输出,进度实时可读
cmd += ["--account", account or "all"]
if force_login:
cmd += ["--force-login"]
if login_method:
cmd += ["--login-method", login_method]
if workspace:
cmd += ["--workspace", workspace]
if email:
cmd += ["--email", email]
if password:
cmd += ["--password", password]
if start or end:
# 指定了下载时间段 → 爬取所有月份后再按时间段过滤
cmd += ["--months", "0"]
if start:
cmd += ["--start", start]
if end:
cmd += ["--end", end]
else:
# 未指定时间段:固定周期传 months,否则(全部数据)months=0 表示不过滤
cmd += ["--months", str(months)]
if incremental:
cmd += ["--incremental"]
return cmd
def load_autofetch_config() -> dict:
"""读取自动更新配置(本地文件持久化,非数据库)。
只认 DEFAULT_AUTOFETCH 里的键:旧版本文件里的 email/password/loginMethod/accountHash
已由 accounts 迁移进注册表,这里过滤掉,下一次保存自然把它们清出配置文件。
"""
cfg = dict(DEFAULT_AUTOFETCH)
if CONFIG_FILE.exists():
try:
data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
if isinstance(data, dict):
cfg.update({k: v for k, v in data.items() if k in DEFAULT_AUTOFETCH})
except Exception:
pass
return cfg
def save_autofetch_config(cfg: dict) -> None:
CONFIG_FILE.write_text(json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8")
def run_scraper_blocking(cmd) -> tuple:
"""阻塞式运行爬虫,返回 (returncode, 末尾日志)。"""
# Windows 默认 locale 为 GBK,pythonw 子进程 stdout 含中文 / 特殊字符时会触发
# "'gbk' codec can't encode ..." 而崩溃。把 Popen 的 stdout 强制按 utf-8 解码,
# 并把 PYTHONIOENCODING 透传给子进程以保证写入端也用 utf-8。
env = None
if IS_WIN:
env = {**_os.environ, "PYTHONIOENCODING": "utf-8", "PYTHONUTF8": "1"}
proc = subprocess.Popen(
cmd, cwd=str(BASE),
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
text=True, encoding="utf-8", errors="replace",
env=env,
creationflags=NO_WINDOW, # Windows: 隐藏子进程控制台窗口,避免每次自动更新弹出黑框
)
assert proc.stdout is not None
log_buf = []
for line in proc.stdout:
line = line.rstrip()
log_buf.append(line)
proc.wait(timeout=1800)
return proc.returncode, "\n".join(log_buf[-80:])
def interval_seconds(cfg: dict) -> int:
"""配置周期换算成秒。"""
unit_sec = {"min": 60, "hour": 3600, "day": 86400}.get(cfg.get("unit", "min"), 60)
return max(1, int(cfg.get("interval") or 30)) * unit_sec
AUTOFETCH_TICK = 2 # 轮询配置的秒数:保存后无需重启即可改期
def autofetch_loop():
"""后台自动更新线程:按配置周期循环执行爬虫(前端页面关闭也持续生效)。
以短周期轮询配置而非一次性 sleep 整个间隔:设置页保存后(间隔、开关、增量)下一 tick
即生效,不需要重启服务。
日志统一写入 AUTOFETCH_LOG 文件,便于事后排查线程是否真正在跑、每次执行结果。"""
AUTOFETCH_LOG.parent.mkdir(parents=True, exist_ok=True)
def _log(msg: str) -> None:
print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {msg}", flush=True)
append_run_log(msg)
def _schedule(cfg: dict) -> float:
ts = time.time() + interval_seconds(cfg)
_log(f"下次执行: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts))} "
f"(interval={cfg.get('interval')} {cfg.get('unit')}, incremental={bool(cfg.get('incremental'))})")
return ts
_log("后台自动更新线程已启动")
deadline = 0.0
deadline_interval = 0
global _next_run_ts
while True:
try:
cfg = load_autofetch_config()
if not cfg.get("enabled"):
if deadline:
_log("自动更新已关闭,暂停排期")
deadline, deadline_interval = 0.0, 0
_next_run_ts = 0.0
time.sleep(AUTOFETCH_TICK)
continue
interval = interval_seconds(cfg)
if not deadline or interval != deadline_interval:
if deadline and interval != deadline_interval:
_log(f"配置已变更(interval={cfg.get('interval')} {cfg.get('unit')}),重新排期")
deadline = _schedule(cfg)
deadline_interval = interval
_next_run_ts = deadline
remaining = deadline - time.time()
if remaining > 0:
time.sleep(min(remaining, AUTOFETCH_TICK))
continue
# 到点:重新读取配置(期间可能被修改/关闭),且无更新任务进行中才执行
deadline = 0.0
cfg = load_autofetch_config()
if not cfg.get("enabled"):
_log("配置已关闭,跳过本轮")
continue
if not _update_lock.acquire(blocking=False):
_log("有更新任务进行中,跳过本轮")
continue
try:
start = cfg.get("start") or ""
end = cfg.get("end") or ""
months = int(cfg.get("months") or 0)
# 自动更新固定遍历全部账号:账号是并列的,不能只刷其中一个
cmd = build_scrape_cmd(account="all", start=start, end=end, months=months,
incremental=bool(cfg.get("incremental")))
_log(f"自动更新开始: {' '.join(cmd)}")
rc, tail = run_scraper_blocking(cmd)
_log(f"自动更新结束 rc={rc}\n{tail}")
except Exception as e:
_log(f"自动更新失败: {e}")
finally:
_update_lock.release()
except Exception as e:
# 任何顶层异常(加载配置 / IO 等)都不能让线程退出,必须持续循环
_log(f"autofetch_loop 顶层异常: {type(e).__name__}: {e}")
time.sleep(5)
def add_common_headers(handler):
handler.send_header("Access-Control-Allow-Origin", "*")
handler.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
handler.send_header("Access-Control-Allow-Headers", "Content-Type")
# 本地工具改版频繁:禁止浏览器缓存页面与接口响应,避免旧版前端脚本站着位置继续覆盖配置
handler.send_header("Cache-Control", "no-store")
class Handler(BaseHTTPRequestHandler):
def _send(self, code, body: bytes, ctype="application/json; charset=utf-8"):
self.send_response(code)
self.send_header("Content-Type", ctype)
self.send_header("Content-Length", str(len(body)))
add_common_headers(self)
self.end_headers()
self.wfile.write(body)
def _send_json(self, code, obj):
self._send(code, json.dumps(obj, ensure_ascii=False).encode())
def _send_agg(self):
"""按分钟×账号×模型聚合的明细,供前端渲染(响应体积随组数增长,但远小于整份报表)。"""
conn = None
try:
conn = usage_db.connect()
# 旧库首次打开时按"升级前那个账号"回填历史行的归属
usage_db.init(conn, accounts.default_identity())
msg = usage_db.import_excel_if_needed(conn, LEGACY_XLSX,
default_identity=accounts.legacy_identity())
if msg.startswith("已从历史"):
append_run_log(f"历史表格一次性迁移: {msg}")
self._send_json(200, {
"rows": usage_db.agg_rows(conn),
"models": usage_db.models(conn),
"records": usage_db.count_records(conn),
"source": "sqlite",
})
except Exception as e:
# 本地库就是唯一数据源,读不出来如实报错(不再回退去读表格,那份数据可能已经过期)
append_run_log(f"本地库聚合失败: {type(e).__name__}: {e}")
self._send_json(503, {"ok": False, "error": f"{type(e).__name__}: {e}"})
finally:
if conn is not None:
conn.close()
def _export_xlsx(self):
"""按需从本地库生成 xlsx 供下载:报表是产物不是存储,临时文件发完即删。"""
tmp, conn, n = "", None, 0
try:
fd, tmp = _tempfile.mkstemp(prefix="ocu_export_", suffix=".xlsx")
_os.close(fd)
conn = usage_db.connect()
usage_db.init(conn, accounts.default_identity())
n = usage_db.export_xlsx(conn, Path(tmp))
data = Path(tmp).read_bytes()
name = f"opencode_usage_history_{time.strftime('%Y%m%d')}.xlsx"
self.send_response(200)
self.send_header("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
self.send_header("Content-Disposition", f'attachment; filename="{name}"')
self.send_header("Content-Length", str(len(data)))
self.send_header("X-Export-Rows", str(n))
add_common_headers(self)
self.end_headers()
self.wfile.write(data)
append_run_log(f"导出报表: {n} 行 → {name}")
except Exception as e:
append_run_log(f"导出报表失败: {type(e).__name__}: {e}")
self._send_json(500, {"ok": False, "error": f"{type(e).__name__}: {e}"})
finally:
if conn is not None:
conn.close()
if tmp:
try:
_os.remove(tmp)
except OSError:
pass
def log_message(self, fmt, *args):
pass
# ---- 预检 ----
def do_OPTIONS(self):
self.send_response(204)
add_common_headers(self)
self.end_headers()
# ---- GET ----
def do_GET(self):
path = self.path.split("?")[0]
if path in ("/", "/index.html"):
if not HTML_FILE.exists():
self._send(404, b"index.html not found")
return
self._send(200, HTML_FILE.read_bytes(), "text/html; charset=utf-8")
elif path == "/favicon.ico":
self._send(204, b"")
elif path == "/api/export.xlsx":
self._export_xlsx()
elif path == "/opencode-icon.svg":
icon = BASE / "assets" / "opencode-icon.svg"
if not icon.exists():
self._send_json(404, {"ok": False, "error": "icon not found"})
return
self._send(200, icon.read_bytes(), "image/svg+xml")
elif path == "/api/status":
# 状态源就是唯一存储本身:records/latest 变化即代表有新数据(WAL 下文件 mtime 会滞后,不能只靠它)
info = {"exists": usage_db.DB_PATH.exists(), "db": usage_db.DB_PATH.name}
conn = None
try:
if info["exists"]:
info["size"] = usage_db.DB_PATH.stat().st_size
info["mtime"] = usage_db.DB_PATH.stat().st_mtime
conn = usage_db.connect()
row = conn.execute("SELECT COUNT(*) AS n, MAX(started_at) AS t FROM usage_records").fetchone()
info["records"] = row["n"]
info["latest"] = row["t"] or ""
except Exception as e:
info["error"] = f"{type(e).__name__}: {e}"
finally:
if conn is not None:
conn.close()
self._send_json(200, info)
elif path == "/api/agg":
self._send_agg()
elif path == "/api/accounts":
# 只返回脱敏视图:密码留在服务端配置文件里,绝不出接口
self._send_json(200, accounts.public_all())
elif path == "/api/autofetch":
cfg = load_autofetch_config()
# 后台线程排定的下次执行时间(禁用它为空串),前端据此展示"下一次什么时候跑"
cfg["nextRun"] = (time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(_next_run_ts))
if _next_run_ts else "")
self._send_json(200, cfg)
else:
self._send_json(404, {"ok": False, "error": "not found"})
# ---- POST ----
def do_POST(self):
if self.path == "/api/update":
self._run_update()
elif self.path == "/api/autofetch":
self._set_autofetch()
elif self.path == "/api/accounts":
self._set_account()
elif self.path == "/api/accounts/select":
self._select_account()
elif self.path == "/api/accounts/delete":
self._delete_account()
else:
self._send_json(404, {"ok": False, "error": "not found"})
def _read_json_body(self):
try:
length = int(self.headers.get("Content-Length") or 0)
if length <= 0:
return {}
return json.loads(self.rfile.read(length).decode("utf-8"))
except Exception:
return {}
def _set_autofetch(self):
body = self._read_json_body()
cfg = load_autofetch_config()
for key in DEFAULT_AUTOFETCH:
if key in body:
cfg[key] = body[key]
save_autofetch_config(cfg)
state = "开启" if cfg.get("enabled") else "关闭"
unit_sec = {"min": "分钟", "hour": "小时", "day": "天"}.get(cfg.get("unit"), "分钟")
self._send_json(200, {"ok": True, "enabled": cfg.get("enabled"),
"desc": f"自动更新已{state}(每 {cfg.get('interval')} {unit_sec} 一次)"})
# ---- 账号(多账号)----
def _set_account(self):
"""新增或修改账号。密码留空表示沿用已存的凭据,不会把后端凭据清掉。"""
body = self._read_json_body()
email = (body.get("email") or "").strip()
password = (body.get("password") or "").strip()
method = (body.get("loginMethod") or "").strip()
entry_id_ = (body.get("id") or "").strip()
if not (email or password or method or entry_id_):
self._send_json(400, {"ok": False, "error": "至少要有账号邮箱或登录方式"})
return
entry = accounts.upsert(email=email, password=password,
login_method=method or "github",
label=(body.get("label") or "").strip(), entry_id_=entry_id_)
if not entry:
self._send_json(404, {"ok": False, "error": f"未找到账号 {entry_id_}"})
return
self._send_json(200, {"ok": True, "account": accounts.public(entry)})
def _select_account(self):
body = self._read_json_body()
entry_id_ = (body.get("id") or "").strip()
entry = accounts.find(entry_id_)
if not entry:
self._send_json(404, {"ok": False, "error": f"未找到账号 {entry_id_}"})
return
reg = accounts.load()
reg["activeId"] = entry["id"]
accounts.save(reg)
self._send_json(200, {"ok": True, "activeId": entry["id"]})
def _delete_account(self):
body = self._read_json_body()
entry_id_ = (body.get("id") or "").strip()
if not accounts.remove(entry_id_):
self._send_json(404, {"ok": False, "error": f"未找到账号 {entry_id_}"})
return
self._send_json(200, {"ok": True, **accounts.public_all()})
def _run_update(self):
if not SCRAPE_SCRIPT.exists():
self._send_json(500, {"ok": False, "error": "scrape_usage.py not found"})
return
if not _update_lock.acquire(blocking=False):
self._send_json(409, {"ok": False, "error": "已有更新任务在运行,请稍候"})
return
body = self._read_json_body()
workspace = (body.get("workspace") or "").strip()
start = (body.get("start") or "").strip()
end = (body.get("end") or "").strip()
months = int(body.get("months") or 0)
incremental = bool(body.get("incremental"))
# accountId:注册表条目 id 只更新该账号;"all"/留空 = 一次遍历全部账号(爬虫内部串行跑完)
account = (body.get("accountId") or body.get("account") or "all").strip() or "all"
if account != "all" and not accounts.find(account):
_update_lock.release()
self._send_json(404, {"ok": False, "error": f"未找到账号 {account}"})
return
cmd = build_scrape_cmd(account=account, workspace=workspace, start=start, end=end,
months=months, incremental=incremental)
# SSE 流式响应:爬虫 stdout 逐行实时推送给前端
self.send_response(200)
self.send_header("Content-Type", "text/event-stream; charset=utf-8")
self.send_header("Cache-Control", "no-cache")
self.send_header("Connection", "keep-alive")
add_common_headers(self)
self.end_headers()
def emit(event_type, **fields):
try:
payload = json.dumps({"type": event_type, **fields}, ensure_ascii=False)
self.wfile.write(("data: " + payload + "\n\n").encode("utf-8"))
self.wfile.flush()
except Exception:
pass
def _stream_scraper(cmd, emit):
"""运行爬虫并逐行 SSE 推送 stdout,返回 (returncode, 完整日志)。"""
env = None
if IS_WIN:
env = {**_os.environ, "PYTHONIOENCODING": "utf-8", "PYTHONUTF8": "1"}
proc = subprocess.Popen(
cmd, cwd=str(BASE),
stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
text=True, encoding="utf-8", errors="replace",
env=env,
creationflags=NO_WINDOW, # Windows: 隐藏子进程控制台窗口
)
assert proc.stdout is not None
log_buf = []
for line in proc.stdout:
line = line.rstrip()
log_buf.append(line)
if line:
emit("line", text=line)
proc.wait(timeout=1800)
return proc.returncode, "\n".join(log_buf)
try:
# 三层恢复由爬虫内部处理(缓存→关联账号→账号密码),此处仅以缓存登录态启动一次
emit("start", cmd=" ".join(cmd))
append_run_log(f"手动更新开始: {' '.join(cmd)}")
rc, full = _stream_scraper(cmd, emit)
m = re.search(r"总计记录[::]\s*(\d+)", full)
rows = int(m.group(1)) if m else None
append_run_log(f"手动更新结束 rc={rc} rows={rows}\n{full[-4000:]}")
emit("done", ok=rc == 0, returncode=rc, rows=rows, log=full[-2500:])
except subprocess.TimeoutExpired:
append_run_log("手动更新结束 超时(超过 30 分钟)")
emit("done", ok=False, error="更新超时(超过 30 分钟)")
except Exception as e:
append_run_log(f"手动更新结束 异常 {type(e).__name__}: {e}")
emit("done", ok=False, error=str(e))
finally:
_update_lock.release()
# 关键:显式关闭 SSE 连接,否则前端 reader.read() 永不结束(done 事件后仍阻塞)
try:
self.wfile.flush()
self.close_connection = True
except Exception:
pass
class Server(ThreadingHTTPServer):
# Windows 下 SO_REUSEADDR 允许同一端口被重复绑定,两个实例会同时跑并各自起定时线程;
# 关掉复用让第二个实例直接绑定失败,保证单实例。
allow_reuse_address = False
if __name__ == "__main__":
print("=" * 60)
print(" OpenCode Usage Console · 一体化工具")
print(f" 页面地址 : http://127.0.0.1:{PORT}/")
print(" 功能 : 前端点更新 / 多账号管理与切换 / 选择下载时间段 / 自动更新 / 导出报表")
print(f" 数据存储 : 本地库 {usage_db.DB_PATH.name}(唯一存储,报表按需导出)")
print(" 停止服务 : 关闭本窗口或 Ctrl + C")
print("=" * 60)
# 启动后台自动更新线程(前端页面关闭也持续生效)
AUTOFETCH_LOG.parent.mkdir(parents=True, exist_ok=True)
try:
with AUTOFETCH_LOG.open("a", encoding="utf-8") as _f:
_f.write(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 服务启动 PID={_os.getpid()} python={_sys.executable}\n")
except Exception:
pass
try:
_t = threading.Thread(target=autofetch_loop, daemon=True, name="autofetch-loop")
_t.start()
with AUTOFETCH_LOG.open("a", encoding="utf-8") as _f:
_f.write(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] autofetch_loop 线程已启动 alive={_t.is_alive()}\n")
except Exception as _e:
try:
with AUTOFETCH_LOG.open("a", encoding="utf-8") as _f:
_f.write(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] autofetch_loop 线程启动失败: {_e}\n")
except Exception:
pass
raise
# 本地库就绪:老库在这里完成"加账号列 + 按升级前账号回填归属"的迁移;
# 只有库里还没有数据时,才把遗留的历史表格一次性灌进来
try:
_conn = usage_db.connect()
try:
usage_db.init(_conn, accounts.default_identity())
_msg = usage_db.import_excel_if_needed(_conn, LEGACY_XLSX,
default_identity=accounts.legacy_identity())
append_run_log(f"本地库就绪: {usage_db.count_records(_conn)} 条明细 · "
f"{len(accounts.list_accounts())} 个账号({_msg})")
finally:
_conn.close()
except Exception as _e:
append_run_log(f"本地库初始化失败(页面将直接报错,不再有表格兜底): {_e!r}")
server = Server(("127.0.0.1", PORT), Handler)
# 默认不再自动打开前端页面;只有显式 OPEN_BROWSER=1 才打开(避免后台启动弹浏览器、占用焦点)
if _os.environ.get("OPEN_BROWSER") == "1":
threading.Timer(1.0, lambda: webbrowser.open(f"http://127.0.0.1:{PORT}/")).start()
try:
server.serve_forever()
except KeyboardInterrupt:
print("\n服务已停止")