@alanwalk/codex-until 0.1.0 → 0.2.0

package/README.md

@@ -2,9 +2,17 @@
 
 Windows Codex 额度监控命令行工具。零 npm 依赖，Node.js 18 或以上。
 
+菜单第一项为“刷新间隔”，左右键切换 `10s / 30s / 1m / 5m`，默认 `1m`；后两项为“转入后台”和“停止监控并退出”。
+
+使用官方轻量轮询参数 `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 命令查看。
+
 需要已安装并通过 ChatGPT 账号登录的官方 Codex CLI / 桌面应用。工具复用本地登录状态，不打印 token。默认使用桌面应用 CLI，找不到时使用 PATH 中的 `codex.exe`；可通过 `CODEX_QUOTA_CLI` 指定完整可执行文件路径。
 
-发布到 npm 后，无需预先执行 `npm install`，直接运行：
+无需预先执行 `npm install`，直接运行：
 
 ```powershell
 npx @alanwalk/codex-until
@@ -14,12 +22,12 @@ npx --yes @alanwalk/codex-until quota
 npx --yes @alanwalk/codex-until logs
 ```
 
-不带参数会立即开启监控：在交互终端中显示最新日志，输入 `b` 并回车转入后台，输入 `q` 并回车停止监控并退出，`Ctrl+C` 同样停止监控。转入后台只是退出控制台，监控进程及本次比较基线保持不变。输入流关闭时也会退出控制台并保留后台监控。
+不带参数会立即开启监控：在交互终端中显示彩色状态面板、剩余额度进度条、查询倒计时和下次重置时间。使用方向键选择操作并回车确认，也可直接按 `b` 转入后台、按 `q` 停止监控并退出，`Ctrl+C` 同样停止监控。转入后台只是退出控制台，监控进程及本次比较基线保持不变。输入流关闭时也会退出控制台并保留后台监控。
 
-`start` 与无参数执行相同，在交互终端默认显示日志和 b/q 选项；使用 `-b / --background` 直接进入后台：
+`start` 与无参数执行相同，在交互终端默认显示状态面板和操作菜单；使用 `-b / --background` 直接进入后台：
 
 ```powershell
-npx @alanwalk/codex-until                      # 显示日志及 b/q 选项
+npx @alanwalk/codex-until                      # 显示状态面板和菜单
 npx @alanwalk/codex-until start                # 同上
 npx @alanwalk/codex-until -b                   # 直接后台运行
 npx @alanwalk/codex-until start --background   # 同上，可简写 -b
@@ -39,38 +47,3 @@ npx @alanwalk/codex-until start --background   # 同上，可简写 -b
 **触发后执行 `taskkill /F /T /IM codex.exe`，强制结束本机所有 Codex 进程及其子进程，包括其他账号的本地会话，正在执行的任务会被中断。远程主机不受影响。** 成功后监控退出；停止失败会记录错误，后续继续尝试。没有自动消费额度重置次数的功能。
 
 日志保存在 `%LOCALAPPDATA%\codex-quota-guard\monitor.log`，不写入 npx 缓存中的包目录。日志不包含凭据。后台监控没有开机自启功能。
