Add configurable live-limits and app-server detection

Introduce configurable live limits handling and explicit app-server selection. Adds --live-limits (auto|on|off) and --app-server-bin flags, a LiveLimitsMode config, and AppServerCommand + resolve_app_server_command to detect/launch either `codex app-server` or a standalone app-server (with Windows auto-detection of bundled locations). UI and app state now surface non-error notices vs errors when limits are unavailable, and token metrics show total/out-of-cache pairs. Update usage snapshot to track cached input tokens, adjust related rendering/formatting, and add docs (AGENTS.md, README) and changelog entry; minor test updates and ergonomics/refactors included. Version bumped to 0.3.6.

Revert "Add configurable live-limits and app-server detection"

This reverts commit eb81244.

Reapply "Add configurable live-limits and app-server detection"

This reverts commit 83cd1fd.

Delete file

Author: ssh4net

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project are documented in this file.
 
+## 0.3.6 - 2026-06-05
+
+- Added `--live-limits auto|on|off` so app-only installs can run without a live-limits spawn error.
+- Added `--app-server-bin` for standalone Codex App Server executables.
+- Added Windows auto-detection for common Codex App bundled App Server locations.
+- Project activity token headers now show total/out-of-cache token pairs.
+
 ## 0.3.4 - 2026-04-24
 
 - Fixed inflated usage totals from forked/subagent session logs by ignoring replayed parent-session token history while preserving new post-fork usage.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "comon"
-version = "0.3.5"
+version = "0.3.6"
 edition = "2021"
 license = "Apache-2.0"
 

Cargo.toml

@@ -6,7 +6,7 @@ Single-binary, cross-platform TUI for:
 
 - Local Codex usage stats (last 7/30 days, chart, top models) by scanning `CODEX_HOME/sessions`.
 - Local session-history browser grouped by project path, with session titles and prompt previews.
-- Live account limits/credits by spawning `codex app-server` and calling `account/rateLimits/read`.
+- Live account limits/credits by spawning Codex App Server and calling `account/rateLimits/read` when an App Server executable is available.
 
 See `CHANGELOG.md` for release history.
 
@@ -38,7 +38,7 @@ See `CHANGELOG.md` for release history.
 
 - Rust toolchain (stable) installed.
 - C/C++ compiler toolchain available (needed to build bundled SQLite through `rusqlite`).
-- Codex CLI installed and available as `codex` on your `PATH` (required for live limits/credits).
+- Codex CLI installed as `codex` on your `PATH`, or a discoverable/explicit Codex App Server executable (required only for live limits/credits).
   - Usage stats still work without Codex CLI (they only need the session logs on disk).
 - For portable Linux builds (`--musl`), `rustup` and musl target toolchain support are required.
 
@@ -52,7 +52,7 @@ Use `--project <path>` (or `--workspace <path>`) to filter usage stats to a spec
 
 If `--project` points to a non-git directory, `comon` falls back to **All workspaces**.
 
-`--cwd` controls where `codex app-server` is launched and does not change usage scope.
+`--cwd` controls where Codex App Server is launched and does not change usage scope.
 
 ```bash
 # If installed (recommended):
@@ -73,8 +73,10 @@ Common flags:
 - `-r` / `--read`: start on the Session history screen
 - `--sessions-dir <path>`: override the Codex sessions directory used by the Session history screen
 - `--print-sessions-dir`: print effective sessions directory and exit
-- `--codex-bin <path>`: override Codex CLI binary (default: `codex`)
-- `--cwd <path>`: directory to launch `codex app-server` in (default: current directory; does not change usage scope)
+- `--codex-bin <path>`: override Codex CLI binary (spawned as `<path> app-server`)
+- `--app-server-bin <path>`: override a standalone Codex App Server executable (spawned directly)
+- `--live-limits <auto|on|off>`: `auto` tries App Server if found, `on` requires it, `off` disables live limits (default: `auto`)
+- `--cwd <path>`: directory to launch Codex App Server in (default: current directory; does not change usage scope)
 - `--project <path>` / `--workspace <path>`: filter usage stats to a specific project/workspace (also becomes default `--cwd` if `--cwd` not set)
 - `--usage-days <n>`: days to scan for usage (clamped 1..=90; default from config)
 - `--refresh-usage-secs <n>`: usage refresh interval in seconds (default from config)
@@ -119,6 +121,19 @@ Example:
 comon --codex-home "C:\\Users\\You\\.codex" --cwd "C:\\Repos\\some-git-repo"
 ```
 
+Codex App-only Windows installs:
+
+```bash
+# Usage/session history only; avoids App Server probing.
+comon --live-limits off
+
+# If auto-detection misses the bundled CLI-style binary:
+comon --codex-bin "C:\\Path\\To\\Codex\\codex.exe"
+
+# If the app ships a standalone App Server binary:
+comon --app-server-bin "C:\\Path\\To\\Codex\\app-server.exe"
+```
+
 Large-log recovery/tuning example:
 
 ```bash
@@ -311,7 +326,7 @@ CI also runs this check on each push and pull request via `.github/workflows/asc
 ## Notes
 
 - Usage stats are derived from Codex session JSONL logs. If you have no session data yet, values will be empty.
