@thlinh/cc-statusline 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kamran Ahmed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,61 @@
+# cc-statusline
+
+Status line for Claude Code CLI. Works with Anthropic or Z.AI.
+
+![demo](./.github/demo.png)
+
+Shows your current model, context percentage, git branch, how long you've been working, and API usage depending on your provider.
+
+## Install
+
+```bash
+npx @thlinh/cc-statusline
+```
+
+This uses Anthropic by default and installs to `~/.claude`.
+
+For Z.AI:
+
+```bash
+npx @thlinh/cc-statusline --provider=zai --dir ~/.claude-z
+```
+
+For scripts or dotfiles (skip the prompts):
+
+```bash
+npx @thlinh/cc-statusline --provider=zai --dir ~/.claude-z
+```
+
+## Requirements
+
+- [jq](https://jqlang.github.io/jq/) — parses JSON
+- curl — fetches usage
+- git — branch info (optional)
+
+macOS: `brew install jq`
+
+## Providers
+
+**Anthropic** — pulls OAuth token from keychain, calls Anthropic's usage API, shows current/weekly/extra.
+
+**Z.AI** — reads token from `~/.chelper/config.yaml`, calls Z.AI's quota API, shows token and tool usage.
+
+## Uninstall
+
+```bash
+npx @thlinh/cc-statusline --uninstall --dir ~/.claude-z
+```
+
+Restores your backup if you had one, otherwise removes the files.
+
+## What gets installed
+
+Three files end up in your claude config directory:
+
+- `statusline.sh` — main script (generated when you run the installer)
+- `statusline-helpers.sh` — shared utilities
+- `statusline-provider.sh` — whichever provider you picked
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+
+// ANSI colors
+const blue = "\x1b[38;2;0;153;255m";
+const green = "\x1b[38;2;0;175;80m";
+const red = "\x1b[38;2;255;85;85m";
+const yellow = "\x1b[38;2;230;200;0m";
+const dim = "\x1b[2m";
+const reset = "\x1b[0m";
+
+function log(msg) {
+  console.log(`  ${msg}`);
+}
+
+function success(msg) {
+  console.log(`  ${green}✓${reset} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${yellow}!${reset} ${msg}`);
+}
+
+function fail(msg) {
+  console.error(`  ${red}✗${reset} ${msg}`);
+}
+
+// Parse command line arguments
+function parseArgs() {
+  const args = {};
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === "--uninstall") {
+      args.uninstall = true;
+    } else if (arg.startsWith("--dir=")) {
+      args.dir = arg.split("=")[1];
+    } else if (arg.startsWith("--provider=")) {
+      args.provider = arg.split("=")[1];
+    }
+  }
+  return args;
+}
+
+// Check required dependencies
+function checkDeps() {
+  const { execSync } = require("child_process");
+  const missing = [];
+
+  try {
+    execSync("which jq", { stdio: "ignore" });
+  } catch {
+    missing.push("jq");
+  }
+
+  try {
+    execSync("which curl", { stdio: "ignore" });
+  } catch {
+    missing.push("curl");
+  }
+
+  // Git is optional
+  let hasGit = false;
+  try {
+    execSync("which git", { stdio: "ignore" });
+    hasGit = true;
+  } catch {
+    // Git is optional
+  }
+
+  return { missing, hasGit };
+}
+
+// Prompt for provider selection
+function promptProvider() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(
+      `\n  ${blue}Which API provider are you using?${reset}\n    ${dim}1) Anthropic${reset}\n    ${dim}2) Z.AI${reset}\n  ${blue}>${reset} `,
+      (answer) => {
+        rl.close();
+        const choice = answer.trim();
+        if (choice === "1" || choice.toLowerCase().startsWith("a")) {
+          resolve("anthropic");
+        } else if (choice === "2" || choice.toLowerCase().startsWith("z")) {
+          resolve("zai");
+        } else {
+          warn("Invalid choice, defaulting to Anthropic");
+          resolve("anthropic");
+        }
+      }
+    );
+  });
+}
+
+// Get provider name (from flag or prompt)
+async function getProvider(args) {
+  if (args.provider) {
+    const provider = args.provider.toLowerCase();
+    if (provider === "anthropic" || provider === "zai") {
+      return provider;
+    }
+    warn(`Unknown provider "${args.provider}", defaulting to Anthropic`);
+    return "anthropic";
+  }
+  return await promptProvider();
+}
+
+// Uninstall function
+function uninstall(targetDir) {
+  const STATUSLINE_DEST = path.join(targetDir, "statusline.sh");
+  const HELPERS_DEST = path.join(targetDir, "statusline-helpers.sh");
+  const PROVIDER_DEST = path.join(targetDir, "statusline-provider.sh");
+  const CACHE_DEST = path.join(targetDir, "statusline-cache.json");
+  const SETTINGS_FILE = path.join(targetDir, "settings.json");
+  const BACKUP_DEST = STATUSLINE_DEST + ".bak";
+
+  console.log();
+  console.log(`  ${blue}Claude Line Uninstaller${reset}`);
+  console.log(`  ${dim}───────────────────────${reset}`);
+  console.log();
+
+  if (fs.existsSync(BACKUP_DEST)) {
+    // Restore from backup
+    fs.copyFileSync(BACKUP_DEST, STATUSLINE_DEST);
+    fs.unlinkSync(BACKUP_DEST);
+    success(`Restored backup from ${dim}statusline.sh.bak${reset}`);
+
+    // Only remove cache file (runtime-generated, always safe)
+    if (fs.existsSync(CACHE_DEST)) {
+      fs.unlinkSync(CACHE_DEST);
+      success(`Removed ${dim}statusline-cache.json${reset}`);
+    }
+
+    log(
+      `${dim}Note: Helper files (statusline-helpers.sh, statusline-provider.sh)${reset}`
+    );
+    log(
+      `${dim}      were preserved as they may belong to the restored backup.${reset}`
+    );
+    log(
+      `${dim}      Remove manually if not needed.${reset}`
+    );
+  } else if (fs.existsSync(STATUSLINE_DEST)) {
+    // No backup: remove all installed files
+    fs.unlinkSync(STATUSLINE_DEST);
+    success(`Removed ${dim}statusline.sh${reset}`);
+
+    if (fs.existsSync(HELPERS_DEST)) {
+      fs.unlinkSync(HELPERS_DEST);
+      success(`Removed ${dim}statusline-helpers.sh${reset}`);
+    }
+
+    if (fs.existsSync(PROVIDER_DEST)) {
+      fs.unlinkSync(PROVIDER_DEST);
+      success(`Removed ${dim}statusline-provider.sh${reset}`);
+    }
+
+    if (fs.existsSync(CACHE_DEST)) {
+      fs.unlinkSync(CACHE_DEST);
+      success(`Removed ${dim}statusline-cache.json${reset}`);
+    }
+  } else {
+    warn("No statusline found — nothing to remove");
+  }
+
+  // Remove statusLine from settings.json
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+      const expectedCommand = `bash "${targetDir}/statusline.sh"`;
+
+      if (
+        settings.statusLine &&
+        settings.statusLine.type === "command" &&
+        settings.statusLine.command === expectedCommand
+      ) {
+        delete settings.statusLine;
+        fs.writeFileSync(
+          SETTINGS_FILE,
+          JSON.stringify(settings, null, 2) + "\n"
+        );
+        success(`Removed statusLine from ${dim}settings.json${reset}`);
+      }
+    } catch (err) {
+      fail(`Could not parse ${SETTINGS_FILE} — ${err.message}`);
+    }
+  }
+
+  console.log();
+  log(`${green}Done!${reset} Restart Claude Code to apply changes.`);
+  console.log();
+}
+
+// Generate statusline.sh content
+function generateStatuslineScript(provider) {
+  const providerName = provider === "anthropic" ? "Anthropic" : "Z.AI";
+
+  return `#!/bin/bash
+set -f
+
+# Generated by cc-statusline installer
+# Provider: ${providerName}
+# DO NOT EDIT THIS FILE DIRECTLY - it will be overwritten on reinstall
+
+input=$(cat)
+
+if [ -z "$input" ]; then
+    printf "Claude"
+    exit 0
+fi
+
+# Self-locate script directory
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+
+# Source shared helpers
+. "\${SCRIPT_DIR}/statusline-helpers.sh"
+
+# Source provider implementation
+. "\${SCRIPT_DIR}/statusline-provider.sh"
+
+# ── Extract JSON data ───────────────────────────────────
+model_name=$(echo "$input" | jq -r '.model.display_name // "Claude"')
+
+size=$(echo "$input" | jq -r '.context_window.context_window_size // 200000')
+[ "$size" -eq 0 ] 2>/dev/null && size=200000
+
+input_tokens=$(echo "$input" | jq -r '.context_window.current_usage.input_tokens // 0')
+cache_create=$(echo "$input" | jq -r '.context_window.current_usage.cache_creation_input_tokens // 0')
+cache_read=$(echo "$input" | jq -r '.context_window.current_usage.cache_read_input_tokens // 0')
+current=$(( input_tokens + cache_create + cache_read ))
+
+used_tokens=$(format_tokens $current)
+total_tokens=$(format_tokens $size)
+
+if [ "$size" -gt 0 ]; then
+    pct_used=$(( current * 100 / size ))
+else
+    pct_used=0
+fi
+
+effort="default"
+settings_path="\${SCRIPT_DIR}/settings.json"
+if [ -f "$settings_path" ]; then
+    effort=$(jq -r '.effortLevel // "default"' "$settings_path" 2>/dev/null)
+fi
+
+# ── LINE 1: Model │ Context % │ Directory (branch) │ Session │ Effort ──
+sep=" \${dim}│\${reset} "
+pct_color=$(color_for_pct "$pct_used")
+cwd=$(echo "$input" | jq -r '.cwd // ""')
+[ -z "$cwd" ] || [ "$cwd" = "null" ] && cwd=$(pwd)
+dirname=$(basename "$cwd")
+
+git_branch=""
+git_dirty=""
+if command -v git >/dev/null 2>&1 && git -C "$cwd" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    git_branch=$(git -C "$cwd" symbolic-ref --short HEAD 2>/dev/null)
+    if [ -n "$(git -C "$cwd" --no-optional-locks status --porcelain 2>/dev/null)" ]; then
+        git_dirty="*"
+    fi
+fi
+
+session_duration=""
+session_start=$(echo "$input" | jq -r '.session.start_time // empty')
+if [ -n "$session_start" ] && [ "$session_start" != "null" ]; then
+    start_epoch=$(iso_to_epoch "$session_start")
+    if [ -n "$start_epoch" ]; then
+        now_epoch=$(date +%s)
+        elapsed=$(( now_epoch - start_epoch ))
+        if [ "$elapsed" -ge 3600 ]; then
+            session_duration="$(( elapsed / 3600 ))h$(( (elapsed % 3600) / 60 ))m"
+        elif [ "$elapsed" -ge 60 ]; then
+            session_duration="$(( elapsed / 60 ))m"
+        else
+            session_duration="\${elapsed}s"
+        fi
+    fi
+fi
+
+line1="\${blue}\${model_name}\${reset}"
+line1+="\${sep}"
+line1+="🧠 \${pct_color}\${pct_used}%${reset}"
+line1+="\${sep}"
+line1+="\${cyan}\${dirname}\${reset}"
+if [ -n "$git_branch" ]; then
+    line1+=" \${green}(\${git_branch}\${red}\${git_dirty}\${green})\${reset}"
+fi
+if [ -n "$session_duration" ]; then
+    line1+="\${sep}"
+    line1+="\${dim}⏱ \${reset}\${white}\${session_duration}\${reset}"
+fi
+line1+="\${sep}"
+case "$effort" in
+    high)   line1+="\${magenta}● \${effort}\${reset}" ;;
+    medium) line1+="\${dim}◑ \${effort}\${reset}" ;;
+    low)    line1+="\${dim}◔ \${effort}\${reset}" ;;
+    *)      line1+="\${dim}◑ \${effort}\${reset}" ;;
+esac
+
+# ── Fetch provider usage data (cached) ──────────────────
+cache_file="\${SCRIPT_DIR}/statusline-cache.json"
+cache_max_age=60
+needs_refresh=true
+usage_data=""
+
+if [ -f "$cache_file" ]; then
+    cache_mtime=$(stat -c %Y "$cache_file" 2>/dev/null || stat -f %m "$cache_file" 2>/dev/null)
+    now=$(date +%s)
+    cache_age=$(( now - cache_mtime ))
+    if [ "$cache_age" -lt "$cache_max_age" ]; then
+        # Check if cached provider matches current provider
+        cached_provider=$(jq -r '.provider // empty' "$cache_file" 2>/dev/null)
+        if [ "$cached_provider" = "${provider}" ]; then
+            needs_refresh=false
+            usage_data=$(cat "$cache_file" 2>/dev/null | jq -r '.data // empty')
+        fi
+    fi
+fi
+
+if $needs_refresh; then
+    token=$(get_provider_token)
+    if [ -n "$token" ] && [ "$token" != "null" ]; then
+        response=$(fetch_usage_data "$token")
+        if [ -n "$response" ]; then
+            usage_data="$response"
+            echo '{"provider": "${provider}", "fetched_at": '$(date +%s)', "data": '$(echo "$response" | jq -c .)'}' > "$cache_file"
+        fi
+    fi
+    if [ -z "$usage_data" ] && [ -f "$cache_file" ]; then
+        usage_data=$(cat "$cache_file" 2>/dev/null | jq -r '.data // empty')
+    fi
+fi
+
+# ── Provider usage lines ─────────────────────────────────
+rate_lines=""
+if [ -n "$usage_data" ] && echo "$usage_data" | jq -e . >/dev/null 2>&1; then
+    rate_lines=$(format_usage_lines "$usage_data")
+fi
+
+# ── Output ──────────────────────────────────────────────
+printf "%b" "$line1"
+[ -n "$rate_lines" ] && printf "\\n\\n%b" "$rate_lines"
+
+exit 0
+`;
+}
+
+// Main install function
+async function run() {
+  const args = parseArgs();
+
+  // Default directory
+  const targetDir = args.dir || path.join(os.homedir(), ".claude");
+
+  // Uninstall mode
+  if (args.uninstall) {
+    uninstall(targetDir);
+    return;
+  }
+
+  // Install mode
+  console.log();
+  console.log(`  ${blue}Claude Line Installer${reset}`);
+  console.log(`  ${dim}─────────────────────${reset}`);
+  console.log();
+
+  // Check dependencies
+  const { missing, hasGit } = checkDeps();
+  if (missing.length > 0) {
+    fail(`Missing required dependencies: ${missing.join(", ")}`);
+    log(`  Install them and try again.`);
+    if (missing.includes("jq")) {
+      log(`  ${dim}brew install jq${reset}`);
+    }
+    process.exit(1);
+  }
+  success("Dependencies found (jq, curl)");
+
+  if (!hasGit) {
+    warn("git not found - branch display will be disabled");
+  }
+
+  // Get provider
+  const provider = await getProvider(args);
+  const providerName = provider === "anthropic" ? "Anthropic" : "Z.AI";
+  success(`Installing for ${providerName}`);
+
+  // Create target directory if needed
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    success(`Created ${targetDir}`);
+  }
+
+  // File paths
+  const STATUSLINE_DEST = path.join(targetDir, "statusline.sh");
+  const HELPERS_DEST = path.join(targetDir, "statusline-helpers.sh");
+  const PROVIDER_DEST = path.join(targetDir, "statusline-provider.sh");
+  const SETTINGS_FILE = path.join(targetDir, "settings.json");
+  const BACKUP_DEST = STATUSLINE_DEST + ".bak";
+
+  // Source files
+  const HELPERS_SRC = path.resolve(__dirname, "shared-helpers.sh");
+  const PROVIDER_SRC = path.resolve(__dirname, "providers", `${provider}.sh`);
+
+  // Check source files exist
+  if (!fs.existsSync(HELPERS_SRC)) {
+    fail(`Source file not found: ${HELPERS_SRC}`);
+    process.exit(1);
+  }
+  if (!fs.existsSync(PROVIDER_SRC)) {
+    fail(`Source file not found: ${PROVIDER_SRC}`);
+    process.exit(1);
+  }
+
+  // Backup existing statusline.sh
+  if (fs.existsSync(STATUSLINE_DEST)) {
+    fs.copyFileSync(STATUSLINE_DEST, BACKUP_DEST);
+    warn(`Backed up existing statusline to ${dim}statusline.sh.bak${reset}`);
+  }
+
+  // Copy shared helpers
+  fs.copyFileSync(HELPERS_SRC, HELPERS_DEST);
+  fs.chmodSync(HELPERS_DEST, 0o644);
+  success(`Installed helpers to ${dim}${HELPERS_DEST}${reset}`);
+
+  // Copy provider script
+  fs.copyFileSync(PROVIDER_SRC, PROVIDER_DEST);
+  fs.chmodSync(PROVIDER_DEST, 0o644);
+  success(
+    `Installed ${providerName} provider to ${dim}${PROVIDER_DEST}${reset}`
+  );
+
+  // Generate and write statusline.sh
+  const statuslineContent = generateStatuslineScript(provider);
+  fs.writeFileSync(STATUSLINE_DEST, statuslineContent);
+  fs.chmodSync(STATUSLINE_DEST, 0o755);
+  success(`Installed statusline to ${dim}${STATUSLINE_DEST}${reset}`);
+
+  // Update settings.json
+  let settings = {};
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+    } catch {
+      fail(`Could not parse ${SETTINGS_FILE} — fix it manually`);
+      process.exit(1);
+    }
+  }
+
+  const statusLineConfig = {
+    type: "command",
+    command: `bash "${targetDir}/statusline.sh"`,
+  };
+
+  if (
+    settings.statusLine &&
+    settings.statusLine.type === "command" &&
+    settings.statusLine.command === statusLineConfig.command
+  ) {
+    success("Settings already configured");
+  } else {
+    settings.statusLine = statusLineConfig;
+    fs.writeFileSync(
+      SETTINGS_FILE,
+      JSON.stringify(settings, null, 2) + "\n"
+    );
+    success(`Updated ${dim}settings.json${reset} with statusLine config`);
+  }
+
+  console.log();
+  log(
+    `${green}Done!${reset} Restart Claude Code to see your new status line.`
+  );
+  console.log();
+  log(`${dim}Provider: ${providerName}${reset}`);
+  console.log();
+}
+
+run().catch((err) => {
+  fail(err.message);
+  process.exit(1);
+});

