ಬಳಕೆಯ ಮಿತಿಗಳು

ccam usage ಪ್ರತಿ ಖಾತೆಯು 5 ಗಂಟೆಯ ಮತ್ತು ವಾರದ ಮಿತಿಗಳಲ್ಲಿ ಎಷ್ಟನ್ನು ಬಳಸಿದೆ ಎಂಬುದನ್ನು, ಪ್ರತಿ ಅವಧಿ ರೀಸೆಟ್ ಆಗಲು ಉಳಿದ ಸಮಯದೊಂದಿಗೆ ತೋರಿಸುತ್ತದೆ. ದೀರ್ಘ ಕೆಲಸವನ್ನು ಆರಂಭಿಸುವ ಮೊದಲು, ಅಥವಾ ಮಿತಿ ಹತ್ತಿರವಾಗಿದೆ ಎಂದು Claude Code ಹೇಳಿದಾಗ, ಯಾವ ಖಾತೆಯಲ್ಲಿ ಇನ್ನೂ ಅವಕಾಶ ಇದೆ ಎಂದು ನೋಡಲು ಇದನ್ನು ಬಳಸಿ. ccam statusline ಎಂಬುದು Claude Code ಗಾಗಿ ಸ್ಟೇಟಸ್ ಲೈನ್ ಕಮಾಂಡ್: ಇದು Claude Code ಒಳಗೆ ಖಾತೆಯ ಹೆಸರು ಮತ್ತು ಬಳಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು ccam usage ಗಾಗಿ ಉಳಿಸುತ್ತದೆ.

ಬಳಕೆ

ccam usage                  # every account, once
ccam u                      # the same, shorter
ccam usage --watch          # redraw every 60 seconds until Ctrl+C
ccam usage --watch=10       # redraw every 10 seconds
ccam usage -v               # add per-model weekly limits and the data source
ccam usage --json           # machine-readable, one object per account
ccam usage --source cache   # saved numbers only, no network
ccam usage --refresh        # also renew expired logins of accounts not running
ccam statusline install     # set the status line in every account's settings.json

$ ccam usage
 Account     5-hour        Resets    Weekly        Resets    As of
 1 personal  ░░░░░░░░   0% -         ██████░░  70% 2d 16h    9h 36m ago (cached)
 2 work      ██░░░░░░  24% 2h 29m    ███░░░░░  41% 3d 11h    just now (cached)
 3 side      login expired, run `ccam side` once to refresh
→ Most headroom: personal   (open it with ccam next --auto)

ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಪಟ್ಟಿ ತಕ್ಷಣ ಕಾಣಿಸುತ್ತದೆ, ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ fetching… ಇರುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿ ಖಾತೆ ಉತ್ತರಿಸಿದಂತೆ ಅದರ ಸಾಲನ್ನು ಮತ್ತೆ ಬರೆಯಲಾಗುತ್ತದೆ. As of ಸಂಖ್ಯೆಗಳು ಎಷ್ಟು ಹಳೆಯವು ಎಂದು ಹೇಳುತ್ತದೆ; (cached) ಎಂದರೆ ಅವು ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಿಂದಲ್ಲ, ಉಳಿಸಿದ ಫೈಲ್‌ನಿಂದ ಬಂದಿವೆ. ಕೊನೆಯ ಸಾಲು 100% ಕ್ಕಿಂತ ಕಡಿಮೆ ಇರುವ, ಅತಿ ಕಡಿಮೆ 5 ಗಂಟೆಯ ಬಳಕೆಯ ಖಾತೆಯನ್ನು ಹೆಸರಿಸುತ್ತದೆ, ಮತ್ತು ನಿಮಗೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಖಾತೆಗಳಿದ್ದಾಗ ಮಾತ್ರ ಕಾಣಿಸುತ್ತದೆ. ಲಾಗಿನ್ ಆಗದ ಖಾತೆ not logged in → ccam login <name> ಎಂದು ತೋರಿಸುತ್ತದೆ, ಮತ್ತು API ಕೀ ಖಾತೆ no limits (API) ಎಂದು ತೋರಿಸುತ್ತದೆ.

ccam statusline install ನಂತರ, Claude Code [work] · Opus · 5h 24% · 7d 41% ನಂತಹ ಸಾಲನ್ನು ತೋರಿಸುತ್ತದೆ.

ಆಯ್ಕೆಗಳು

