> ## Documentation Index
> Fetch the complete documentation index at: https://docs.befailproof.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# एजेंटों के लिए CLI रेसिपी

> एजेंटों के लिए AgentEye CLI रेसिपी दस्तावेज़।

सीधे स्क्रिप्ट या कोडिंग एजेंट से सेशन, イベント और मूल्यांकन डेटा खींचें (और पुनः-मूल्यांकन ट्रिगर करें), stdout पर स्वच्छ JSON के साथ जो सीधे `jq` में पाइप करता है। ये रेसिपी AgentEye के अवलोकन योग्य डेटा को कुछ ऐसे में बदलते हैं जिसे टर्मिनल उपयोगकर्ता या AI कोडिंग एजेंट (Claude Code, Cursor) डैशबोर्ड के माध्यम से क्लिक किए बिना क्वेरी और स्वचालित कर सकते हैं।

नीचे दिए गए पैटर्न AgentEye CLI (`agenteye`) के लिए कॉपी-पेस्ट के लिए तैयार हैं। इंस्टॉलेशन, प्रमाणीकरण और पूर्ण विकल्प सूची के लिए [CLI](/hi/agenteye/cli) देखें; `agenteye -h` या `agenteye <command> -h` चलाएं बिल्ट-इन सहायता के लिए।

## स्वर्णिम नियम

1. **ग्लोबल विकल्प कमांड से *पहले* आते हैं।** `agenteye --json sessions` सही है; `agenteye sessions --json` नहीं है। ग्लोबल विकल्प हैं `--json`, `--base-url`, `--org`, `--token`, `--insecure`/`--secure`, `--timeout`, `--quiet`, `--no-color`।
2. **जब भी आप आउटपुट पार्स करते हैं तो `--json` पास करें।** डेटा **stdout** पर JSON के रूप में जाता है; मानव स्थिति और त्रुटियां **stderr** पर जाती हैं, इसलिए stdout `jq` में पाइपिंग के लिए स्वच्छ रहता है।
3. **stderr टेक्स्ट पर नहीं, exit कोड पर ब्रांच करें**: `0` ठीक है · `2` ख़राब तर्क · `3` डैशबोर्ड तक नहीं पहुंच सकते · `4` लॉगिन नहीं या एक्सपायर्ड · `5` अनुमति नहीं।
4. **`-h` से खोजें।** प्रत्येक कमांड अपने फ़िल्टर, मान प्रारूप और JSON आकार को दस्तावेज़ित करता है।

## एक बार का सेटअप

```bash theme={null}
export AGENTEYE_DASHBOARD_URL=https://agenteye.example.com   # ताकि आप --base-url दोहराएं न
agenteye login --email you@example.com                       # ईमेल किए गए कोड को पेस्ट करें; ~24h वैध
```

## काम करने से पहले प्रमाणीकरण की पुष्टि करें

`whoami` एक लापता या एक्सपायर्ड सेशन पर कभी त्रुटि नहीं देता; यह इसके बजाय `logged_in:false` रिपोर्ट करता है, इसलिए एक एजेंट सुरक्षित रूप से प्रमाणीकरण स्थिति को जांच सकता है। (यदि कोई बेस URL सेट नहीं है या डैशबोर्ड अप्राप्य है तो यह अभी भी गैर-शून्य बाहर निकल सकता है।)

```bash theme={null}
if [ "$(agenteye --json whoami | jq -r .logged_in)" != "true" ]; then
  echo "Not authenticated. Run: agenteye login" >&2; exit 1
fi
```

## विफल या कम स्कोरिंग सेशन खोजें

```bash theme={null}
# पिछले 24h में सेशन जिनका मूल्यांकन त्रुटि में हुआ
agenteye --json sessions --since 24h --status error | jq -r '.sessions[].session_id'

# एक एजेंट के लिए सहायकता पर <= 0.5 स्कोरिंग मूल्यांकन
agenteye --json evals --agent-id checkout-bot --score helpfulness:..0.5 \
  | jq '.evaluations[] | {session_id, scores}'
```