-- Limits/credits require `codex app-server` to start successfully (auth, environment, and a usable working directory).
+- Limits/credits require Codex App Server to start successfully (auth, environment, and a usable working directory). CoMon auto-detects `codex` on `PATH` and common Windows Codex App bundle locations; use `--codex-bin` or `--app-server-bin` when needed.
 - comon stores local app state in `~/.comon/state.json` by default (or `$COMON_HOME`, or `--comon-home`).
 - comon stores scan cache in `~/.comon/comon.db` to avoid rereading unchanged session files.
 - Large session logs are parsed incrementally with persisted parser offsets in `comon.db`; unchanged files are reused from cache.

README.md

@@ -15,6 +15,8 @@ use tokio::sync::{mpsc, watch};
 #[derive(Debug, Clone)]
 pub struct Config {
     pub codex_bin: Option<String>,
+    pub app_server_bin: Option<std::path::PathBuf>,
+    pub live_limits_mode: LiveLimitsMode,
     pub comon_home: std::path::PathBuf,
     pub codex_home: std::path::PathBuf,
     pub read_sessions_dir: std::path::PathBuf,
@@ -28,6 +30,13 @@ pub struct Config {
     pub rebuild_cache_on_start: bool,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LiveLimitsMode {
+    Auto,
+    On,
+    Off,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum ChartOrientation {
     Vertical,
@@ -48,7 +57,7 @@ enum UsageCommand {
 enum AppEvent {
     UsageUpdated(Result<LocalUsageSnapshot>),
     LimitsUpdated(Result<AccountRateLimits>),
-    LimitsUnavailable(String),
+    LimitsUnavailable { message: String, is_error: bool },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -92,6 +101,7 @@ pub(crate) struct AppState {
     pub(crate) limits: Option<AccountRateLimits>,
     pub(crate) limits_updated_at: Option<Instant>,
     pub(crate) limits_error: Option<String>,
+    pub(crate) limits_notice: Option<String>,
     pub(crate) limits_enabled: bool,
     pub(crate) read_sessions_dir: PathBuf,
     pub(crate) read_browser: crate::read::tui::BrowserState,
@@ -274,16 +284,45 @@ async fn run_inner(
     {
         let evt_tx = evt_tx.clone();
         let codex_bin = config.codex_bin.clone();
+        let app_server_bin = config.app_server_bin.clone();
+        let live_limits_mode = config.live_limits_mode;
         let cwd = config.cwd.clone();
         let refresh = Duration::from_secs(config.refresh_limits_secs);
         let mut limits_refresh_rx = limits_refresh_rx;
         let mut shutdown_rx = shutdown_rx.clone();
         tokio::spawn(async move {
-            let rpc = match CodexRpc::spawn(codex_bin, cwd).await {
+            if live_limits_mode == LiveLimitsMode::Off {
+                let _ = evt_tx
+                    .send(AppEvent::LimitsUnavailable {
+                        message: "Live limits disabled (--live-limits off).".to_string(),
+                        is_error: false,
+                    })
+                    .await;
+                return;
+            }
+
+            let Some(app_server) =
+                crate::codex_rpc::resolve_app_server_command(codex_bin, app_server_bin)
+            else {
+                let _ = evt_tx
+                    .send(AppEvent::LimitsUnavailable {
+                        message: missing_app_server_message().to_string(),
+                        is_error: live_limits_mode == LiveLimitsMode::On,
+                    })
+                    .await;
+                return;
+            };
+            let app_server_is_explicit = app_server.is_explicit();
+
+            let rpc = match CodexRpc::spawn(app_server, cwd).await {
                 Ok(rpc) => rpc,
                 Err(err) => {
                     let _ = evt_tx
-                        .send(AppEvent::LimitsUnavailable(err.to_string()))
+                        .send(AppEvent::LimitsUnavailable {
+                            message: err.to_string(),
+                            is_error: live_limits_mode == LiveLimitsMode::On
+                                || app_server_is_explicit,
+                        })
                         .await;
                     return;
                 }
@@ -371,6 +410,7 @@ async fn run_inner(
         limits: None,
         limits_updated_at: None,
         limits_error: None,
+        limits_notice: None,
         limits_enabled: true,
         read_sessions_dir: config.read_sessions_dir.clone(),
         read_browser,
@@ -705,16 +745,24 @@ fn handle_app_event(state: &mut AppState, evt: AppEvent) -> bool {
             }
             true
         }
-        AppEvent::LimitsUnavailable(msg) => {
+        AppEvent::LimitsUnavailable { message, is_error } => {
             state.limits_enabled = false;
-            state.limits_error = Some(msg);
+            if is_error {
+                state.limits_error = Some(message);
+                state.limits_notice = None;
+            } else {
+                state.limits_error = None;
+                state.limits_notice = Some(message);
+            }
             true
         }
         AppEvent::LimitsUpdated(res) => {
             match res {
                 Ok(limits) => {
+                    state.limits_enabled = true;
                     state.limits = Some(limits);
                     state.limits_error = None;
+                    state.limits_notice = None;
                     state.limits_updated_at = Some(Instant::now());
                 }
                 Err(err) => {
@@ -726,6 +774,10 @@ fn handle_app_event(state: &mut AppState, evt: AppEvent) -> bool {
     }
 }
 
+fn missing_app_server_message() -> &'static str {
+    "Codex App Server not found; usage/history still work. Install Codex CLI or pass --codex-bin/--app-server-bin."
+}
+
 fn load_persisted_ui_state(
     comon_home: &Path,
     workspace_hint: Option<&Path>,