package/bin/providers/anthropic.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# Anthropic provider for cc-statusline
+# Implements: get_provider_token, fetch_usage_data, format_usage_lines
+
+# ── Get Anthropic OAuth token ─────────────────────────────
+get_provider_token() {
+    local token=""
+
+    # Check environment variable first
+    if [ -n "$CLAUDE_CODE_OAUTH_TOKEN" ]; then
+        echo "$CLAUDE_CODE_OAUTH_TOKEN"
+        return 0
+    fi
+
+    # Check macOS keychain
+    if command -v security >/dev/null 2>&1; then
+        local blob
+        blob=$(security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null)
+        if [ -n "$blob" ]; then
+            token=$(echo "$blob" | jq -r '.claudeAiOauth.accessToken // empty' 2>/dev/null)
+            if [ -n "$token" ] && [ "$token" != "null" ]; then
+                echo "$token"
+                return 0
+            fi
+        fi
+    fi
+
+    # Check credentials file
+    local creds_file="${HOME}/.claude/.credentials.json"
+    if [ -f "$creds_file" ]; then
+        token=$(jq -r '.claudeAiOauth.accessToken // empty' "$creds_file" 2>/dev/null)
+        if [ -n "$token" ] && [ "$token" != "null" ]; then
+            echo "$token"
+            return 0
+        fi
+    fi
+
+    # Check Linux secret-tool
+    if command -v secret-tool >/dev/null 2>&1; then
+        local blob
+        blob=$(timeout 2 secret-tool lookup service "Claude Code-credentials" 2>/dev/null)
+        if [ -n "$blob" ]; then
+            token=$(echo "$blob" | jq -r '.claudeAiOauth.accessToken // empty' 2>/dev/null)
+            if [ -n "$token" ] && [ "$token" != "null" ]; then
+                echo "$token"
+                return 0
+            fi
+        fi
+    fi
+
+    echo ""
+}
+
+# ── Fetch Anthropic usage data ────────────────────────────
+fetch_usage_data() {
+    local token="$1"
+    [ -z "$token" ] && return 1
+
+    local response
+    response=$(curl -s --max-time 5 \
+        -H "Accept: application/json" \
+        -H "Content-Type: application/json" \
+        -H "Authorization: Bearer $token" \
+        -H "anthropic-beta: oauth-2025-04-20" \
+        -H "User-Agent: claude-code/2.1.34" \
+        "https://api.anthropic.com/api/oauth/usage" 2>/dev/null)
+
+    if [ -n "$response" ] && echo "$response" | jq -e '.five_hour' >/dev/null 2>&1; then
+        echo "$response"
+        return 0
+    fi
+
+    return 1
+}
+
+# ── Format Anthropic usage lines ──────────────────────────
+format_usage_lines() {
+    local usage_data="$1"
+    [ -z "$usage_data" ] && return
+
+    local bar_width=10
+    local rate_lines=""
+
+    # Five hour (current) usage
+    local five_hour_pct five_hour_reset_iso five_hour_reset five_hour_bar five_hour_pct_color five_hour_pct_fmt
+    five_hour_pct=$(echo "$usage_data" | jq -r '.five_hour.utilization // 0' | awk '{printf "%.0f", $1}')
+    five_hour_reset_iso=$(echo "$usage_data" | jq -r '.five_hour.resets_at // empty')
+    five_hour_reset=$(format_reset_time "$five_hour_reset_iso" "time")
+    five_hour_bar=$(build_bar "$five_hour_pct" "$bar_width")
+    five_hour_pct_color=$(color_for_pct "$five_hour_pct")
+    five_hour_pct_fmt=$(printf "%3d" "$five_hour_pct")
+
+    rate_lines+="${white}current${reset} ${five_hour_bar} ${five_hour_pct_color}${five_hour_pct_fmt}%${reset} ${dim}⟳${reset} ${white}${five_hour_reset}${reset}"
+
+    # Seven day (weekly) usage
+    local seven_day_pct seven_day_reset_iso seven_day_reset seven_day_bar seven_day_pct_color seven_day_pct_fmt
+    seven_day_pct=$(echo "$usage_data" | jq -r '.seven_day.utilization // 0' | awk '{printf "%.0f", $1}')
+    seven_day_reset_iso=$(echo "$usage_data" | jq -r '.seven_day.resets_at // empty')
+    seven_day_reset=$(format_reset_time "$seven_day_reset_iso" "datetime")
+    seven_day_bar=$(build_bar "$seven_day_pct" "$bar_width")
+    seven_day_pct_color=$(color_for_pct "$seven_day_pct")
+    seven_day_pct_fmt=$(printf "%3d" "$seven_day_pct")
+
+    rate_lines+="\n${white}weekly${reset}  ${seven_day_bar} ${seven_day_pct_color}${seven_day_pct_fmt}%${reset} ${dim}⟳${reset} ${white}${seven_day_reset}${reset}"
+
+    # Extra usage (monthly credits) - if enabled
+    local extra_enabled extra_pct extra_used extra_limit extra_bar extra_pct_color extra_reset extra_col
+    extra_enabled=$(echo "$usage_data" | jq -r '.extra_usage.is_enabled // false')
+    if [ "$extra_enabled" = "true" ]; then
+        extra_pct=$(echo "$usage_data" | jq -r '.extra_usage.utilization // 0' | awk '{printf "%.0f", $1}')
+        extra_used=$(echo "$usage_data" | jq -r '.extra_usage.used_credits // 0' | awk '{printf "%.2f", $1/100}')
+        extra_limit=$(echo "$usage_data" | jq -r '.extra_usage.monthly_limit // 0' | awk '{printf "%.2f", $1/100}')
+        extra_bar=$(build_bar "$extra_pct" "$bar_width")
+        extra_pct_color=$(color_for_pct "$extra_pct")
+
+        # Calculate next month reset
+        extra_reset=$(date -v+1m -v1d +"%b %-d" 2>/dev/null | tr '[:upper:]' '[:lower:]')
+        if [ -z "$extra_reset" ]; then
+            extra_reset=$(date -d "$(date +%Y-%m-01) +1 month" +"%b %-d" 2>/dev/null | tr '[:upper:]' '[:lower:]')
+        fi
+
+        extra_col="${white}extra${reset}   ${extra_bar} ${extra_pct_color}\$${extra_used}${dim}/${reset}${white}\$${extra_limit}${reset} ${dim}⟳${reset} ${white}${extra_reset}${reset}"
+        rate_lines+="\n${extra_col}"
+    fi
+
+    printf "%b" "$rate_lines"
+}