-
-## 本地验证
-
-```powershell
-npm run prepublishOnly
-npm pack
-```
-
-当前包名是 `@alanwalk/codex-until`，未确认 npm 名称可用性。包内使用 files 白名单，不包含本机日志、测试或登录凭据。无需构建、无需 npm install。npx 首次运行仍需联网下载并缓存包。
-
-## GitHub Actions 自动发布 npm
-
-沿用 [alanwalk/svn-merge-tool](https://github.com/alanwalk/svn-merge-tool/blob/main/.github/workflows/npm-publish.yml) 的发布方式：发布 GitHub Release 后，检查通过才发布 npm。配置文件为 `.github/workflows/npm-publish.yml`，Node.js 24，使用 npm Trusted Publishing（OIDC），无需配置 `NPM_TOKEN`。
-
-### 首次配置
-
-1. 将项目上传到你自己的 GitHub 仓库，包含 `.github/workflows/npm-publish.yml`。
-2. 确认 npm 账号有 `@alanwalk` scope 的发布权限。若该包尚不存在，先在本机完成首次发布：
-
-   ```powershell
-   npm login
-   npm publish --access public
-   ```
-
-3. 打开 npm 网站中 `@alanwalk/codex-until` 的 Settings → Trusted Publisher，选择 GitHub Actions，填写实际 GitHub 用户/组织、仓库名，以及工作流文件名 `npm-publish.yml`。当前 workflow 未使用 GitHub Environment，此项留空；如果页面提供 Allowed actions，允许直接执行 `npm publish`。
-4. 按 [npm 官方 Trusted Publishing 文档](https://docs.npmjs.com/trusted-publishers/) 保存配置。上传源码本身不会触发发布；只有发布 GitHub Release 才触发。
-
-### 后续发版
-
-1. 修改代码，运行 `npm run prepublishOnly`。
-2. 修改版本，例如运行 `npm version patch --no-git-tag-version`，然后提交并推送代码。
-3. 在 GitHub 创建并发布 Release，tag 必须为 `v` 加 `package.json` 中的版本，例如 `v0.1.1`。tag 应指向准备发布的提交。
-4. Actions 先在 Windows 上检查 tag、语法、帮助入口、判断测试及包内容，再在 Ubuntu 上使用 OIDC 执行 `npm publish`。全程无需安装 npm 依赖。
-
-版本号必须是 npm 尚未发布的版本；相同版本不能重复发布。`package.json` 已设置 public access。Release 的 prerelease 标志不会自动切换 npm dist-tag，当前流程统一使用 `latest`，请只发布准备正式使用的版本。

package/bin/cli.cjs

@@ -4,7 +4,7 @@ const os = require('node:os');
 const path = require('node:path');
 const fs = require('node:fs');
 const crypto = require('node:crypto');
-const readline = require('node:readline');
+const { consoleMode } = 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);
@@ -38,7 +38,11 @@ async function daemon() {
     socket.on('error', () => {});
     socket.once('data', data => {
       const action = data.toString().trim();
-      const result = { running: action !== 'stop', pid: process.pid, logPath: watch.logPath };
+      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 };
       socket.end(JSON.stringify(result) + '\n', () => {
         if (action === 'stop') process.exit(0);
       });
@@ -57,6 +61,7 @@ async function daemon() {
 }
 
 function parseOptions(args, interactive) {
+  if (args.length === 1 && args[0] === '--daemon') return { action: '--daemon', foreground: false };
   const hasCommand = args.length > 0 && !args[0].startsWith('-');
   const action = hasCommand ? args[0] : 'start';
   if (['--help', '-h'].includes(args[0])) return { action: 'help', foreground: false };
@@ -69,62 +74,6 @@ function parseOptions(args, interactive) {
   return { action, foreground: action === 'start' && interactive && !background };
 }
 
-async function consoleMode() {
-  console.log('监控中：输入 b 回车转入后台；输入 q 回车停止监控并退出。Ctrl+C 同样停止监控。');
-  const input = readline.createInterface({ input: process.stdin, output: process.stdout });
-  let lastLog = '';
-  let busy = false;
-  let closing = false;
-  return new Promise(resolve => {
-    const finish = async stop => {
-      if (closing) return;
-      closing = true;
-      clearInterval(timer);
-      try {
-        if (stop) {
-          const current = await status();
-          if (current.running) await request('stop');
-          console.log('监控已停止。Codex 会话保持运行。');
-        } else console.log('已退出控制台，监控继续在后台运行。');
-      } catch (error) { console.error(error.message); process.exitCode = 1; }
-      input.close();
-      process.removeListener('SIGINT', interrupt);
-      resolve();
-    };
-    const interrupt = () => { void finish(true); };
-    const refresh = async () => {
-      if (busy || closing) return;
-      busy = true;
-      try {
-        if (fs.existsSync(watch.logPath)) {
-          const latest = fs.readFileSync(watch.logPath, 'utf8').trimEnd().split('\n').slice(-1)[0];
-          if (latest !== lastLog) { console.log(latest); lastLog = latest; }
-        }
-        if (!(await status()).running) {
-          console.log('后台监控已退出。');
-          closing = true;
-          clearInterval(timer);
-          input.close();
-          process.removeListener('SIGINT', interrupt);
-          resolve();
-        }
-      } catch (error) { console.error(error.message); }
-      finally { busy = false; }
-    };
-    const timer = setInterval(refresh, 1000);
-    input.on('line', line => {
-      const choice = line.trim().toLowerCase();
-      if (choice === 'b') void finish(false);
-      else if (choice === 'q') void finish(true);
-      else console.log('输入 b 转入后台，或 q 停止并退出。');
-    });
-    input.on('SIGINT', interrupt);
-    process.on('SIGINT', interrupt);
-    input.on('close', () => { if (!closing) void finish(false); });
-    void refresh();
-  });
-}
-
 async function main() {
   const { action, foreground } = parseOptions(process.argv.slice(2), Boolean(process.stdin.isTTY && process.stdout.isTTY));
   if (['help', '--help', '-h'].includes(action)) {
@@ -158,8 +107,8 @@ Restarting the monitor establishes a fresh baseline. No baseline is persisted.`)
     return;
   }
   if (before.running) {
-    console.log(JSON.stringify({ ...before, changed: false }));
-    if (foreground) await consoleMode();
+    if (foreground) await consoleMode({ status, request, logPath: watch.logPath });
+    else console.log(JSON.stringify({ ...before, changed: false }));
     return;
   }
   fs.mkdirSync(path.dirname(watch.logPath), { recursive: true });
@@ -174,8 +123,8 @@ Restarting the monitor establishes a fresh baseline. No baseline is persisted.`)
     await new Promise(resolve => setTimeout(resolve, 100));
     const result = await status();
     if (result.running) {
-      console.log(JSON.stringify({ ...result, changed: true }));
-      if (foreground) await consoleMode();
+      if (foreground) await consoleMode({ status, request, logPath: watch.logPath });
+      else console.log(JSON.stringify({ ...result, changed: true }));
       return;
     }
   }

package/bin/terminal.cjs

@@ -0,0 +1,145 @@
+const fs = require('node:fs');
+const readline = require('node:readline');
+
+const intervals = [10000, 30000, 60000, 300000];
+const intervalLabels = ['10s', '30s', '1m', '5m'];
+
+function renderPanel({ running, pid, lines, selected = 0, columns = 80, color = true,
+  now = Date.now(), intervalMs = 60000, nextQueryAt, querying, cooldownUntil }) {
+  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+)/);
+  const width = Math.max(8, Math.min(28, columns - 20));
+  const latestRecord = records.at(-1) || '';
+  const lastAttempt = Date.parse(latestRecord.split(' ')[0]);
+  const deadline = nextQueryAt ?? lastAttempt + intervalMs;
+  const secondsUntilQuery = Math.max(0, Math.ceil((deadline - now) / 1000));
+  let queryStatus = '正在查询…';
+  if (!querying && Number.isFinite(deadline) && secondsUntilQuery > 0) {
+    queryStatus = `${secondsUntilQuery} 秒后查询`;
+  }
+  if (cooldownUntil > now) queryStatus = `退避等待 · ${Math.ceil((cooldownUntil - now) / 1000)} 秒后重试`;
+  const output = [
+    '', 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)}`,
+  ];
+  if (match) {
+    const remaining = Math.max(0, Math.min(100, Number(match[2])));
+    const filled = Math.round(width * remaining / 100);
+    output.push('', `  剩余额度  ${paint('1;36', `${remaining}%`)}`,
+      `  ${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', '  刷新失败，以上为上次成功数据。'));
+  }
+  output.push('', paint('90', '  额度重置后，结束本机全部 Codex 会话。'), '');
+  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}`));
+  }
+  output.push('');
+  return output.join('\n');
+}
+
+async function consoleMode({ status, request, logPath }) {
+  const input = process.stdin;
+  const output = process.stdout;
+  let selected = 0;
+  let busy = false;
+  let closing = false;
+  let changingInterval = false;
+  let current = { running: true };
+  let lines = [];
+  let lastPanel = '';
+  const wasRaw = input.isRaw;
+  readline.emitKeypressEvents(input);
+  input.setRawMode(true);
+  input.resume();
+  output.write('\x1b[?1049h\x1b[?25l');
+  return new Promise(resolve => {
+    const draw = () => {
+      if (closing) return;
+      const panel = renderPanel({ ...current, lines, selected,
+        columns: output.columns || 80, color: !process.env.NO_COLOR });
+      if (panel === lastPanel) return;
+      lastPanel = panel;
+      output.write('\x1b[H\x1b[2J' + panel);
+    };
+    const finish = async (stop, message) => {
+      if (closing) return;
+      closing = true;
+      clearInterval(timer);
+      input.removeListener('keypress', onKey);
+      input.removeListener('end', onEnd);
+      output.removeListener('resize', draw);
+      process.removeListener('SIGINT', onInterrupt);
+      let resultMessage = message;
+      try {
+        if (stop) {
+          if ((await status()).running) await request('stop');
+          resultMessage = '监控已停止，Codex 会话继续运行。';
+        }
+      } catch (error) { resultMessage = `停止失败：${error.message}`; process.exitCode = 1; }
+      finally {
+        input.setRawMode(Boolean(wasRaw));
+        input.pause();
+        output.write('\x1b[?25h\x1b[?1049l');
+      }
+      console.log(resultMessage || '已转入后台，监控继续运行。');
+      resolve();
+    };
+    const changeInterval = async direction => {
+      if (changingInterval || closing) return;
+      changingInterval = true;
+      try {
+        const currentIndex = intervals.indexOf(current.intervalMs ?? 60000);
+        const nextIndex = (currentIndex + direction + intervals.length) % intervals.length;
+        const result = await request(`interval:${intervals[nextIndex]}`);
+        if (result.error) throw new Error(result.error);
+        if (!Number.isFinite(result.intervalMs)) throw new Error('当前后台版本不支持切换间隔，请停止后重新启动监控。');
+        current = result;
+        draw();
+      } catch (error) { lines = [...lines, `ERROR: ${error.message}`]; draw(); }
+      finally { changingInterval = false; }
+    };
+    const onKey = (text, key = {}) => {
+      if (key.name === 'up') { selected = (selected + 2) % 3; draw(); }
+      else if (key.name === 'down') { selected = (selected + 1) % 3; draw(); }
+      else if (selected === 0 && key.name === 'left') void changeInterval(-1);
+      else if (selected === 0 && key.name === 'right') void changeInterval(1);
+      else if (key.name === 'return' && selected !== 0) void finish(selected === 2);
+      else if (text === 'b') void finish(false);
+      else if (text === 'q' || (key.ctrl && key.name === 'c')) void finish(true);
+    };
+    const onEnd = () => { void finish(false); };
+    const onInterrupt = () => { void finish(true); };
+    const refresh = async () => {
+      if (busy || closing) return;
+      busy = true;
+      try {
+        if (fs.existsSync(logPath)) lines = fs.readFileSync(logPath, 'utf8').trimEnd().split('\n').slice(-150);
+        current = await status();
+        if (closing) return;
+        draw();
+        if (!current.running) await finish(false, '后台监控已退出，请用 logs 查看原因。');
+      } catch (error) { lines = [...lines, `ERROR: ${error.message}`]; draw(); }
+      finally { busy = false; }
+    };
+    const timer = setInterval(refresh, 1000);
+    input.on('keypress', onKey);
+    input.on('end', onEnd);
+    output.on('resize', draw);
+    process.on('SIGINT', onInterrupt);
+    draw();
+    void refresh();
+  });
+}
+
+module.exports = { consoleMode, renderPanel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alanwalk/codex-until",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Stop local Codex sessions when quota resets during monitoring.",
   "homepage": "https://github.com/alanwalk/codex-until#readme",
   "repository": {
@@ -16,7 +16,7 @@
   "engines": { "node": ">=18" },
   "os": ["win32"],
   "scripts": {
-    "check": "node --check bin/cli.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 watch-codex-quota.cjs && node bin/cli.cjs --help",
     "test": "node watch-codex-quota.test.cjs",
     "prepublishOnly": "npm run check && npm test"
   },

package/watch-codex-quota.cjs

@@ -5,6 +5,70 @@ const path = require('node:path');
 const os = require('node:os');
 
 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 quotaParams = { excludeResetCreditDetails: true };
+function quotaError(error) {
+  const result = new Error(error.message || 'Quota query failed');
+  result.data = error.data;
+  return result;
+}
+
+function retryAfterMs(error, now = Date.now()) {
+  const data = error.data;
+  const headers = data?.headers ?? data?.response?.headers;
+  let value = headers?.['retry-after'] ?? headers?.['Retry-After'] ?? data?.retryAfter ?? data?.retry_after;
+  if (value == null) {
+    const match = error.message.match(/retry-after["']?\s*[=:]\s*["']?([^\r\n"'}]+)/i);
+    if (match) value = match[1].trim();
+  }
+  if (value == null || String(value).trim() === '') return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
+  const date = Date.parse(String(value));
+  return Number.isFinite(date) ? Math.max(0, date - now) : null;
+}
+
+function recordFailure(error, now = Date.now()) {
+  polling.failureCount += 1;
+  const requestedWait = retryAfterMs(error, now);
+  const backoff = Math.min(1800000, 60000 * 2 ** Math.min(5, polling.failureCount - 1));
+  const delay = Math.max(polling.intervalMs, requestedWait ?? backoff);
+  polling.cooldownUntil = now + delay;
+  return delay;
+}
+
+function recordSuccess() {
+  polling.failureCount = 0;
+  polling.cooldownUntil = null;
+}
+
+function queryDeadline(requested) {
+  return Math.max(requested, polling.cooldownUntil || 0);
+}
+let reschedule = null;
+function setIntervalMs(intervalMs) {
+  if (![10000, 30000, 60000, 300000].includes(intervalMs)) throw new Error('Unsupported polling interval');
+  polling.intervalMs = intervalMs;
+  if (reschedule) reschedule(Date.now() + intervalMs);
+}
+
+function waitForNextQuery(started) {
+  return new Promise(resolve => {
+    let timer;
+    reschedule = nextQueryAt => {
+      clearTimeout(timer);
+      polling.nextQueryAt = queryDeadline(nextQueryAt);
+      const remaining = Math.max(0, polling.nextQueryAt - Date.now());
+      // Long Retry-After values must not overflow Node's timer and cause an immediate retry.
+      timer = setTimeout(() => {
+        if (Date.now() < polling.nextQueryAt) { reschedule(polling.nextQueryAt); return; }
+        reschedule = null;
+        resolve();
+      }, Math.min(remaining, 2147483647));
+    };
+    reschedule(started + polling.intervalMs);
+  });
+}
 function log(message) {
   fs.mkdirSync(path.dirname(logPath), { recursive: true });
   const line = `${new Date().toISOString()} ${message}`;
@@ -41,10 +105,10 @@ function readQuota() {
       let message;
       try { message = JSON.parse(line); } catch { return; }
       if (message.id !== 1 && message.id !== 2) return;
-      if (message.error) return finish(new Error(message.error.message));
+      if (message.error) return finish(quotaError(message.error));
       if (message.id === 1) {
         send({ method: 'initialized', params: {} });
-        send({ id: 2, method: 'account/rateLimits/read', params: {} });
+        send({ id: 2, method: 'account/rateLimits/read', params: quotaParams });
       } else {
         finish(null, message.result);
       }
@@ -106,8 +170,11 @@ async function main(queryOnly = process.argv.includes('--once')) {
   log('Started. Polling every 60 seconds. Ctrl+C stops this monitor.');
   for (;;) {
     const started = Date.now();
+    polling.querying = true;
+    polling.nextQueryAt = null;
     try {
       const current = getSnapshot(await readQuota());
+      recordSuccess();
       log(Object.entries(current.windows).map(([name, window]) =>
         `${name}: remaining ${100 - window.usedPercent}%, reset ${new Date(window.resetsAt * 1000).toISOString()}`
       ).join('; '));
@@ -122,10 +189,14 @@ async function main(queryOnly = process.argv.includes('--once')) {
     } catch (error) {
       log(`ERROR: ${error.message}`);
       if (queryOnly) { process.exitCode = 1; return; }
+      const delay = recordFailure(error);
+      log(`BACKOFF: retry no earlier than ${new Date(polling.cooldownUntil).toISOString()} (${Math.ceil(delay / 1000)}s)`);
     }
-    await new Promise(resolve => setTimeout(resolve, Math.max(0, 60000 - (Date.now() - started))));
+    polling.querying = false;
+    await waitForNextQuery(started);
   }
 }
 
-module.exports = { getSnapshot, resetReason, main, logPath };
+module.exports = { getSnapshot, resetReason, main, logPath, polling, setIntervalMs, waitForNextQuery,
+  quotaParams, quotaError, retryAfterMs, recordFailure, recordSuccess, queryDeadline };
 if (require.main === module) main().catch(error => { console.error(error); process.exitCode = 1; });