@alanwalk/codex-until 0.2.0 → 0.2.2

package/README.md

@@ -1,49 +1,44 @@
-# @alanwalk/codex-until
+# codex-until
 
-Windows Codex 额度监控命令行工具。零 npm 依赖，Node.js 18 或以上。
+监控 Codex 剩余额度，发现额度重置时结束本机所有 Codex 会话。
 
-菜单第一项为“刷新间隔”，左右键切换 `10s / 30s / 1m / 5m`，默认 `1m`；后两项为“转入后台”和“停止监控并退出”。
+支持 Windows、macOS、Linux。需要 Node.js 18+，以及已登录 ChatGPT 账号的官方 Codex CLI 或桌面应用。
 
-使用官方轻量轮询参数 `excludeResetCreditDetails: true`，跳过不需要的重置次数详情查询。查询失败自动退避：若 App Server 错误数据或文本中包含有效的 `Retry-After`，至少等待服务端要求的时间；否则依次等待 1、2、4、8、16、30 分钟，之后保持最多每 30 分钟重试。等待不会短于所选刷新间隔，成功后恢复所选间隔。退避期间修改刷新间隔不能提前结束服务端等待。
+## 使用
 
-App Server 当前并不保证透传 HTTP 响应头，因此不能保证总能获取 `Retry-After`；无法获得时使用上述退避。面板显示退避倒计时，保留上次成功数据和额度比较基线。
-
-终端面板展示剩余额度、下次额度重置时间（按本地时区显示），并逐秒更新距下次查询的预计倒计时。后台默认每 60 秒查询额度，可在菜单中上下选中“刷新间隔”，再用左右键切换 `10s / 30s / 1m / 5m`。修改即时应用到同一后台进程，转入后台后保持所选间隔；重新启动恢复默认 `1m`。后台按所选间隔查询额度，查询期间显示“正在查询”。查询失败时保留上次成功数据并提示错误；详细记录通过 logs 命令查看。
+```sh
+npx @alanwalk/codex-until        # 打开交互面板
+npx @alanwalk/codex-until -b     # 后台运行
+npx @alanwalk/codex-until status # 查看状态
+npx @alanwalk/codex-until stop   # 停止监控
+npx @alanwalk/codex-until quota  # 查询一次额度
+npx @alanwalk/codex-until logs   # 查看日志
+```
 
-需要已安装并通过 ChatGPT 账号登录的官方 Codex CLI / 桌面应用。工具复用本地登录状态，不打印 token。默认使用桌面应用 CLI，找不到时使用 PATH 中的 `codex.exe`；可通过 `CODEX_QUOTA_CLI` 指定完整可执行文件路径。
+`status` 输出一次当前状态面板，不显示操作菜单；未运行时只显示标题和“未启动”。
 
-无需预先执行 `npm install`，直接运行：
+面板显示剩余额度、下次重置时间和查询倒计时。上下键选择操作，左右键切换刷新间隔：`10s / 30s / 1m / 5m`，默认 `1m`。
 
-```powershell
-npx @alanwalk/codex-until
-npx --yes @alanwalk/codex-until status
-npx --yes @alanwalk/codex-until stop
-npx --yes @alanwalk/codex-until quota
-npx --yes @alanwalk/codex-until logs
-```
+每次打开面板会主动刷新一次，返回前显示等待，不展示上次额度。已有查询会复用，限流退避期间仍按要求等待。`status` 只查看现有状态，不触发刷新。
 
-不带参数会立即开启监控：在交互终端中显示彩色状态面板、剩余额度进度条、查询倒计时和下次重置时间。使用方向键选择操作并回车确认，也可直接按 `b` 转入后台、按 `q` 停止监控并退出，`Ctrl+C` 同样停止监控。转入后台只是退出控制台，监控进程及本次比较基线保持不变。输入流关闭时也会退出控制台并保留后台监控。
+- **转入后台**：关闭面板，继续监控。也可按 `b`。
+- **停止并退出**：停止监控，保留 Codex 会话。也可按 `q` 或 `Ctrl+C`。
 
-`start` 与无参数执行相同，在交互终端默认显示状态面板和操作菜单；使用 `-b / --background` 直接进入后台：
+## 工作方式
 