ಬೇರೆ ಯಾವುದೇ --source ಮೌಲ್ಯ --source must be live or cache ಎಂದು ವಿಫಲವಾಗುತ್ತದೆ. ccam usage ಯಾವುದೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.

ccam statusline Claude Code ನ ಸ್ಟೇಟಸ್ ಲೈನ್ JSON ಅನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇನ್‌ಪುಟ್‌ನಿಂದ ಓದುತ್ತದೆ. ಅದರ ಏಕೈಕ ಆಯ್ಕೆ --wrap <command>: ಈಗಿರುವ ಸ್ಟೇಟಸ್ ಲೈನ್ ಕಮಾಂಡ್, ಅದರ ಔಟ್‌ಪುಟ್‌ನ ಮೊದಲ ಸಾಲಿನ ಮುಂದೆ ಖಾತೆಯ ಹೆಸರು ಸೇರುತ್ತದೆ. ccam statusline install ಯಾವುದೇ ಆಯ್ಕೆ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಎರಡೂ --dry-run ಅನ್ನು --dry-run is not supported by `ccam statusline`; nothing was changed ಎಂದು ನಿರಾಕರಿಸುತ್ತವೆ.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಸಂಖ್ಯೆಗಳು ಎರಡು ಕಡೆಯಿಂದ ಬರುತ್ತವೆ: ಪ್ರತಿ ಖಾತೆಯ ಸ್ವಂತ ಲಾಗಿನ್‌ನೊಂದಿಗೆ ಕರೆಯಲಾಗುವ Anthropic ನ ದಾಖಲಾಗದ ಬಳಕೆಯ ಎಂಡ್‌ಪಾಯಿಂಟ್ GET https://api.anthropic.com/api/oauth/usage, ಮತ್ತು Claude Code ತನ್ನ ಸ್ಟೇಟಸ್ ಲೈನ್ ಕಮಾಂಡ್‌ಗೆ ನೀಡುವ ಮೌಲ್ಯಗಳು. ಇದೆಲ್ಲವೂ internal/usage ನಲ್ಲಿದೆ.

1. cli.usageCmd config.toml ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಖಾತೆಗೆ ಒಂದು usage.Account ರಚಿಸುತ್ತದೆ: ಅದರ ಫೋಲ್ಡರ್ ~/.local/share/ccam/profiles/<name>/, ಅದರ ಸೆಷನ್ ಫೋಲ್ಡರ್ (ಅದು ಚಾಲನೆಯಲ್ಲಿದೆಯೇ ಎಂದು ನೋಡಲು) ಮತ್ತು ಅದನ್ನು ಇದ್ದಲ್ಲೇ ಇಂಪೋರ್ಟ್ ಮಾಡಲಾಗಿದೆಯೇ ಎಂಬುದು.
2. Fetcher.FetchAll ಪ್ರತಿ ಖಾತೆಗೆ ಒಂದು goroutine ಆರಂಭಿಸುತ್ತದೆ. ಎಲ್ಲವೂ ಒಂದೇ http.Client ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ, ಹೀಗಾಗಿ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ ಸಂಪರ್ಕಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಲಾಗುತ್ತದೆ. ಸಂಪರ್ಕಕ್ಕೆ 2 s ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ಪ್ರತಿ ಖಾತೆಗೆ ಒಟ್ಟು 3 s ಸಿಗುತ್ತದೆ. ಕ್ಲೈಂಟ್ ರೀಡೈರೆಕ್ಟ್‌ಗಳನ್ನು ಅನುಸರಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ರೀಡೈರೆಕ್ಟ್ ಟೋಕನ್ ಅನ್ನು ಬೇರೆಡೆಗೆ ಮತ್ತೆ ಕಳುಹಿಸುತ್ತದೆ, ಮತ್ತು ಉತ್ತರದ ಗರಿಷ್ಠ 1 MB ಅನ್ನು ಮಾತ್ರ ಓದುತ್ತದೆ.
3. ಪ್ರತಿ ಖಾತೆ ಮುಗಿದಂತೆ ಅದರ ಸಾಲನ್ನು ಮತ್ತೆ ಬರೆಯಲಾಗುತ್ತದೆ. ವಿಫಲವಾದ ಅಥವಾ ಸಮಯಕ್ಕೆ ಉತ್ತರಿಸದ ಖಾತೆ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳಿಗೆ ಮರಳುತ್ತದೆ, ಹೀಗಾಗಿ ಒಂದು ನಿಧಾನ ಖಾತೆ ಇತರವನ್ನು ಎಂದಿಗೂ ತಡೆಯುವುದಿಲ್ಲ.