स्कोर फ़िल्टरिंग `sessions` पर नहीं, **`evals`** पर रहता है। `--score KEY:MIN..MAX` दोहराया जा सकता है और AND-संयोजित है; कोई भी बाउंड वैकल्पिक है (`..0.5` का मतलब ≤ 0.5 है, `0.9..` का मतलब ≥ 0.9 है)। आप प्रति अनुरोध 20 तक स्कोर फ़िल्टर पास कर सकते हैं; अधिक HTTP 400 लौटाता है। `sessions` `evals` के साथ `--env`, `--status`, `--agent-id`, `--session-id` और समय-श्रेणी फ़िल्टर साझा करता है, लेकिन `--score` नहीं है।

## एक सेशन को अंत तक पढ़ें

कोई एकल `session show` कमांड नहीं है — इवेंट ट्रेल को सेशन के मूल्यांकन के साथ संयोजित करें:

```bash theme={null}
# सेशन का नवीनतम मूल्यांकन (स्थिति + स्कोर)
agenteye --json evals --session-id run-001 | jq '.evaluations[0] | {status, scores}'

# रन में प्रत्येक इवेंट (पूर्ण स्वीप के लिए --limit बढ़ाएं)
agenteye --json events --session-id run-001 --all --limit 1000 | jq '.events[] | {ts, event_type}'

# सेशन में केवल टूल कॉल
agenteye --json events --session-id run-001 --event-type tool_use,tool_result --all \
  | jq '.events[].payload'
```

## सब कुछ प्राप्त करें (पेजिनेशन)

परिणाम सबसे नए-प्रथम और कर्सर-पेजिनेटेड हैं।

```bash theme={null}
# एक शॉट: 200-पंक्ति पृष्ठों में 500 पंक्तियों तक प्राप्त करें
agenteye --json events --session-id run-001 --limit 500 --all > events.json

# मैनुअल पेजिंग: अगले कर्सर को वापस फीड करें
page=$(agenteye --json events --limit 100)
cursor=$(echo "$page" | jq -r '.next_cursor // empty')
[ -n "$cursor" ] && agenteye --json events --limit 100 --cursor "$cursor"
```

## --fields के साथ आउटपुट को पतला करें

एजेंट को पढ़ना पड़ने वाले को कम करने के लिए कुंजियों को (टेबल और `--json` दोनों में) प्रतिबंधित करें।

```bash theme={null}
agenteye --json sessions --since 7d --fields session_id,status,scores | jq -c '.sessions[]'
agenteye --json events --session-id run-001 --fields ts,event_type --all
```

अज्ञात फ़ील्ड नाम अस्वीकार किए जाते हैं (exit `2`) वैध सूची के साथ, फ़ील्ड नाम खोजने का एक सस्ता तरीका।

## वैध फ़िल्टर मान खोजें

```bash theme={null}
agenteye --json list envs | jq -r '.values[]'           # --env के लिए मान
agenteye --json list tools | jq -r '.values[]'          # टूल नाम; साथ ही एजेंट, मॉडल, event_types, ...
agenteye --json list score_filters | jq -r '.values[]'  # --score KEY:MIN..MAX के लिए वैध KEY
```

## अपना org चुनें (बहु-किरायेदार)

यदि आप एक से अधिक org के सदस्य हैं, तो लॉगिन पर सक्रिय टेनेंट चुनें (यह सहेजा जाता है):

```bash theme={null}
agenteye login --org acme --email you@corp.com   # लॉगिन के समान चरण में टेनेंट सेट करें
agenteye --json orgs list | jq -r '.orgs[].org_slug'
agenteye --org globex --json sessions --since 24h   # एक कमांड के लिए ओवरराइड करें
```

`--org` के बिना एक बहु-org लॉगिन गैर-शून्य से बाहर निकलता है और चुनने के लिए org को प्रिंट करता है।

## SDK/कलेक्टर के लिए API की प्रदान करें

```bash theme={null}
# गुप्त ONCE प्रिंट किया जाता है — --json के साथ यह .key फ़ील्ड है
key=$(agenteye --json keys create ci-bot --add events:read.add | jq -r '.key')
agenteye keys regenerate ci-bot --yes    # घुमाएं; ci-bot को रद्द करने के लिए agenteye keys disable ci-bot --yes
```

