ai-battery 0.1.0 → 0.1.1

package/README.md

@@ -9,7 +9,7 @@ Codex와 Claude Code의 남은 사용량을 배터리처럼 확인하는 터미
 ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20WSL%20%7C%20Linux%20%7C%20macOS-blue)
 ![License](https://img.shields.io/badge/license-MIT-green)
 
-[Install](#install) · [Features](#features) · [Quick Start](#quick-start) · [Claude StatusLine](#claude-statusline) · [Floating HUD](#floating-hud) · [Caution](#caution)
+[Install](#install) · [Features](#features) · [Quick Start](#quick-start) · [Claude StatusLine](#claude-statusline) · [Desktop HUD](#desktop-hud) · [Caution](#caution)
 
 ## Overview
 
@@ -40,7 +40,7 @@ Codex 86% │ 5h 18:09 │ 7d 82%  ┃  Claude 4% │ 5h 18:10 │ 7d 71%
 | 색상 기준 | 40% 초과 초록, 21-40% 주황, 20% 이하 빨강으로 배터리만 강조합니다. |
 | Codex terminal row | Codex 아래에 별도 사용량 행을 고정하는 PTY wrapper를 제공합니다. |
 | Claude statusLine | Claude Code 내장 statusLine hook과 실제 429 hit 로그로 Claude rate limit 상태를 읽습니다. |
-| Windows HUD | Windows native와 WSL에서 실행하는 작은 floating HUD를 제공합니다. |
+| HUD / menu bar | Windows native/WSL에서는 floating HUD, macOS에서는 menu bar status item을 제공합니다. |
 | npm 실행 | `npm install -g` 또는 `npx`로 실행할 수 있습니다. |
 
 ## Platform Support
@@ -52,7 +52,7 @@ Codex 86% │ 5h 18:09 │ 7d 82%  ┃  Claude 4% │ 5h 18:10 │ 7d 71%
 | Claude statusLine | 지원 | 지원 | 지원 | 지원 | Claude Code `statusLine`에 `node <script>` 명령을 저장합니다. |
 | Codex terminal row | 미지원 | 지원 | 지원 | 지원 | `ai-battery-run`이 POSIX PTY와 `python3`를 사용합니다. |
 | `ai-battery setup codex` | 미지원 | 지원 | 지원 | 지원 | `codex` wrapper가 POSIX shell/PTY 기반입니다. |
-| `ai-battery hud` | 지원 | 지원 | 미지원 | 미지원 | Windows PowerShell/WinForms HUD입니다. Linux/macOS 터미널에서는 `ai-battery --watch`를 사용하세요. |
+| `ai-battery hud` | 지원 | 지원 | 미지원 | 지원 | Windows/WSL은 PowerShell/WinForms HUD, macOS는 menu bar status item입니다. |
 
 실행 중 감지(흰색/회색 표시)는 Linux/WSL은 `/proc`, macOS는 `ps`, Windows는 PowerShell 프로세스 목록을 사용합니다.
 
@@ -91,7 +91,7 @@ npx ai-battery
    codex
    ```
 
-4. Windows HUD가 필요하면 실행합니다.
+4. 데스크톱 HUD나 macOS menu bar 표시가 필요하면 실행합니다.
 
    ```bash
    ai-battery hud
@@ -134,7 +134,13 @@ ai-battery setup claude
 ai-battery setup codex
 ```
 
-Codex wrapper는 기존 `codex` 명령을 직접 덮어쓰지 않습니다. `~/.local/bin/codex`에 관리형 wrapper를 만들고, 필요한 경우 셸 설정에 `~/.local/bin`을 PATH 앞쪽으로 추가합니다. 새 터미널부터 `codex`가 자동으로 AI Battery 하단 행과 함께 실행됩니다.
+Codex wrapper는 기존 `codex` 명령을 직접 덮어쓰지 않습니다. `~/.local/bin/codex`에 관리형 wrapper를 만들고, 필요한 경우 셸 설정에 `~/.local/bin`을 PATH 앞쪽으로 추가합니다. 새 터미널부터 `codex`가 자동으로 AI Battery 하단 행과 함께 실행됩니다. 현재 터미널에서 바로 쓰려면 `setup` 출력에 표시되는 `source ...` 명령을 실행하세요.
+
+Codex 하단 행이 보이지 않으면 진단을 실행합니다.
+
+```bash
+ai-battery doctor
+```
 
 표시할 provider는 짧은 on/off 명령으로 바꿉니다.
 
@@ -196,15 +202,15 @@ ai-battery uninstall-claude-statusline
 
 Claude가 한 번 이상 statusLine payload를 전달해야 Claude의 사용량 캐시가 생성됩니다. 그 전에는 Claude 로컬 로그 기반 fallback이 표시됩니다.
 
-## Floating HUD
+## Desktop HUD
 
-일반 터미널 위에 외부 프로세스가 안전하게 status line을 덧그리는 방식은 안정적이지 않습니다. 그래서 HUD는 Windows floating overlay로 제공합니다. Windows native에서는 WSL 없이 PowerShell/WinForms로 바로 실행되고, WSL에서는 `powershell.exe`를 통해 같은 HUD를 띄웁니다.
+일반 터미널 위에 외부 프로세스가 안전하게 status line을 덧그리는 방식은 안정적이지 않습니다. 그래서 Windows에서는 floating overlay를, macOS에서는 상단 menu bar status item을 제공합니다. Windows native에서는 WSL 없이 PowerShell/WinForms로 바로 실행되고, WSL에서는 `powershell.exe`를 통해 같은 HUD를 띄웁니다. macOS에서는 메뉴바 두께에 맞춰 `Cx 75% | Cl 4%`처럼 한 줄 요약만 표시하고, 클릭하면 자세한 상태를 볼 수 있습니다.
 
 ```bash
 ai-battery hud
 ```
 
-HUD는 백그라운드에서 실행되고 터미널을 바로 돌려줍니다. 위치는 드래그로 옮길 수 있으며, 다음 실행 때 저장된 위치를 재사용합니다.
+HUD는 백그라운드에서 실행되고 터미널을 바로 돌려줍니다. Windows HUD는 위치를 드래그로 옮길 수 있으며, 다음 실행 때 저장된 위치를 재사용합니다. macOS menu bar item은 시스템 메뉴바 오른쪽 영역에 표시됩니다.
 
 ```text
 Codex  [battery:88] │ 5h 00:47 │ 7d 93%
@@ -213,18 +219,18 @@ Claude [battery:76] │ 5h 00:47 │ 7d 59%
 
 | Command | Role |
 | --- | --- |
-| `ai-battery hud` / `ai-battery hud start` | floating HUD를 시작합니다. 이미 떠 있으면 새 인스턴스로 교체합니다. |
-| `ai-battery hud stop` | 실행 중인 HUD를 종료합니다. (`--stop`도 동일) |
-| `ai-battery hud status` | HUD 실행 여부와 autostart 등록 상태를 보여줍니다. |
-| `ai-battery hud autostart on` | Windows 로그인 시 HUD 자동 실행을 등록합니다. |
+| `ai-battery hud` / `ai-battery hud start` | Windows floating HUD 또는 macOS menu bar item을 시작합니다. |
+| `ai-battery hud stop` | 실행 중인 HUD/menu bar item을 종료합니다. (`--stop`도 동일) |
+| `ai-battery hud status` | HUD/menu bar 실행 여부와 autostart 등록 상태를 보여줍니다. |
+| `ai-battery hud autostart on` | Windows 로그인 또는 macOS 로그인 시 자동 실행을 등록합니다. |
 | `ai-battery hud autostart off` | 자동 실행 등록을 해제합니다. |
 | `ai-battery hud autostart status` | 자동 실행 등록 상태만 보여줍니다. |
 | `ai-battery hud -Foreground` | 디버깅용으로 터미널에 붙여 실행합니다. |
 | `ai-battery hud -Once` | 콘솔에서 한 번만 출력합니다. |
 | `ai-battery hud -Interval 2` | 갱신 주기를 바꿉니다. |
-| `ai-battery hud -Mode tray` | Windows tray icon 모드로 실행합니다. |
+| `ai-battery hud -Mode tray` | Windows tray icon 모드로 실행합니다. macOS에서는 menu bar item이 기본입니다. |
 
-autostart는 `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`에 사용자 단위로 등록됩니다. Windows native에서는 WSL 없이 바로 실행되고, WSL에서 등록한 경우에는 HUD 스크립트 사본을 `%LOCALAPPDATA%\ai-battery`에 두어 로그인 시 WSL이 아직 시작되지 않아도 HUD가 먼저 뜨도록 합니다(WSL 로그 기반 사용량은 WSL이 올라온 뒤 채워집니다). ai-battery를 업데이트한 뒤에는 `ai-battery hud autostart on`을 다시 실행해 사본을 갱신하세요.
+Windows autostart는 `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`에 사용자 단위로 등록됩니다. Windows native에서는 WSL 없이 바로 실행되고, WSL에서 등록한 경우에는 HUD 스크립트 사본을 `%LOCALAPPDATA%\ai-battery`에 둡니다. macOS autostart는 `~/Library/LaunchAgents/com.ai-battery.hud.plist`로 등록됩니다. ai-battery를 업데이트한 뒤에는 `ai-battery hud autostart on`을 다시 실행해 등록 경로를 갱신하세요.
 
 ## Shell Prompt
 
@@ -247,7 +253,7 @@ flowchart LR
     F --> R
     R --> T[Terminal output]
     R --> P[PTY reserved row]
-    R --> H[Windows HUD]
+    R --> H[Desktop HUD / menu bar]
 ```
 
 Codex는 최근 세션 로그에서 `rate_limits` 이벤트를 찾습니다. Claude Code는 statusLine payload로 사용률과 리셋 시각을 제공하고, 실제 429 rate-limit hit 로그가 있으면 reset 전까지 0%로 반영합니다. fallback 모드에서는 최근 토큰 사용량만 확인할 수 있습니다.
@@ -258,13 +264,13 @@ Codex는 최근 세션 로그에서 `rate_limits` 이벤트를 찾습니다. Cla
 | --- | --- | --- |
 | CLI | Node.js | 로그 파싱, Claude cache, ANSI/statusLine 출력 |
 | PTY row | Python 3 | Codex 실행용 reserved terminal row |
-| HUD launcher | Node.js / Bash compatibility wrapper | Windows native/WSL에서 PowerShell HUD 실행 |
-| HUD UI | PowerShell WinForms | Windows floating overlay와 tray icon |
+| HUD launcher | Node.js / Bash compatibility wrapper | Windows native/WSL PowerShell HUD와 macOS menu bar 실행 |
+| HUD UI | PowerShell WinForms / AppleScriptObjC | Windows floating overlay, tray icon, macOS menu bar item |
 | Data | JSONL logs, statusLine JSON | Codex/Claude 사용량 소스 |
 
 ## Source Environment
 
-기본 CLI는 Node.js 18 이상이 있으면 Windows native, WSL, Linux, macOS에서 실행됩니다. `ai-battery-run`과 Codex terminal row는 Python 3와 POSIX PTY가 필요해서 WSL/Linux/macOS에서 지원됩니다. HUD는 Windows PowerShell/WinForms를 사용하므로 Windows native와 WSL에서만 지원됩니다.
+기본 CLI는 Node.js 18 이상이 있으면 Windows native, WSL, Linux, macOS에서 실행됩니다. `ai-battery-run`과 Codex terminal row는 Python 3와 POSIX PTY가 필요해서 WSL/Linux/macOS에서 지원됩니다. HUD는 Windows/WSL에서는 PowerShell/WinForms, macOS에서는 내장 `osascript`와 AppleScriptObjC를 사용합니다.
 
 Codex 데이터는 기본적으로 `~/.codex/sessions`를 읽습니다. 다른 위치를 쓰고 있다면 `CODEX_HOME`을 설정하세요.
 
@@ -279,5 +285,5 @@ Claude의 사용량 표시는 Claude Code statusLine hook을 설치한 뒤부터
 - 이 도구는 로컬 로그와 Claude statusLine payload를 읽습니다. 서비스의 공식 과금/한도 화면을 대체하지 않습니다.
 - Codex rate limit 이벤트가 아직 생성되지 않았거나 오래된 경우 최신 상태와 차이가 있을 수 있습니다.
 - Claude statusLine은 사용률과 reset 시각만 제공하므로, 실제 hit 상태는 Claude가 남긴 429 rate-limit 로그를 함께 읽어 반영합니다.
-- HUD는 Windows PowerShell/WinForms 기반입니다. Windows native에서는 직접 실행하고, WSL에서는 `powershell.exe`와 `wsl.exe`를 함께 사용합니다.
+- HUD는 Windows에서는 PowerShell/WinForms 기반이고, macOS에서는 menu bar status item 기반입니다. WSL에서는 `powershell.exe`와 `wsl.exe`를 함께 사용합니다.
 - `ai-battery-run`은 PTY wrapper입니다. 일부 전체 화면 TUI는 화면을 지우는 escape sequence 때문에 status row가 잠시 흔들릴 수 있습니다.

package/bin/ai-battery-hud.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 const scriptPath = fs.realpathSync(fileURLToPath(import.meta.url));
 const scriptDir = path.dirname(scriptPath);
 const ps1Path = path.join(scriptDir, "ai-battery-hud.ps1");
+const macStatusPath = path.join(scriptDir, "ai-battery-macos-status.applescript");
 
 function isWsl() {
   if (process.platform !== "linux") return false;
@@ -112,12 +113,242 @@ function prefetchInitialJson(command, useWslCommand) {
   return null;
 }
 
+function relevantEnvPrefix() {
+  const names = [
+    "AI_BATTERY_STATE_DIR",
+    "CLAUDEX_BATTERY_STATE_DIR",
+    "AI_BATTERY_COLUMNS",
+    "CLAUDEX_BATTERY_COLUMNS",
+    "AI_BATTERY_COLUMN_GUARD",
+    "CLAUDEX_BATTERY_COLUMN_GUARD",
+    "CODEX_HOME"
+  ];
+  const pairs = [`HOME=${shellQuote(os.homedir())}`];
+  for (const name of names) {
+    if (process.env[name]) pairs.push(`${name}=${shellQuote(process.env[name])}`);
+  }
+  return pairs.join(" ");
+}
+
+function parseMacHudArgs(cliArgs) {
+  const options = {
+    foreground: false,
+    once: false,
+    stop: false,
+    subcommand: null,
+    autostartAction: "status",
+    interval: 10,
+    provider: "all"
+  };
+
+  for (let i = 0; i < cliArgs.length; i += 1) {
+    const arg = cliArgs[i];
+    if (arg === "-Foreground" || arg === "--foreground") {
+      options.foreground = true;
+    } else if (arg === "-Once" || arg === "--once") {
+      options.once = true;
+    } else if (arg === "-Stop" || arg === "--stop" || arg === "stop") {
+      options.stop = true;
+    } else if (arg === "start") {
+      // Starting is the default action.
+    } else if (arg === "status") {
+      options.subcommand = "status";
+    } else if (arg === "autostart") {
+      options.subcommand = "autostart";
+      const next = cliArgs[i + 1];
+      if (next === "on" || next === "off" || next === "status") {
+        options.autostartAction = next;
+        i += 1;
+      }
+    } else if (arg === "-Interval" || arg === "--interval") {
+      const next = cliArgs[i + 1];
+      if (next && !next.startsWith("-")) {
+        options.interval = Math.max(1, Number(next) || options.interval);
+        i += 1;
+      }
+    } else if (arg === "--provider" || arg === "-p") {
+      const next = cliArgs[i + 1];
+      if (["all", "codex", "claude"].includes(next)) {
+        options.provider = next;
+        i += 1;
+      }
+    }
+  }
+
+  return options;
+}
+
+function macProviderArgs(provider) {
+  return provider === "all" ? "" : ` --provider ${shellQuote(provider)}`;
+}
+
+function macCommands(options) {
+  const node = shellQuote(process.execPath);
+  const batteryJs = shellQuote(path.join(scriptDir, "ai-battery.js"));
+  const providerArgs = macProviderArgs(options.provider);
+  const envPrefix = relevantEnvPrefix();
+  return {
+    title: `${envPrefix} ${node} ${batteryJs} --menu-bar${providerArgs} 2>/dev/null`,
+    detail: `${envPrefix} ${node} ${batteryJs} --no-color${providerArgs} 2>/dev/null`
+  };
+}
+
+function macHudPids() {
+  const result = spawnSync("pgrep", ["-f", macStatusPath], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return [];
+  return (result.stdout || "")
+    .trim()
+    .split(/\s+/)
+    .map((pid) => Number(pid))
+    .filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+
+function macLaunchAgentPath() {
+  return path.join(os.homedir(), "Library", "LaunchAgents", "com.ai-battery.hud.plist");
+}
+
+function macLaunchctlDomain() {
+  return `gui/${typeof process.getuid === "function" ? process.getuid() : ""}`;
+}
+
+function xmlEscape(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function plistString(value) {
+  return `    <string>${xmlEscape(value)}</string>`;
+}
+
+function macAutostartPlist(options) {
+  const args = [process.execPath, scriptPath, "start", "--interval", String(options.interval)];
+  if (options.provider !== "all") args.push("--provider", options.provider);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.ai-battery.hud</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map(plistString).join("\n")}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+
+function macAutostartStatus() {
+  const filePath = macLaunchAgentPath();
+  return { enabled: fs.existsSync(filePath), filePath };
+}
+
+function macAutostartEnable(options) {
+  const filePath = macLaunchAgentPath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, macAutostartPlist(options), "utf8");
+  spawnSync("launchctl", ["bootstrap", macLaunchctlDomain(), filePath], { stdio: "ignore" });
+  return filePath;
+}
+
+function macAutostartDisable() {
+  const filePath = macLaunchAgentPath();
+  spawnSync("launchctl", ["bootout", macLaunchctlDomain(), filePath], { stdio: "ignore" });
+  fs.rmSync(filePath, { force: true });
+  return filePath;
+}
+
+function runMacHud(cliArgs) {
+  const options = parseMacHudArgs(cliArgs);
+  const commands = macCommands(options);
+
+  if (options.once) {
+    const result = spawnSync(process.execPath, [
+      path.join(scriptDir, "ai-battery.js"),
+      "--menu-bar",
+      ...(options.provider === "all" ? [] : ["--provider", options.provider])
+    ], { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
+    if (result.stdout) process.stdout.write(result.stdout);
+    process.exit(result.status ?? 0);
+  }
+
+  if (options.subcommand === "status") {
+    const pids = macHudPids();
+    const auto = macAutostartStatus();
+    console.log(`HUD: ${pids.length ? `running (PID ${pids[0]})` : "stopped"}`);
+    console.log(`Autostart: ${auto.enabled ? "on" : "off"}`);
+    if (auto.enabled) console.log(`  ${auto.filePath}`);
+    process.exit(0);
+  }
+
+  if (options.subcommand === "autostart") {
+    if (options.autostartAction === "on") {
+      console.log(`HUD autostart enabled: ${macAutostartEnable(options)}`);
+    } else if (options.autostartAction === "off") {
+      console.log(`HUD autostart disabled: ${macAutostartDisable()}`);
+    } else {
+      const auto = macAutostartStatus();
+      console.log(`Autostart: ${auto.enabled ? "on" : "off"}`);
+      if (auto.enabled) console.log(`  ${auto.filePath}`);
+    }
+    process.exit(0);
+  }
+
+  if (options.stop) {
+    const pids = macHudPids();
+    if (!pids.length) {
+      console.log("AI Battery menu bar is not running.");
+      process.exit(0);
+    }
+    const result = spawnSync("kill", pids.map(String), { stdio: "inherit" });
+    if ((result.status ?? 0) === 0) console.log("AI Battery menu bar stopped.");
+    process.exit(result.status ?? 0);
+  }
+
+  if (macHudPids().length) {
+    console.log("AI Battery menu bar is already running.");
+    process.exit(0);
+  }
+
+  const osascriptArgs = [
+    macStatusPath,
+    commands.title,
+    commands.detail,
+    String(options.interval)
+  ];
+
+  if (options.foreground) {
+    const result = spawnSync("osascript", osascriptArgs, { stdio: "inherit" });
+    process.exit(result.status ?? 0);
+  }
+
+  const child = spawn("osascript", osascriptArgs, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  console.log("AI Battery menu bar started. Click the menu bar item for details; use \"ai-battery hud stop\" to close it.");
+  process.exit(0);
+}
+
+if (process.platform === "darwin") {
+  runMacHud(process.argv.slice(2));
+}
+
 const useWsl = isWsl();
 const powershell = "powershell.exe";
 
 if (!useWsl && process.platform !== "win32") {
-  console.error("ai-battery-hud: the floating HUD needs Windows (native or WSL).");
-  console.error("On macOS/Linux terminals use: ai-battery --watch");
+  console.error("ai-battery-hud: desktop HUD needs Windows (native or WSL) or macOS.");
+  console.error("On Linux terminals use: ai-battery --watch");
   process.exit(1);
 }
 

package/bin/ai-battery-macos-status.applescript

@@ -0,0 +1,78 @@
+use framework "AppKit"
+use framework "Foundation"
+use scripting additions
+
+property statusItem : missing value
+property detailItem : missing value
+property refreshTimer : missing value
+property titleCommand : ""
+property detailCommand : ""
+property refreshInterval : 10
+
+on run argv
+  if (count of argv) < 2 then error "ai-battery macOS status item requires title and detail commands"
+
+  set titleCommand to item 1 of argv
+  set detailCommand to item 2 of argv
+  if (count of argv) is greater than or equal to 3 then
+    try
+      set refreshInterval to (item 3 of argv) as real
+    end try
+  end if
+
+  current application's NSApplication's sharedApplication()
+  current application's NSApp's setActivationPolicy:(current application's NSApplicationActivationPolicyAccessory)
+
+  set statusItem to current application's NSStatusBar's systemStatusBar()'s statusItemWithLength:(current application's NSVariableStatusItemLength)
+  statusItem's button()'s setTitle:"AI --"
+  statusItem's button()'s setToolTip:"AI Battery"
+
+  set statusMenu to current application's NSMenu's alloc()'s initWithTitle:"AI Battery"
+  set detailItem to current application's NSMenuItem's alloc()'s initWithTitle:"Loading..." action:(missing value) keyEquivalent:""
+  detailItem's setEnabled:false
+  statusMenu's addItem:detailItem
+  statusMenu's addItem:(current application's NSMenuItem's separatorItem())
+
+  set refreshItem to current application's NSMenuItem's alloc()'s initWithTitle:"Refresh" action:"refresh:" keyEquivalent:"r"
+  refreshItem's setTarget:me
+  statusMenu's addItem:refreshItem
+
+  set quitItem to current application's NSMenuItem's alloc()'s initWithTitle:"Quit AI Battery" action:"quit:" keyEquivalent:"q"
+  quitItem's setTarget:me
+  statusMenu's addItem:quitItem
+
+  statusItem's setMenu:statusMenu
+  my refresh_(missing value)
+
+  set refreshTimer to current application's NSTimer's scheduledTimerWithTimeInterval:refreshInterval target:me selector:"refresh:" userInfo:(missing value) repeats:true
+  current application's NSRunLoop's currentRunLoop()'s addTimer:refreshTimer forMode:(current application's NSRunLoopCommonModes)
+  current application's NSApp's run()
+end run
+
+on refresh_(sender)
+  set titleText to "AI --"
+  set detailText to "AI Battery unavailable"
+
+  try
+    set titleText to do shell script titleCommand
+  end try
+
+  try
+    set detailText to do shell script detailCommand
+  end try
+
+  if titleText is "" then set titleText to "AI --"
+  if detailText is "" then set detailText to "AI Battery unavailable"
+
+  statusItem's button()'s setTitle:titleText
+  statusItem's button()'s setToolTip:detailText
+  detailItem's setTitle:detailText
+end refresh_
+
+on quit_(sender)
+  try
+    refreshTimer's invalidate()
+  end try
+  current application's NSStatusBar's systemStatusBar()'s removeStatusItem:statusItem
+  current application's NSApp's terminate:me
+end quit_

package/bin/ai-battery.js

@@ -41,6 +41,7 @@ function parseArgs(argv) {
     leftPadding: 0,
     activeProvider: null,
     showPaths: false,
+    menuBar: false,
     silent: false,
     force: false,
     header: true,
@@ -95,6 +96,9 @@ function parseArgs(argv) {
       args.activeProvider = argv[++i] || null;
     } else if (arg === "--show-paths") {
       args.showPaths = true;
+    } else if (arg === "--menu-bar") {
+      args.menuBar = true;
+      args.style = "plain";
     } else if (arg === "--help" || arg === "-h") {
       args.help = true;
     } else {
@@ -139,6 +143,7 @@ Options:
       --left-padding N             Prefix status output with N spaces
       --active-provider codex|claude
       --show-paths                 Include source log paths in text output
+      --menu-bar                   Print compact macOS menu bar text
       --tmux                       Emit tmux status-line color markup
       --force                      Replace an existing Claude statusLine
       --no-color                   Disable ANSI colors
@@ -350,6 +355,7 @@ function shellRcPath() {
   if (process.env.AI_BATTERY_RC) return process.env.AI_BATTERY_RC;
   const shell = path.basename(process.env.SHELL || "");
   if (shell === "zsh") return homePath(".zshrc");
+  if (shell === "bash" && process.platform === "darwin") return homePath(".bash_profile");
   if (shell === "bash") return homePath(".bashrc");
   if (shell === "fish") return homePath(".config", "fish", "config.fish");
   return homePath(".profile");
@@ -448,6 +454,13 @@ function installCodexWrapper(args) {
   };
 }
 
+function sourcePathCommand(rcPath) {
+  const shell = path.basename(process.env.SHELL || "");
+  if (!rcPath) return null;
+  if (["bash", "fish", "zsh"].includes(shell)) return `source ${shellArg(rcPath)}`;
+  return `. ${shellArg(rcPath)}`;
+}
+
 function codexRestartNote() {
   if (!runningInsideCodex() || runningInsideAiBatteryCodexWrapper()) return null;
   return "Current Codex was not started through AI Battery. Exit this Codex session and run plain \"codex\" again from a normal terminal.";
@@ -461,6 +474,9 @@ function diagnoseCodex() {
   const wrapperInstalled = configuredWrapper ? managedCodexWrapper(configuredWrapper) : false;
   const activeIsWrapper = activeCodex ? managedCodexWrapper(activeCodex) : false;
   const originalExists = configuredOriginal ? fs.existsSync(configuredOriginal) : false;
+  const runnerPath = path.join(scriptDir(), "ai-battery-run");
+  const runnerExists = isExecutable(runnerPath);
+  const python3 = findCommand("python3");
   const providerEnabled = providerVisible("codex");
   const notes = [];
 
@@ -473,6 +489,12 @@ function diagnoseCodex() {
   if (wrapperInstalled && !activeIsWrapper) {
     notes.push("Plain \"codex\" does not resolve to the AI Battery wrapper in this shell. Open a new terminal or put ~/.local/bin before the original codex on PATH.");
   }
+  if (!runnerExists) {
+    notes.push(`AI Battery runner is missing or not executable: ${runnerPath}`);
+  }
+  if (wrapperInstalled && !python3) {
+    notes.push("Codex wrapper needs python3 for the POSIX PTY row. Install Python 3, then run plain \"codex\" again.");
+  }
   if (configuredOriginal && !originalExists) {
     notes.push(`Original codex path saved by setup no longer exists: ${configuredOriginal}`);
   }
@@ -485,6 +507,9 @@ function diagnoseCodex() {
     activeIsWrapper,
     wrapperPath: configuredWrapper,
     wrapperInstalled,
+    runnerPath,
+    runnerExists,
+    python3,
     originalCommand: configuredOriginal,
     originalExists: configuredOriginal ? originalExists : null,
     insideCodex: runningInsideCodex(),
@@ -662,18 +687,60 @@ function prioritizeCodexSessionFiles(files) {
   });
 }
 
+function firstFiniteValue(source, keys) {
+  for (const key of [keys].flat().filter(Boolean)) {
+    const value = source?.[key];
+    if (Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      const numeric = Number(value);
+      if (Number.isFinite(numeric)) return numeric;
+    }
+  }
+  return null;
+}
+
+function percentValue(value) {
+  if (!Number.isFinite(value)) return null;
+  return value >= 0 && value <= 1 ? value * 100 : value;
+}
+
+function usageInputTokens(usage) {
+  if (!usage) return null;
+  const inputTokens = firstFiniteValue(usage, ["input_tokens", "inputTokens"]);
+  const cacheCreationTokens = firstFiniteValue(usage, ["cache_creation_input_tokens", "cacheCreationInputTokens"]);
+  const cacheReadTokens = firstFiniteValue(usage, ["cache_read_input_tokens", "cacheReadInputTokens"]);
+  if (
+    !Number.isFinite(inputTokens)
+    && !Number.isFinite(cacheCreationTokens)
+    && !Number.isFinite(cacheReadTokens)
+  ) {
+    return null;
+  }
+  return (Number(inputTokens) || 0) + (Number(cacheCreationTokens) || 0) + (Number(cacheReadTokens) || 0);
+}
+
+function resetEpochSeconds(value) {
+  if (Number.isFinite(value)) return value > 1_000_000_000_000 ? Math.floor(value / 1000) : value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return resetEpochSeconds(numeric);
+    const millis = Date.parse(value);
+    if (!Number.isNaN(millis)) return Math.floor(millis / 1000);
+  }
+  return null;
+}
+
 function normalizeLimit(limit, options = {}) {
   if (!limit) return null;
 
-  const usedKey = options.usedKey || "used_percent";
+  const usedKeys = options.usedKey || "used_percent";
   const remainingKeys = [options.remainingKey].flat().filter(Boolean);
-  const windowMinutes = options.windowMinutes ?? limit?.window_minutes ?? null;
-  const usedValue = limit?.[usedKey];
-  const remainingValue = remainingKeys
-    .map((key) => limit?.[key])
-    .find((value) => Number.isFinite(value));
+  const windowMinutes = options.windowMinutes ?? limit?.window_minutes ?? limit?.windowMinutes ?? null;
+  const usedValue = percentValue(firstFiniteValue(limit, usedKeys));
+  const remainingValue = percentValue(firstFiniteValue(limit, remainingKeys));
   const nowSeconds = Math.floor(Date.now() / 1000);
-  const resetPassed = Number.isFinite(limit.resets_at) && limit.resets_at <= nowSeconds;
+  const resetsAtSeconds = resetEpochSeconds(limit.resets_at ?? limit.resetsAt ?? limit.reset_at ?? limit.resetAt);
+  const resetPassed = Number.isFinite(resetsAtSeconds) && resetsAtSeconds <= nowSeconds;
   const inferResetPassed = options.inferResetPassed !== false;
 
   if (!Number.isFinite(usedValue) && !Number.isFinite(remainingValue) && !(resetPassed && inferResetPassed)) return null;
@@ -693,8 +760,8 @@ function normalizeLimit(limit, options = {}) {
     usedPercent,
     remainingPercent,
     windowMinutes,
-    resetsAt: limit.resets_at ? new Date(limit.resets_at * 1000).toISOString() : null,
-    resetsInSeconds: limit.resets_at ? Math.max(0, limit.resets_at - nowSeconds) : null,
+    resetsAt: resetsAtSeconds ? new Date(resetsAtSeconds * 1000).toISOString() : null,
+    resetsInSeconds: resetsAtSeconds ? Math.max(0, resetsAtSeconds - nowSeconds) : null,
     resetPassed
   };
 }
@@ -932,34 +999,119 @@ function readStdin() {
 
 function claudeLimitFromStatusline(limit, windowMinutes) {
   if (!limit) return null;
-  const hasUsedPercentage = Number.isFinite(limit.used_percentage);
-  const remainingPercentage = [
-    limit.remaining_percentage,
-    limit.remaining_percent,
-    limit.percent_remaining
-  ].find((value) => Number.isFinite(value));
+  const usedPercentage = percentValue(firstFiniteValue(limit, [
+    "used_percentage",
+    "usedPercent",
+    "percent_used",
+    "percentUsed",
+    "utilization"
+  ]));
+  const remainingPercentage = percentValue(firstFiniteValue(limit, [
+    "remaining_percentage",
+    "remainingPercent",
+    "remaining_percent",
+    "percent_remaining",
+    "percentRemaining"
+  ]));
+  const resetsAt = resetEpochSeconds(limit.resets_at ?? limit.resetsAt ?? limit.reset_at ?? limit.resetAt);
+  const hasUsedPercentage = Number.isFinite(usedPercentage);
   const hasRemainingPercentage = Number.isFinite(remainingPercentage);
-  const hasReset = Number.isFinite(limit.resets_at);
+  const hasReset = Number.isFinite(resetsAt);
   if (!hasUsedPercentage && !hasRemainingPercentage && !hasReset) return null;
   return {
     ...limit,
-    used_percentage: hasUsedPercentage ? limit.used_percentage : null,
+    used_percentage: hasUsedPercentage ? usedPercentage : null,
     remaining_percentage: hasRemainingPercentage ? remainingPercentage : null,
-    resets_at: hasReset ? limit.resets_at : null,
-    window_minutes: limit.window_minutes ?? windowMinutes
+    resets_at: hasReset ? resetsAt : null,
+    window_minutes: limit.window_minutes ?? limit.windowMinutes ?? windowMinutes
   };
 }
 
 function normalizeClaudeCachedLimit(limit, options = {}) {
   if (!limit) return null;
   return normalizeLimit(limit, {
-    usedKey: "used_percentage",
-    remainingKey: ["remaining_percentage", "remaining_percent", "percent_remaining"],
-    windowMinutes: limit.window_minutes ?? null,
+    usedKey: ["used_percentage", "usedPercent", "percent_used", "percentUsed", "utilization"],
+    remainingKey: ["remaining_percentage", "remainingPercent", "remaining_percent", "percent_remaining", "percentRemaining"],
+    windowMinutes: limit.window_minutes ?? limit.windowMinutes ?? null,
     ...options
   });
 }
 
+function claudeRateLimitsFromStatusline(input) {
+  const rateLimits = input.rate_limits ?? input.rateLimits ?? input.limits ?? {};
+  const fiveHour = rateLimits.five_hour
+    ?? rateLimits.fiveHour
+    ?? rateLimits.five_hour_limit
+    ?? rateLimits.fiveHourLimit
+    ?? rateLimits.session
+    ?? rateLimits.session_limit
+    ?? rateLimits.sessionLimit
+    ?? rateLimits.primary
+    ?? null;
+  const sevenDay = rateLimits.seven_day
+    ?? rateLimits.sevenDay
+    ?? rateLimits.seven_day_limit
+    ?? rateLimits.sevenDayLimit
+    ?? rateLimits.weekly
+    ?? rateLimits.weekly_limit
+    ?? rateLimits.weeklyLimit
+    ?? rateLimits.weekly_scoped
+    ?? rateLimits.weeklyScoped
+    ?? rateLimits.secondary
+    ?? null;
+  return { fiveHour, sevenDay, raw: rateLimits };
+}
+
+function normalizeClaudeContextWindow(context) {
+  if (!context) return null;
+
+  const usedPercentage = percentValue(firstFiniteValue(context, ["used_percentage", "usedPercentage", "percent_used", "percentUsed"]));
+  let remainingPercentage = percentValue(firstFiniteValue(context, [
+    "remaining_percentage",
+    "remainingPercentage",
+    "percent_remaining",
+    "percentRemaining"
+  ]));
+  const currentUsage = context.current_usage ?? context.currentUsage ?? null;
+  const contextWindowSize = firstFiniteValue(context, ["context_window_size", "contextWindowSize", "size", "max_tokens", "maxTokens"]);
+  const totalInputTokens = firstFiniteValue(context, ["total_input_tokens", "totalInputTokens"])
+    ?? usageInputTokens(currentUsage)
+    ?? firstFiniteValue(context, ["input_tokens", "inputTokens"]);
+  const totalOutputTokens = firstFiniteValue(context, ["total_output_tokens", "totalOutputTokens", "output_tokens", "outputTokens"])
+    ?? firstFiniteValue(currentUsage, ["output_tokens", "outputTokens"]);
+  const totalTokens = firstFiniteValue(context, ["total_tokens", "totalTokens"])
+    ?? ((Number.isFinite(totalInputTokens) || Number.isFinite(totalOutputTokens))
+      ? (Number(totalInputTokens) || 0) + (Number(totalOutputTokens) || 0)
+      : null);
+
+  if (!Number.isFinite(remainingPercentage) && Number.isFinite(usedPercentage)) {
+    remainingPercentage = 100 - usedPercentage;
+  }
+  if (!Number.isFinite(remainingPercentage) && Number.isFinite(contextWindowSize) && Number.isFinite(totalTokens) && contextWindowSize > 0) {
+    remainingPercentage = 100 - ((totalTokens / contextWindowSize) * 100);
+  }
+
+  return {
+    usedPercentage: Number.isFinite(usedPercentage)
+      ? clamp(Math.round(usedPercentage), 0, 100)
+      : (Number.isFinite(remainingPercentage) ? clamp(100 - Math.round(remainingPercentage), 0, 100) : null),
+    remainingPercentage: Number.isFinite(remainingPercentage) ? clamp(Math.round(remainingPercentage), 0, 100) : null,
+    contextWindowSize: contextWindowSize ?? null,
+    totalInputTokens: totalInputTokens ?? null,
+    totalOutputTokens: totalOutputTokens ?? null
+  };
+}
+
+function claudeContextWindowFromStatusline(input) {
+  const context = input.context_window
+    ?? input.contextWindow
+    ?? input.context
+    ?? input.context_window_info
+    ?? (input.context_window_size || input.contextWindowSize ? input : null)
+    ?? null;
+  return normalizeClaudeContextWindow(context);
+}
+
 function claudeTranscriptSessionKind(transcriptPath) {
   if (!transcriptPath) return null;
   const text = readTail(transcriptPath, 256 * 1024);
@@ -1107,48 +1259,44 @@ function applyClaudeRateLimitHit(limit, hit, window) {
 }
 
 function captureClaudeStatusline(input) {
-  const rateLimits = input.rate_limits ?? {};
-  const sessionId = input.session_id ?? null;
+  const rateLimits = claudeRateLimitsFromStatusline(input);
+  const sessionId = input.session_id ?? input.sessionId ?? null;
   const previous = (sessionId ? readJson(claudeSessionCachePath(sessionId)) : null) ?? readJson(claudeCachePath());
   const sessionKind = claudeStatuslineSessionKind(input);
+  const contextWindow = claudeContextWindowFromStatusline(input);
   const snapshot = {
     version: 1,
     provider: "claude",
     sourceType: "statusline",
     capturedAt: new Date().toISOString(),
     sessionId,
-    promptId: input.prompt_id ?? null,
-    transcriptPath: input.transcript_path ?? null,
+    promptId: input.prompt_id ?? input.promptId ?? null,
+    transcriptPath: input.transcript_path ?? input.transcriptPath ?? null,
     sessionKind,
     claudeVersion: input.version ?? null,
     model: {
-      id: input.model?.id ?? null,
-      displayName: input.model?.display_name ?? null
+      id: typeof input.model === "string" ? input.model : input.model?.id ?? null,
+      displayName: typeof input.model === "string" ? input.model : input.model?.display_name ?? input.model?.displayName ?? null
     },
     rateLimits: {
-      fiveHour: claudeLimitFromStatusline(rateLimits.five_hour, 300),
-      sevenDay: claudeLimitFromStatusline(rateLimits.seven_day, 10080)
+      fiveHour: claudeLimitFromStatusline(rateLimits.fiveHour, 300),
+      sevenDay: claudeLimitFromStatusline(rateLimits.sevenDay, 10080)
     },
-    rawRateLimits: rateLimits,
-    contextWindow: input.context_window
-      ? {
-          usedPercentage: input.context_window.used_percentage ?? null,
-          remainingPercentage: input.context_window.remaining_percentage ?? null,
-          contextWindowSize: input.context_window.context_window_size ?? null,
-          totalInputTokens: input.context_window.total_input_tokens ?? null,
-          totalOutputTokens: input.context_window.total_output_tokens ?? null
-        }
-      : null
+    rawRateLimits: rateLimits.raw,
+    contextWindow
   };
 
   if (previous?.provider === "claude" && previous?.sourceType === "statusline") {
-    const sameSession = previous.sessionId && previous.sessionId === snapshot.sessionId;
-    if (sameSession && !snapshot.rateLimits.fiveHour) {
+    const sameSession = previous.sessionId && snapshot.sessionId && previous.sessionId === snapshot.sessionId;
+    if (!snapshot.rateLimits.fiveHour) {
       snapshot.rateLimits.fiveHour = previous.rateLimits?.fiveHour ?? null;
     }
-    if (sameSession && !snapshot.rateLimits.sevenDay) {
+    if (!snapshot.rateLimits.sevenDay) {
       snapshot.rateLimits.sevenDay = previous.rateLimits?.sevenDay ?? null;
     }
+    if (sameSession && !snapshot.contextWindow) {
+      snapshot.contextWindow = previous.contextWindow ?? null;
+    }
   }
 
   if (snapshot.sessionId) {
@@ -1674,18 +1822,18 @@ function statusLineUsableColumns(input) {
   return Math.max(20, statusLineColumns(input) - guard);
 }
 
-function contextRemainingPercent(input) {
-  const context = input.context_window ?? input.contextWindow ?? null;
-  const remaining = context?.remaining_percentage ?? context?.remainingPercentage;
+function contextRemainingPercent(input, fallbackContext = null) {
+  const context = claudeContextWindowFromStatusline(input) ?? fallbackContext;
+  const remaining = context?.remainingPercentage;
   if (typeof remaining === "number") return clamp(Math.round(remaining), 0, 100);
 
-  const used = context?.used_percentage ?? context?.usedPercentage;
+  const used = context?.usedPercentage;
   if (typeof used === "number") return clamp(100 - Math.round(used), 0, 100);
   return null;
 }
 
-function contextLeftText(input) {
-  const remaining = contextRemainingPercent(input);
+function contextLeftText(input, fallbackContext = null) {
+  const remaining = contextRemainingPercent(input, fallbackContext);
   if (remaining === null) return null;
   return `${remaining}% context left`;
 }
@@ -1730,13 +1878,20 @@ function statuslineGitBranch(input) {
     || input.git_branch
     || input.workspace?.git_branch
     || input.workspace?.git?.branch
+    || input.workspace?.branch
+    || input.worktree?.branch
+    || input.worktree?.original_branch
     || null;
   if (explicit) return explicit;
 
   const dirs = [
     input.workspace?.current_dir,
+    input.workspace?.currentDir,
     input.cwd,
-    input.workspace?.project_dir
+    input.current_dir,
+    input.currentDir,
+    input.workspace?.project_dir,
+    input.workspace?.projectDir
   ].filter(Boolean);
 
   for (const dir of dirs) {
@@ -1746,10 +1901,19 @@ function statuslineGitBranch(input) {
   return null;
 }
 
-function claudeHeader(input, args) {
-  const model = input.model?.display_name || input.model?.id || "Claude";
-  const effort = input.effort?.level || null;
-  const workspaceRoot = input.workspace?.project_dir || input.cwd || input.workspace?.current_dir || "";
+function claudeHeader(input, args, capturedClaude = null) {
+  const model = typeof input.model === "string"
+    ? input.model
+    : input.model?.display_name || input.model?.displayName || input.model?.id || "Claude";
+  const effort = input.effort?.level || input.effortLevel || null;
+  const workspaceRoot = input.workspace?.project_dir
+    || input.workspace?.projectDir
+    || input.cwd
+    || input.current_dir
+    || input.currentDir
+    || input.workspace?.current_dir
+    || input.workspace?.currentDir
+    || "";
   const gitBranch = statuslineGitBranch(input);
   const parts = [model];
   if (effort) parts.push(effort);
@@ -1760,7 +1924,7 @@ function claudeHeader(input, args) {
     parts.push(gitBranch);
   }
   const left = parts.join(" ");
-  const right = contextLeftText(input);
+  const right = contextLeftText(input, capturedClaude?.contextWindow ?? null);
   const columns = Math.max(20, statusLineUsableColumns(input) - (args.leftPadding || 0));
   const header = alignHeader(left, right, columns);
   return statusColorize({ running: false }, header, args);
@@ -1891,6 +2055,17 @@ function renderLine(snapshot, args) {
     .join(providerDivider);
 }
 
+function renderMenuBar(snapshot) {
+  const parts = snapshot.results
+    .map((result) => {
+      const label = result.provider === "codex" ? "Cx" : "Cl";
+      if (!result.ok || typeof result.percentRemaining !== "number") return `${label} --`;
+      return `${label} ${result.percentRemaining}%`;
+    })
+    .filter(Boolean);
+  return parts.length ? parts.join(" | ") : "AI --";
+}
+
 function applyLeftPadding(output, args) {
   const padding = Math.max(0, Number(args.leftPadding) || 0);
   if (!padding) return output;
@@ -1903,6 +2078,7 @@ function applyLeftPadding(output, args) {
 
 function render(snapshot, args) {
   if (args.json) return JSON.stringify(snapshot, null, 2);
+  if (args.menuBar) return renderMenuBar(snapshot);
 
   const maxWidth = args.maxWidth
     ? Math.max(20, args.maxWidth - (Number(args.leftPadding) || 0))
@@ -1938,6 +2114,8 @@ async function main() {
         console.log(`Codex wrapper installed: ${result.codex.wrapperPath}`);
         console.log(`Original codex: ${result.codex.originalCommand}`);
         if (result.codex.path?.note) console.log(result.codex.path.note);
+        const reloadCommand = sourcePathCommand(result.codex.path?.rcPath);
+        if (reloadCommand) console.log(`For this terminal now, run: ${reloadCommand}`);
       } else if (result.codex?.skipped) {
         console.log(`Codex wrapper skipped: ${result.codex.reason}`);
       }
@@ -1958,6 +2136,8 @@ async function main() {
       console.log(`Codex provider: ${result.codex.providerEnabled ? "on" : "off"}`);
       console.log(`Codex on PATH: ${result.codex.activeCodex || "not found"}`);
       console.log(`Codex wrapper: ${result.codex.wrapperInstalled ? "installed" : "missing"} (${result.codex.wrapperPath})`);
+      console.log(`AI Battery runner: ${result.codex.runnerExists ? "found" : "missing"} (${result.codex.runnerPath})`);
+      console.log(`python3: ${result.codex.python3 || "not found"}`);
       console.log(`PATH uses wrapper: ${result.codex.activeIsWrapper ? "yes" : "no"}`);
       console.log(`Inside Codex: ${result.codex.insideCodex ? "yes" : "no"}`);
       console.log(`Current Codex wrapped: ${result.codex.currentCodexWrapped ? "yes" : "no"}`);
@@ -2032,7 +2212,7 @@ async function main() {
         const claudeData = claudeStatuslineResultFromCache(capturedClaude, capturedSource, { includeBackground: true }) ?? readClaude();
         results.push({ ...claudeData, running: true });
       }
-      const header = args.header ? applyLeftPadding(claudeHeader(input, args), args) : "";
+      const header = args.header ? applyLeftPadding(claudeHeader(input, args, capturedClaude), args) : "";
       const usage = render({
         generatedAt: new Date().toISOString(),
         results

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-battery",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Tiny terminal battery meter for local Codex and Claude Code usage.",
   "type": "module",
   "keywords": [
@@ -25,13 +25,14 @@
     "bin/ai-battery-run",
     "bin/ai-battery-hud",
     "bin/ai-battery-hud.js",
+    "bin/ai-battery-macos-status.applescript",
     "bin/ai-battery-hud.ps1",
     "docs/*.svg",
     "README.md"
   ],
   "scripts": {
     "start": "node ./bin/ai-battery.js",
-    "check": "node --check ./bin/ai-battery.js"
+    "check": "node --check ./bin/ai-battery.js && node --check ./bin/ai-battery-hud.js"
   },
   "engines": {
     "node": ">=18"