ಪ್ರತಿ ಖಾತೆ ತನ್ನದೇ goroutine ನಲ್ಲಿ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಕೇಳುತ್ತದೆ; ಸಮಯ ಮೀರಿದ ಖಾತೆ ಬದಲಿಗೆ ತನ್ನ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

personal ಮತ್ತು work ಸಮಯಕ್ಕೆ ಉತ್ತರಿಸುತ್ತವೆ ಮತ್ತು ನೇರ ಸಂಖ್ಯೆಗಳನ್ನು ತೋರಿಸುತ್ತವೆ. side 3 s ಗಿಂತ ಹೆಚ್ಚು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಹೀಗಾಗಿ fallback() ಅದರ ಎರಡು ಕ್ಯಾಶ್ ಫೈಲ್‌ಗಳನ್ನು ಓದಿ ಕೊನೆಯದಾಗಿ ಬರೆದದ್ದನ್ನು ಬಳಸುತ್ತದೆ. usage.Table() ಸಾಲುಗಳನ್ನು ಬರೆಯುತ್ತದೆ ಮತ್ತು usage.Best() ಕೊನೆಯ ಸಾಲಿನಲ್ಲಿ ಹೆಸರಿಸುವ ಖಾತೆಯನ್ನು ಆಯ್ಕೆಮಾಡುತ್ತದೆ.

ಒಂದು ಖಾತೆಗಾಗಿ, Fetcher.Fetch ಈ ಪರಿಶೀಲನೆಗಳನ್ನು ಈ ಕ್ರಮದಲ್ಲಿ ಮಾಡುತ್ತದೆ:

1. --source cache ಇದ್ದರೆ, ಅದು ನೇರವಾಗಿ fallback() ಗೆ ಹೋಗುತ್ತದೆ.
2. --no-cache ಇಲ್ಲದಿದ್ದರೆ, ~/.local/state/ccam/usage/<name>.json ನಲ್ಲಿರುವ 60 ಸೆಕೆಂಡ್‌ಗಳಿಗಿಂತ (CacheTTL) ಹೊಸ ನೇರ ಫಲಿತಾಂಶವನ್ನು ಹಾಗೆಯೇ ಹಿಂದಿರುಗಿಸಲಾಗುತ್ತದೆ. ccam usage ಅನ್ನು ಸತತ ಎರಡು ಬಾರಿ ರನ್ ಮಾಡಿದರೆ ಪ್ರತಿ ಖಾತೆಗೆ ಒಂದೇ ವಿನಂತಿ ಆಗುತ್ತದೆ.
3. readCredentials() .credentials.json ಅನ್ನು (ಅಥವಾ macOS Keychain ಅನ್ನು) ಬದಲಾಯಿಸದೆ ಓದುತ್ತದೆ, ಮತ್ತು claudeAiOauth ಕೀಯನ್ನು ಮಾತ್ರ ಡಿಕೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ಚಂದಾದಾರಿಕೆ ಲಾಗಿನ್ ಇಲ್ಲದಿದ್ದರೆ not logged in, ಅಥವಾ .claude.json ನಲ್ಲಿ API ಕೀ ಇದ್ದರೆ no limits (API).
4. ಅವಧಿ ಮುಗಿದ ಆಕ್ಸೆಸ್ ಟೋಕನ್ ಅನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ. --refresh ಇಲ್ಲದೆ, ಖಾತೆ ತನ್ನ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳನ್ನು ಅವಧಿ ಮುಗಿದಿದೆ ಎಂಬ ಗುರುತಿನೊಂದಿಗೆ ತೋರಿಸುತ್ತದೆ.
5. ಇಲ್ಲದಿದ್ದರೆ ccam ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಕರೆಯುತ್ತದೆ. 401 ಅಥವಾ 403 ಅನ್ನು ಅವಧಿ ಮುಗಿದ ಲಾಗಿನ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಬೇರೆ ಯಾವುದೇ ಸ್ಟೇಟಸ್ ಅಥವಾ ಓದಲಾಗದ ಉತ್ತರವನ್ನು ದೋಷ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಎರಡೂ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳಿಗೆ ಮರಳುತ್ತವೆ.
6. ಸರಿಯಾದ ಉತ್ತರವನ್ನು ಅಳೆದ ಸಮಯದೊಂದಿಗೆ <name>.json ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ.