## सहेजी गई या तदर्थ क्वेरी चलाएं

```bash theme={null}
agenteye --json query run --sql "select count(*) from analytics.events" | jq '.rows'
agenteye --json query run errs --arg prod | jq '.rows'   # एक सहेजी गई क्वेरी + एक स्थितीय $1
```

## गैर-इंटरैक्टिव रूप से एक घटना का विश्लेषण करें

```bash theme={null}
id=$(agenteye --json incidents list --state firing | jq -r '.incidents[0].id')
agenteye incidents ack "$id"
agenteye incidents assign "$id" --assignee you@corp.com
agenteye incidents resolve "$id" --yes
```

> म्यूटेशन `--json` के तहत या जब stdin TTY नहीं है तो अपने पुष्टि प्रॉम्प्ट को स्वचालित रूप से छोड़ देते हैं, इसलिए एजेंट कभी हैंग नहीं होते; अन्यत्र स्पष्ट रूप से छोड़ने के लिए `--yes`/`-y` पास करें।

## स्क्रिप्ट में Exit-code हैंडलिंग

```bash theme={null}
out=$(agenteye --json sessions --since 1h) || code=$?
case "${code:-0}" in
  0) echo "$out" | jq '.sessions | length' ;;
  4) echo "Session expired - run 'agenteye login'." >&2 ;;
  5) echo "Missing permission (ask an admin for evaluations:read)." >&2 ;;
  3) echo "Dashboard unreachable - check the URL." >&2 ;;
  *) echo "Unexpected error (exit ${code})." >&2 ;;
esac
```

## JSON आउटपुट आकार

| कमांड                            | stdout JSON (`--json` के साथ)                                                                                                                 |
| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `whoami`                         | `{"logged_in": true, "id", "email", "is_instance_admin", "active_org", "permissions": [...], "memberships": [...]}` या `{"logged_in": false}` |
| `orgs list`                      | `{"active_org", "orgs": [{"org_slug","org_name","permission_set","permissions"}]}`                                                            |
| `events`                         | `{"events": [...], "next_cursor": <cursor or null>}`                                                                                          |
| `evals`                          | `{"evaluations": [...], "next_cursor": <cursor or null>}`                                                                                     |
| `sessions`                       | `{"sessions": [...], "next_cursor": <cursor or null>}`                                                                                        |
| `errors`                         | `{"errors": [...], "next_cursor": <cursor or null>}`                                                                                          |
| `list <kind>`                    | `{"kind", "values": [...]}`                                                                                                                   |
| `keys list` / `keys create`      | `{"keys": [...]}` / `{id, name, permissions, created_at, key}` (`key` एक बार दिखाया गया)                                                      |
| `query run`                      | `{columns: [{name,type}], rows: [[...]], truncated, elapsed_ms}`                                                                              |
| `users list` / `settings list`   | `{"users": [...]}` / `{"settings": [...]}`                                                                                                    |
| `alerts list` / `incidents list` | `{"alerts": [...]}` / `{"incidents": [...]}`                                                                                                  |
| create/update/delete (कोई भी)    | संसाधन ऑब्जेक्ट, या हटाने के लिए `{"deleted": true, "id"}`                                                                                    |
| विफलता (कोई भी, `--json` के साथ) | stdout पर `{"error": "...", "exit_code": <n>, "status"?: <http>, "hint"?: "..."}`                                                             |

* प्रत्येक **event** आइटम (`events`): `id, session_id, agent_id, event_type, ts, payload, environment`।
* प्रत्येक **evaluation** आइटम (`evals`): `id, session_id, agent_id, environment, status, scores, reasoning, summary, error, attempt_count, duration_ms, completed_at, created_at`।
* प्रत्येक **session** आइटम (`sessions`): `session_id, agent_id, environment, status, scores, event_count, started_at, last_event_at, first_event_id, last_event_id, latest_evaluation`।

प्रत्येक कमांड की `--fields` बिल्कुल अपने आइटम के फ़ील्ड नामों को स्वीकार करते हैं — सेट `sessions` और `evals` के बीच अलग है, इसलिए एक के लिए वैध नाम दूसरे द्वारा अस्वीकार किया जा सकता है।