package/bin/providers/zai.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# Z.AI provider for cc-statusline
+# Implements: get_provider_token, fetch_usage_data, format_usage_lines
+
+# ── Get Z.AI API token from config.yaml ───────────────────
+get_provider_token() {
+    local config_file="${HOME}/.chelper/config.yaml"
+    [ ! -f "$config_file" ] && echo "" && return 1
+
+    # Extract api_key using basic string parsing (no yaml parser dependency)
+    local token
+    token=$(grep "^api_key:" "$config_file" | sed 's/^api_key:[[:space:]]*//' | tr -d '[:space:]"'"'')
+
+    if [ -n "$token" ]; then
+        echo "$token"
+        return 0
+    fi
+
+    echo ""
+    return 1
+}
+
+# ── Fetch Z.AI usage data ──────────────────────────────────
+fetch_usage_data() {
+    local token="$1"
+    [ -z "$token" ] && return 1
+
+    local response
+    response=$(curl -s --max-time 5 \
+        -H "Accept: application/json" \
+        -H "Content-Type: application/json" \
+        -H "Authorization: Bearer $token" \
+        "https://api.z.ai/api/monitor/usage/quota/limit" 2>/dev/null)
+
+    if [ -n "$response" ] && echo "$response" | jq -e '.data' >/dev/null 2>&1; then
+        echo "$response"
+        return 0
+    fi
+
+    return 1
+}
+
+# ── Format Z.AI usage lines ────────────────────────────────
+format_usage_lines() {
+    local usage_data="$1"
+    [ -z "$usage_data" ] && return
+
+    local bar_width=10
+    local rate_lines=""
+
+    # TOKENS_LIMIT (current)
+    local tokens_used tokens_limit tokens_pct tokens_reset_iso tokens_reset tokens_bar tokens_pct_color tokens_pct_fmt tokens_display
+    tokens_used=$(echo "$usage_data" | jq -r '.data.TOKENS_LIMIT.used // 0')
+    tokens_limit=$(echo "$usage_data" | jq -r '.data.TOKENS_LIMIT.limit // 1')
+    tokens_reset_iso=$(echo "$usage_data" | jq -r '.data.TOKENS_LIMIT.reset_time // empty')
+
+    if [ "$tokens_limit" -gt 0 ]; then
+        tokens_pct=$(( tokens_used * 100 / tokens_limit ))
+    else
+        tokens_pct=0
+    fi
+
+    tokens_reset=$(format_reset_time "$tokens_reset_iso" "time")
+    tokens_bar=$(build_bar "$tokens_pct" "$bar_width")
+    tokens_pct_color=$(color_for_pct "$tokens_pct")
+    tokens_pct_fmt=$(printf "%3d" "$tokens_pct")
+    tokens_display=$(format_tokens "$tokens_used")
+
+    rate_lines+="${white}current${reset} ${tokens_bar} ${tokens_pct_color}${tokens_pct_fmt}%${reset} ${dim}(${reset}${white}${tokens_display}${reset}${dim})${reset} ${dim}⟳${reset} ${white}${tokens_reset}${reset}"
+
+    # TIME_LIMIT (tools/MCP) - no reset time shown
+    local time_used time_limit time_pct time_bar time_pct_color time_pct_fmt time_seconds
+    time_used=$(echo "$usage_data" | jq -r '.data.TIME_LIMIT.used // 0')
+    time_limit=$(echo "$usage_data" | jq -r '.data.TIME_LIMIT.limit // 1')
+
+    if [ "$time_limit" -gt 0 ]; then
+        time_pct=$(( time_used * 100 / time_limit ))
+    else
+        time_pct=0
+    fi
+
+    time_bar=$(build_bar "$time_pct" "$bar_width")
+    time_pct_color=$(color_for_pct "$time_pct")
+    time_pct_fmt=$(printf "%3d" "$time_pct")
+
+    # Convert seconds to readable format
+    if [ "$time_used" -ge 3600 ]; then
+        time_seconds="$(( time_used / 3600 ))h$(( (time_used % 3600) / 60 ))m"
+    elif [ "$time_used" -ge 60 ]; then
+        time_seconds="$(( time_used / 60 ))m"
+    else
+        time_seconds="${time_used}s"
+    fi
+
+    rate_lines+="\n${white}tools${reset}   ${time_bar} ${time_pct_color}${time_pct_fmt}%${reset} ${dim}(${reset}${white}${time_seconds}${reset}${dim})${reset}"
+
+    printf "%b" "$rate_lines"
+}

package/bin/shared-helpers.sh

@@ -0,0 +1,117 @@
+#!/bin/bash
+# Shared helper functions for cc-statusline
+# This file is copied to ~/.claude/ or ~/.claude-z/ at install time
+
+# ── Colors ──────────────────────────────────────────────
+blue='\033[38;2;0;153;255m'
+orange='\033[38;2;255;176;85m'
+green='\033[38;2;0;175;80m'
+cyan='\033[38;2;86;182;194m'
+red='\033[38;2;255;85;85m'
+yellow='\033[38;2;230;200;0m'
+white='\033[38;2;220;220;220m'
+magenta='\033[38;2;180;140;255m'
+dim='\033[2m'
+reset='\033[0m'
+
+# ── Format token counts ───────────────────────────────────
+format_tokens() {
+    local num=$1
+    if [ "$num" -ge 1000000 ]; then
+        awk "BEGIN {printf \"%.1fm\", $num / 1000000}"
+    elif [ "$num" -ge 1000 ]; then
+        awk "BEGIN {printf \"%.0fk\", $num / 1000}"
+    else
+        printf "%d" "$num"
+    fi
+}
+
+# ── Get color based on percentage ─────────────────────────
+color_for_pct() {
+    local pct=$1
+    if [ "$pct" -ge 90 ]; then printf "$red"
+    elif [ "$pct" -ge 70 ]; then printf "$yellow"
+    elif [ "$pct" -ge 50 ]; then printf "$orange"
+    else printf "$green"
+    fi
+}
+
+# ── Build visual bar ─────────────────────────────────────
+build_bar() {
+    local pct=$1
+    local width=$2
+    [ "$pct" -lt 0 ] 2>/dev/null && pct=0
+    [ "$pct" -gt 100 ] 2>/dev/null && pct=100
+
+    local filled=$(( pct * width / 100 ))
+    local empty=$(( width - filled ))
+    local bar_color
+    bar_color=$(color_for_pct "$pct")
+
+    local filled_str="" empty_str=""
+    for ((i=0; i<filled; i++)); do filled_str+="●"; done
+    for ((i=0; i<empty; i++)); do empty_str+="○"; done
+
+    printf "${bar_color}${filled_str}${dim}${empty_str}${reset}"
+}
+
+# ── Convert ISO 8601 to epoch (cross-platform) ───────────
+iso_to_epoch() {
+    local iso_str="$1"
+
+    local epoch
+    # Try GNU date first (Linux)
+    epoch=$(date -d "${iso_str}" +%s 2>/dev/null)
+    if [ -n "$epoch" ]; then
+        echo "$epoch"
+        return 0
+    fi
+
+    # Strip milliseconds and timezone for macOS date
+    local stripped="${iso_str%%.*}"
+    stripped="${stripped%%Z}"
+    stripped="${stripped%%+*}"
+    stripped="${stripped%%-[0-9][0-9]:[0-9][0-9]}"
+
+    # Try macOS date with timezone handling
+    if [[ "$iso_str" == *"Z"* ]] || [[ "$iso_str" == *"+00:00"* ]] || [[ "$iso_str" == *"-00:00"* ]]; then
+        epoch=$(env TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%S" "$stripped" +%s 2>/dev/null)
+    else
+        epoch=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$stripped" +%s 2>/dev/null)
+    fi
+
+    if [ -n "$epoch" ]; then
+        echo "$epoch"
+        return 0
+    fi
+
+    return 1
+}
+
+# ── Format reset times ───────────────────────────────────
+format_reset_time() {
+    local iso_str="$1"
+    local style="$2"
+    [ -z "$iso_str" ] || [ "$iso_str" = "null" ] && return
+
+    local epoch
+    epoch=$(iso_to_epoch "$iso_str")
+    [ -z "$epoch" ] && return
+
+    local result=""
+    case "$style" in
+        time)
+            result=$(date -j -r "$epoch" +"%l:%M%p" 2>/dev/null | sed 's/^ //; s/\.//g' | tr '[:upper:]' '[:lower:]')
+            [ -z "$result" ] && result=$(date -d "@$epoch" +"%l:%M%P" 2>/dev/null | sed 's/^ //; s/\.//g')
+            ;;
+        datetime)
+            result=$(date -j -r "$epoch" +"%b %-d, %l:%M%p" 2>/dev/null | sed 's/  / /g; s/^ //; s/\.//g' | tr '[:upper:]' '[:lower:]')
+            [ -z "$result" ] && result=$(date -d "@$epoch" +"%b %-d, %l:%M%P" 2>/dev/null | sed 's/  / /g; s/^ //; s/\.//g')
+            ;;
+        *)
+            result=$(date -j -r "$epoch" +"%b %-d" 2>/dev/null | tr '[:upper:]' '[:lower:]')
+            [ -z "$result" ] && result=$(date -d "@$epoch" +"%b %-d" 2>/dev/null)
+            ;;
+    esac
+    printf "%s" "$result"
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@thlinh/cc-statusline",
+  "version": "2.0.0",
+  "description": "Multi-provider status line for Claude Code CLI supporting Anthropic and Z.AI APIs",
+  "bin": {
+    "cc-statusline": "./bin/install.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "cli",
+    "anthropic",
+    "zai",
+    "multi-provider"
+  ],
+  "license": "MIT",
+  "author": "Linh Truong",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thlinhit/cc-statusline.git"
+  }
+}