fallback() <name>.json ಮತ್ತು <name>.statusline.json ಎರಡನ್ನೂ ಓದಿ ಹೊಸದನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳನ್ನು ತೋರಿಸುವ ಮೊದಲು, ಅದು ಪ್ರತಿ ಅವಧಿಯ ರೀಸೆಟ್ ಸಮಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ: ಸಂಖ್ಯೆಗಳನ್ನು ಉಳಿಸಿದ ನಂತರ ರೀಸೆಟ್ ಆಗಿರುವ ಅವಧಿ 0% ತೋರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಹಳೆಯ ಶೇಕಡಾವಾರು ಇನ್ನು ಅನ್ವಯಿಸುವುದಿಲ್ಲ. ಅದಕ್ಕಾಗಿಯೇ ಮೇಲಿನ personal ರೀಸೆಟ್ ಸಮಯವಿಲ್ಲದೆ 0% ತೋರಿಸುತ್ತದೆ.

ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ ಎರಡು ಉತ್ತರ ಸ್ವರೂಪಗಳಿವೆ. ಹೊಸದರಲ್ಲಿ session (5 ಗಂಟೆ), weekly_all ಮತ್ತು weekly_scoped (ಮಾಡೆಲ್‌ವಾರು) ಐಟಂಗಳಿರುವ limits ಅರೇ ಇದೆ. ಹಳೆಯದರಲ್ಲಿ five_hour, seven_day, seven_day_opus ಮತ್ತು seven_day_sonnet ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿವೆ. ParseLive ಎರಡನ್ನೂ ಓದುತ್ತದೆ: limits ಅರೇಗೆ ಆದ್ಯತೆ, ಮತ್ತು ಅದು ಒಳಗೊಳ್ಳದ್ದನ್ನು ಹಳೆಯ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ತುಂಬುತ್ತವೆ. ಯಾವುದೇ ಮಿತಿಗಳಿಲ್ಲದ ಉತ್ತರವನ್ನು ಬದಲಾದ ಸ್ವರೂಪ ಎಂದು ವರದಿ ಮಾಡಲಾಗುತ್ತದೆ, ಅದರ ಬಗ್ಗೆ ccam doctor ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ.

ಟೋಕನ್‌ಗಳನ್ನು ನವೀಕರಿಸುವುದು

ರಿಫ್ರೆಶ್ ಟೋಕನ್‌ಗಳು ಬದಲಾಗುತ್ತಾ ಇರುತ್ತವೆ: ಒಂದನ್ನು ನವೀಕರಿಸಿದರೆ ಹೊಸ ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಸಿಗುತ್ತದೆ ಮತ್ತು ಹಳೆಯದು ಅಮಾನ್ಯವಾಗುತ್ತದೆ. ಅದೇ ಖಾತೆಯಾಗಿ Claude Code ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ccam ಲಾಗಿನ್ ಅನ್ನು ನವೀಕರಿಸಿದರೆ, ಆ ಸೆಷನ್ ಸೈನ್ ಔಟ್ ಆಗುತ್ತದೆ. ಹೀಗಾಗಿ ccam usage ಟೋಕನ್‌ಗಳನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಎಂದಿಗೂ ಬರೆಯುವುದಿಲ್ಲ, ನೀವು --refresh ನೀಡದ ಹೊರತು. ಆಗ Fetcher.refresh:

1. ccam import ಮೂಲಕ ಇದ್ದಲ್ಲೇ ನೋಂದಾಯಿಸಿದ ಖಾತೆಗಳನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ccam ಗೆ ತಿಳಿಯದೆ ಸಾಮಾನ್ಯ claude ಆ ಲಾಗಿನ್ ಅನ್ನು ಬಳಸಬಹುದು;
2. macOS Keychain ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಲಾಗಿನ್‌ಗಳನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ;
3. ಒಂದು ಲಾಕ್ ಫೈಲ್ ಅನ್ನು ಪಡೆಯುತ್ತದೆ, $XDG_RUNTIME_DIR/ccam/profile-<name>.refresh.lock (ಆ ವೇರಿಯೇಬಲ್ ಹೊಂದಿಸದಿದ್ದಾಗ ~/.local/state/ccam/locks/ ಅಡಿಯಲ್ಲಿ), ಹೀಗಾಗಿ ಎರಡು ccam ಪ್ರಕ್ರಿಯೆಗಳು ಒಂದೇ ಟೋಕನ್ ಅನ್ನು ಎಂದಿಗೂ ಎರಡು ಬಾರಿ ನವೀಕರಿಸುವುದಿಲ್ಲ;
4. ಲಾಕ್ ಅಡಿಯಲ್ಲಿ, ಖಾತೆಯ ಸೆಷನ್ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ನಿರಾಕರಿಸುತ್ತದೆ, ಮತ್ತು ಇನ್ನೊಂದು ಪ್ರಕ್ರಿಯೆ ಈಗಾಗಲೇ ಟೋಕನ್ ಅನ್ನು ನವೀಕರಿಸಿದ್ದರೆ ವಿನಂತಿಯನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ;
5. ರಿಫ್ರೆಶ್ ಟೋಕನ್ ಅನ್ನು ಟೋಕನ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಹೊಸ ಟೋಕನ್‌ಗಳನ್ನು fsutil.AtomicWrite ಮೂಲಕ .credentials.json ಗೆ ಮತ್ತೆ ಬರೆಯುತ್ತದೆ, ಫೈಲ್‌ನಲ್ಲಿರುವ ಉಳಿದ ಎಲ್ಲಾ ಕೀಗಳನ್ನು ಹಾಗೆಯೇ ಇಟ್ಟುಕೊಳ್ಳುತ್ತದೆ.

ಸ್ಟೇಟಸ್ ಲೈನ್ ಸಂಗ್ರಾಹಕ

Claude Code ಸ್ಟೇಟಸ್ ಲೈನ್ ಕಮಾಂಡ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಅದಕ್ಕೆ ಒಂದು JSON ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಪೈಪ್ ಮಾಡುತ್ತದೆ. ccam ಅದರಿಂದ ಮಾಡೆಲ್ ಹೆಸರು ಮತ್ತು rate_limits ಅನ್ನು ಓದುತ್ತದೆ:

1. runStatusline ಖಾತೆಯನ್ನು CCAM_PROFILE ನಿಂದ ಕಂಡುಹಿಡಿಯುತ್ತದೆ, ಇದನ್ನು ccam Claude Code ಆರಂಭಿಸುವಾಗ ಹೊಂದಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ CLAUDE_CONFIG_DIR ಅನ್ನು ಖಾತೆಯ ಫೋಲ್ಡರ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಿಸಿ ನೋಡುತ್ತದೆ.
2. ParseStatusLine rate_limits.five_hour ಮತ್ತು rate_limits.seven_day ಅನ್ನು ಓದುತ್ತದೆ. API ಕೀ ಖಾತೆಗಳಿಗೆ, ಅಥವಾ ಸೆಷನ್‌ನ ಮೊದಲ ಉತ್ತರದ ಮೊದಲು, JSON ನಲ್ಲಿ ರೇಟ್ ಮಿತಿಗಳಿರುವುದಿಲ್ಲ; ಆಗ ಏನನ್ನೂ ಉಳಿಸಲಾಗುವುದಿಲ್ಲ.
3. SaveStatusLine ~/.local/state/ccam/usage/<name>.statusline.json ಅನ್ನು ಬರೆಯುತ್ತದೆ. ಎಂಡ್‌ಪಾಯಿಂಟ್ ಉತ್ತರಿಸದಿದ್ದಾಗ ccam usage ಇದನ್ನು ಬಳಸುತ್ತದೆ.
4. ccam [name] · model · 5h N% · 7d N% ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. --wrap ಇದ್ದರೆ, ಅದು ನಿಮ್ಮ ಕಮಾಂಡ್ ಅನ್ನು ಅದೇ ಇನ್‌ಪುಟ್‌ನೊಂದಿಗೆ sh -c ಮೂಲಕ ರನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬದಲಿಗೆ [name] ನಂತರ ಕಮಾಂಡ್‌ನ ಮೊದಲ ಸಾಲನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಸುತ್ತಿದ ಕಮಾಂಡ್‌ಗೆ 2 ಸೆಕೆಂಡ್ ಸಿಗುತ್ತದೆ. ಅದರ ನಂತರ ಅದನ್ನು ನಿಲ್ಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸಾಲು ಖಾತೆಯ ಹೆಸರನ್ನು ಮಾತ್ರ ತೋರಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ನಿಧಾನವಾದ ಕಮಾಂಡ್ Claude Code ನ ಸ್ಟೇಟಸ್ ಲೈನ್ ಅನ್ನು ತಡೆಯಲಾರದು.

