@xyagent/cli 0.0.1

package/src-ext/runtime/claude/usageProbe.mjs

@@ -0,0 +1,576 @@
+// Claude Code `/usage` TUI 抓取探针。
+//
+// 背景：
+//   Claude Code CLI 的 5h/weekly 额度只能通过交互式 TUI 的 `/usage` 查看，
+//   -p / stream-json 模式下不可用。要拿到额度数据，只能起 PTY 真实运行
+//   claude，输入 `/usage`、从渲染出的 ANSI 字符流里 scrape。
+//
+// 设计：
+//   - 必选依赖 node-pty —— 装不上就 fail loudly（package.json 移出 optional）。
+//   - 独立 short-lived claude 进程（不复用主会话），干净退出。
+//   - 抓取结果归一化到 usageReporter 的 rate_limits 形状：
+//       { primary:{used_percent, window_minutes:300, resets_at}, secondary:{...}, plan_type }
+//   - 不依赖具体提示符检测 —— 固定延时后直接发 /usage，再轮询 buffer 里是否
+//     出现"% used" + "Resets in …"双重特征，稳定 500ms 后结束。
+//   - 宽容解析：5h/weekly/Current session 三大类标签都尝试命中，percent 接受
+//     "30%"、"30.5% used"、"Used: 30%"、"30/100"；resets 接受多种常见自然语言。
+
+import { stripAnsi } from "./usageProbeStrip.mjs";
+import { execFileSync, spawn as cpSpawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const PROBE_HARD_TIMEOUT_MS = 15_000;
+const STABLE_DWELL_MS = 1500;      // 识别到双特征后额外等待多久再 parse
+                                    // —— v2.1 TUI 第一遍渲染可能含坏字符（Resets→Reses），
+                                    //    第二遍才完整；等久一点确保两遍都进 buffer
+const POLL_INTERVAL_MS = 200;
+
+let nodePtyDisabledReason = null;
+
+/**
+ * 运行一次 `/usage` 探针。
+ *
+ * @param {Object} opts
+ * @param {string} opts.cwd
+ * @param {import("../../../src-shared/logger.mjs").Logger} opts.log
+ * @param {AbortSignal} [opts.signal]
+ * @returns {Promise<null | {
+ *   primary: null|{used_percent:number, window_minutes:number, resets_at:number},
+ *   secondary: null|{used_percent:number, window_minutes:number, resets_at:number},
+ *   plan_type: string|null,
+ * }>}
+ */
+export async function probeClaudeUsage({ cwd, log, signal }) {
+  const pLog = log.child({ comp: "usage-probe", runtime: "claude" });
+
+  const claudeBin = resolveClaudeBin();
+  const env = buildProbeEnv();
+  // Probe 子进程的 cwd：**必须**用 claude 已信任过的目录，否则被"Trust this folder?"
+  // 安全弹窗拦住，根本进不了 TUI。
+  // 优先级：传入 cwd 已信任 > ~/.claude.json 里任意已信任项 > HOME（兜底）
+  // 三端通用：claude-code 在 macOS/Linux/Windows 都用同一个 ~/.claude.json。
+  let probeCwd = pickExistingTrustedCwd(cwd) || pickAnyTrustedCwd() || os.homedir();
+  pLog.info("probe.cwd", "resolved probe cwd", { probeCwd, passedCwd: cwd });
+
+  // macOS service 环境里 node-pty 的失败路径可能泄漏 PTY FD；优先用系统
+  // script(1)，保留 node-pty 作为 script 不可用时的跨平台后备。
+  const preferScript = process.platform === "darwin";
+  let term = null;
+  let via = null;
+  if (preferScript) {
+    term = createScriptPtyTerm({ claudeBin, cwd: probeCwd, env, pLog });
+    if (term) via = "script(1)";
+  }
+  if (!term) {
+    term = await createNodePtyTerm({ claudeBin, cwd: probeCwd, env, pLog });
+    if (term) via = "node-pty";
+  }
+  if (!term && !preferScript) {
+    term = createScriptPtyTerm({ claudeBin, cwd: probeCwd, env, pLog });
+    if (term) via = "script(1)";
+  }
+  if (!term) {
+    pLog.error("probe.pty.unavailable", "no PTY mechanism available", { claudeBin });
+    return null;
+  }
+  pLog.info("probe.pty.via", "probe PTY backend", { via });
+
+  return new Promise((resolve) => {
+    let buffer = "";
+    let settled = false;
+    let sentUsage = false;
+    let stableTimer = null;
+    let hardTimer = null;
+    let pollTimer = null;
+    let bootstrapTimer = null;
+    const cleanups = [];
+
+    const done = (result, reason) => {
+      if (settled) return;
+      settled = true;
+      if (stableTimer) clearTimeout(stableTimer);
+      if (hardTimer) clearTimeout(hardTimer);
+      if (pollTimer) clearInterval(pollTimer);
+      if (bootstrapTimer) clearInterval(bootstrapTimer);
+      for (const cleanup of cleanups.splice(0)) {
+        try { cleanup(); } catch {}
+      }
+      try { term.write("\x03"); } catch {}   // Ctrl-C 让 TUI 主动退出
+      setTimeout(() => { try { term.kill(); } catch {} }, 100);
+      const got = result || parseUsageOutput(stripAnsi(buffer));
+      pLog.info("probe.finished", "probe finished", {
+        reason,
+        via,
+        buffer_len: buffer.length,
+        got_primary: !!got?.primary,
+        got_secondary: !!got?.secondary,
+        got_plan: !!got?.plan_type,
+      });
+      if (!got || (!got.primary && !got.secondary && !got.plan_type)) {
+        // 抬到 info 级别，便于在 service 日志里看到（debug 默认不输出）
+        pLog.info("probe.parse.empty", "parse found nothing — buffer tail for diagnosis", {
+          buffer_len: buffer.length,
+          sample_head: stripAnsi(buffer).slice(0, 800),
+          sample_tail: stripAnsi(buffer).slice(-1500),
+        });
+      }
+      resolve(got);
+    };
+
+    const onAbort = () => done(null, "aborted");
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal) cleanups.push(() => signal.removeEventListener("abort", onAbort));
+    if (signal?.aborted) {
+      done(null, "aborted");
+      return;
+    }
+
+    let trustDismissed = false;
+    const dataSub = term.onData((data) => {
+      buffer += data;
+      if (buffer.length > 262144) buffer = buffer.slice(-131072);
+    });
+    if (dataSub && typeof dataSub.dispose === "function") {
+      cleanups.push(() => dataSub.dispose());
+    }
+    const exitSub = term.onExit(({ exitCode }) => done(null, `child-exit-${exitCode}`));
+    if (exitSub && typeof exitSub.dispose === "function") {
+      cleanups.push(() => exitSub.dispose());
+    }
+
+    const sendUsage = () => {
+      if (settled || sentUsage) return;
+      try {
+        term.write("/usage\r");
+        sentUsage = true;
+        pLog.info("probe.usage.sent", "/usage written");
+      } catch (err) {
+        pLog.warn("probe.usage.write.failed", "write /usage failed", {
+          err: err?.message,
+        });
+      }
+    };
+
+    // 启动流程：
+    //   t=0          spawn claude
+    //   每 200ms 轮询 stripped buffer：
+    //     - 见到 trust prompt → 发 Enter（选默认 #1）→ 继续等 2s → sendUsage
+    //     - 无 prompt 但 3s 已过 → 认定已信任 → sendUsage
+    //   之后进入 hasUsageMarkers 正常轮询 → 稳定后 parse
+    const spawnAt = Date.now();
+    const TRUST_WAIT_MAX_MS = 3000;   // 3s 内没 prompt 就假设不需要信任
+    const TRUST_POST_DELAY_MS = 2000; // 信任接受后再等主 TUI 渲染
+    bootstrapTimer = setInterval(() => {
+      if (settled || sentUsage) { clearInterval(bootstrapTimer); return; }
+      const stripped = stripAnsi(buffer);
+      // 三端通用的 trust prompt 关键短语 —— script(1) 剥空格后都用 \s* 宽松
+      const sawTrust = /trust\s*this\s*folder|i\s*trust\s*this\s*folder|yes,\s*i\s*trust/i.test(stripped);
+      if (sawTrust && !trustDismissed) {
+        trustDismissed = true;
+        try { term.write("\r"); } catch {} // Enter 选择默认 #1
+        pLog.info("probe.trust.dismissed", "trust prompt auto-accepted (Enter)");
+        setTimeout(sendUsage, TRUST_POST_DELAY_MS);
+        clearInterval(bootstrapTimer);
+        return;
+      }
+      // 超过阈值仍无 trust prompt → 认定不需要信任，直接发 /usage
+      if (Date.now() - spawnAt >= TRUST_WAIT_MAX_MS) {
+        pLog.info("probe.trust.skipped", "no trust prompt detected within window");
+        sendUsage();
+        clearInterval(bootstrapTimer);
+      }
+    }, 200);
+
+    // 轮询：/usage 发出后，只要 buffer 出现"% used"+"Resets"双特征就稳定 500ms 后收网
+    pollTimer = setInterval(() => {
+      if (!sentUsage || settled) return;
+      const stripped = stripAnsi(buffer);
+      if (hasUsageMarkers(stripped) && !stableTimer) {
+        stableTimer = setTimeout(() => {
+          done(parseUsageOutput(stripAnsi(buffer)), "markers-stable");
+        }, STABLE_DWELL_MS);
+      }
+    }, POLL_INTERVAL_MS);
+
+    // 硬兜底：15s 无论如何解析并返回
+    hardTimer = setTimeout(() => {
+      done(parseUsageOutput(stripAnsi(buffer)), "hard-timeout");
+    }, PROBE_HARD_TIMEOUT_MS);
+  });
+}
+
+// ── PTY 抽象层 ────────────────────────────────────────────────────────────
+//
+// 两套实现，对外同接口：write / onData / onExit / kill。
+//   1. node-pty（首选，原生 PTY，fork+posix_spawnp）
+//   2. script(1) fallback（macOS/Linux 自带，绕过 node-pty 的 posix_spawnp
+//      受限场景；用 `script -q /dev/null <cmd>` 创建 PTY，主进程走管道与它通信）
+//
+// 抽象好处：主流程不用关心哪种后端，跑不通一种就换一种。
+
+/**
+ * 构造 probe 子进程的 env：
+ *   - 从 process.env 起步
+ *   - 剥掉 Claude Desktop / 托管环境注入的强制 provider 变量
+ *     （否则 probe 被绑定到 host OAuth，不再读用户磁盘上的订阅凭证）
+ *   - 强制 TERM/FORCE_COLOR，并关掉更新检查
+ */
+function buildProbeEnv() {
+  const base = { ...process.env };
+  for (const k of [
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_AGENT_SDK_VERSION",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+  ]) {
+    delete base[k];
+  }
+  return {
+    ...base,
+    CLAUDE_CODE_NO_UPDATE_CHECK: "1",
+    TERM: "xterm-256color",
+    FORCE_COLOR: "1",
+  };
+}
+
+/**
+ * 读 ~/.claude.json 的 projects，找出用户已接受信任对话框的路径集合。
+ * 三端通用：claude-code 在 macOS / Linux / Windows 都把这个配置存在 $HOME 下。
+ */
+function readTrustedProjects() {
+  try {
+    const file = path.join(os.homedir(), ".claude.json");
+    const raw = readFileSync(file, "utf8");
+    const obj = JSON.parse(raw);
+    const projects = obj?.projects;
+    if (!projects || typeof projects !== "object") return [];
+    return Object.entries(projects)
+      .filter(([, meta]) => meta && meta.hasTrustDialogAccepted === true)
+      .map(([p]) => p);
+  } catch {
+    return [];
+  }
+}
+
+/** 传入 cwd 若正好在已信任列表里且目录仍存在 → 返回它；否则 null。 */
+function pickExistingTrustedCwd(cwd) {
+  if (!cwd || cwd === "/" || cwd === "\\") return null;
+  const trusted = readTrustedProjects();
+  if (trusted.includes(cwd) && existsSync(cwd)) return cwd;
+  return null;
+}
+
+/** 从已信任列表里挑**仍然存在**的首个路径，作为 probe 安全 cwd 兜底。 */
+function pickAnyTrustedCwd() {
+  const trusted = readTrustedProjects();
+  for (const p of trusted) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+
+function resolveClaudeBin() {
+  // node-pty posix_spawnp 对 PATH 搜索有时失败，先解析绝对路径。跨平台：
+  //   - Unix (macOS/Linux):  `which claude` 或 POSIX `command -v`
+  //   - Windows:             `where claude`（可能返回多行 .exe/.cmd，取首行）
+  const isWin = process.platform === "win32";
+  const attempts = isWin
+    ? [["where", "claude"]]
+    : [["which", "claude"], ["/bin/sh", "-c", "command -v claude"]];
+  for (const args of attempts) {
+    try {
+      const out = execFileSync(args[0], args.slice(1), {
+        encoding: "utf8", timeout: 2000, windowsHide: true,
+      }).trim();
+      if (out) return out.split(/\r?\n/)[0];
+    } catch {}
+  }
+  return isWin ? "claude.cmd" : "claude";
+}
+
+async function createNodePtyTerm({ claudeBin, cwd, env, pLog }) {
+  if (nodePtyDisabledReason) {
+    pLog.info("probe.pty.skipped", "node-pty disabled for this agent process after earlier failure", {
+      reason: nodePtyDisabledReason,
+    });
+    return null;
+  }
+  let pty;
+  try {
+    pty = await import("node-pty");
+  } catch (err) {
+    const reason = `load failed: ${err?.message || String(err)}`;
+    nodePtyDisabledReason = reason;
+    pLog.warn("probe.pty.load.failed", "node-pty failed to load, disabling node-pty backend for this process", { err: reason });
+    return null;
+  }
+  // 跨平台：macOS/Linux 用 xterm 兼容 pty；Windows 走 ConPTY（node-pty 内置）
+  const isWin = process.platform === "win32";
+  try {
+    const term = pty.spawn(claudeBin, [], {
+      name: isWin ? "windows-terminal" : "xterm-256color",
+      cols: 120, rows: 40, cwd, env,
+      // Windows ConPTY 默认即启；node-pty 用 useConpty=true 是默认
+    });
+    return {
+      write: (s) => term.write(s),
+      kill: () => { try { term.kill(); } catch {} },
+      onData: (cb) => term.onData(cb),
+      onExit: (cb) => term.onExit(cb),
+    };
+  } catch (err) {
+    const reason = `spawn failed: ${err?.message || String(err)}`;
+    nodePtyDisabledReason = reason;
+    pLog.warn("probe.pty.spawn.failed", "node-pty spawn failed, disabling node-pty backend for this process", {
+      err: reason, bin: claudeBin,
+    });
+    return null;
+  }
+}
+
+/**
+ * Unix（macOS/Linux）fallback：用系统自带的 `script(1)` 包一层 PTY。
+ * Windows 没有 `script(1)` —— 直接返回 null，让 node-pty（ConPTY）成为唯一路径。
+ * 如果 Windows 上 node-pty 也不可用，probe 就无法工作 —— 这是底层限制，无兜底。
+ */
+function createScriptPtyTerm({ claudeBin, cwd, env, pLog }) {
+  if (process.platform === "win32") {
+    pLog.warn("probe.script.unsupported", "script(1) fallback unavailable on Windows — relying on node-pty");
+    return null;
+  }
+  // script(1) 的路径和参数在 macOS 与 Linux 上不同：
+  //   macOS:  /usr/bin/script -q /dev/null <cmd> [args...]
+  //   Linux:  /usr/bin/script -q -c "<cmd args>" /dev/null
+  const scriptPath = "/usr/bin/script";
+  if (!existsSync(scriptPath)) {
+    pLog.warn("probe.script.missing", "script(1) not found at /usr/bin/script");
+    return null;
+  }
+  const isMac = process.platform === "darwin";
+  const args = isMac
+    ? ["-q", "/dev/null", claudeBin]
+    : ["-q", "-c", claudeBin, "/dev/null"];
+  let child;
+  try {
+    child = cpSpawn(scriptPath, args, {
+      cwd, env, stdio: ["pipe", "pipe", "pipe"],
+    });
+  } catch (err) {
+    pLog.warn("probe.script.spawn.failed", "script(1) spawn failed", { err: err?.message });
+    return null;
+  }
+  const dataCbs = [];
+  const exitCbs = [];
+  child.stdout.on("data", (d) => { const s = d.toString(); dataCbs.forEach((cb) => cb(s)); });
+  child.stderr.on("data", (d) => { const s = d.toString(); dataCbs.forEach((cb) => cb(s)); });
+  child.on("exit", (code) => { exitCbs.forEach((cb) => cb({ exitCode: code ?? -1 })); });
+  return {
+    write: (s) => { try { child.stdin.write(s); } catch {} },
+    kill: () => {
+      try { child.kill("SIGINT"); } catch {}
+      setTimeout(() => { try { child.kill("SIGKILL"); } catch {} }, 500);
+    },
+    onData: (cb) => {
+      dataCbs.push(cb);
+      return { dispose: () => removeCallback(dataCbs, cb) };
+    },
+    onExit: (cb) => {
+      exitCbs.push(cb);
+      return { dispose: () => removeCallback(exitCbs, cb) };
+    },
+  };
+}
+
+function removeCallback(callbacks, cb) {
+  const idx = callbacks.indexOf(cb);
+  if (idx >= 0) callbacks.splice(idx, 1);
+}
+
+function hasUsageMarkers(text) {
+  // 至少一对 % + Reset/Reses 关键字 视为 /usage 已渲染。
+  // 放宽条件原因：bridge service 环境下 script(1) 流速慢，原来要求 2 次的阈值常常
+  // 等不到；就算只有 1 对，parse 也能拿到部分数据（比双空更好）。
+  const hasPct = /\d{1,3}(?:\.\d+)?\s*%/.test(text);
+  const hasReset = /res[ea]ts?\b/i.test(text); // 吃 "Resets" / "Reses"（第一遍坏字符）
+  return hasPct && hasReset;
+}
+
+/**
+ * 解析 `/usage` 的明文（已 strip ANSI）。
+ * 宽容策略：命中哪段算哪段；空返回 null。
+ */
+export function parseUsageOutput(text) {
+  if (typeof text !== "string" || !text) return null;
+  const now = Math.floor(Date.now() / 1000);
+
+  // 宽松标签匹配：涵盖多版本 TUI 文案
+  // v2.1 常见：
+  //   "Current session" / "Current 5h session"
+  //   "Weekly usage" / "Current week"
+  //   "Opus weekly" / "All models usage"
+  // 标签用 \s* —— v2.1 TUI 第一遍渲染带空格、script(1) 抓的第二遍压成无空格，都要能吃
+  const primary = extractWindow(
+    text,
+    /(current\s*session|5[- ]?hour|5h(?:our)?\s*(?:limit|session|window)?|current\s*5h)/gi,
+    300, now,
+  );
+  const secondary = extractWindow(
+    text,
+    /(current\s*week|weekly(?:\s+limit|\s+usage|\s+session)?|7[- ]?day\s*(?:limit|usage)?|this\s*week|week\s*limit)/gi,
+    10080, now,
+  );
+
+  // plan: "Plan: Pro" / "Your plan: Max 5x" / "Subscription: Pro"
+  let planType = null;
+  const planPatterns = [
+    /(?:^|\n|│|\|)\s*(?:your\s+)?plan\s*[:：]\s*([A-Za-z0-9_+.\- ]{1,40}?)(?=\s*(?:$|\r|\n|│|\|))/im,
+    /subscription\s*[:：]\s*([A-Za-z0-9_+.\- ]{1,40}?)(?=\s*(?:$|\r|\n|│|\|))/im,
+  ];
+  for (const re of planPatterns) {
+    const m = re.exec(text);
+    if (m) {
+      planType = m[1].trim().toLowerCase().replace(/\s+/g, "_");
+      if (planType) break;
+    }
+  }
+
+  if (!primary && !secondary && !planType) return null;
+  return { primary, secondary, plan_type: planType };
+}
+
+// 各 window 的 label 统称 —— 用于切片时"下一个 label 出现处"截断，
+// 避免 primary 的 slice 吃到 secondary 的 reset 时间。
+const NEXT_LABEL_RE = /current\s*(?:session|week|5h)|5[- ]?hour|weekly|this\s*week|current\s*5h|week\s*limit/i;
+
+function extractWindow(text, labelRe, windowMinutes, nowSec) {
+  // labelRe 必须带 /g —— 我们会枚举所有 label 匹配，挑出第一个"能同时拿到 pct + reset"
+  // 的切片；如果都拿不到 reset，退回第一个能拿 pct 的。
+  // 原因：v2.1 TUI 第一遍渲染可能缺字符（"Resets" 被切成 "Reses"），但第二遍完整。
+  let fallbackPct = null;
+  let m;
+  labelRe.lastIndex = 0;
+  while ((m = labelRe.exec(text))) {
+    const afterLabel = text.slice(m.index + m[0].length);
+    const nextLabelMatch = NEXT_LABEL_RE.exec(afterLabel);
+    const sliceEnd = m.index + m[0].length + (nextLabelMatch ? nextLabelMatch.index : 400);
+    const slice = text.slice(m.index, sliceEnd);
+    const pct = matchPercent(slice);
+    if (pct == null) continue;
+    const resetsAt = matchResetsAt(slice, nowSec);
+    if (resetsAt) {
+      return { used_percent: pct, window_minutes: windowMinutes, resets_at: resetsAt };
+    }
+    if (fallbackPct == null) fallbackPct = pct;
+  }
+  if (fallbackPct != null) {
+    return { used_percent: fallbackPct, window_minutes: windowMinutes, resets_at: 0 };
+  }
+  return null;
+}
+
+function matchPercent(slice) {
+  // 优先 "used: 30%" / "30% used" / "30.5%"
+  const m = slice.match(/(?:used\s*[:：]?\s*)?(\d{1,3}(?:\.\d+)?)\s*%/i);
+  if (m) {
+    const v = Number(m[1]);
+    if (Number.isFinite(v)) return clamp(v, 0, 100);
+  }
+  // 回退 "30 / 100" 样式（个别版本）
+  const frac = slice.match(/(\d+(?:\.\d+)?)\s*\/\s*(\d+(?:\.\d+)?)/);
+  if (frac) {
+    const a = Number(frac[1]), b = Number(frac[2]);
+    if (Number.isFinite(a) && Number.isFinite(b) && b > 0) return clamp((a / b) * 100, 0, 100);
+  }
+  return null;
+}
+
+function matchResetsAt(slice, nowSec) {
+  // 1. v2.1+ TUI 新格式 —— 两种写法都吃：
+  //    "Resets 2:59pm (Asia/Shanghai)"             带空格
+  //    "ResetsApr24at11am(Asia/Shanghai)"          script(1) 剥离后的无空格版
+  //    "Resets 14:59" / "Resets3pm"                24h 或无 tz
+  //    时区：直接用本机当前 TZ 做转换，忽略 TUI 里带的 (TZ) 标注 —— 一般跟 claude 设置一致
+  // 关键字吃 "Resets" / "Reses"（第一遍坏字符） / "Reset" 三种写法
+  const mNew = slice.match(
+    /(?:resets?|reses)\s*(?:([A-Za-z]{3})\s*(\d{1,2})\s*at\s*)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\([^)]+\))?/i
+  );
+  if (mNew) {
+    const [, monStr, dayStr, hourStr, minStr, ampm] = mNew;
+    let hour = Number(hourStr);
+    const minute = minStr ? Number(minStr) : 0;
+    if (ampm) {
+      const isPm = /pm/i.test(ampm);
+      if (isPm && hour < 12) hour += 12;
+      if (!isPm && hour === 12) hour = 0;
+    }
+    const epoch = resolveLocalEpoch({
+      month: monStr ? parseShortMonth(monStr) : null,
+      day: dayStr ? Number(dayStr) : null,
+      hour, minute, nowSec,
+    });
+    if (epoch && epoch > nowSec) return epoch;
+  }
+  // 2. 旧格式："Resets in 2h 14m" / "resets in 45m" / "resets in 4d 8h"
+  const rel = slice.match(/reset(?:s)?\s+in\s+([0-9dhms\s]+)(?=[^0-9dhms]|$)/i);
+  if (rel) {
+    let sec = 0;
+    for (const p of rel[1].matchAll(/(\d+)\s*([dhms])/gi)) {
+      const n = Number(p[1]);
+      if (!Number.isFinite(n)) continue;
+      const u = p[2].toLowerCase();
+      if (u === "d") sec += n * 86400;
+      else if (u === "h") sec += n * 3600;
+      else if (u === "m") sec += n * 60;
+      else if (u === "s") sec += n;
+    }
+    if (sec > 0) return nowSec + sec;
+  }
+  // 3. "Resets on 2026-04-25" —— 允许 ISO 日期
+  const abs = slice.match(/reset(?:s)?\s+(?:on|at)\s+(\d{4}-\d{2}-\d{2})/i);
+  if (abs) {
+    const t = Date.parse(abs[1] + "T00:00:00Z");
+    if (!Number.isNaN(t)) return Math.floor(t / 1000);
+  }
+  return null;
+}
+
+const MONTH_MAP = {
+  jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5,
+  jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11,
+};
+function parseShortMonth(s) {
+  const k = String(s).toLowerCase().slice(0, 3);
+  return MONTH_MAP[k] ?? null;
+}
+
+/**
+ * 把「年月日时分」按**本机当前时区**转换成 unix seconds。
+ * 缺省 month/day 时用"今天"；若结果已过当前时间则推到"明天"（或明年）。
+ */
+function resolveLocalEpoch({ month, day, hour, minute, nowSec }) {
+  const now = new Date(nowSec * 1000);
+  const year = now.getFullYear();
+  const m = month != null ? month : now.getMonth();
+  const d = day != null ? day : now.getDate();
+  let target = new Date(year, m, d, hour, minute, 0, 0);
+  // 没给日期且结果已过 → 推到次日
+  if (month == null && target.getTime() <= now.getTime()) {
+    target = new Date(year, m, d + 1, hour, minute, 0, 0);
+  }
+  // 给了月日但结果在过去 → 跨年
+  if (month != null && target.getTime() <= now.getTime()) {
+    target = new Date(year + 1, m, d, hour, minute, 0, 0);
+  }
+  const sec = Math.floor(target.getTime() / 1000);
+  return sec > nowSec ? sec : null;
+}
+
+function clamp(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}

