cron-up 26.9.1

package/src/sessions.mjs

@@ -0,0 +1,187 @@
+// 预热会话的整个生命周期：存活探测、pid 身份指纹、拉起、停止、日志文件
+// 名、进程表兜底。被拉起的是 /usr/bin/script 包裹的 TUI，detached 独立进
+// 程组，与短命的巡检进程在进程层早就分开。
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { deps } from './internals.mjs';
+import {
+  LOG_ROTATE_BYTES,
+  SESSION_IDLE_SECONDS,
+} from './constants.mjs';
+
+// pid 是否对应活进程。走到这儿的 pid 已经过入口范围校验。
+export function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ps 报告的进程启动时间，作为 pid 的身份指纹：macOS 高负载下几小时就回收
+// pid，单靠 kill -0 分不出我们的预热会话和后来继承同一编号的进程。
+export function procStartedAt(pid) {
+  // 固定 locale：这个字符串会跨轮次做精确相等比较，手动 run（终端
+  // LANG，可能本地化）与 launchd 驱动的巡检若格式不同，会把自己的会话
+  // 误判成回收 pid。
+  const r = deps.execFile(
+    '/bin/ps',
+    ['-p', String(pid), '-o', 'lstart='],
+    { env: { ...process.env, LC_ALL: 'C', LANG: 'C' }, timeout: 5000 },
+  );
+  const out = (r.stdout ?? '').trim();
+  return out || null;
+}
+
+// 仅当记录的 pid 仍是我们当初 spawn 的那个进程时为 true。
+export function trackedAlive(ent) {
+  if (!ent || !ent.pid) return false;
+  if (!deps.alive(ent.pid)) return false;
+  const started = ent.procStart;
+  if (!started) return true; // 旧版本写的条目：退回 kill -0 判定
+  return deps.procStartedAt(ent.pid) === started;
+}
+
+// 日志文件名折法：下划线转义必须在斜杠折叠之前——/a/b → a_b，
+// /a_b → a__b，两类路径才不会共用同一个日志文件（script(1) 启动即截断，
+// 撞名意味着两个工作区互相覆盖记录）。
+export function sessionLogPath(ws) {
+  const slug = ws.replace(/^\/+|\/+$/g, '')
+    .replace(/_/g, '__')
+    .replace(/\//g, '_');
+  return path.join(deps.paths.sessionLogDir, `${slug}.log`);
+}
+
+// POSIX shell 引用：安全字符白名单内原样返回，否则单引号包裹，内部单引
+// 号写成 '"'"'。
+export function shellQuote(s) {
+  if (s === '') return "''";
+  if (/^[-@%+=:,./\w]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, `'"'"'`)}'`;
+}
+
+export function sessionArgv(ws, logPath) {
+  // -l -i 都不能少。-i 加载定义了私有端点/模型路由（claude shell 函数）
+  // 的交互 rc；-l 加载 /etc/zprofile 的 path_helper，这是 launchd 最小环
+  // 境里唯一把 homebrew（进而 fnm/node）放上 PATH 的东西。光 -ic 在终端
+  // 里靠继承现成 PATH 一切正常，交给 launchd 就 fnm: command not found。
+  return [
+    '/usr/bin/script', '-q', logPath,
+    '/bin/zsh', '-lic', `cd ${shellQuote(ws)} && claude`,
+  ];
+}
+
+// 预热会话继承的环境：strip 掉所有 CLAUDE_CODE_* 注入标记（从另一个 CC
+// 会话里手动 run 时，否则 TUI 会以子会话身份启动，没有 transcript/登记），
+// 再打上自我标识供外部观察工具归组。纯函数：绝不能改父进程的 process.env
+// （Node 没有 fork，子环境只能显式构造）。
+export function buildChildEnv(parentEnv) {
+  const env = { ...parentEnv };
+  for (const k of Object.keys(env)) {
+    if (k.startsWith('CLAUDE_CODE_')) delete env[k];
+  }
+  // 刻意不带 CLAUDE_CODE_ 前缀（上一步刚把那批 strip 掉）；值必须严格是
+  // 字符串 '1'（观察侧 === '1' 判定）。
+  env.CRON_UP_SESSION = '1';
+  return env;
+}
+
+// 拉起一个 detached 的 pty TUI，返回 {pid, procStart}。
+export function spawnSession(ws) {
+  const logPath = sessionLogPath(ws);
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  try {
+    fs.chmodSync(path.dirname(logPath), 0o700);
+  } catch {
+    // 目录权限维持现状。
+  }
+  // script(1) 不带 O_APPEND 打开 typescript，下次 spawn 会截断，所以只轮
+  // 转仍在增长的会话留下的超大日志。
+  try {
+    if (fs.existsSync(logPath) && fs.statSync(logPath).size > LOG_ROTATE_BYTES) {
+      const old = `${logPath}.1`;
+      fs.rmSync(old, { force: true });
+      fs.renameSync(logPath, old);
+    }
+  } catch {
+    // 轮转失败不阻断拉起。
+  }
+  // spawn 没有 umask 选项，而 typescript 可能含任务输出、必须 0600：先以
+  // 0600 预创建，script 随后以 O_TRUNC 打开已存在文件时模式位不变。
+  const fd = fs.openSync(logPath, 'a', 0o600);
+  fs.closeSync(fd);
+  try {
+    fs.chmodSync(logPath, 0o600);
+  } catch {
+    // 维持 0600。
+  }
+  const argv = sessionArgv(ws, logPath);
+  const child = deps.spawn(argv[0], argv.slice(1), {
+    detached: true, // 子侧 setsid：child.pid 即新进程组组长
+    stdio: 'ignore', // script 把 typescript 写进 logPath
+    cwd: ws,
+    env: buildChildEnv(process.env),
+  });
+  // unref 后即使异步启动失败也不要变成 uncaught（监听器不影响 loop 退出）。
+  child.on('error', () => {});
+  child.unref();
+  return { pid: child.pid, procStart: deps.procStartedAt(child.pid) };
+}
+
+// 按进程组结束我们拉起的会话。发信号前先核身份：state 条目可能比它命名
+// 的进程活得久，给回收 pid 发组信号会杀掉无关进程组。
+export async function stopSession(ent) {
+  if (!deps.trackedAlive(ent)) return;
+  const pid = ent.pid;
+  try {
+    process.kill(-pid, 'SIGTERM');
+  } catch {
+    return;
+  }
+  for (let i = 0; i < 20; i++) {
+    await deps.sleep(100);
+    if (!deps.alive(pid)) return;
+  }
+  // 升级 SIGKILL 前再核一次指纹。
+  if (deps.trackedAlive(ent)) {
+    try {
+      process.kill(-pid, 'SIGKILL');
+    } catch {
+      // 组已消失。
+    }
+    await deps.sleep(100);
+  }
+}
+
+// typescript 多少秒没被写。文件缺失读作「没有活动证据」，不挡轮转。
+export function sessionLogIdleSeconds(logPath, cur) {
+  try {
+    return Math.max(0, cur - Math.floor(fs.statSync(logPath).mtimeMs / 1000));
+  } catch {
+    return SESSION_IDLE_SECONDS + 1;
+  }
+}
+
+// 进程表是 state.json 丢失时的兜底：被遗忘的预热会话卡在提问界面时不会出
+// 现在会话登记里，没这层交叉检查就会在同目录堆第二个 TUI。
+export function listScriptProcesses() {
+  const r = deps.execFile('/bin/ps', ['-axo', 'pid=,args='], { timeout: 5000 });
+  const out = [];
+  for (const line of (r.stdout ?? '').split('\n')) {
+    const m = line.match(/^\s*(\d+)\s+(\/usr\/bin\/script\s.*)$/);
+    if (m) out.push([parseInt(m[1], 10), m[2]]);
+  }
+  return out;
+}
+
+Object.assign(deps, {
+  alive,
+  procStartedAt,
+  trackedAlive,
+  spawnSession,
+  stopSession,
+  listScriptProcesses,
+});

