cron-up 26.10.33 → 26.10.35

package/src/patrol.mjs

@@ -10,7 +10,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
-import { deps, packageVersion, isPlainObject } from './internals.mjs';
+import {
+  deps,
+  packageVersion,
+  isPlainObject,
+  getOwn,
+  setOwn,
+} from './internals.mjs';
 import {
   FAIL_LIMIT,
   COOLDOWN_SECONDS,
@@ -41,6 +47,7 @@ import {
   TaskFileChanged,
   taskFileExists,
   groupTasksByKey,
+  taskOwnedBy,
 } from './tasks.mjs';
 import { taskWanted, parseCronOrNone, wantedNow } from './cron.mjs';
 import {
@@ -381,7 +388,7 @@ export async function patrolWorkspace(
   for (const [key, group] of taskGroups) {
     if (group.length !== 1) continue;
     const t = group[0];
-    let ent = bucket[key] ?? null;
+    let ent = getOwn(bucket, key) ?? null;
     const logPath = sessionLogPath(ws, key);
     const ownerIsOurs = entryClaimed(ent)
       && typeof t.createdBySessionId === 'string'
@@ -476,9 +483,9 @@ export async function patrolWorkspace(
     // 盖印（跨轮老条目）：已认亲且任务归属还没盖到本代预热（活创建者
     // 已在 (a) 排除）。当轮新 spawn 的会话在第三步之后的轮内等待里认
     // 亲，由 cmdRun 的 stampClaimed 补盖，不走这里。
-    if (entryClaimed(ent)
-        && (!t.createdBySessionId || t.createdBySessionId !== ent.sessionId)) {
-      stamps.set(key, reownTarget(ent));
+    if (entryClaimed(ent)) {
+      const target = reownTarget(ent);
+      if (!taskOwnedBy(t, target)) stamps.set(key, target);
     }
 
     // warm 未到回收 / spawning 宽限内：本轮无事。
@@ -496,15 +503,15 @@ export async function patrolWorkspace(
     }
 
     if (fails >= FAIL_LIMIT) {
-      bucket[key] = {
+      const next = setOwn(bucket, key, {
         ...ent,
         ws,
         taskId: key,
         pid: null,
         fails,
         log: ent?.log ?? logPath,
-      };
-      enterCooldown(bucket[key], ws, key, fails, cur, stats);
+      });
+      enterCooldown(next, ws, key, fails, cur, stats);
       continue;
     }
 
@@ -520,7 +527,7 @@ export async function patrolWorkspace(
           scriptProcLogPath(procArgs) === logPath && deps.alive(procPid));
       if (adopted) {
         const [procPid] = adopted;
-        bucket[key] = {
+        setOwn(bucket, key, {
           ws,
           taskId: key,
           pid: procPid,
@@ -528,7 +535,7 @@ export async function patrolWorkspace(
           procStart: deps.procStartedAt(procPid),
           fails: 0,
           log: logPath,
-        };
+        });
         note('adopt', `接管 ${ws} 任务 ${key} pid=${procPid}：state 记录缺失，`
           + '但进程表里仍有本该任务的预热会话，重新纳入跟踪');
         pending.push({ ws, key, pid: procPid });
@@ -542,25 +549,25 @@ export async function patrolWorkspace(
     if (spawned?.pid == null) {
       const newFails = fails + 1;
       if (newFails >= FAIL_LIMIT) {
-        bucket[key] = {
+        const next = setOwn(bucket, key, {
           ws, taskId: key, pid: null, fails: newFails, log: logPath,
-        };
-        enterCooldown(bucket[key], ws, key, newFails, cur, stats);
+        });
+        enterCooldown(next, ws, key, newFails, cur, stats);
         continue;
       }
-      bucket[key] = {
+      setOwn(bucket, key, {
         ws,
         taskId: key,
         pid: null,
         startedAt: cur,
         fails: newFails,
         log: logPath,
-      };
+      });
       note('fail', `启动失败 ${ws} 任务 ${key}：会话进程没有拉起`
         + `（连续失败计数 ${newFails}）`);
       continue;
     }
-    bucket[key] = {
+    setOwn(bucket, key, {
       ws,
       taskId: key,
       pid: spawned.pid,
@@ -568,7 +575,7 @@ export async function patrolWorkspace(
       procStart: spawned.procStart,
       fails,
       log: logPath,
-    };
+    });
     note('spawn', `已启动 ${ws} 任务 ${key} pid=${spawned.pid}`
       + `（连续失败计数 ${fails}）`);
     pending.push({ ws, key, pid: spawned.pid });
@@ -588,8 +595,9 @@ export async function patrolWorkspace(
     }
     throw e;
   }
-  // 与 readTasks 不一致的极端竞态：保守不动，新 spawn 也全留跨轮路径。
-  if (result === null) return [];
+  // 与 readTasks 不一致的极端竞态：维护保守不动，但本轮新 spawn 仍要进入
+  // 等待认亲与补盖流程；丢掉 pending 会把同轮收尾无故推迟到下一轮。
+  if (result === null) return pending;
   if (result.renewed) {
     deps.log(`已续期 ${ws}：${result.renewed} 个周期任务标记为 permanent，`
       + '不再受 7 天过期限制');
@@ -628,7 +636,7 @@ async function awaitWarmups(pending, state, cur, stats) {
   const recognize = () => {
     const rest = [];
     for (const p of pending) {
-      const ent = state[p.ws]?.[p.key];
+      const ent = getOwn(state[p.ws], p.key);
       if (!ent || ent.pid !== p.pid) continue;
       if (!deps.trackedAlive(ent)) {
         // 启动即崩的典型窗口：真拉起过却死掉，计一次失败并置空 pid，条
@@ -696,10 +704,12 @@ function stampClaimed(claimedByWs, taskfiles, stats) {
 // 拉）；state.json 已丢的旧孤儿 script（日志是旧命名，不含任务键段）从
 // 进程表兜底清扫。只在 loadLegacyEntries 非空（确在跨版本）时执行。
 async function retireLegacy(legacy, stats) {
+  let retired = true;
   for (const ent of legacy) {
     if (deps.trackedAlive(ent)) {
       const stopped = await deps.stopSession(ent);
       if (!stopped) {
+        retired = false;
         bump(stats, 'warn');
         deps.log(`旧版迁移暂缓 ${ent.ws} pid=${ent.pid}：记录的进程仍存活，`
           + '本次无法安全停止目录级预热会话；本次不记为已回收');
@@ -721,6 +731,7 @@ async function retireLegacy(legacy, stats) {
     if (!deps.trackedAlive(ent)) continue;
     const stopped = await deps.stopSession(ent);
     if (!stopped) {
+      retired = false;
       bump(stats, 'warn');
       deps.log(`旧版迁移暂缓 pid=${pid}：记录的进程仍存活，本次无法安全停止`
         + `目录级预热孤儿会话（日志 ${file}）；本次不记为已回收`);
@@ -730,6 +741,7 @@ async function retireLegacy(legacy, stats) {
         + '升级后按任务重新预热');
     }
   }
+  return retired;
 }
 
 // 跑一轮巡检；抢不到锁返回 false。
@@ -793,8 +805,9 @@ export async function cmdRun(args) {
       deps.log(`告警：${registryAlert}`);
     }
 
-    // 旧版收尾必须先于一切 spawn 决策（state 轮末被新形状整体覆盖）。
-    if (legacy.length > 0) await retireLegacy(legacy, stats);
+    // 旧版收尾必须先于一切 spawn 决策。停止失败时轮末保留原 state，下轮
+    // 才能继续重试；本轮新会话可由任务专属日志认领，不会因未落盘而重拉。
+    const legacyRetired = legacy.length === 0 || await retireLegacy(legacy, stats);
 
     // 轮初把上轮末仍相信活着的条目分成三组：活、resume 脱离（script 已
     // 死但 sid 还在，不报退出）、真死（立即报）。带 deadSince 的旧报条
@@ -865,7 +878,7 @@ export async function cmdRun(args) {
         for (const d of died) {
           bump(stats, 'exit');
           deps.log(exitLine(d.ws, d.key,
-            { ...state[d.ws]?.[d.key], pid: d.pid }));
+            { ...getOwn(state[d.ws], d.key), pid: d.pid }));
         }
         stampClaimed(claimedByWs, taskfiles, stats);
       } catch (e) {
@@ -894,27 +907,23 @@ export async function cmdRun(args) {
     for (const [ws, bucket] of Object.entries(state)) {
       const out = {};
       for (const [taskId, ent] of Object.entries(bucket)) {
-        if (deps.trackedAlive(ent)) {
-          out[taskId] = ent;
-          continue;
-        }
-        if (typeof ent.sessionId === 'string'
-            && sidInDetails(ws, ent.sessionId)) {
-          out[taskId] = ent;
-          continue;
-        }
-        if (isCooling(ent, cur)) {
-          out[taskId] = ent;
+        if (deps.trackedAlive(ent)
+            || (typeof ent.sessionId === 'string'
+              && sidInDetails(ws, ent.sessionId))
+            || isCooling(ent, cur)) {
+          setOwn(out, taskId, ent);
           continue;
         }
         if ((ent.fails ?? 0) > 0) {
           ent.deadSince ??= cur;
-          if (cur - ent.deadSince < FAIL_TTL_SECONDS) out[taskId] = ent;
+          if (cur - ent.deadSince < FAIL_TTL_SECONDS) {
+            setOwn(out, taskId, ent);
+          }
         }
       }
-      if (Object.keys(out).length > 0) kept[ws] = out;
+      if (Object.keys(out).length > 0) setOwn(kept, ws, out);
     }
-    saveState(kept);
+    if (legacyRetired) saveState(kept);
 
     // 轮末汇总：一行交代这轮看见了什么、动了什么、花了多久，随后更新心跳。
     const actions = EVENT_LABELS

package/src/service.mjs

@@ -292,7 +292,10 @@ function scriptPathDirs(scriptPath) {
 export function launcherHealth() {
   if (!fs.existsSync(deps.paths.plistPath)) return null;
   const args = readPlistProgramArgs();
-  if (!args || args.length !== 1) return null;
+  if (!args || args.length !== 1) {
+    return `LaunchAgent ${deps.paths.plistPath} 的 ProgramArguments 无法解读，`
+      + '重跑 cron-up install 覆盖重生成';
+  }
   const [scriptPath] = args;
   if (!fs.existsSync(scriptPath)) {
     return `launchd 配置中的启动脚本已失效（${path.basename(scriptPath)} `
@@ -360,11 +363,12 @@ export async function cmdInstall(args) {
   validateConfig(cfg, (m) => deps.print(m));
   if (JSON.stringify(cfg.roots)
       === JSON.stringify(normalizeRoots(DEFAULT_CONFIG.roots))) {
-    // 与 README 安全说明同一句话，在配置落定的这一刻当面再说一遍。
+    // 与 README「安全与自动修改」同一口径，在配置落定时再提示一次。
     deps.print(`提示：未指定 --roots，默认扫描 ${DEFAULT_CONFIG.roots.join('、')}`
       + '（不存在的目录跳过）；今后 clone 进这些容器的仓库也会进入巡检，'
-      + '其中的周期任务会被自动续期永久化。目录布局不同或需收窄时用 '
-      + '--roots 指定（见 README 安全说明）');
+      + '其中的周期任务会被自动续期永久化，任务、CLAUDE.md 与项目配置都会'
+      + '影响无人值守会话。目录布局不同或需收窄时用 --roots 指定'
+      + '（见 README「安全与自动修改」）');
   }
 
   const launcher = deps.resolveLauncher();
@@ -515,7 +519,7 @@ export async function cmdUninstall(args) {
       // npm 管的文件不能手删：命令行本身交给 npm 卸载。
       deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
     } else {
-      deps.print('配置与日志已保留（--purge 可删除全部产物）');
+      deps.print('配置与日志已保留（--purge 可删除 cron-up 自有配置与日志）');
     }
   } finally {
     deps.releaseRunLock(lock);

package/src/sessions.mjs

@@ -119,11 +119,11 @@ function canSignalProcessGroup(pid) {
 // 为一个任务拉起一个 detached 的 pty TUI，返回 {pid, procStart}。
 export function spawnSession(ws, taskId) {
   const logPath = sessionLogPath(ws, taskId);
-  // 会话日志目录 700（README 承诺）：每任务独立文件，目录只在此处创建。
+  // 会话日志目录 700（README 权限约定）：每任务独立文件，目录只在此处创建。
   ensurePrivateDir(path.dirname(logPath));
-  // 「一代会话 = 一次执行」：script(1) 打开即截断，不轮转的话上一代（上
-  // 一次执行）的界面记录会随本次拉起被抹掉。无条件保留一代（.1）——总
-  // 量上界两代，活着的一代增长再快也只影响自身，不会经轮转放大。
+  // script(1) 启动即截断：每次新拉起前无条件保留上一代（.1），避免上次
+  // 启动以来的界面记录被抹掉。总量上界两代，活着的一代增长再快也只影响
+  // 自身，不会经轮转放大。
   try {
     if (fs.existsSync(logPath)) rotateOnce(logPath);
   } catch {

package/src/tasks.mjs

@@ -235,6 +235,14 @@ export function atomicWriteJson(file, doc, expectedMtimeNs) {
   fs.renameSync(tmp, file);
 }
 
+// 任务归属是否已完全等于盖印目标。巡检预判与实际写入共用同一判据，
+// 避免一层只看 sessionId、另一层比较三字段而逐渐漂移。
+export function taskOwnedBy(t, target) {
+  return t.createdBySessionId === target.sessionId
+    && t.createdByPid === target.pid
+    && t.createdByProcStart === target.procStart;
+}
+
 // 一轮巡检对一个任务文件做的维护：renew（补 permanent）与 reown（把任务
 // 归属盖给各自的预热会话）合并为同一次带 mtime 乐观检测的原子写。先取
 // mtimeNs、清残留 .cron-up-tmp、loadTaskDoc round-trip 整文档；两项计数
@@ -244,8 +252,8 @@ export function atomicWriteJson(file, doc, expectedMtimeNs) {
 // reown 形状：Map<taskKey, {sessionId, pid, procStart}>。一轮内同一文件的
 // 不同任务可盖向不同预热（一任务一会话）；内容相同但 id 不同的任务互不
 // 影响。同一个 taskKey 对应多条任务是病态输入，无法把 state/会话唯一对应
-// 到条目，这些键全部跳过盖印。只盖 createdBySessionId 不等于目标的任务，
-// 第二轮起字节级不动；pid/procStart 是登记里 claude 进程的 pid 与 lstart。
+// 到条目，这些键全部跳过盖印。归属三字段未完全等于目标时才写，第二轮起
+// 字节级不动；pid/procStart 是登记里 claude 进程的 pid 与 lstart。
 export function maintainWorkspace(taskfile, { reown = null } = {}) {
   let mtimeNs;
   try {
@@ -284,7 +292,7 @@ export function maintainWorkspace(taskfile, { reown = null } = {}) {
       const target = reown.get(key);
       // 没有 owner 字段的外部条目同样盖——窗口内任务统一归各自预热，语义
       // 不因条目来源留例外。
-      if (target && t.createdBySessionId !== target.sessionId) {
+      if (target && !taskOwnedBy(t, target)) {
         t.createdBySessionId = target.sessionId;
         t.createdByPid = target.pid;
         // ps lstart 原文（含「Oct  8」双空格），原样取自会话登记。