package/src-ext/runtime/claude/usageProbeStrip.mjs

@@ -0,0 +1,14 @@
+// 极简 ANSI escape 剥离 —— 避免额外依赖。
+// 覆盖：CSI 序列（\x1b[...）、OSC 序列（\x1b]...\x07/\x1b\\）、常见 C0/C1 控制字符。
+
+const CSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+const OSC_RE = /\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)/g;
+const SINGLE_ESC_RE = /\x1B[@-_]/g;
+
+export function stripAnsi(input) {
+  if (typeof input !== "string") return "";
+  return input
+    .replace(OSC_RE, "")
+    .replace(CSI_RE, "")
+    .replace(SINGLE_ESC_RE, "");
+}

package/src-ext/runtime/codex/codexCustomCommandsCollector.mjs

@@ -0,0 +1,87 @@
+/**
+ * codexCustomCommandsCollector.mjs — codex 自定义 prompt 命令收集器
+ *
+ * collectCodexCustomCommands({_promptsDir?})
+ *   → Promise<Array<{command, description, argumentHint, kind}>>
+ *
+ * 扫 ~/.codex/prompts/*.md，解析 YAML frontmatter，返回命令列表。
+ * 解析规则：
+ *   - name 字段 → command（加 / 前缀）；无 name 则取文件名去 .md
+ *   - description 字段 → 描述；无则空串
+ *   - argument-hint / argumentHint 字段 → argumentHint；
+ *     若无该字段但正文含 $ARGUMENTS 或 $1-$9 → "[arguments]"
+ *   - kind 固定为 "custom"
+ */
+
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+
+// 检测占位符 $ARGUMENTS / $1-$9
+const PLACEHOLDER_RE = /\$ARGUMENTS|\$[1-9]/;
+
+/**
+ * 简单 frontmatter 解析（单行 key: value 格式）。
+ * 返回 {fields, body} —— fields 是键值对，body 是 --- 之后的正文。
+ */
+function parseFrontmatter(content) {
+  if (typeof content !== "string") return { fields: {}, body: content };
+  const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(content);
+  if (!m) return { fields: {}, body: content };
+  const fields = {};
+  for (const line of m[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const val = line.slice(idx + 1).trim();
+    if (key) fields[key] = val;
+  }
+  return { fields, body: m[2] };
+}
+
+/**
+ * @param {{
+ *   _promptsDir?: string,   // 测试注入；默认 ~/.codex/prompts/
+ * }} opts
+ * @returns {Promise<Array<{command, description, argumentHint, kind}>>}
+ */
+export async function collectCodexCustomCommands({ _promptsDir } = {}) {
+  const promptsDir = _promptsDir ?? join(homedir(), ".codex", "prompts");
+
+  if (!existsSync(promptsDir)) return [];
+
+  let files;
+  try {
+    files = readdirSync(promptsDir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+
+  const result = [];
+  for (const file of files) {
+    const filePath = join(promptsDir, file);
+    let content = "";
+    try {
+      content = readFileSync(filePath, "utf8");
+    } catch {
+      continue;
+    }
+
+    const { fields, body } = parseFrontmatter(content);
+    const name = fields["name"] || basename(file, ".md");
+    const description = fields["description"] ?? "";
+    const rawHint = fields["argument-hint"] ?? fields["argumentHint"] ?? null;
+    const argumentHint = rawHint
+      ? String(rawHint)
+      : PLACEHOLDER_RE.test(body) ? "[arguments]" : null;
+
+    result.push({
+      command: `/${name}`,
+      description: String(description),
+      argumentHint,
+      kind: "custom",
+    });
+  }
+
+  return result;
+}