feat(zaly): add Zaly as a backend (session JSONL, mixed billing split)

Author: hamidi-dev

CLAUDE.md

@@ -23,17 +23,19 @@ Code/Insiders/VSCodium variants, or `--vscode-dir` — from WSL, pointed at the
 store — `VscodeStore`),
 **pi-agent** sessions (`~/.pi/agent/sessions/**/*.jsonl` or `$PI_AGENT_DIR`, `PiStore`),
 **OpenClaw** gateway sessions (`~/.openclaw/agents/**/sessions/*.jsonl` or `$OPENCLAW_DIR`,
-`OpenClawStore`), and a **JSONL/NDJSON of logged API requests** (the per-line twin of the
+`OpenClawStore`), **Zaly** sessions
+(`~/.local/share/zaly/sessions/*/*/session.jsonl` or `$ZALY_DATA`/`$ZALY_ROOT`,
+`ZalyStore`), and a **JSONL/NDJSON of logged API requests** (the per-line twin of the
 CSV source; `--jsonl`, default `~/.config/opentab/requests.jsonl`, `JsonlStore`).
 `CombinedStore` merges them. Pick with
-`--source {auto,opencode,claude,codex,hermes,csv,jsonl,copilot,vscode,pi,openclaw,all}` or
-switch live with **`c`**.
+`--source {auto,opencode,claude,codex,hermes,csv,jsonl,copilot,vscode,pi,openclaw,zaly,all}`
+or switch live with **`c`**.
 
 Cost model: Claude Code, Codex, and Copilot (CLI and VS Code) record **no per-message
 cost**, so they behave like an OpenCode *subscription* session — **$0 in normal mode**, a
-list-price estimate (tokens × API price) only under **`$`**. Hermes, CSV/JSONL, pi, and
-OpenClaw are **mixed**: subscription/OAuth routes stay $0/estimated, metered routes record
-real spend. See each backend's note under Architecture.
+list-price estimate (tokens × API price) only under **`$`**. Hermes, CSV/JSONL, pi,
+OpenClaw, and Zaly are **mixed**: subscription/OAuth routes stay $0/estimated, metered
+routes record real spend. See each backend's note under Architecture.
 
 ## Commands
 
@@ -118,7 +120,7 @@ src/opentab/
   sources.py         make_store/resolve_source/available_sources/source_cycle + path routing
   state.py           load_state/save_state/apply_state
   themes.py          THEMES palettes (single source for the web browser + the TUI) + hex math
-  stores/            opencode, claude, codex, hermes, csv_source, jsonl_source, copilot, vscode, pi, openclaw, combined, cached
+  stores/            opencode, claude, codex, hermes, csv_source, jsonl_source, copilot, vscode, pi, openclaw, zaly, combined, cached
   tui/               renderer (Renderer), app (App)
   web.py             build_payload/session_extras + html_command/serve_command (ReportServer)
   webpage.py         render_html: the self-contained browser page (inline CSS/JS strings)