-```powershell
-npx @alanwalk/codex-until                      # 显示状态面板和菜单
-npx @alanwalk/codex-until start                # 同上
-npx @alanwalk/codex-until -b                   # 直接后台运行
-npx @alanwalk/codex-until start --background   # 同上，可简写 -b
-```
+通过官方 App Server 轻量查询额度，不发送模型请求。查询失败会自动退避；能取得 `Retry-After` 时遵守服务端等待时间。
 
-通过自动化工具等非交互环境无参数执行时，默认后台启动，不等待输入。重复启动不会产生多个监控，前台模式可连接已有监控。`stop` 只停止监控，不停止 Codex。`status` 输出 JSON；表示后台监控进程可响应，不代表最近的额度请求一定成功，请结合 `logs` 查看查询结果。`--help` 显示帮助；添加 `--yes`（例如 `npx --yes @alanwalk/codex-until`）可跳过 npx 首次下载确认。
+同一账号、同一额度窗口的剩余百分比上升，或重置时间推迟且已用比例未增加，就视为重置。首次查询只建立基线，重启监控会重新建立基线。
 
-## 重置判断
+**检测到重置后会强制结束本机全部 Codex 进程及其子进程，正在执行的任务会中断。** 服务器修正额度也可能触发。
 
-首次成功查询只建立内存基线。后续对比上次成功查询，在账号、窗口名称和窗口时长相同的前提下，任一窗口满足以下条件即触发：
+## 路径
 
-- 已用百分比下降，即剩余额度上升，哪怕只上升 1%。
-- 重置时间推迟，且已用百分比没有增加。
+默认查找 Codex 桌面应用内的 CLI，找不到则使用 PATH 中的 `codex`。可用 `CODEX_QUOTA_CLI` 指定可执行文件完整路径。
 
-查询失败记录日志并重试，不清空上一次成功结果。停止再启动重新建立基线，不比较监控停机期间的变化。服务端额度修正也可能满足上述规则。轮询存在约一分钟延迟，另加网络请求耗时。
+日志位置：
 
-**触发后执行 `taskkill /F /T /IM codex.exe`，强制结束本机所有 Codex 进程及其子进程，包括其他账号的本地会话，正在执行的任务会被中断。远程主机不受影响。** 成功后监控退出；停止失败会记录错误，后续继续尝试。没有自动消费额度重置次数的功能。
+- Windows：`%LOCALAPPDATA%/.cache/codex-until/`
+- macOS / Linux：`~/.cache/codex-until/`
 
-日志保存在 `%LOCALAPPDATA%\codex-quota-guard\monitor.log`，不写入 npx 缓存中的包目录。日志不包含凭据。后台监控没有开机自启功能。
+每次启动单独创建日志，按本地启动时间命名，例如 `codex-until-2026-10-15_16-50-30-123.log`。`logs` 查看当前监控日志；未运行时查看最近一次日志。

package/bin/cli.cjs

@@ -1,14 +1,12 @@
 #!/usr/bin/env node
 const net = require('node:net');
-const os = require('node:os');
 const path = require('node:path');
 const fs = require('node:fs');
-const crypto = require('node:crypto');
-const { consoleMode } = require('./terminal.cjs');
+const { runtimePaths, latestLog } = require('../platform.cjs');
+const { consoleMode, renderPanel, monitorLines } = require('./terminal.cjs');
 const { spawn } = require('node:child_process');
 const watch = require('../watch-codex-quota.cjs');