package/src/tasks.mjs

@@ -0,0 +1,220 @@
+// Claude Code 任务文件层：发现工作区、读任务、续期（permanent 标记）与
+// 原子写。任务文件是另一个程序写的外部输入，所有入口都校验形状，坏数据
+// 读作「没有任务」而不是抛进巡检循环。
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { deps } from './internals.mjs';
+import { TASK_REL } from './paths.mjs';
+import { PRUNE_DIRS } from './constants.mjs';
+
+export function expandHome(p) {
+  const home = deps.paths.home;
+  if (p === '~') return home;
+  if (p.startsWith('~/') || p.startsWith('~\\')) {
+    return home + p.slice(1);
+  }
+  return p; // ~user 形式不支持（macOS 实践中不会出现）
+}
+
+function isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function realpathOrNull(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+
+// 路径在磁盘上真实存储的大小写形态；任何一段读不出时原样返回。
+// macOS 默认文件系统大小写不敏感，而 realpath 不规范化大小写：敲错大小
+// 写的路径照样通过 isDirectory，却与会话登记里真实大小写的 cwd 永远匹配
+// 不上。在扫描边界认回一次真实写法，下游就不必各自提防。
+export function onDiskCase(p) {
+  const parts = [];
+  let cur = path.resolve(p).replace(/\/+$/, '') || '/';
+  while (true) {
+    const head = path.dirname(cur);
+    const tail = path.basename(cur);
+    if (!tail || head === cur) break;
+    parts.push(tail);
+    cur = head;
+  }
+  // cur 停在根，自顶向下逐段认回磁盘上的真实条目名。
+  for (const name of parts.reverse()) {
+    let entries;
+    try {
+      entries = fs.readdirSync(cur);
+    } catch {
+      return p;
+    }
+    const match = entries.find((e) => e.toLowerCase() === name.toLowerCase());
+    if (!match) return p;
+    cur = path.join(cur, match);
+  }
+  return cur;
+}
+
+// 枚举所有含任务文件的工作区，产出 [workspace, taskfile]。生成器：一个工
+// 作区出问题不该跳过其后所有工作区（调用方另有 per-workspace 保护）。
+export function* discover(roots, maxDepth) {
+  const seen = new Set();
+  for (const raw of roots) {
+    let root = realpathOrNull(path.resolve(expandHome(String(raw))));
+    if (root === null || !isDir(root)) continue;
+    // 在边界认回真实大小写：带错大小写的 root 会让 ws 与会话登记的 cwd
+    // 匹配不上，同目录被重复拉起会话。
+    root = onDiskCase(root).replace(/\/+$/, '') || '/';
+    const baseDepth = root.split('/').length - 1;
+
+    function* walk(dirpath) {
+      let entries;
+      try {
+        entries = fs.readdirSync(dirpath, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const depth = dirpath.split('/').length - 1 - baseDepth;
+      // 先剪枝：depth==maxDepth 这一层本身仍要检查候选文件，只是不再下
+      // 降；再做候选检查。
+      const subdirs = depth >= maxDepth
+        ? []
+        : entries.filter((e) => e.isDirectory() && !PRUNE_DIRS.has(e.name));
+      const candidate = path.join(dirpath, TASK_REL);
+      const ws = realpathOrNull(dirpath);
+      let isFile = false;
+      try {
+        isFile = fs.statSync(candidate).isFile();
+      } catch {
+        isFile = false;
+      }
+      if (ws && isFile && !seen.has(ws)) {
+        seen.add(ws);
+        yield [ws, candidate];
+      }
+      for (const d of subdirs) {
+        yield* walk(path.join(dirpath, d.name));
+      }
+    }
+    yield* walk(root);
+  }
+}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+// 读一个工作区的任务列表，坏形状一律返回 null。
+export function readTasks(ws) {
+  let doc;
+  try {
+    doc = JSON.parse(fs.readFileSync(
+      path.join(ws, TASK_REL), 'utf-8'));
+  } catch {
+    return null;
+  }
+  if (!isPlainObject(doc) || !Array.isArray(doc.tasks)) return null;
+  return doc.tasks.filter(isPlainObject);
+}
+
+// 任务文件在「读到」与「写回」之间被别的写者改了（Claude Code 更新
+// lastFiredAt 或删除已触发任务）：绝不覆盖，抛 TaskFileChanged 让下轮
+// 巡检基于更新的文档重试。
+export class TaskFileChanged extends Error {
+  constructor(file) {
+    super(`任务文件已被其他写者改动：${file}`);
+    this.name = 'TaskFileChanged';
+  }
+}
+
+// 读整份文档（未知顶层键保留）：renew 要就地重写文件，必须 round-trip
+// Claude Code 或其他工具放进去的每个键，而不只是 tasks 子集。
+export function loadTaskDoc(file) {
+  let doc;
+  try {
+    doc = JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return null;
+  }
+  if (!isPlainObject(doc) || !Array.isArray(doc.tasks)) return null;
+  return doc;
+}
+
+// 旁边写再 rename 的原子替换，保留原文件权限位与中文字面量。
+// tmp 以 0600 创建（绝不更宽），写完再放宽到原 mode。expectedMtimeNs 是
+// 乐观锁：路径 mtime 自调用方读后变了说明别的写者抢先，抛
+// TaskFileChanged 而不是覆盖它的更新。
+export function atomicWriteJson(file, doc, expectedMtimeNs) {
+  let mode = 0o600;
+  try {
+    mode = fs.statSync(file).mode & 0o777;
+  } catch {
+    // 新文件用 0600。
+  }
+  const tmp = `${file}.tmp`;
+  // JSON.stringify 两空格缩进：中文按字面写出（不转 \u），无尾换行。
+  fs.writeFileSync(tmp, JSON.stringify(doc, null, 2), {
+    flag: 'w',
+    mode: 0o600,
+  });
+  try {
+    fs.chmodSync(tmp, mode);
+  } catch {
+    // 保持 0600。
+  }
+  let current = null;
+  try {
+    current = fs.statSync(file, { bigint: true }).mtimeNs;
+  } catch {
+    current = null;
+  }
+  if (current !== expectedMtimeNs) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+      // 忽略清理失败。
+    }
+    throw new TaskFileChanged(file);
+  }
+  fs.renameSync(tmp, file);
+}
+
+// 给所有缺 truthy permanent 标记的周期任务打上标记。
+// 返回：打标的数量（文件只重写一次）；0 表示文件已全部标好（字节级不
+// 动，这是 5 分钟巡检不会永远重写别人文件的幂等性）；null 表示文件缺失/
+// 损坏；读到的与写间被改抛 TaskFileChanged。一次性任务与无标志的手写文
+// 件永不修改。
+export function renewWorkspace(taskfile) {
+  let mtimeNs;
+  try {
+    mtimeNs = fs.statSync(taskfile, { bigint: true }).mtimeNs;
+  } catch {
+    return null;
+  }
+  const doc = deps.loadTaskDoc(taskfile);
+  if (doc === null) return null;
+  let tagged = 0;
+  for (const t of doc.tasks) {
+    // truthy 而非 === true：与 Claude Code 自己的加载器一致
+    // （...o.permanent && {permanent:true}），它已认作永久的任何值都算，
+    // 不再重写。只有显式周期任务有资格——绝不从 cron 形状推断周期性，
+    // 一次性任务不碰。
+    if (isPlainObject(t) && t.recurring && !t.permanent) {
+      t.permanent = true;
+      tagged += 1;
+    }
+  }
+  if (tagged === 0) return 0;
+  atomicWriteJson(taskfile, doc, mtimeNs);
+  return tagged;
+}
+
+Object.assign(deps, { discover, readTasks, loadTaskDoc });