@@ -157,7 +159,7 @@ Three logical layers (the class names below live in the files above — `Store`
   `getattr`, each gated by `supports_*(workflow_id)` so the merged view hides an
   unsupported tab rather than showing it empty (`CombinedStore` routes by owning backend).
   Turns is implemented by every backend except Hermes; Tools by OpenCode, Claude, Codex,
-  pi, and CSV/JSONL (the others record no per-step tool calls with usage). Records
+  pi, Zaly, and CSV/JSONL (the others record no per-step tool calls with usage). Records
   **no per-message cost** → a *subscription* backend: `model_breakdown` reports `cost=0`
   with tokens in the `unpriced_*`/`root_unpriced_*` splits, so the normal `$` machinery
   gives **$0 / list-price estimate** with no special-casing. `records_cost=False` drives
@@ -297,7 +299,31 @@ grouping and the regenerate/append dedup) and **Tools** (the optional `tool` col
   OpenClaw's generic cwd); messages dedupe by record `id` across live + archived
   (`.jsonl.reset.`/`.jsonl.deleted.`). No subagent tree; usage-less sessions dropped.
   Implements **Turns** exactly like pi (epoch-seconds timestamps).
-- **`JsonlStore`** — ninth backend over a **JSONL/NDJSON of logged API requests** (one JSON
+- **`ZalyStore`** — ninth backend over **Zaly** session NDJSON
+  (`<data>/sessions/<encoded-workspace>/<uuid>/session.jsonl`; data resolved like zaly's
+  own envPaths — `$ZALY_DATA` / `$ZALY_ROOT/data` / `$XDG_DATA_HOME/zaly`, default
+  `~/.local/share/zaly`, or `--zaly-dir`), same methods. Each session is one append-only
+  JSONL **DAG** (`session-settings` snapshots `{sessionId, cwd/workspace, modelId}`;
+  resume/fork append to the *same* file, so no cross-file dedup — assistant messages
+  still dedupe by `message.id`, and abandoned regenerated branches count: each was a
+  real API call). Usage lives on `message.meta.usage` (model on `meta.modelId`, already
+  provider-qualified — `openai-codex/gpt-5.6-sol` — used verbatim): **Anthropic-normalized**
+  tokens (`input` already uncached — zaly's OpenAI adapter subtracts `cached_tokens`
+  itself; cacheRead/cacheWrite separate) with **`reasoning` a subset of `output`**
+  (OpenAI's reasoning_tokens detail) → reported as 0 like Codex/Copilot, since opentab's
+  reasoning column is additive and counting it would double-bill under `$`. The
+  per-message `usage.cost` is a **per-component USD object** ({input, output, cacheRead,
+  …}, no `.total` — summed) computed from zaly's catalog for **every** route, so the
+  pi/OpenClaw **metered-vs-subscription split**: subscription when the `meta.modelId`
+  provider prefix is an OAuth login in zaly's `<state>/auth.json`
+  (`{provider: {type: "oauth"|"api-key"}}`, `$ZALY_STATE`-resolved, read-only) or matches
+  `_SUBSCRIPTION_MARKERS` (codex/copilot/ollama/lm-studio/…); **`records_cost`
+  per-instance**. Workspace → git root; settings `sessionId` beats the dir name. **No
+  subagent tree** — zaly writes subagent transcripts to tmpdir and does *not* fold their
+  usage into the parent (a latent undercount, documented in the docstring). Settings-only
+  sessions (zaly launched, nothing asked) are dropped. Implements **Turns** (epoch-ms
+  timestamps, ▸-grouped like pi) and **Tools** (the step's `tool-call` content parts).
+- **`JsonlStore`** — tenth backend over a **JSONL/NDJSON of logged API requests** (one JSON
   object per line, generic). **Subclasses `CsvStore`** — its per-line twin — inheriting
   OpenAI-style token accounting, mixed per-row cost (`records_cost` per-instance;
   `cost_usd`/`credits`), provider-prefixed models, synthetic `(date, project)` sessions,
@@ -375,7 +401,7 @@ tuples `month_tabs`/`day_tabs`/`project_tabs`/`workflow_tabs`. `current_tabs()`
 source of truth (don't index a class tuple directly): it appends, in order, a **Turns**
 tab (when `supports_turns(id)` — every backend except Hermes, whose DB records no
 per-message usage) and a **Tools** tab (when
-`supports_tools(id)` — OpenCode, Claude, Codex, pi, and CSV/JSONL sessions whose log
+`supports_tools(id)` — OpenCode, Claude, Codex, pi, Zaly, and CSV/JSONL sessions whose log
 carries the optional `tool` column) to the *selected* session's `workflow_tabs`, each
 gated per-session so the merged view hides an unsupported tab rather than showing it
 empty, and injects **Sources** in the merged view — so `draw_detail` dispatches the

README.md

@@ -27,7 +27,8 @@ no accounts — it opens those files **read-only**. Standard-library-only at run
 
 - **One tab for every tool** — [OpenCode](https://opencode.ai),
   [Claude Code](https://claude.com/claude-code), [Codex](https://developers.openai.com/codex),
-  Hermes, GitHub Copilot (its CLI and Copilot Chat in VS Code), pi-agent, OpenClaw, and
+  Hermes, GitHub Copilot (its CLI and Copilot Chat in VS Code), pi-agent, OpenClaw,
+  [zaly](https://github.com/folke/zaly), and
   CSV/JSONL logs of your own API requests — [each detailed below](#data-sources).
 - **Drill, don't scroll** — month → day → project → session → model, down the recursive
   subagent tree, with a live fuzzy filter (fzf-style) and live date-range scoping.
@@ -128,6 +129,7 @@ opentab --source copilot                     # GitHub Copilot CLI (default ~/.co
 opentab --source vscode                      # Copilot Chat in VS Code (every installed variant)
 opentab --source pi                          # pi-agent (default ~/.pi/agent/sessions)
 opentab --source openclaw                    # OpenClaw gateway (default ~/.openclaw)
+opentab --source zaly                        # zaly (default ~/.local/share/zaly)
 opentab --csv requests.csv                   # a CSV of logged API requests (or --jsonl)
 opentab --source all                         # all present sources, merged
 ```
@@ -145,6 +147,7 @@ What each tool's records support on top:
 | Copilot Chat in VS Code | tokens only — `$` estimates | — | ✓ | — |
 | pi-agent | mixed — metered real, rest estimated | — | ✓ | ✓ |
 | OpenClaw | mixed — metered real, rest estimated | — | ✓ | — |
+| zaly | mixed — metered real, rest estimated | — | ✓ | ✓ |
 | CSV / JSONL request logs | mixed — per-row cost column | — | ✓ | ✓ ² |
 
 <sub>**Subagent tree** — recursive per-subagent cost under the session that delegated ·
@@ -260,6 +263,22 @@ Where each tool's records live, and their quirks:
 
 </details>
 
+<details>
+<summary><strong>zaly</strong> — session JSONL · mixed: metered real, plan routes estimated</summary>
+
+- **Reads** `~/.local/share/zaly/sessions/*/*/session.jsonl` (`--zaly-dir`, honors
+  `$ZALY_DATA` and `$ZALY_ROOT`).
+- **Cost**: zaly prices every message from its model catalog regardless of route, so —
+  like pi and OpenClaw — only **metered** routes (a direct API key) count as real
+  spend; OAuth/plan logins (a ChatGPT-plan `openai-codex`, Claude Pro/Max) and local
+  models stay `$0` and are estimated under `$`. The split is read from zaly's
+  `auth.json`, read-only.
+- **Notes**: projects fold to the workspace's git root; resume/fork append to the same
+  file, so nothing double-counts. Subagent transcripts are not persisted by zaly
+  (they live in the temp dir), so their usage can't be shown.
+
+</details>
+
 <details>
 <summary><strong>CSV / JSONL request logs</strong> — bring your own ledger · mixed per row</summary>
 
@@ -447,9 +466,9 @@ Local-only, no network, no telemetry, no accounts — it opens every source file
 <summary><strong>Full transparency</strong> — everything it reads, writes, and runs</summary>
 
 - **Reads** your tools' own records, read-only: OpenCode's SQLite DB, the JSONL
-  transcripts of Claude Code / Codex / pi-agent / OpenClaw, Hermes' SQLite DB, the Copilot
-  CLI's OpenTelemetry export, VS Code's Copilot Chat session store, and a CSV/JSONL of
-  logged API requests (`--csv`/`--jsonl`).
+  transcripts of Claude Code / Codex / pi-agent / OpenClaw / zaly, Hermes' SQLite DB, the
+  Copilot CLI's OpenTelemetry export, VS Code's Copilot Chat session store, and a
+  CSV/JSONL of logged API requests (`--csv`/`--jsonl`).
   To fold git worktrees into their main repo it also reads project `.git` files (no `git`
   process is spawned; disable with `--no-worktrees`).
 - **Writes** a small preferences file at `~/.config/opentab/state.json` (your last

src/opentab/__init__.py

@@ -1,7 +1,7 @@
 """OpenTab — a lazygit-style browser for your AI coding spend.
 
 Reads OpenCode, Claude Code, Codex, Hermes, the Copilot CLI, pi-agent, OpenClaw,
-and logged-request CSVs read-only and shows cost by month / day / project /
+Zaly, and logged-request CSVs read-only and shows cost by month / day / project /
 session / model, including the recursive subagent tree.
 
 This package is the modular form of what used to be a single ``opentab`` script.
@@ -139,6 +139,7 @@
 from opentab.stores.opencode import MODEL_EXPR, MSG_MODEL_EXPR, MSG_TOKEN_TOTAL_EXPR, Store
 from opentab.stores.pi import PiStore
 from opentab.stores.vscode import VscodeStore
+from opentab.stores.zaly import ZalyStore
 from opentab.themes import (
     DEFAULT_THEME,
     THEME_IDS,

src/opentab/cli.py

@@ -27,6 +27,7 @@
     DEFAULT_JSONL_PATH,
     _default_openclaw_dir,
     _default_pi_dir,
+    _default_zaly_dir,
     _jsonl_dir_available,
     _route_path_arg,
     resolve_source,
@@ -55,15 +56,16 @@ def parse_args() -> argparse.Namespace:
             "vscode",
             "pi",
             "openclaw",
+            "zaly",
             "all",
         ),
         default="auto",
         help="data source: opencode (SQLite), claude (Claude Code transcripts), codex "
         "(Codex CLI rollouts), hermes (Hermes Agent DB), csv (a CSV of logged API "
         "requests, e.g. GitHub Copilot), jsonl (an NDJSON of logged API requests), "
         "copilot (GitHub Copilot CLI via its OTEL export), vscode (Copilot Chat sessions "
-        "in VS Code), pi (pi-agent sessions), openclaw (OpenClaw gateway sessions), or "
-        "all (merged); auto merges every present "
+        "in VS Code), pi (pi-agent sessions), openclaw (OpenClaw gateway sessions), "
+        "zaly (Zaly sessions), or all (merged); auto merges every present "
         "source (default: auto). Or just pass a file path -- e.g. `opentab requests.csv`",
     )
     parser.add_argument(
@@ -118,6 +120,12 @@ def parse_args() -> argparse.Namespace:
         help="OpenClaw gateway home holding agents/ and openclaw.json (for --source "
         "openclaw); honors $OPENCLAW_DIR, default ~/.openclaw",
     )
+    parser.add_argument(
+        "--zaly-dir",
+        default=_default_zaly_dir(),
+        help="Zaly data directory holding sessions/ (for --source zaly); honors "
+        "$ZALY_DATA and $ZALY_ROOT, default ~/.local/share/zaly",
+    )
     parser.add_argument(
         "--csv",
         default=None,

src/opentab/sources.py

@@ -18,6 +18,7 @@
 from opentab.stores.opencode import Store
 from opentab.stores.pi import PiStore
 from opentab.stores.vscode import VscodeStore
+from opentab.stores.zaly import ZalyStore, default_zaly_data_dir
 
 DEFAULT_CSV_PATH = os.path.expanduser("~/.config/opentab/requests.csv")
 DEFAULT_JSONL_PATH = os.path.expanduser("~/.config/opentab/requests.jsonl")
@@ -69,6 +70,14 @@ def _default_openclaw_dir() -> str:
     return env or os.path.expanduser("~/.openclaw")
 
 
+def _default_zaly_dir() -> str:
+    # Zaly's data dir (holding sessions/), resolved like zaly's own envPaths:
+    # $ZALY_DATA / $ZALY_ROOT/data / $XDG_DATA_HOME/zaly, default ~/.local/share/zaly
+    # (LOCALAPPDATA\\zaly\\Data on native Windows). Lives in the store module so the
+    # auth.json (state-dir) twin sits beside it.
+    return default_zaly_data_dir()
+
+
 # Which --flag each concrete source reads its path from (used to route a bare
 # positional path into the right slot).
 _PATH_SLOT = {
@@ -82,6 +91,7 @@ def _default_openclaw_dir() -> str:
     "vscode": "vscode_dir",
     "pi": "pi_dir",
     "openclaw": "openclaw_dir",
+    "zaly": "zaly_dir",
 }
 
 
@@ -164,6 +174,18 @@ def _openclaw_available(root_dir: str) -> bool:
     )
 
 
+def _zaly_available(root_dir: str) -> bool:
+    # Zaly sessions live at <data>/sessions/<encoded-workspace>/<uuid>/session.jsonl;
+    # check that precise shape (launching zaly writes settings-only files, but only under
+    # that layout) so an unrelated zaly-named directory never trips detection.
+    if not root_dir or not os.path.isdir(root_dir):
+        return False
+    return (
+        next(glob.iglob(os.path.join(root_dir, "sessions", "*", "*", "session.jsonl")), None)
+        is not None
+    )
+
+
 def _copilot_otel_available(args: argparse.Namespace) -> bool:
     # Copilot CLI usage lives only in its (opt-in) OTEL export: the export directory
     # holding *.jsonl, or the single file named by $COPILOT_OTEL_FILE_EXPORTER_PATH.
@@ -210,6 +232,7 @@ def _vscode_available(args: argparse.Namespace) -> bool:
     "vscode": "VS Code",
     "pi": "Pi",
     "openclaw": "OpenClaw",
+    "zaly": "Zaly",
     "all": "all",
 }
 
@@ -222,6 +245,7 @@ def _vscode_available(args: argparse.Namespace) -> bool:
     "Hermes": "hermes --resume",
     "Copilot": "copilot --resume",
     "Pi": "pi --session",
+    "Zaly": "zaly --session",
 }
 
 
@@ -242,6 +266,7 @@ def _detect_fingerprint(args: argparse.Namespace) -> tuple:
             "vscode_dir",
             "pi_dir",
             "openclaw_dir",
+            "zaly_dir",
         )
     ) + (os.environ.get("COPILOT_OTEL_FILE_EXPORTER_PATH", ""),)
 
@@ -277,6 +302,8 @@ def available_sources(args: argparse.Namespace) -> list[str]:
         keys.append("pi")
     if _openclaw_available(getattr(args, "openclaw_dir", "")):
         keys.append("openclaw")
+    if _zaly_available(getattr(args, "zaly_dir", "")):
+        keys.append("zaly")
     args._available_sources = (fp, keys)
     return list(keys)
 
@@ -389,6 +416,14 @@ def _build_store(args: argparse.Namespace, key: str) -> tuple[object, str]:
                 f"OpenClaw home holding agents/*/sessions/*.jsonl (looked in {args.openclaw_dir})."
             )
         return OpenClawStore(args.openclaw_dir, args), "OpenTab: loading OpenClaw sessions…\r"
+    if key == "zaly":
+        if not _zaly_available(getattr(args, "zaly_dir", "")):
+            raise SystemExit(
+                "No Zaly sessions found. Point --zaly-dir (or $ZALY_DATA) at a Zaly data "
+                "directory holding sessions/*/*/session.jsonl "
+                f"(looked in {getattr(args, 'zaly_dir', '')})."
+            )
+        return ZalyStore(args.zaly_dir, args), "OpenTab: loading Zaly sessions…\r"
     if not os.path.exists(args.db):
         raise SystemExit(f"OpenCode database not found: {args.db}")
     return Store(args.db, args), "OpenTab: loading OpenCode database…\r"