ccam statusline install ಪ್ರತಿ ಖಾತೆಯ settings.json ನಲ್ಲಿ statusLine ಅನ್ನು ಬರೆಯುತ್ತದೆ. ಒಂದು ಖಾತೆಗೆ ಈಗಾಗಲೇ ಸ್ಟೇಟಸ್ ಲೈನ್ ಕಮಾಂಡ್ ಇದ್ದಾಗ, ccam ಅದನ್ನು --wrap '<old command>' ಆಗಿ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಗುಂಪಿನ ಮೂಲಕ ಹಂಚಿಕೊಂಡ settings.json ಅನ್ನು ಅದರ ಲಿಂಕ್ ಮೂಲಕ ಒಮ್ಮೆ ಮಾತ್ರ ಬರೆಯಲಾಗುತ್ತದೆ, ಹೀಗಾಗಿ ಗುಂಪಿನ ಪ್ರತಿ ಖಾತೆಗೂ ಅದು ಸಿಗುತ್ತದೆ. ಇದನ್ನು ಮತ್ತೆ ರನ್ ಮಾಡಿದರೆ, ಈಗಾಗಲೇ ccam ಬಳಸುತ್ತಿರುವ ಫೈಲ್‌ಗಳಿಗೆ (already set) ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ.

ಸುರಕ್ಷತೆ ಮತ್ತು ವಿಶೇಷ ಸಂದರ್ಭಗಳು

• ನೀವು --refresh ನೀಡದ ಹೊರತು ccam usage ಟೋಕನ್ ಫೈಲ್ ಅನ್ನು ಎಂದಿಗೂ ಬದಲಾಯಿಸುವುದಿಲ್ಲ. ಲಾಗಿನ್ ಅವಧಿ ಮುಗಿದಾಗ, ಖಾತೆಯನ್ನು ccam <name> ಮೂಲಕ ಒಮ್ಮೆ ಆರಂಭಿಸಿ; Claude Code ಅದನ್ನು ನವೀಕರಿಸುತ್ತದೆ.
• --refresh ಚಾಲನೆಯಲ್ಲಿರುವ ಖಾತೆಗಳು, ಇಂಪೋರ್ಟ್ ಮಾಡಿದ ಖಾತೆಗಳು ಅಥವಾ Keychain ಲಾಗಿನ್‌ಗಳನ್ನು ಎಂದಿಗೂ ಮುಟ್ಟುವುದಿಲ್ಲ. ನಿರಾಕರಿಸಿದ ನವೀಕರಣ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳನ್ನು ಮತ್ತು ಕಾರಣವನ್ನು ತೋರಿಸುತ್ತದೆ.
• ಬಳಕೆಯ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಸಾರ್ವಜನಿಕವಾಗಿ ದಾಖಲಾಗಿಲ್ಲ ಮತ್ತು ಬದಲಾಗಬಹುದು. ಅದು ಬದಲಾದಾಗಲೂ ನಿಮಗೆ ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳು ಕಾಣಿಸುತ್ತವೆ, ಮತ್ತು ccam doctor ಸ್ವರೂಪದ ಬದಲಾವಣೆಯನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ.
• ಉಳಿಸಿದ ಸಂಖ್ಯೆಗಳೂ ಇಲ್ಲದೆ ಉತ್ತರವೂ ಇಲ್ಲದಿದ್ದಾಗ, ಸಾಲು lookup failed: ಮತ್ತು ಕಾರಣವನ್ನು ತೋರಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ --source cache ಜೊತೆ no saved usage.
• ಕ್ಯಾಶ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಶೇಕಡಾವಾರುಗಳು ಮತ್ತು ರೀಸೆಟ್ ಸಮಯಗಳು ಮಾತ್ರ ಇರುತ್ತವೆ, ಟೋಕನ್‌ಗಳು ಎಂದಿಗೂ ಇರುವುದಿಲ್ಲ.

ಸಂಬಂಧಿತ

• ಬಳಕೆಯ ಮಿತಿಗಳು ಮತ್ತು ಖಾತೆ ಬದಲಾವಣೆ
• ಮುಂದಿನ ಖಾತೆಗೆ ಬದಲಾಯಿಸುವುದು
• ಬಳಕೆಯ ಮಿತಿ ತಲುಪಿದಾಗ ಕೆಲಸದ ಹರಿವು
• ಕಮಾಂಡ್‌ಗಳು