cron-up 26.10.30 → 26.10.31

package/src/overview.mjs

@@ -1,4 +1,4 @@
-// 无子命令时的总览页：一眼看清服务、配置、任务、保活会话与需要留意的
+// 无子命令时的总览页：一眼看清服务、配置、任务、预热会话与需要留意的
 // 事。它回答「现在一切正常吗」：除汇总现状外，还把巡检视角的异常集中成
 // 一个「需要留意」清单。
 
@@ -6,6 +6,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { deps, packageVersion } from './internals.mjs';
+import {
+  INTERVAL_SECONDS,
+  LEAD_SECONDS,
+} from './constants.mjs';
 import {
   loadConfig,
   loadState,
@@ -15,7 +19,7 @@ import {
   isCooling,
   cooldownEtaMinutes,
 } from './config.mjs';
-import { taskFileExists } from './tasks.mjs';
+import { taskFileExists, taskKey } from './tasks.mjs';
 import { serviceLine, launcherHealth } from './service.mjs';
 import {
   humanDelta,
@@ -30,21 +34,28 @@ import {
   sameMinute,
 } from './display.mjs';
 
-// 总览页任务盘点。返回 [告警, 已在告警里说明冷却的工作区集合, 本轮发现
-// 的工作区集合]（第三个供会话部分识别「已移出巡检视野」的会话）。
-function overviewTasks(cfg, cols, consumers, state) {
+// entry 此刻是否算「正在承接任务」：script 活（启动中或已认亲），或用户
+// --resume 接管后 sid 仍活。冷却/死条目不报「没有会话」。
+function entryHolds(ent, details, ws) {
+  if (!ent) return false;
+  if (deps.trackedAlive(ent)) return true;
+  return typeof ent.sessionId === 'string'
+    && (details.get(ws) ?? []).some((d) => d.sessionId === ent.sessionId);
+}
+
+// 总览页任务盘点。返回 [告警, 已在告警里说明冷却的 entry 键集合, 本轮发
+// 现的工作区集合]（第三个供会话部分识别「已移出巡检视野」的会话）。
+function overviewTasks(cfg, cols, details, state) {
   const alerts = [];
   const coolingWarned = new Set();
   const discovered = new Set();
   const now = new Date();
-  const cur = Math.floor(now.getTime() / 1000);
-  const leadMs = cfg.leadSeconds * 1000;
+  const leadMs = LEAD_SECONDS * 1000;
 
   let nWs = 0;
   let nTasks = 0;
-  let unrenewed = 0;
   let soonest = null;
-  for (const [ws] of deps.discover(cfg.roots, cfg.maxDepth)) {
+  for (const [ws] of deps.discover(cfg.roots)) {
     discovered.add(ws);
     const tasks = deps.readTasks(ws);
     if (tasks === null) {
@@ -58,13 +69,9 @@ function overviewTasks(cfg, cols, consumers, state) {
     if (tasks.length === 0) continue;
     nWs += 1;
     nTasks += tasks.length;
+    const liveSids = deps.liveSessionIds(details, ws);
     let bad = 0;
-    let wanted = false;
     for (const t of tasks) {
-      // 与 renew 同一条字段规则：显式周期任务却没有 truthy permanent，仍
-      // 受 7 天过期约束。从原始任务计数，与 cron 合法性无关，坏 cron 也照
-      // 提醒。
-      if (t.recurring && !t.permanent) unrenewed += 1;
       const v = taskView(t, now, leadMs);
       if (!v.valid) {
         bad += 1;
@@ -75,33 +82,34 @@ function overviewTasks(cfg, cols, consumers, state) {
       if (fire && (!soonest || fire.getTime() < soonest[0].getTime())) {
         soonest = [fire, ws, v.summary, v.nxt];
       }
-      if (v.wanted) wanted = true;
-    }
-    if (bad > 0) {
-      alerts.push(`${ws} 有 ${bad} 个任务的 cron 无法解析，`
-        + `巡检会跳过${bad > 1 ? '它们' : '它'}`);
-    }
-    if (wanted && !consumers.has(ws)) {
-      const ent = state[ws] ?? {};
-      if (isCooling(ent, cur)) {
-        // 与「下轮会自动启动」互斥：冷却中就是不会启动，两条同现会自相
-        // 矛盾，这里合并成一条。
+      if (!v.wanted) continue;
+      // 窗口内任务：创建者会话还开着（任务铁定投进它）或我们的预热已在
+      // 承接，都不是异常；否则按 entry 的冷却/失败状态给一条可执行的告
+      // 警。
+      const key = taskKey(t);
+      const ent = state[ws]?.[key];
+      if (deps.creatorSessionAlive(t, liveSids) || entryHolds(ent, details, ws)) {
+        continue;
+      }
+      if (isCooling(ent, Math.floor(now.getTime() / 1000))) {
+        const cur = Math.floor(now.getTime() / 1000);
         const eta = cooldownEtaMinutes(ent, cur);
         alerts.push(
-          `${ws} 有任务即将执行（或错过待补执行），但保活会话连续失败 `
+          `${ws} 任务 ${key} 即将执行（或错过待补执行），但预热连续失败 `
           + `${ent.fails ?? '?'} 次正处冷却中，约 ${eta} 分钟后才会重试；`
-          + `请运行 cron-up logs ${path.basename(ws)} 排查`);
-        coolingWarned.add(ws);
+          + `请运行 cron-up logs ${path.basename(ws)}--${key} 排查`);
+        coolingWarned.add(`${ws}\0${key}`);
       } else {
-        // 失败计数放在句子中部：总览告警按终端宽度截尾，计数比尾部的
-        // 「下轮会自动启动」更该活下来；满额后的去向由「冷却中」那条合并
-        // 告警解释，这里不重复。
-        const fails = ent.fails ?? 0;
+        const fails = ent?.fails ?? 0;
         const streak = fails > 0 ? `，近期已失败 ${fails} 次` : '';
-        alerts.push(`${ws} 有任务即将执行（或错过待补执行）${streak}，`
-          + '但当前没有交互会话，下轮巡检会自动启动');
+        alerts.push(`${ws} 任务 ${key} 即将执行（或错过待补执行）${streak}，`
+          + '但当前没有承接会话，下轮巡检会自动启动预热');
       }
     }
+    if (bad > 0) {
+      alerts.push(`${ws} 有 ${bad} 个任务的 cron 无法解析，`
+        + `巡检会跳过${bad > 1 ? '它们' : '它'}`);
+    }
   }
 
   deps.print(nTasks > 0
@@ -116,52 +124,64 @@ function overviewTasks(cfg, cols, consumers, state) {
       + `${setTag}） ${path.basename(ws)} · ${summary}`;
     deps.print(clip(line, cols));
   }
-  if (!cfg.autoRenew && unrenewed > 0) {
-    alerts.push(
-      `自动续期已关闭：${unrenewed} 个周期任务尚未标记 permanent，创建满 7 `
-      + '天后会末次执行并被删除。运行 cron-up renew 立即续期，或在配置中'
-      + '开启 autoRenew');
-  }
   return [alerts, coolingWarned, discovered];
 }
 
-function overviewSessions(cols, state, suppressCooling, discovered) {
+function overviewSessions(cols, state, details, suppressCooling, discovered) {
   const alerts = [];
   const cur = Math.floor(Date.now() / 1000);
   const live = [];
+  const detached = [];
   const cooling = [];
   const dead = [];
-  for (const [ws, ent] of Object.entries(state)) {
-    if (isCooling(ent, cur)) cooling.push([ws, ent]);
-    else if (deps.trackedAlive(ent)) live.push([ws, ent]);
-    else dead.push(ws); // 记录还在、进程已没：带失败计数的保留至老化，其余下轮清理
+  for (const [ws, bucket] of Object.entries(state)) {
+    for (const [taskId, ent] of Object.entries(bucket)) {
+      const sidAlive = typeof ent.sessionId === 'string'
+        && (details.get(ws) ?? []).some((d) => d.sessionId === ent.sessionId);
+      if (isCooling(ent, cur)) {
+        cooling.push([ws, taskId, ent]);
+      } else if (deps.trackedAlive(ent)) {
+        live.push([ws, taskId, ent]);
+      } else if (sidAlive) {
+        detached.push([ws, taskId, ent]);
+      } else {
+        dead.push([ws, taskId]);
+      }
+    }
   }
   let tail = '';
   if (cooling.length) tail += `，冷却 ${cooling.length} 个`;
+  if (detached.length) tail += `，终端接管 ${detached.length} 个`;
   if (dead.length) tail += `，已失效 ${dead.length} 个`;
+  const describe = ([ws, taskId, ent]) =>
+    `${path.basename(ws)}/${taskId}（pid ${ent.pid}，已运行 `
+    + `${sessionAgeZh(ent.startedAt ?? cur, cur)}）`;
   if (live.length) {
-    const desc = live.map(([ws, ent]) =>
-      `${path.basename(ws)}（pid ${ent.pid}，已运行 `
-      + `${sessionAgeZh(ent.startedAt ?? cur, cur)}）`).join('、');
-    const head = `会话：保活 ${live.length} 个（`;
-    const fixed = dispWidth(head) + dispWidth(tail) + dispWidth('）');
-    deps.print(`${head}${clip(desc, cols - fixed)}）${tail}`);
+    const head = '预热会话：';
+    const avail = cols - dispWidth(head) - dispWidth(tail)
+      - (tail ? dispWidth('（）') : 0);
+    const desc = clip(live.map(describe).join('、'), Math.max(0, avail));
+    deps.print(`${head}${live.length} 个：${desc}${tail ? `（${tail.slice(1)}）` : ''}`);
   } else {
-    deps.print(`会话：无保活会话${tail}`);
+    deps.print(`预热会话：无${tail ? `（${tail.slice(1)}）` : ''}`);
+  }
+  for (const [ws, taskId] of detached) {
+    deps.print(`  · ${path.basename(ws)}/${taskId}：已在终端 --resume 接管，`
+      + '巡检不再另拉；该会话关闭后任务恢复自动预热');
   }
-  for (const [ws, ent] of cooling) {
-    if (suppressCooling.has(ws)) continue; // 任务区已给过带上下文的合并告警
+  for (const [ws, taskId, ent] of cooling) {
+    if (suppressCooling.has(`${ws}\0${taskId}`)) continue;
     const eta = cooldownEtaMinutes(ent, cur);
-    alerts.push(`${ws} 保活连续失败 ${ent.fails ?? '?'} 次，冷却中，约 ${eta} `
-      + '分钟后重试');
+    alerts.push(`${ws} 任务 ${taskId} 预热连续失败 ${ent.fails ?? '?'} 次，`
+      + `冷却中，约 ${eta} 分钟后重试`);
   }
   if (discovered !== null) {
-    for (const [ws, ent] of live) {
+    for (const [ws, taskId, ent] of live) {
       if (!discovered.has(ws)) {
         alerts.push(
-          `${ws} 的保活会话（pid ${ent.pid}）仍在运行，但该目录已不在巡检范`
-          + '围内（任务文件被删或已移出 roots），cron-up 不会再回收或换代'
-          + '它；不需要时请自行结束');
+          `${ws} 任务 ${taskId} 的预热会话（pid ${ent.pid}）仍在运行，但该`
+          + '目录已不在巡检范围内（任务文件被删或已移出 roots），cron-up 不'
+          + '会再回收它；不需要时请自行结束');
       }
     }
   }
@@ -169,11 +189,10 @@ function overviewSessions(cols, state, suppressCooling, discovered) {
 }
 
 const COMMANDS = [
-  ['list', '逐个列出任务的内容摘要、设定/预计触发时间与会话状态'],
+  ['list', '逐个列出任务的内容摘要、设定/预计触发时间与预热状态'],
   ['logs [目录片段] [-f]', '查看巡检日志或后台会话记录'],
   ['run', '立即手动巡检一轮'],
-  ['renew', '立即给所有周期任务补 permanent 并改小 id'],
-  ['install --force', '更新配置并重新安装（全部参数见 --help）'],
+  ['install --roots ~/a,~/b', '更新扫描目录并重新安装（不带参数保留现有配置）'],
 ];
 
 export async function cmdOverview(args) {
@@ -181,7 +200,7 @@ export async function cmdOverview(args) {
   const v = packageVersion();
   deps.print(v === null
     ? 'cron-up —— 为定时任务提前备好交互会话'
-    : `cron-up ${v} —— 为定时任务提前备好交互会话`);
+    : `cron-up ${v} —— 为定时任务提前备好交互会话（一任务一会话）`);
 
   const cfgPath = args?.config ?? deps.paths.configPath;
   let cfg = null;
@@ -196,76 +215,56 @@ export async function cmdOverview(args) {
   deps.print(serviceLine(info, fs.existsSync(deps.paths.plistPath)));
 
   const alerts = [];
-  // plist 写死的 node/入口路径失效（Node 版本目录被清）时 launchd 每轮
-  // 都静默拉不起来，这是总览唯一能发现它的地方。
   const health = launcherHealth();
   if (health) alerts.push(health);
-  // 父链快照是 stampOwner 的按需成本：只有开关确实开启时才拍，总览页也
-  // 才能顺带显示「认亲退化」这第四枚告警。
-  const [consumers, registryAlert] =
-    await deps.scanSessions({ lineage: cfg?.stampOwner === true });
+  // 祖先链恒拍：总览要同时给出逐任务的活创建者/预热承接判定。
+  const [, registryAlert, details] = await deps.scanSessions();
   if (registryAlert) alerts.push(registryAlert);
   const state = loadState();
   const curOv = Math.floor(Date.now() / 1000);
   const heartbeat = loadHeartbeat();
-  let coolingWarned = new Set();
-  let discovered = null;
 
   if (cfgError !== null) {
-    // 页面不能死在半路：损坏或字段类型不对的配置是「需要留意」的一种；巡
-    // 检本身仍会以退出码 2 失败（loadConfig 与这里共用同一套校验）。
+    // 页面不能死在半路：损坏配置是「需要留意」的一种；巡检本身仍会以退
+    // 出码 2 失败。
     deps.print(`配置：无法生效（${cfgPath}）`);
     alerts.push(`配置无法生效（巡检将以退出码 2 失败）：${cfgError.message}`);
   } else if (cfg === null) {
     deps.print('配置：缺失，运行 cron-up install 生成');
   } else {
-    const actualIv = info ? info.interval : null;
-    const renewTag = cfg.autoRenew ? '，自动续期开' : '，自动续期关';
-    const minIdTag = cfg.autoMinId ? '，id 自动改小' : '，id 保持原样';
-    const retainTag = cfg.sessionRetain === 'always'
-      ? '，会话常驻' : '，会话按执行回收';
-    const stampTag = cfg.stampOwner ? '，任务归属预热' : '';
-    if (actualIv == null) {
-      deps.print(`巡检：配置为每 ${cfg.intervalSeconds} 秒一轮（服务未加载），`
-        + `提前 ${cfg.leadSeconds} 秒启动会话${renewTag}${minIdTag}${retainTag}${stampTag}`);
-    } else {
-      deps.print(`巡检：每 ${actualIv} 秒一轮，提前 ${cfg.leadSeconds} 秒启动`
-        + `会话${renewTag}${minIdTag}${retainTag}${stampTag}`);
-      if (actualIv !== cfg.intervalSeconds) {
-        alerts.push(`launchd 实际间隔 ${actualIv} 秒与配置 ${cfg.intervalSeconds} `
-          + '秒不一致，重新运行 cron-up install 后生效');
-      }
+    deps.print(`巡检：每 ${INTERVAL_SECONDS} 秒一轮，提前 ${LEAD_SECONDS} `
+      + '秒为每个窗口内任务启动专属预热会话');
+    if (info && info.interval !== null && info.interval !== undefined
+        && info.interval !== INTERVAL_SECONDS) {
+      alerts.push(`launchd 实际间隔 ${info.interval} 秒与当前版本的 `
+        + `${INTERVAL_SECONDS} 秒不一致，重新运行 cron-up install 后生效`);
     }
-    const suffix = `（深度 ${cfg.maxDepth}）`;
     const rootsText = cfg.roots.join('、');
-    const prefix = '扫描：';
-    deps.print(prefix
-      + clip(rootsText, cols - dispWidth(prefix) - dispWidth(suffix))
-      + suffix);
-    // 心跳回答「巡检最近真的在跑吗」：launchd 已加载但启动脚本运行期失
-    // 效时，静态健康检查（launcherHealth）全绿而轮次早已停摆，只有沉默的
-    // 心跳能戳穿。服务未加载（info 为 null）时不告警，服务行已说明未安装。
+    deps.print(`扫描：${clip(rootsText, cols - dispWidth('扫描：'))}`);
+    // 心跳回答「巡检最近真的在跑吗」：服务已加载但启动链运行期失效时，
+    // 只有沉默的心跳能戳穿。
     if (heartbeat) {
       deps.print(`上次巡检：${elapsedZh(curOv - heartbeat.ranAt)}前`);
-      if (info && heartbeatStale(heartbeat, cfg.intervalSeconds, curOv)) {
+      if (info && heartbeatStale(heartbeat, INTERVAL_SECONDS, curOv)) {
         alerts.push(`巡检已沉默 ${elapsedZh(curOv - heartbeat.ranAt)}：launchd `
-          + `显示服务已加载（配置每 ${cfg.intervalSeconds} 秒一轮），但最近没有`
-          + '成功跑完的轮次，启动链可能已失效；请运行 cron-up logs 查看巡检'
-          + '日志，必要时重跑 cron-up install');
+          + `显示服务已加载，但最近没有成功跑完的轮次，启动链可能已失效；`
+          + '请运行 cron-up logs 查看巡检日志，必要时重跑 cron-up install');
       }
     }
     alerts.push(...validateConfig(cfg));
     deps.print('');
-    const [taskAlerts, coolingWarnedNow, found] = overviewTasks(
-      cfg, cols, consumers, state);
+    const [taskAlerts, coolingWarned, found] = overviewTasks(
+      cfg, cols, details, state);
     alerts.push(...taskAlerts);
-    coolingWarned = coolingWarnedNow;
-    discovered = found;
+    // 会话区需要上面产出的冷却抑制集合。
+    alerts.push(...overviewSessions(cols, state, details, coolingWarned, found));
   }
 
-  // 会话状态来自 state.json，与配置无关：未安装/配置损坏时也可能有残留保
-  // 活会话，照常展示。
-  alerts.push(...overviewSessions(cols, state, coolingWarned, discovered));
+  // 未安装/配置损坏时也可能有残留预热会话，照常展示（没有 discovered
+  // 上下文，不做「移出 roots」告警）。
+  if (cfg === null || cfgError !== null) {
+    alerts.push(...overviewSessions(cols, state, details, new Set(), null));
+  }
 
   if (alerts.length) {
     deps.print('需要留意：');