-const userKey = crypto.createHash('sha256').update(os.homedir()).digest('hex').slice(0, 16);
-const pipe = `\\\\.\\pipe\\codex-quota-guard-${userKey}`;
+const { address: pipe, windows } = runtimePaths();
 
 function request(action) {
   return new Promise((resolve, reject) => {
@@ -33,31 +31,53 @@ async function status() {
 }
 
 async function daemon() {
+  let ownsSocket = false;
+  let staleSocketRetried = false;
   const server = net.createServer(socket => {
     socket.setTimeout(2000, () => socket.destroy());
     socket.on('error', () => {});
     socket.once('data', data => {
       const action = data.toString().trim();
+      let requiredSequence;
+      if (action === 'refresh') requiredSequence = watch.requestRefresh();
       if (action.startsWith('interval:')) {
         try { watch.setIntervalMs(Number(action.slice('interval:'.length))); }
         catch (error) { socket.end(JSON.stringify({ error: error.message }) + '\n'); return; }
       }
-      const result = { running: action !== 'stop', pid: process.pid, logPath: watch.logPath, ...watch.polling };
+      const result = { running: action !== 'stop', pid: process.pid, logPath: watch.logPath,
+        ...watch.polling, requiredSequence };
       socket.end(JSON.stringify(result) + '\n', () => {
         if (action === 'stop') process.exit(0);
       });
     });
   });
-  server.on('error', error => {
+  server.on('error', async error => {
+    if (!windows && error.code === 'EADDRINUSE' && !staleSocketRetried) {
+      try {
+        const existing = await status();
+        if (existing.running) { process.exit(0); return; }
+        fs.unlinkSync(pipe);
+        staleSocketRetried = true;
+        server.listen(pipe);
+        return;
+      } catch (failure) { console.error(failure.message); process.exit(1); return; }
+    }
     if (error.code !== 'EADDRINUSE') console.error(error.message);
     process.exit(error.code === 'EADDRINUSE' ? 0 : 1);
   });
-  server.listen(pipe, () => {
+  process.once('exit', () => {
+    if (ownsSocket && !windows) { try { fs.unlinkSync(pipe); } catch {} }
+  });
+  process.once('SIGTERM', () => process.exit(0));
+  server.on('listening', () => {
+    ownsSocket = true;
+    if (!windows) fs.chmodSync(pipe, 0o600);
     watch.main().then(() => process.exit(process.exitCode || 0)).catch(error => {
       console.error(error.message);
       process.exit(1);
     });
   });
+  server.listen(pipe);
 }
 
 function parseOptions(args, interactive) {
@@ -77,30 +97,36 @@ function parseOptions(args, interactive) {
 async function main() {
   const { action, foreground } = parseOptions(process.argv.slice(2), Boolean(process.stdin.isTTY && process.stdout.isTTY));
   if (['help', '--help', '-h'].includes(action)) {
-    console.log(`Codex Until (Windows, Node >=18)
+    console.log(`Codex Until (Windows / macOS / Linux, Node >=18)
 Usage: codex-until [start|stop|status|quota|logs]
 No command defaults to start. Without -b, show b/q controls in a terminal.
 Non-interactive invocations run in the background.
   start   Start polling every 60 seconds; repeated calls are safe.
           --background / -b: start directly in the background.
   stop    Stop monitoring only. Codex sessions remain running.
-  status  Print monitor status as JSON.
+  status  Show the current status panel once, without a menu.
   quota   Query quota once without enabling monitoring.
   logs    Print the last 50 log lines.
-Reset detection stops ALL local codex.exe processes and their children.
+Reset detection stops ALL local Codex processes and their children.
 Restarting the monitor establishes a fresh baseline. No baseline is persisted.`);
     return;
   }
-  if (process.platform !== 'win32') throw new Error('This version supports Windows only.');
   if (action === '--daemon') return daemon();
   if (action === 'quota') return watch.main(true);
   if (action === 'logs') {
-    if (!fs.existsSync(watch.logPath)) return console.log('No logs yet.');
-    return console.log(fs.readFileSync(watch.logPath, 'utf8').trimEnd().split('\n').slice(-50).join('\n'));
+    const current = await status();
+    const logPath = current.running ? current.logPath : latestLog(runtimePaths().logDirectory);
+    if (!logPath || !fs.existsSync(logPath)) return console.log('No logs yet.');
+    return console.log(fs.readFileSync(logPath, 'utf8').trimEnd().split('\n').slice(-50).join('\n'));
   }
   if (!['start', 'stop', 'status'].includes(action)) throw new Error(`Unknown command: ${action}. Use --help.`);
   const before = await status();
-  if (action === 'status') return console.log(JSON.stringify(before));
+  if (action === 'status') {
+    const lines = before.running ? monitorLines(before, watch.logPath) : [];
+    console.log(renderPanel({ ...before, lines, showMenu: false,
+      columns: process.stdout.columns || 80, color: Boolean(process.stdout.isTTY && !process.env.NO_COLOR) }));
+    return;
+  }
   if (action === 'stop') {
     const result = before.running ? await request('stop') : before;
     console.log(JSON.stringify({ ...result, changed: before.running }));
@@ -108,13 +134,17 @@ Restarting the monitor establishes a fresh baseline. No baseline is persisted.`)
   }
   if (before.running) {
     if (foreground) await consoleMode({ status, request, logPath: watch.logPath });
-    else console.log(JSON.stringify({ ...before, changed: false }));
+    else {
+      const refreshed = await request('refresh');
+      console.log(JSON.stringify({ ...refreshed, quota: null, changed: false }));
+    }
     return;
   }
   fs.mkdirSync(path.dirname(watch.logPath), { recursive: true });
   const output = fs.openSync(watch.logPath, 'a');
   const child = spawn(process.execPath, [__filename, '--daemon'], {
     detached: true, windowsHide: true, stdio: ['ignore', 'ignore', output],
+    env: { ...process.env, CODEX_UNTIL_LOG_PATH: watch.logPath },
   });
   fs.closeSync(output);
   child.on('error', error => { console.error(error.message); process.exitCode = 1; });

package/bin/terminal.cjs

@@ -4,13 +4,28 @@ const readline = require('node:readline');
 const intervals = [10000, 30000, 60000, 300000];
 const intervalLabels = ['10s', '30s', '1m', '5m'];
 
+function monitorLines(state, fallbackPath) {
+  // Older daemons only expose a log path; new daemons return quota directly.
+  if (state.quota !== undefined) return [];
+  const logPath = state.logPath || fallbackPath;
+  return logPath && fs.existsSync(logPath)
+    ? fs.readFileSync(logPath, 'utf8').trimEnd().split('\n').slice(-150) : [];
+}
+
 function renderPanel({ running, pid, lines, selected = 0, columns = 80, color = true,
-  now = Date.now(), intervalMs = 60000, nextQueryAt, querying, cooldownUntil }) {
+  now = Date.now(), intervalMs = 60000, nextQueryAt, querying, cooldownUntil, showMenu = true,
+  quota: snapshot, lastSuccessfulAt, lastError, minimumSequence = 0, successfulSequence = 0 }) {
   const paint = (code, text) => color ? `\x1b[${code}m${text}\x1b[0m` : text;
   const clean = text => text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/[\x00-\x1f\x7f]/g, '');
   const records = lines.map(clean);
   const quota = [...records].reverse().find(line => /remaining [\d.]+%/.test(line));
-  const match = quota?.match(/^(\S+).*?remaining ([\d.]+)%, reset (\S+)/);
+  let match = quota?.match(/^(\S+).*?remaining ([\d.]+)%, reset (\S+)/);
+  if (snapshot !== undefined) {
+    const fresh = successfulSequence >= minimumSequence;
+    const window = fresh ? snapshot?.primary ?? snapshot?.secondary : null;
+    match = window ? [null, new Date(lastSuccessfulAt).toISOString(), String(100 - window.usedPercent),
+      new Date(window.resetsAt * 1000).toISOString()] : null;
+  }
   const width = Math.max(8, Math.min(28, columns - 20));
   const latestRecord = records.at(-1) || '';
   const lastAttempt = Date.parse(latestRecord.split(' ')[0]);
@@ -25,9 +40,10 @@ function renderPanel({ running, pid, lines, selected = 0, columns = 80, color =
     '', paint('36', '  ╭───────────────────────╮'),
     paint('36', '  │') + paint('1;36', '  CODEX UNTIL          ') + paint('36', '│'),
     paint('36', '  ╰───────────────────────╯'), '',
-    `  ${paint(running ? '32' : '33', running ? '● 正在监控' : '○ 监控已退出')}  ${paint('90', `PID ${pid ?? '—'}`)}`,
-    `  ${paint('36', queryStatus)}`,
+    `  ${paint(running ? '32' : '33', running ? '● 正在监控' : '○ 未启动')}${running ? '  ' + paint('90', `PID ${pid ?? '—'}`) : ''}`,
   ];
+  if (!running) return output.join('\n') + '\n';
+  output.push(`  ${paint('36', queryStatus)}`);
   if (match) {
     const remaining = Math.max(0, Math.min(100, Number(match[2])));
     const filled = Math.round(width * remaining / 100);
@@ -35,11 +51,12 @@ function renderPanel({ running, pid, lines, selected = 0, columns = 80, color =
       `  ${paint('36', '━'.repeat(filled))}${paint('90', '─'.repeat(width - filled))}`,
       `  下次重置  ${new Date(match[3]).toLocaleString('zh-CN', { hour12: false })}`);
   } else output.push('', '  剩余额度  —', '  下次重置  —',
-    paint('90', '  正在等待首次额度查询…'));
-  if (records.at(-1)?.includes('ERROR')) {
-    output.push(paint('33', '  刷新失败，以上为上次成功数据。'));
+    paint('90', '  正在等待本次额度查询…'));
+  if (lastError || records.at(-1)?.includes('ERROR')) {
+    output.push(paint('33', match ? '  刷新失败，以上为上次成功数据。' : '  本次查询失败，等待重试。'));
   }
   output.push('', paint('90', '  额度重置后，结束本机全部 Codex 会话。'), '');
+  if (!showMenu) return output.join('\n');
   const choices = intervalLabels.map((label, index) => intervals[index] === intervalMs ? `[${label}]` : label).join('  ');
   for (const [index, label] of [`刷新间隔  ‹ ${choices} ›`, '转入后台，继续监控', '停止监控并退出'].entries()) {
     output.push(index === selected ? paint('1;36', `  ❯ ${label}`) : paint('90', `    ${label}`));
@@ -49,6 +66,11 @@ function renderPanel({ running, pid, lines, selected = 0, columns = 80, color =
 }
 
 async function consoleMode({ status, request, logPath }) {
+  const initial = await request('refresh');
+  if (!Number.isFinite(initial.requiredSequence)) {
+    throw new Error('当前后台版本不支持启动时刷新，请先 stop，再重新启动。');
+  }
+  const minimumSequence = initial.requiredSequence;
   const input = process.stdin;
   const output = process.stdout;
   let selected = 0;
@@ -67,7 +89,7 @@ async function consoleMode({ status, request, logPath }) {
     const draw = () => {
       if (closing) return;
       const panel = renderPanel({ ...current, lines, selected,
-        columns: output.columns || 80, color: !process.env.NO_COLOR });
+        minimumSequence, columns: output.columns || 80, color: !process.env.NO_COLOR });
       if (panel === lastPanel) return;
       lastPanel = panel;
       output.write('\x1b[H\x1b[2J' + panel);
@@ -124,8 +146,8 @@ async function consoleMode({ status, request, logPath }) {
       if (busy || closing) return;
       busy = true;
       try {
-        if (fs.existsSync(logPath)) lines = fs.readFileSync(logPath, 'utf8').trimEnd().split('\n').slice(-150);
         current = await status();
+        lines = monitorLines(current, logPath);
         if (closing) return;
         draw();
         if (!current.running) await finish(false, '后台监控已退出，请用 logs 查看原因。');
@@ -142,4 +164,4 @@ async function consoleMode({ status, request, logPath }) {
   });
 }
 
-module.exports = { consoleMode, renderPanel };
+module.exports = { consoleMode, renderPanel, monitorLines };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alanwalk/codex-until",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Stop local Codex sessions when quota resets during monitoring.",
   "homepage": "https://github.com/alanwalk/codex-until#readme",
   "repository": {
@@ -12,11 +12,10 @@
   "publishConfig": { "access": "public" },
   "bin": { "codex-until": "bin/cli.cjs" },
   "main": "watch-codex-quota.cjs",
-  "files": ["bin/", "watch-codex-quota.cjs", "README.md"],
+  "files": ["bin/", "platform.cjs", "watch-codex-quota.cjs", "README.md"],
   "engines": { "node": ">=18" },
-  "os": ["win32"],
   "scripts": {
-    "check": "node --check bin/cli.cjs && node --check bin/terminal.cjs && node --check watch-codex-quota.cjs && node bin/cli.cjs --help",
+    "check": "node --check bin/cli.cjs && node --check bin/terminal.cjs && node --check platform.cjs && node --check watch-codex-quota.cjs && node bin/cli.cjs --help",
     "test": "node watch-codex-quota.test.cjs",
     "prepublishOnly": "npm run check && npm test"
   },

package/platform.cjs

@@ -0,0 +1,57 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function logFileName(startedAt = new Date()) {
+  const pad = (value, width = 2) => String(value).padStart(width, '0');
+  return `codex-until-${startedAt.getFullYear()}-${pad(startedAt.getMonth() + 1)}-${pad(startedAt.getDate())}_${pad(startedAt.getHours())}-${pad(startedAt.getMinutes())}-${pad(startedAt.getSeconds())}-${pad(startedAt.getMilliseconds(), 3)}.log`;
+}
+
+function latestLog(logDirectory) {
+  if (!fs.existsSync(logDirectory)) return null;
+  const names = fs.readdirSync(logDirectory).filter(name => /^codex-until-\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}-\d{3}\.log$/.test(name)).sort();
+  return names.length ? path.join(logDirectory, names.at(-1)) : null;
+}
+
+function runtimePaths(platform = process.platform, env = process.env, home = os.homedir()) {
+  const windows = platform === 'win32';
+  const key = crypto.createHash('sha256').update(home).digest('hex').slice(0, 16);
+  const desktopCli = windows
+    ? path.join(env.LOCALAPPDATA || '', 'Programs/OpenAI/Codex/bin/codex.exe')
+    : '/Applications/Codex.app/Contents/Resources/codex';
+  const cacheRoot = windows ? env.LOCALAPPDATA || home : home;
+  const logDirectory = path.join(cacheRoot, '.cache', 'codex-until');
+  let cli = env.CODEX_QUOTA_CLI;
+  if (!cli) {
+    if (fs.existsSync(desktopCli)) cli = desktopCli;
+    else if (windows) cli = 'codex.exe';
+    else cli = 'codex';
+  }
+  return {
+    windows,
+    address: windows ? `\\\\.\\pipe\\codex-quota-guard-${key}` : path.join(os.tmpdir(), `codex-until-${key}.sock`),
+    logDirectory,
+    logPath: path.join(logDirectory, logFileName()),
+    cli,
+  };
+}
+
+function codexProcessIds(processList, ownPid = process.pid) {
+  const processes = processList.split('\n').flatMap(line => {
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+    if (!match) return [];
+    return [{ pid: Number(match[1]), parent: Number(match[2]), name: path.posix.basename(match[3]) }];
+  });
+  const targets = new Set(processes.filter(item => /^(codex|codex-(aarch64|x86_64)-.+)$/i.test(item.name)).map(item => item.pid));
+  let added = true;
+  while (added) {
+    added = false;
+    for (const item of processes) {
+      if (targets.has(item.parent) && !targets.has(item.pid)) { targets.add(item.pid); added = true; }
+    }
+  }
+  return [...targets].reverse().filter(pid => pid !== ownPid && pid > 1);
+}
+
+module.exports = { runtimePaths, codexProcessIds, logFileName, latestLog };

package/watch-codex-quota.cjs

@@ -2,10 +2,12 @@ const { spawn, spawnSync } = require('node:child_process');
 const readline = require('node:readline');
 const fs = require('node:fs');
 const path = require('node:path');
-const os = require('node:os');
+const { runtimePaths, codexProcessIds } = require('./platform.cjs');
 
-const logPath = path.join(process.env.LOCALAPPDATA || os.homedir(), 'codex-quota-guard', 'monitor.log');
-const polling = { intervalMs: 60000, nextQueryAt: null, querying: false, cooldownUntil: null, failureCount: 0 };
+const logPath = process.env.CODEX_UNTIL_LOG_PATH || runtimePaths().logPath;
+const polling = { intervalMs: 60000, nextQueryAt: null, querying: false, cooldownUntil: null,
+  failureCount: 0, quota: null, lastSuccessfulAt: null, lastError: null,
+  querySequence: 0, successfulSequence: 0 };
 const quotaParams = { excludeResetCreditDetails: true };
 function quotaError(error) {
   const result = new Error(error.message || 'Quota query failed');
@@ -29,6 +31,7 @@ function retryAfterMs(error, now = Date.now()) {
 }
 
 function recordFailure(error, now = Date.now()) {
+  polling.lastError = error.message;
   polling.failureCount += 1;
   const requestedWait = retryAfterMs(error, now);
   const backoff = Math.min(1800000, 60000 * 2 ** Math.min(5, polling.failureCount - 1));
@@ -38,6 +41,7 @@ function recordFailure(error, now = Date.now()) {
 }
 
 function recordSuccess() {
+  polling.lastError = null;
   polling.failureCount = 0;
   polling.cooldownUntil = null;
 }
@@ -46,6 +50,11 @@ function queryDeadline(requested) {
   return Math.max(requested, polling.cooldownUntil || 0);
 }
 let reschedule = null;
+function requestRefresh(now = Date.now()) {
+  const requiredSequence = polling.querying ? polling.querySequence : polling.querySequence + 1;
+  if (!polling.querying && reschedule) reschedule(now);
+  return requiredSequence;
+}
 function setIntervalMs(intervalMs) {
   if (![10000, 30000, 60000, 300000].includes(intervalMs)) throw new Error('Unsupported polling interval');
   polling.intervalMs = intervalMs;
@@ -78,8 +87,7 @@ function log(message) {
 
 function readQuota() {
   return new Promise((resolve, reject) => {
-    const desktopCli = path.join(process.env.LOCALAPPDATA || '', 'Programs/OpenAI/Codex/bin/codex.exe');
-    const cli = process.env.CODEX_QUOTA_CLI || (fs.existsSync(desktopCli) ? desktopCli : 'codex.exe');
+    const { cli } = runtimePaths();
     const child = spawn(cli, ['app-server', '--stdio'], {
       windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -155,6 +163,18 @@ function resetReason(previous, current) {
 }
 
 function stopCodex() {
+  if (process.platform !== 'win32') {
+    const result = spawnSync('ps', ['-A', '-o', 'pid=,ppid=,comm='], { encoding: 'utf8' });
+    if (result.error || result.status !== 0) throw new Error('Failed to enumerate Codex processes');
+    const failures = [];
+    for (const pid of codexProcessIds(result.stdout)) {
+      try { process.kill(pid, 'SIGKILL'); }
+      catch (error) { if (error.code !== 'ESRCH') failures.push(`${pid}: ${error.code}`); }
+    }
+    if (failures.length) throw new Error(`Failed to stop Codex: ${failures.join(', ')}`);
+    log('All local Codex processes and their child processes stopped.');
+    return;
+  }
   // /T also stops tasks spawned by each Codex process.
   const result = spawnSync('taskkill.exe', ['/F', '/T', '/IM', 'codex.exe'], {
     windowsHide: true, encoding: 'utf8',
@@ -171,9 +191,13 @@ async function main(queryOnly = process.argv.includes('--once')) {
   for (;;) {
     const started = Date.now();
     polling.querying = true;
+    polling.querySequence += 1;
     polling.nextQueryAt = null;
     try {
       const current = getSnapshot(await readQuota());
+      polling.quota = current.windows;
+      polling.lastSuccessfulAt = Date.now();
+      polling.successfulSequence = polling.querySequence;
       recordSuccess();
       log(Object.entries(current.windows).map(([name, window]) =>
         `${name}: remaining ${100 - window.usedPercent}%, reset ${new Date(window.resetsAt * 1000).toISOString()}`
@@ -198,5 +222,5 @@ async function main(queryOnly = process.argv.includes('--once')) {
 }
 
 module.exports = { getSnapshot, resetReason, main, logPath, polling, setIntervalMs, waitForNextQuery,
-  quotaParams, quotaError, retryAfterMs, recordFailure, recordSuccess, queryDeadline };
+  quotaParams, quotaError, retryAfterMs, recordFailure, recordSuccess, queryDeadline, requestRefresh };
 if (require.main === module) main().catch(error => { console.error(error); process.exitCode = 1; });