creditdaddy 1.3.0 → 1.3.2

package/README.md

@@ -16,7 +16,10 @@
 
 [下载](#下载) · [架构](#%EF%B8%8F-架构) · [功能](#功能) · [10Router 集成](#10router-集成) · [产品线说明](#产品线说明) · [快速开始](#快速开始) · [HTTP API](#本地-http-api) · [相关项目](#-相关项目) · [贡献者致谢](#-贡献者致谢) · [许可证](#-许可证)
 
-<img src="docs/screenshot-dashboard.png" width="860" alt="CreditDaddy 仪表盘">
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/screenshot-dashboard-dark.png">
+  <img src="docs/screenshot-dashboard-light.png" width="860" alt="CreditDaddy 仪表盘">
+</picture>
 
 </div>
 
@@ -146,10 +149,29 @@
 # 全局安装（npm）
 npm i -g creditdaddy
 
-# 启动后台守护进程（默认访问 http://127.0.0.1:47860）
+# 后台启动（关掉终端也继续跑，默认 http://127.0.0.1:47860）
+creditdaddy start
+
+# 或者前台跑（Ctrl+C 停止，调试用）
 creditdaddy daemon
 ```
 
+**后台运行**（CLI 用户用这个，不需要一直开着终端）：
+
+```bash
+creditdaddy start      # 后台启动；已在运行则直接报出地址，不会起第二个
+creditdaddy status     # 查看运行状态（未运行时退出码 1，便于脚本判断）
+creditdaddy stop       # 停止（没在跑也算成功）
+creditdaddy restart    # 重启
+```
+
+`start` 会把实例拉到独立进程组，终端窗口关掉、SSH 断开都不影响每日自动签到。运行信息记在
+`<数据目录>/daemon.json`，日志在 `<数据目录>/logs/background.log`（按日归档的运行日志另在
+`daemon-<日期>.log`）。`start` / `stop` 都是幂等的，脚本里可以放心串着写。
+
+> 想要**托盘图标**和**开机自启**请用方式一的桌面版；CLI 这条路只做后台守护，不装任何原生依赖。
+> 也可以把 `creditdaddy start` 挂到系统服务 / 任务计划程序上实现开机自启。
+
 **CLI 常用命令**：
 
 ```bash

package/bin/creditdaddy.js

@@ -8,6 +8,8 @@
  *   creditdaddy remove <id>     删除账号
  *   creditdaddy export/import   导出/导入账号
  *   creditdaddy logs            查看领取状态（state.json）
+ *   creditdaddy start/stop      后台运行（关掉终端不影响每日签到）
+ *   creditdaddy status          查看后台运行状态
  *   creditdaddy help            显示帮助
  */
 
@@ -16,6 +18,7 @@ import { logger } from '../src/logger.js';
 
 const args = process.argv.slice(2);
 const cmd = args[0] || 'daemon';
+const DEFAULT_BG_PORT = 47860;   // 与 src/daemon.js 的 DEFAULT_PORT 一致
 
 const HELP = `CreditDaddy — Qoder / WorkBuddy / ZCode / mirasim / 妙手 / Trae 多账号管理 + 每日积分自动领取
 
@@ -31,6 +34,10 @@ const HELP = `CreditDaddy — Qoder / WorkBuddy / ZCode / mirasim / 妙手 / Tra
   creditdaddy import <file.json> [--password 口令]        导入 CreditDaddy / 10router 导出文件
   creditdaddy scan                                       导入本机 Qoder / WorkBuddy / ZCode / mirasim / 妙手 / Trae 客户端已登录的账号
   creditdaddy umid [install|remove]                      Qoder 设备身份组件（Linux / fnOS 国际版领取用）
+  creditdaddy start [--port 47860] [--host 127.0.0.1]    后台启动（关掉终端也继续跑）
+  creditdaddy stop                                       停止后台实例
+  creditdaddy status                                     查看后台运行状态
+  creditdaddy restart                                    重启后台实例
   creditdaddy logs                                       查看领取状态
   creditdaddy help                                       显示本帮助`;
 
@@ -39,15 +46,137 @@ function flag(name) {
   return i >= 0 ? args[i + 1] : undefined;
 }
 
+/** 面板访问地址（只监听回环时用 127.0.0.1，0.0.0.0 不能当访问地址用） */
+function panelUrl(host, port) {
+  const h = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+  return `http://${h}:${port}`;
+}
+
+/** 把运行时长说成人话（status 用） */
+function humanUptime(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '未知';
+  const min = Math.floor(ms / 60000);
+  if (min < 1) return '不到 1 分钟';
+  if (min < 60) return `${min} 分钟`;
+  const h = Math.floor(min / 60);
+  if (h < 24) return `${h} 小时 ${min % 60} 分`;
+  return `${Math.floor(h / 24)} 天 ${h % 24} 小时`;
+}
+
+/**
+ * 优雅退出。之前 src/ 里一个 process.on 都没有，Ctrl+C 是 Node 默认的硬杀：
+ * 状态文件留在原地（下次 start 会当成「已在运行」）、当天的日志既不落盘也不归档。
+ */
+function installShutdown({ server, background }) {
+  let closing = false;
+  const shutdown = async (signal) => {
+    if (closing) return;
+    closing = true;
+    try { logger.info('CLI', `收到 ${signal}，正在退出…`); } catch {}
+    try { (await import('../src/checkin.js')).stopScheduler(); } catch {}
+    try { await server?.close(); } catch {}
+    if (background) {
+      // 只删自己写的状态文件：并发跑着第二个实例时别把它的状态抹掉
+      try { const { clearRuntime } = await import('../src/bgdaemon.js'); await clearRuntime(process.pid); } catch {}
+    }
+    // 等归档流真的 close（gzip 完成）再退，否则今天的日志丢了
+    try { await (await import('../src/logger.js')).closeArchiveStream(); } catch {}
+    process.exit(0);
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  // 关掉终端会发 SIGHUP。后台实例（stdout 不是 TTY）本来就该在终端消失后活着，
+  // 照着这个忽略；前台则当作用户要收摊。
+  process.on('SIGHUP', () => { if (process.stdout.isTTY) shutdown('SIGHUP'); });
+}
+
 async function main() {
   switch (cmd) {
     case 'daemon': {
       const port = Number(flag('--port')) || Number(process.env.PORT) || undefined;
       const host = flag('--host') || process.env.HOST || undefined;
-      await startDaemon(port, host);
+      const { server, port: boundPort } = await startDaemon(port, host);
+      // 端口被占时 daemon 会自动 +1 重试，真正在听的是 boundPort；
+      // 后台模式要把它记进状态文件，start/status 打印的必须是这个值
+      const background = process.env.CREDITDADDY_BG === '1';
+      if (background) {
+        const { APP_VERSION } = await import('../src/constants.js');
+        const { writeRuntime } = await import('../src/bgdaemon.js');
+        await writeRuntime({
+          pid: process.pid,
+          port: boundPort,
+          host: host || '127.0.0.1',
+          startedAt: new Date().toISOString(),
+          version: APP_VERSION,
+        });
+        logger.info('CLI', '已在后台运行');
+      }
       const { startScheduler } = await import('../src/checkin.js');
       startScheduler();
-      logger.info('CLI', '按 Ctrl+C 停止');
+      installShutdown({ server, background });
+      logger.info('CLI', background ? '按 creditdaddy stop 停止' : '按 Ctrl+C 停止');
+      break;
+    }
+    case 'start': {
+      const { startBackground, backgroundLogFile } = await import('../src/bgdaemon.js');
+      const { APP_VERSION } = await import('../src/constants.js');
+      const port = Number(flag('--port')) || Number(process.env.PORT) || DEFAULT_BG_PORT;
+      const host = flag('--host') || '127.0.0.1';
+      console.log('正在后台启动 CreditDaddy…');
+      const r = await startBackground({ port, host });
+      if (r.error) { console.error('✗', r.error); process.exit(1); }
+      const rec = r.rec;
+      console.log(r.already ? '✓ 已在运行' : '✓ 已启动');
+      console.log('  面板：', panelUrl(rec.host, rec.port));
+      console.log('  进程：pid', rec.pid, '· 端口', rec.port, '· 版本', rec.version || APP_VERSION);
+      console.log('  日志：', backgroundLogFile());
+      console.log('  停止：creditdaddy stop');
+      break;
+    }
+    case 'stop': {
+      const { stopDaemon } = await import('../src/bgdaemon.js');
+      const r = await stopDaemon();
+      // 没在跑也算成功：脚本里 stop 之后紧接 start 不该因为「本来就没跑」而中断
+      if (!r.stopped) {
+        console.log(r.stale ? '· 清理了残留状态（进程已不在）' : '· 未在运行');
+        break;
+      }
+      console.log('✓ 已停止（pid ' + r.rec.pid + '）');
+      break;
+    }
+    case 'status': {
+      const { statusRuntime } = await import('../src/bgdaemon.js');
+      const s = await statusRuntime();
+      if (!s.running) {
+        console.log('· 未在运行');
+        if (s.reason === 'no-state') {
+          console.log('  启动：creditdaddy start');
+        } else if (s.pidAlive) {
+          // 进程在但端口不应答：多半卡在 listen 之前，或状态文件指向了旧实例
+          console.log('  进程 pid ' + s.pid + ' 还在，但面板没有应答；建议 creditdaddy stop 后重启');
+        }
+        process.exit(1);
+      }
+      const startedMs = s.startedAt ? Date.now() - Date.parse(s.startedAt) : NaN;
+      console.log('✓ 运行中');
+      console.log('  面板：', panelUrl(s.host, s.port));
+      console.log('  进程：pid', s.pid, '· 端口', s.port, '· 版本', s.probe?.version || s.version || '未知');
+      console.log('  已运行：', humanUptime(startedMs));
+      if (s.probe?.needsKey) console.log('  账号数：需面板密码（creditdaddy 设过访问密码）');
+      else if (s.probe?.accountsCount != null) console.log('  账号数：', s.probe.accountsCount);
+      if (s.probe?.nextTickAt) console.log('  下次签到：', new Date(s.probe.nextTickAt).toLocaleString());
+      break;
+    }
+    case 'restart': {
+      const { stopDaemon, startBackground, backgroundLogFile } = await import('../src/bgdaemon.js');
+      await stopDaemon();
+      const port = Number(flag('--port')) || Number(process.env.PORT) || DEFAULT_BG_PORT;
+      const host = flag('--host') || '127.0.0.1';
+      const r = await startBackground({ port, host });
+      if (r.error) { console.error('✗', r.error); process.exit(1); }
+      console.log('✓ 已重启');
+      console.log('  面板：', panelUrl(r.rec.host, r.rec.port));
+      console.log('  日志：', backgroundLogFile());
       break;
     }
     case 'add': {

package/package.json

@@ -1,29 +1,29 @@
-{
-  "name": "creditdaddy",
-  "version": "1.3.0",
-  "description": "CreditDaddy — Qoder / WorkBuddy / ZCode / mirasim / 妙手 / Trae / MiniMax 多账号本地管理与每日积分自动签到助手",
-  "homepage": "https://github.com/techysy/CreditDaddy",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/techysy/CreditDaddy.git"
-  },
-  "type": "module",
-  "bin": {
-    "creditdaddy": "bin/creditdaddy.js"
-  },
-  "files": [
-    "bin",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
-  "scripts": {
-    "start": "node bin/creditdaddy.js daemon",
-    "test": "node --test",
-    "release-check": "bash scripts/release-check.sh"
-  },
-  "license": "MIT"
-}
+{
+  "name": "creditdaddy",
+  "version": "1.3.2",
+  "description": "CreditDaddy — Qoder / WorkBuddy / ZCode / mirasim / 妙手 / Trae / MiniMax 多账号本地管理与每日积分自动签到助手",
+  "homepage": "https://github.com/techysy/CreditDaddy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/techysy/CreditDaddy.git"
+  },
+  "type": "module",
+  "bin": {
+    "creditdaddy": "bin/creditdaddy.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node bin/creditdaddy.js daemon",
+    "test": "node --test",
+    "release-check": "bash scripts/release-check.sh"
+  },
+  "license": "MIT"
+}

package/src/bgdaemon.js

@@ -0,0 +1,332 @@
+/**
+ * CreditDaddy 后台守护 —— 让 `creditdaddy start` 把 daemon 丢到后台跑，终端可以随手关掉。
+ *
+ * 为什么不直接把日志接到 daemon-YYYY-MM-DD.log：
+ *   同一个数据目录可能同时有多个实例（后台实例 + 用户手动跑的前台 daemon + 桌面版），
+ *   它们以 O_APPEND 共享当天文件。logger.js 关闭流时会 gzip 并清空原文件；子进程那侧
+ *   单独接 background.log，两个实例互不干扰，也避开 cleanupArchive 的文件名前缀约定。
+ *
+ * 状态落在 <数据目录>/daemon.json（不是 .pid），因为要记的不止 pid —— daemon 端口被占
+ * 时会自动 +1 重试最多 10 次（见 daemon.js 的 EADDRINUSE 分支），真正在听的端口只有
+ * startDaemon() resolve 后的 r.port 知道，所以由 daemon 进程自己写这个文件。
+ *
+ * 「在运行」= pid 存活 **且** 端口应答：pid 会被系统回收、文件会被手删，只查 pid 会误报；
+ * 只查端口又会把同端口的桌面版误认成 CLI 实例。状态查询走带鉴权的 /api/status（不新增
+ * 任何未鉴权端点），401 同样算「活着」—— 说明服务在，只是要面板密码。
+ */
+
+import { spawn, execFileSync } from 'node:child_process';
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import http from 'node:http';
+import net from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dataDir } from './store.js';
+import { logger } from './logger.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_ENTRY = path.join(__dirname, '..', 'bin', 'creditdaddy.js');
+const DEFAULT_PORT = 47860;
+const DEFAULT_HOST = '127.0.0.1';
+
+// 后台启动最多等这么久：daemon 要读账号库、建 HTTP server、起签到定时器，冷启动慢一点正常
+const READY_TIMEOUT_MS = 30_000;
+const READY_INTERVAL_MS = 250;
+const PROBE_TIMEOUT_MS = 2000;
+const STOP_TIMEOUT_MS = 8000;
+
+/** 状态文件路径：跟随 store.js 的 dataDir()，尊重 CREDITDADDY_HOME */
+export function runtimeFile() {
+  return path.join(dataDir(), 'daemon.json');
+}
+
+/** 后台实例的 stdout/stderr 落点（与按日归档的 daemon-*.log 分开，见文件头） */
+export function backgroundLogFile() {
+  return path.join(dataDir(), 'logs', 'background.log');
+}
+
+/** 读状态文件。文件不存在 / 内容损坏都返回 null（调用方按「没有后台实例」处理） */
+export function readRuntime() {
+  try {
+    const raw = fsSync.readFileSync(runtimeFile(), 'utf8');
+    const r = JSON.parse(raw);
+    if (!r || typeof r !== 'object' || !Number.isInteger(r.pid) || r.pid <= 0) return null;
+    return r;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeRuntime(rec) {
+  const file = runtimeFile();
+  try {
+    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    await fs.writeFile(file, JSON.stringify(rec, null, 2), { mode: 0o600 });
+    return true;
+  } catch (e) {
+    logger.warn('BG', `写状态文件失败：${e?.message || e}`);
+    return false;
+  }
+}
+
+/** 删状态文件。仅当 pid 与自己一致时才删——避免把后一个实例的状态误删 */
+export async function clearRuntime(expectedPid = null) {
+  try {
+    const cur = readRuntime();
+    if (expectedPid != null && cur && cur.pid !== expectedPid) return false;
+    await fs.unlink(runtimeFile());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 进程是否还活着。
+ * ESRCH = 确实没有；EPERM = 在、只是当前用户无权发信号（不能当成已死）；
+ * 抛到调用方的其他异常同样按「活着」处理——宁可多报一次运行中，也不要误杀。
+ */
+export function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code !== 'ESRCH';
+  }
+}
+
+/**
+ * 面板访问密码，取值顺序与 daemon.js 的 initPanelKey 保持一致：
+ * 面板设置里存的 panelKey 优先（用户可能已改过），环境变量兜底。
+ */
+export async function readPanelKey() {
+  try {
+    const { loadSettings } = await import('./store.js');
+    const s = await loadSettings();
+    if (typeof s.panelKey === 'string' && s.panelKey) return s.panelKey;
+  } catch { /* 读不到就退到环境变量 */ }
+  return process.env.CREDITDADDY_PASSWORD || process.env.QODERDADDY_PASSWORD || '';
+}
+
+/**
+ * 探一次 /api/status。200 与 401 都算 reachable（详见文件头）。
+ * 不带 Origin，能过 daemon 的 rejectForeignRequest（非浏览器客户端不受该校验约束）。
+ */
+export function probeStatus(rec, timeoutMs = PROBE_TIMEOUT_MS) {
+  const port = Number(rec?.port);
+  const host = rec?.host || DEFAULT_HOST;
+  const probeHost = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+  if (!Number.isInteger(port) || port <= 0) return Promise.resolve({ reachable: false });
+
+  return new Promise((resolve) => {
+    const req = http.request(
+      { host: probeHost, port, path: '/api/status', method: 'GET', headers: { Host: `${probeHost}:${port}` } },
+      (res) => {
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          const reachable = res.statusCode === 200 || res.statusCode === 401;
+          let body = null;
+          if (res.statusCode === 200) {
+            try { body = JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch { body = null; }
+          }
+          resolve({
+            reachable,
+            status: res.statusCode,
+            needsKey: res.statusCode === 401,
+            version: body?.version || null,
+            accountsCount: Number.isInteger(body?.accountsCount) ? body.accountsCount : null,
+            nextTickAt: body?.scheduler?.nextTickAt || null,
+          });
+        });
+      },
+    );
+    // 401 也要把面板密码带上再试一次：daemon 可能在跑但设了访问密码，
+    // 拿不到 version 不影响「在运行」的判定，但要账号数就得认证。
+    req.on('error', () => resolve({ reachable: false }));
+    req.setTimeout(timeoutMs, () => { req.destroy(); resolve({ reachable: false }); });
+    readPanelKey().then((key) => {
+      if (key) req.setHeader('x-qd-key', key);
+      req.end();
+    });
+  });
+}
+
+/** 后台实例的完整状态：文件 + 进程 + 端口三处都查 */
+export async function statusRuntime() {
+  const rec = readRuntime();
+  if (!rec) return { running: false, reason: 'no-state' };
+  const pidAlive = isAlive(rec.pid);
+  const probe = pidAlive ? await probeStatus(rec) : { reachable: false };
+  return { running: pidAlive && probe.reachable, pidAlive, probe, ...rec };
+}
+
+/**
+ * 端口已被别的东西占了？（和「本 daemon 已在上一个端口跑着」是两回事）
+ * 后台启动前先探，避免子进程悄悄漂到 47861 让用户摸不着面板在哪。
+ */
+/**
+ * 端口是否已被别的东西占了？（和「本 daemon 已在上一个端口跑着」是两回事）
+ *
+ * 用「自己试着 bind 一下」判断，而不是发 HTTP 请求探活：非 HTTP 的程序（数据库、
+ * 别的服务）占着端口时不会回话，HTTP 探测会一直等到超时，然后误报「端口空闲」，
+ * 子进程就这么悄悄漂到了下一个端口，用户摸不着面板到底在哪。绑一下立刻 close，
+ * 唯一目的就是拿到 EADDRINUSE 这个答案。
+ */
+export function portTaken(port, host = DEFAULT_HOST) {
+  return new Promise((resolve) => {
+    const probe = net.createServer();
+    probe.once('error', (e) => resolve(e?.code === 'EADDRINUSE'));
+    probe.once('listening', () => probe.close(() => resolve(false)));
+    try {
+      probe.listen(port, host);
+    } catch {
+      resolve(true);
+    }
+  });
+}
+
+/** 等后台实例真正开始应答（子进程要先写状态文件，再能被探到） */
+async function waitReady(timeoutMs = READY_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const rec = readRuntime();
+    if (rec && isAlive(rec.pid)) {
+      const probe = await probeStatus(rec);
+      if (probe.reachable) return { ok: true, rec, probe };
+    }
+    await new Promise((r) => setTimeout(r, READY_INTERVAL_MS));
+  }
+  return { ok: false };
+}
+
+/**
+ * 后台拉起 daemon。
+ * 已有一个活着的实例就直接返回（幂等）——脚本里 `start` 连跑两次不该起两个服务。
+ */
+export async function startBackground({ port = DEFAULT_PORT, host = DEFAULT_HOST } = {}) {
+  const cur = await statusRuntime();
+  if (cur.running) return { already: true, rec: cur };
+
+  const stale = readRuntime();
+  if (stale) await clearRuntime();   // 残留状态（进程已死 / 端口失联），先清掉再起
+
+  if (await portTaken(port, host)) {
+    return { already: false, error: `端口 ${port} 已被其他程序占用` };
+  }
+
+  const logFile = backgroundLogFile();
+  try {
+    await fs.mkdir(path.dirname(logFile), { recursive: true });
+  } catch { /* 目录建不了就退回继承父进程 stdio，daemon 本身不受影响 */ }
+
+  let out = 'ignore';
+  let logFd = null;
+  try {
+    logFd = fsSync.openSync(logFile, 'a');
+    out = logFd;
+  } catch { /* 落不了盘就让 daemon 继承 stdio */ }
+
+  let child;
+  try {
+    child = spawn(process.execPath, [CLI_ENTRY, 'daemon', '--port', String(port), '--host', host], {
+      detached: true,            // 独立进程组：关掉终端不影响它
+      windowsHide: true,         // Windows 上不要弹控制台窗口
+      stdio: ['ignore', out, out],
+      env: { ...process.env, CREDITDADDY_BG: '1' },   // 让 daemon 知道自己跑在后台
+    });
+  } catch (e) {
+    if (logFd != null) try { fsSync.closeSync(logFd); } catch {}
+    return { already: false, error: `启动失败：${e?.message || e}` };
+  }
+
+  if (logFd != null) try { fsSync.closeSync(logFd); } catch {}
+  child.unref();   // 父进程立刻可以退出，子进程继续活着
+
+  const ready = await waitReady();
+  if (!ready.ok) {
+    // 没等到应答：把刚起的进程收掉，否则会留一个查不到状态的孤儿
+    await killPid(child.pid);
+    return { already: false, error: `启动超时（${Math.round(READY_TIMEOUT_MS / 1000)}s），日志见 ${logFile}` };
+  }
+  return { already: false, rec: ready.rec };
+}
+
+/**
+ * 杀掉一个 pid。
+ * Windows 没有进程组概念，process.kill(-pid) 会直接抛 EINVAL，所以用 taskkill /T 杀进程树；
+ * taskkill 不可用（精简系统 / 容器）时退回单杀。
+ */
+export async function killPid(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (process.platform === 'win32') {
+    try {
+      execFileSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+        windowsHide: true, stdio: 'ignore', timeout: 10_000,
+      });
+      return true;
+    } catch { /* 进程可能已经没了，或 taskkill 不可用 */ }
+  }
+  try {
+    // POSIX 下 detached 起的子进程自成进程组，-pid 才能连它自己拉起的子进程一起收掉
+    process.kill(-pid, 'SIGTERM');
+    return true;
+  } catch { /* 不是组长或已退出 */ }
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 端口是否已从监听状态退下 */
+async function waitPortFree(port, host = DEFAULT_HOST, timeoutMs = STOP_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!(await portTaken(port, host))) return true;
+    await new Promise((r) => setTimeout(r, READY_INTERVAL_MS));
+  }
+  return false;
+}
+
+/**
+ * 等进程真正从进程表里消失。
+ * SIGTERM 只是投递信号，handler 跑完 + 内核回收之间还有几十毫秒到几秒的窗口——
+ * 端口先释放、pid 后回收是常态。不等它就报 stopped:true，调用方紧接着的
+ * isAlive(pid) 仍会读到 true，误判「停不干净」。
+ */
+async function waitPidDead(pid, timeoutMs = STOP_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, READY_INTERVAL_MS));
+  }
+  return false;
+}
+
+/**
+ * 停掉后台实例。
+ * 没在跑也正常返回（幂等）——脚本里 `stop` 后紧接 `start` 不该因为「本来就没跑」而中断。
+ */
+export async function stopDaemon() {
+  const rec = readRuntime();
+  if (!rec) return { stopped: false, reason: 'no-state' };
+
+  if (!isAlive(rec.pid)) {
+    await clearRuntime();
+    return { stopped: false, reason: 'not-running', stale: true };
+  }
+
+  await killPid(rec.pid);
+  const free = await waitPortFree(rec.port, rec.host);
+  // 端口释放不等于进程退出：SIGTERM 只是投递，handler 收尾 + 内核回收还有窗口。
+  // 必须等到 pid 真的没了再报 stopped，否则调用方紧接着 isAlive(pid) 仍读到 true。
+  const dead = await waitPidDead(rec.pid);
+  await clearRuntime();
+  if (!free) logger.warn('BG', `端口 ${rec.port} 迟迟没有释放，进程可能仍在收尾`);
+  if (!dead) logger.warn('BG', `进程 ${rec.pid} 在 ${Math.round(STOP_TIMEOUT_MS / 1000)}s 内没有退出干净`);
+  return { stopped: true, rec, portFree: free, pidDead: dead };
+}

package/src/checkin.js

@@ -4,7 +4,7 @@
 
 import { loadAccounts, loadState, withAccounts, withState } from './store.js';
 import { productImpl } from './providers.js';
-import { productOf } from './constants.js';
+import { productOf, PROVIDER_LABEL } from './constants.js';
 import { startUsageSyncScheduler } from './tenrouter.js';
 import { refreshContext } from './accounts.js';
 import { zcodeAutoClaim } from './zcodeAutoClaim.js';
@@ -237,7 +237,8 @@ async function runTickInner(opts) {
   let deviceClaim = state?.deviceClaim?.day === today ? state.deviceClaim : null;
 
   for (const account of accounts) {
-    const label = account.name || account.id;
+    const pTag = `[${PROVIDER_LABEL[account.provider] || account.provider}]`;
+    const label = `${pTag} ${account.name || account.id}`;
     // 「今日已领」按各产品自己的业务日界比对：Qoder 10 点翻日，其余 0 点翻日
     const todayFor = dayKey(Date.now(), account.provider);
     try {