मैं देख रहा हूँ कि आपने इनपुट प्रदान नहीं किया है। कृपया वह Markdown सामग्री भेजें जिसे आप अनुवाद करना चाहते हैं, और मैं आपके निर्देशों के अनुसार उसका अनुवाद कर दूँगा।```typescript
import { loadSecrets } from "@envsec/sdk";

// Load and inject into process.env
await loadSecrets({ context: "myapp.dev", inject: true });

// Or use the client for full control
import { EnvsecClient } from "@envsec/sdk";
const client = await EnvsecClient.create({ context: "myapp.dev" });
const apiKey = await client.get("api.key");
await client.close();

एक चालू D-Bus सत्र और एक keyring डेमॉन (जैसे `gnome-keyring-daemon`) सक्रिय होना चाहिए। अधिकांश डेस्कटॉप वातावरण इसे स्वचालित रूप से संभाल लेते हैं।

### Windows

कोई अतिरिक्त निर्भरता नहीं। `cmdkey` और PowerShell के माध्यम से अंतर्निहित Windows Credential Manager का उपयोग करता है।

## इंस्टॉलेशन

### Homebrew (macOS / Linux)```bash
brew tap davidnussio/homebrew-tap
brew install envsec

### npx (बिना इंस्टॉल किए)```bash
npx envsec

## उपयोग

अधिकांश कमांड्स के लिए `--context` (या `-c`) के साथ एक कॉन्टेक्स्ट निर्दिष्ट करना आवश्यक है।
कॉन्टेक्स्ट सीक्रेट्स को समूहीकृत करने के लिए एक फ्री-फॉर्म लेबल है — जैसे `myapp.dev`, `stripe-api.prod`, `work.staging`।

### वैश्विक विकल्प

ये विकल्प सभी कमांड्स पर उपलब्ध हैं:

- `--context`, `-c` — कॉन्टेक्स्ट का नाम (जैसे `myapp.dev`, `stripe-api.prod`)। यह `ENVSEC_CONTEXT` एनवायरनमेंट वेरिएबल को भी पढ़ता है
- `--debug`, `-d` — डीबग लॉगिंग सक्षम करें
- `--json` — स्क्रिप्टिंग के लिए JSON प्रारूप में आउटपुट
- `--db` — SQLite डेटाबेस फ़ाइल का पथ (डिफ़ॉल्ट: `~/.envsec/store.sqlite`)। यह `ENVSEC_DB` एनवायरनमेंट वेरिएबल को भी पढ़ता है

### कस्टम डेटाबेस पथ

डिफ़ॉल्ट रूप से, मेटाडेटा `~/.envsec/store.sqlite` पर संग्रहीत होता है। आप इसे `--db` या `ENVSEC_DB` एनवायरनमेंट वेरिएबल के साथ ओवरराइड कर सकते हैं:```bash
# Use a project-local database
envsec --db ./local-store.sqlite -c myapp.dev list

# Or via environment variable
export ENVSEC_DB=/shared/team/envsec.sqlite
envsec -c myapp.dev list

### कोई सीक्रेट प्राप्त करें

OS क्रेडेंशियल स्टोर से सीक्रेट मान पुनर्प्राप्त करें।

- `<key>` — पुनर्प्राप्त करने के लिए सीक्रेट कुंजी का नाम
- `--quiet`, `-q` — केवल कच्चा मान प्रिंट करें (कोई चेतावनी या अतिरिक्त आउटपुट नहीं)
- `--json` — JSON प्रारूप में आउटपुट (context, key, value, expires_at शामिल है)```bash
envsec -c myapp.dev get api.key

# Print only the raw value (no warnings or extra output)
envsec -c myapp.dev get api.key --quiet
envsec -c myapp.dev get api.key -q

### किसी सीक्रेट का नाम बदलें

उसी कॉन्टेक्स्ट के भीतर किसी सीक्रेट की कुंजी का नाम बदलें। वैल्यू और समाप्ति मेटाडेटा संरक्षित रहते हैं।

- `<old-key>` — वर्तमान सीक्रेट कुंजी का नाम
- `<new-key>` — नया सीक्रेट कुंजी का नाम
- `--force`, `-f` — यदि लक्ष्य पहले से मौजूद है तो उसे अधिलेखित करें```bash
# Rename a key
envsec -c myapp.dev rename old.key new.key

# Overwrite target if it already exists
envsec -c myapp.dev rename old.key existing.key --force

### सभी कॉन्टेक्स्ट सूचीबद्ध करें

सीक्रेट गिनती के साथ सभी उपलब्ध कॉन्टेक्स्ट सूचीबद्ध करें।

- `--json` — आउटपुट JSON प्रारूप में```bash
# Without --context, lists all available contexts with secret counts
envsec list

### संदर्भों के बीच सीक्रेट्स स्थानांतरित करें

सीक्रेट्स को एक संदर्भ से दूसरे में स्थानांतरित करें। स्थानांतरण के बाद स्रोत सीक्रेट्स हटा दिए जाते हैं।

- `<pattern>` — स्थानांतरित करने के लिए ग्लोब पैटर्न या सटीक कुंजी (यदि `--all` उपयोग किया जाता है तो वैकल्पिक)
- `--to`, `-t` — लक्ष्य संदर्भ जिसमें सीक्रेट्स स्थानांतरित करने हैं
- `--all` — स्रोत संदर्भ से सभी सीक्रेट्स स्थानांतरित करें
- `--force`, `-f` — लक्ष्य संदर्भ में मौजूदा सीक्रेट्स को अधिलेखित करें
- `--yes`, `-y` — पुष्टिकरण संकेत छोड़ें```bash
# Move a single secret
envsec -c myapp.dev move api.token --to myapp.prod

# Move secrets matching a glob pattern
envsec -c myapp.dev move "redis.*" --to myapp.prod -y

# Move all secrets from one context to another
envsec -c myapp.dev move --all --to myapp.prod -y

# Overwrite existing secrets in the target context
envsec -c myapp.dev move "redis.*" --to myapp.prod --force -y

### रहस्यों के साथ एक कमांड चलाएँ

प्लेसहोल्डर्स के माध्यम से इंटरपोलेट किए गए या पर्यावरण चर के रूप में इंजेक्ट किए गए गुप्त मानों के साथ एक कमांड निष्पादित करें।

- `<command>` — निष्पादित करने के लिए कमांड। गुप्त इंटरपोलेशन के लिए `{key}` प्लेसहोल्डर्स का उपयोग करें
- `--inject`, `-i` — सभी संदर्भ रहस्यों को पर्यावरण चर के रूप में इंजेक्ट करें (`KEY.NAME` → `KEY_NAME`)
- `--save`, `-s` — इस कमांड को बाद में उपयोग के लिए सहेजें
- `--name`, `-n` — सहेजे गए कमांड के लिए नाम (`--save` के साथ छोड़े जाने पर इंटरैक्टिव रूप से संकेत दिया जाता है)```bash
# Placeholders {key} are resolved with secret values before execution
envsec -c myapp.dev run 'curl {api.url} -H "Authorization: Bearer {api.token}"'

# Any {dotted.key} in the command string is replaced with its value
envsec -c myapp.prod run 'psql {db.connection_string}'

# Inject ALL context secrets as environment variables (KEY.NAME → KEY_NAME)
envsec -c myapp.dev run --inject 'node server.js'
envsec -c myapp.dev run -i 'docker compose up'

# Combine --inject with placeholders
envsec -c myapp.dev run --inject 'curl {api.url} -H "Authorization: Bearer $API_TOKEN"'

# Save the command for later use with --save (-s) and --name (-n)
envsec -c myapp.dev run --save --name deploy 'kubectl apply -f - <<< {k8s.manifest}'

# If you use --save without --name, you'll be prompted interactively
envsec -c myapp.dev run --save 'psql {db.connection_string}'

### सहेजे गए कमांड

सहेजे गए कमांड `cmd` उपकमांड के अंतर्गत रहते हैं, जो उन्हें गुप्त कार्यों से अलग रखता है।

#### cmd list

सभी सहेजे गए कमांड की सूची दिखाएँ।```bash
envsec cmd list

#### cmd search

सहेजे गए कमांड को नाम या कमांड स्ट्रिंग द्वारा खोजें।

- `<pattern>` — खोज पैटर्न
- `--name`, `-n` — केवल कमांड नामों में खोजें
- `--command`, `-m` — केवल कमांड स्ट्रिंग्स में खोजें```bash
envsec cmd search psql

# Search only by name
envsec cmd search deploy -n

# Search only by command string
envsec cmd search kubectl -m

### एक `.env` फ़ाइल उत्पन्न करें

किसी कॉन्टेक्स्ट से सभी सीक्रेट्स को एक `.env` फ़ाइल में एक्सपोर्ट करें।

- `--output`, `-o` — आउटपुट फ़ाइल पथ (डिफ़ॉल्ट: `.env`)```bash
# Creates .env with all secrets from the context
envsec -c myapp.dev env-file

# Specify a custom output path
envsec -c myapp.dev env-file --output .env.local

समर्थित शेल: `bash` (डिफ़ॉल्ट), `zsh`, `fish`, `powershell`। कुंजियाँ `UPPER_SNAKE_CASE` में बदल दी जाती हैं (जैसे `api.token` → `API_TOKEN`)। आउटपुट stdout पर जाता है ताकि इसे `eval` में पाइप किया जा सके या सीधे सोर्स किया जा सके — डिस्क पर कोई फ़ाइल नहीं लिखी जाती।

### सीक्रेट्स-स्कोप्ड शेल सत्र शुरू करें

कॉन्टेक्स्ट के सभी सीक्रेट्स को पर्यावरण चर के रूप में इंजेक्ट करके एक इंटरैक्टिव सबशेल स्पॉन करें। जब आप `exit` करते हैं, तो सीक्रेट्स गायब हो जाते हैं — किसी सफाई की आवश्यकता नहीं।

- `--shell`, `-s` — स्पॉन करने के लिए शेल (`bash`, `zsh`, `fish`, `powershell`)। डिफ़ॉल्ट: ऑटो-डिटेक्ट
- `--no-inherit` — पैरेंट पर्यावरण चर इनहेरिट न करें
- `--quiet`, `-q` — स्टार्टअप/एग्ज़िट बैनर दबाएँ```bash
envsec -c myapp.dev shell

## स्थापना

### आवश्यक शर्तें

- Python 3.8+
- pip

### चरण-दर-चरण स्थापना

```bash
git clone https://github.com/example/repo.git
cd repo
pip install -r requirements.txt

pip install extra-package

python main.py --target example.com

python main.py --target example.com --verbose --timeout 60

target: example.com
threads: 10
retries: 3

▶ envsec shell — context: myapp.dev (8 secrets loaded)
Type 'exit' or press Ctrl+D to leave the session.

(envsec:myapp.dev) ~ $ echo $DATABASE_URL
postgres://user:pass@localhost/mydb

(envsec:myapp.dev) ~ $ exit
→ Exiting envsec shell — secrets cleared.
```
मैंने आपके द्वारा दिए गए इनपुट में कोई सामग्री नहीं देखी। कृपया वह Markdown सामग्री प्रदान करें जिसे आप अनुवाद करना चाहते हैं, और मैं नियमों के अनुसार उसका अनुवाद करूँगा।```bash
# Force a specific shell
envsec -c myapp.dev shell --shell zsh

# Only envsec secrets in env (no parent variables, except PATH)
envsec -c myapp.dev shell --no-inherit

# Suppress the startup/exit banner
envsec -c myapp.dev shell --quiet
```
चर `ENVSEC_CONTEXT` हमेशा सत्र के अंदर सेट होता है, इसलिए आप इसे स्क्रिप्ट या प्रॉम्प्ट अनुकूलन में संदर्भित कर सकते हैं।

### .env फ़ाइल से सीक्रेट लोड करें

`.env` फ़ाइल से सीक्रेट को एक कॉन्टेक्स्ट में आयात करें।

- `--input`, `-i` — इनपुट `.env` फ़ाइल पथ (डिफ़ॉल्ट: `.env`)
- `--force`, `-f` — बिना पूछे मौजूदा सीक्रेट को अधिलेखित करें
- `--batch`, `-b` — बैच मोड: सभी सीक्रेट आयात होने तक डेटाबेस स्थिरता को स्थगित करें```bash
# Import secrets from .env into the context
envsec -c myapp.dev load

# Specify a custom input file
envsec -c myapp.dev load --input .env.local

# Overwrite existing secrets without warning
envsec -c myapp.dev load --force
```
कुंजियाँ `UPPER_SNAKE_CASE` से `dotted.lowercase` में परिवर्तित की जाती हैं (जैसे `API_TOKEN` → `api.token`)। यदि कोई कुंजी पहले से मौजूद है, तो उसे चेतावनी के साथ छोड़ दिया जाता है, जब तक कि `--force` (`-f`) प्रदान न किया गया हो।

### रहस्य साझा करें (GPG एन्क्रिप्टेड)

GPG का उपयोग करके किसी टीम सदस्य के लिए किसी कॉन्टेक्स्ट के सभी रहस्यों को एन्क्रिप्ट करें।

- `--encrypt-to` — GPG प्राप्तकर्ता कुंजी (ईमेल, कुंजी ID, या फिंगरप्रिंट) जिसके लिए एन्क्रिप्ट करना है
- `--output`, `-o` — आउटपुट फ़ाइल पथ (डिफ़ॉल्ट: stdout)। स्पष्ट रूप से stdout के लिए `-` का उपयोग करें
- `--json` — एन्क्रिप्टेड पेलोड के अंदर JSON प्रारूप का उपयोग करें (डिफ़ॉल्ट: `.env` प्रारूप)```bash
# Encrypt all secrets from a context for a team member
envsec -c myapp.dev share --encrypt-to [email protected]

# Save encrypted output to a file
envsec -c myapp.dev share --encrypt-to [email protected] -o secrets.enc

# Use JSON format inside the encrypted payload
envsec -c myapp.dev --json share --encrypt-to [email protected] -o secrets.enc
```
प्राप्तकर्ता `gpg --decrypt secrets.enc` के साथ डिक्रिप्ट कर सकता है और परिणाम को `envsec load` में पाइप कर सकता है। डिफ़ॉल्ट रूप से, एन्क्रिप्टेड पेलोड `.env` प्रारूप (`KEY="value"`) का उपयोग करता है; `--json` के साथ यह एक संरचित JSON ऑब्जेक्ट का उपयोग करता है। GPG इंस्टॉल होना और प्राप्तकर्ता की सार्वजनिक कुंजी आपके कीरिंग में होना आवश्यक है।

### समाप्ति के लिए रहस्यों का ऑडिट करें

समाप्त या समाप्त होने वाले रहस्यों और ट्रैक किए गए `.env` फ़ाइल निर्यातों की जाँच करें।

- `--within`, `-w` — इस अवधि के भीतर समाप्त होने वाले रहस्य दिखाएँ (डिफ़ॉल्ट: `30d`)। केवल पहले से समाप्त रहस्य दिखाने के लिए `0d` का उपयोग करें
- `--json` — JSON प्रारूप में आउटपुट```bash
# Check for expired or expiring secrets in a context (default window: 30 days)
envsec -c myapp.dev audit

# Specify a custom window
envsec -c myapp.dev audit --within 7d

# Show only already-expired secrets
envsec -c myapp.dev audit --within 0d

# Audit across all contexts (omit --context)
envsec audit

# JSON output
envsec -c myapp.dev audit --json
```
`--expires` अवधि के साथ `envsec add` के माध्यम से सेट किए गए रहस्य मेटाडेटा में ट्रैक किए जाते हैं। `audit` कमांड उन रहस्यों को स्कैन करता है जो पहले ही समाप्त हो चुके हैं या निर्दिष्ट विंडो के भीतर समाप्त हो जाएंगे। `get` और `list` कमांड भी इनलाइन समाप्ति चेतावनियाँ प्रदर्शित करते हैं।

`audit` कमांड उत्पन्न `.env` फ़ाइलों को भी ट्रैक करता है। हर बार `env-file` का उपयोग होने पर, आउटपुट पथ, संदर्भ और टाइमस्टैम्प दर्ज किए जाते हैं। ऑडिट आउटपुट में इन फ़ाइलों को सूचीबद्ध करने वाला एक दूसरा अनुभाग शामिल होता है। यदि कोई ट्रैक की गई `.env` फ़ाइल अब डिस्क पर मौजूद नहीं है, तो ऑडिट स्वचालित रूप से इसे मेटाडेटा से हटा देता है और सफाई की रिपोर्ट करता है।

### एक यादृच्छिक रहस्य उत्पन्न करें

क्रिप्टोग्राफ़िक रूप से सुरक्षित यादृच्छिक रहस्य उत्पन्न करें, वैकल्पिक रूप से इसे संग्रहीत करें।

- `<key>` — रहस्य कुंजी का नाम (वैकल्पिक; स्टैंडअलोन पासवर्ड निर्माण के लिए छोड़ दें)
- `--length`, `-l` — उत्पन्न रहस्य की लंबाई (डिफ़ॉल्ट: `32`)
- `--prefix`, `-p` — उत्पन्न रहस्य के आगे जोड़ने के लिए उपसर्ग (जैसे `sk_`)
- `--expires`, `-e` — समाप्ति अवधि (जैसे `30m`, `2h`, `7d`, `4w`, `3mo`, `1y`)
- `--alphanumeric`, `-a` — केवल अल्फ़ान्यूमेरिक वर्ण `[a-zA-Z0-9]` का उपयोग करें (डिफ़ॉल्ट)
- `--special`, `-s` — सामान्य विशेष वर्ण शामिल करें `[a-zA-Z0-9!@#$%^&*]`
- `--all-chars`, `-A` — अधिकतम एन्ट्रॉपी के लिए सभी प्रिंट करने योग्य ASCII वर्णों का उपयोग करें```bash
# Generate and store a 32-char alphanumeric secret
envsec -c myapp.dev secret api.key

# Custom length and prefix
envsec -c myapp.dev secret api.key --prefix "sk_" --length 48

# Character sets:
#   --alphanumeric (-a)  [a-zA-Z0-9] (default)
#   --special (-s)       [a-zA-Z0-9] + !@#$%^&*
#   --all-chars (-A)     all printable ASCII
envsec -c myapp.dev secret db.password --special --length 64

# With expiry
envsec -c myapp.dev secret api.key --prefix "sk_" -l 48 --expires 90d

# Standalone password generator (no store, just print)
envsec secret --length 32
envsec secret --special --length 64 --prefix "pk_"
```
जब दोनों context और key प्रदान किए जाते हैं, तो उत्पन्न मान संग्रहीत और प्रिंट किया जाता है। इनमें से किसी के बिना, कच्चा मान stdout पर जाता है — `pbcopy`, `xclip`, या अन्य टूल्स में पाइप करने के लिए उपयोगी।

### इंटरैक्टिव TUI

envsec में सीक्रेट्स को इंटरैक्टिव रूप से प्रबंधित करने के लिए एक फुल-स्क्रीन टर्मिनल UI शामिल है — कमांड याद रखने की कोई आवश्यकता नहीं है।```bash
# Launch the TUI
envsec tui

# Launch with a pre-selected context
envsec -c myapp.dev tui
```
TUI मुख्य मेनू से आठ स्क्रीन प्रदान करता है:

- **Contexts** — सभी contexts ब्राउज़ करें, `s` से सक्रिय context सेट करें, `x` से context साफ़ करें, secret गिनती देखें, पूरे contexts हटाएं
- **Secrets** — secrets को तालिका में सूचीबद्ध करें, मान प्रकट करें, secrets जोड़ें या हटाएं
- **Add Secret** — मास्क्ड इनपुट और वैकल्पिक समाप्ति अवधि के साथ इंटरैक्टिव फॉर्म
- **Search** — secrets या contexts में glob पैटर्न खोज
- **Saved Commands** — सहेजे गए command टेम्पलेट्स को सूचीबद्ध करें, देखें और हटाएं
- **Audit** — समाप्त/समाप्त होने वाले secrets की जांच करें, ट्रैक किए गए `.env` फ़ाइल निर्यातों की समीक्षा करें
- **Import .env** — `.env` फ़ाइल से वर्तमान context में secrets लोड करें
- **Export .env** — secrets को `.env` फ़ाइल में निर्यात करें (ऑडिट के लिए ट्रैक किया गया)

कीबोर्ड शॉर्टकट:

| Key | क्रिया |
|-----|--------|
| `↑` / `↓` | मेनू आइटम और तालिका पंक्तियों को नेविगेट करें |
| `Enter` | चुनें / पुष्टि करें |
| `c` | Contexts दृश्य खोलें (मुख्य मेनू) |
| `s` | चयनित को सक्रिय context के रूप में सेट करें (contexts दृश्य) |
| `x` | सक्रिय context साफ़ करें (contexts दृश्य) |
| `a` | नया secret जोड़ें (secrets दृश्य) |
| `d` | चयनित आइटम हटाएं |
| `r` | Secret मान प्रकट करें (विवरण दृश्य) |
| `Esc` | वापस जाएं / रद्द करें |
| `q` | TUI से बाहर निकलें |

### अपने सेटअप की जांच करें

अपने envsec इंस्टॉलेशन को सत्यापित करने के लिए health checks चलाएं।

- `--json` — स्क्रिप्टिंग के लिए JSON प्रारूप में आउटपुट```bash
# Run all health checks
envsec doctor

# JSON output for scripting
envsec --json doctor
```
`doctor` कमांड यह सत्यापित करता है कि आपका envsec इंस्टॉलेशन सही ढंग से काम कर रहा है। यह जाँचता है:
- प्लेटफ़ॉर्म समर्थन और Node.js संस्करण
- क्रेडेंशियल स्टोर उपलब्धता (macOS Keychain, Linux secret-tool, Windows cmdkey)
- Keychain रीड/राइट एक्सेस
- डेटाबेस पथ, अनुमतियाँ, और स्कीमा अखंडता
- अनाथ सीक्रेट्स (keychain प्रविष्टि के बिना मेटाडेटा)
- समाप्त हो चुके सीक्रेट्स
- पर्यावरण चर (`ENVSEC_DB`, `ENVSEC_CONTEXT`)
- वर्तमान शेल

### शेल कम्प्लीशन

envsec bash, zsh, और fish के लिए डायनामिक टैब कम्प्लीशन का समर्थन करता है। कम्प्लीशन संदर्भ-जागरूक होते हैं: वे मेटाडेटा डेटाबेस को क्वेरी करके वास्तविक समय में आपके वास्तविक संदर्भ नाम, सीक्रेट कुंजियाँ, और सहेजे गए कमांड नाम सुझाते हैं।```bash
# Bash (add to ~/.bashrc)
eval "$(envsec --completions bash)"

# Zsh (add to ~/.zshrc)
eval "$(envsec --completions zsh)"

# Fish (add to ~/.config/fish/config.fish)
envsec --completions fish | source
```
गतिशील रूप से क्या पूरा होता है:
- `--context` / `-c` — आपके सभी कॉन्टेक्स्ट की सूची देता है
- सीक्रेट की तर्क (`get`, `add`, `delete`) — वर्तमान कॉन्टेक्स्ट के लिए कुंजियाँ सूचीबद्ध करता है
- `cmd run` / `cmd delete` — सहेजे गए कमांड नामों की सूची देता है
- `--override-context` / `-o` — `cmd run` के लिए कॉन्टेक्स्ट की सूची देता है
- उपकमांड, फ्लैग, और स्थिर विकल्प (शेल, आदि) भी पूरे होते हैं

## तुलना

envsec पर्यावरण सीक्रेट प्रबंधित करने के लिए अन्य टूल्स की तुलना में कैसा है?

| सुविधा | envsec | dotenv / dotenvx | 1Password CLI (`op`) |
|---|---|---|---|
| सीक्रेट भंडारण | OS क्रेडेंशियल स्टोर (Keychain, Secret Service, Credential Manager) | डिस्क पर `.env` फ़ाइलें (dotenvx एन्क्रिप्शन जोड़ता है) | 1Password क्लाउड वॉल्ट |
| आराम पर एन्क्रिप्शन | OS को सौंपा गया (Keychain, GNOME Keyring, DPAPI) | कोई नहीं (dotenv) / प्रति-फ़ाइल ECIES (dotenvx) | 1Password क्लाउड में AES-256 |
| डिस्क पर सीक्रेट | कभी नहीं — मान सीधे OS क्रेडेंशियल स्टोर में जाते हैं | हमेशा — `.env` फ़ाइलें डिफ़ॉल्ट रूप से प्लेनटेक्स्ट होती हैं | स्थानीय रूप से कभी नहीं (रनटाइम पर क्लाउड से लाए जाते हैं) |
| ऑफ़लाइन पहुंच | पूर्ण — सीक्रेट OS स्टोर में स्थानीय होते हैं | पूर्ण — फ़ाइलें स्थानीय होती हैं | नेटवर्क की आवश्यकता होती है (कैश्ड आइटम ऐप में ऑफ़लाइन उपलब्ध) |
| खाता / सदस्यता | कोई नहीं — मुफ्त, ओपन सोर्स, कोई साइनअप नहीं | मुफ्त (dotenv) / मुफ्त ओपन सोर्स (dotenvx) | भुगतान सदस्यता (व्यक्तिगत ~$3/माह से, व्यवसाय ~$8/उपयोगकर्ता/माह) |
| क्रॉस-प्लेटफ़ॉर्म | macOS, Linux, Windows | Node.js वाला कोई भी प्लेटफ़ॉर्म / कोई भी रनटाइम (dotenvx) | macOS, Linux, Windows |
| कॉन्टेक्स्ट / पर्यावरण संगठन | कॉन्टेक्स्ट (जैसे `myapp.dev`, `stripe.prod`) | प्रति पर्यावरण अलग `.env` फ़ाइलें | वॉल्ट और आइटम |
| सीक्रेट के साथ कमांड चलाना | `envsec run` — प्लेसहोल्डर इंटरपोलेशन + `--inject` env वेरिएबल्स | `dotenvx run -- cmd` — एन्क्रिप्टेड `.env` से इंजेक्ट करता है | `op run -- cmd` — सीक्रेट संदर्भों के माध्यम से इंजेक्ट करता है |
| `.env` फ़ाइल में निर्यात | `envsec env-file` (ऑडिट के लिए ट्रैक किया गया) | मूल प्रारूप — `.env` फ़ाइलें स्रोत सत्य हैं | `op inject --out-file` |
| `.env` फ़ाइल से आयात | `envsec load` (संघर्ष पहचान के साथ) | लागू नहीं — `.env` प्राथमिक स्टोर है | मैनुअल आइटम निर्माण |
| शेल env निर्यात | `eval $(envsec env)` — bash, zsh, fish, powershell | `dotenvx run` या `node -r dotenv/config` | `op run --env-file` |
| इंटरैक्टिव शेल सत्र | `envsec shell` — स्वचालित सफाई के साथ स्कोप्ड सबशेल | अंतर्निहित नहीं | अंतर्निहित नहीं |
| सीक्रेट खोज | कुंजियों और कॉन्टेक्स्ट पर ग्लोब पैटर्न | अंतर्निहित नहीं | `op item list --tags/--category` फ़िल्टरिंग |
| समाप्ति / रोटेशन ऑडिट | `envsec audit` — समाप्त, समाप्त होने वाले, ट्रैक किए गए `.env` फ़ाइलें | अंतर्निहित नहीं | Watchtower (ऐप में, CLI नहीं) |
| सहेजे गए कमांड | `envsec cmd` — सहेजें, सूचीबद्ध करें, खोजें, चलाएं, हटाएं | अंतर्निहित नहीं | अंतर्निहित नहीं |
| सीक्रेट स्थानांतरित / कॉपी करें | कॉन्टेक्स्ट के बीच `envsec move` और `envsec copy` | मैनुअल फ़ाइल कॉपी | वॉल्ट के बीच `op item move` |
| सीक्रेट का नाम बदलें | `envsec rename` (मान और मेटाडेटा संरक्षित करता है) | `.env` फ़ाइल का मैनुअल संपादन | `op item edit` |
| GPG-एन्क्रिप्टेड साझाकरण | `envsec share --encrypt-to` | एन्क्रिप्टेड `.env` फ़ाइलें git में कमिट की गईं (dotenvx) | अंतर्निहित वॉल्ट साझाकरण, टीम प्रावधान |
| इंटरैक्टिव TUI | `envsec tui` — पूर्ण-स्क्रीन टर्मिनल UI | अंतर्निहित नहीं | अंतर्निहित नहीं |
| स्वास्थ्य निदान | `envsec doctor` — प्लेटफ़ॉर्म, keychain, DB अखंडता की जाँच करता है | अंतर्निहित नहीं | अंतर्निहित नहीं |
| शेल पूर्णताएँ | bash, zsh, fish के लिए गतिशील (कॉन्टेक्स्ट, कुंजियाँ, कमांड) | अंतर्निहित नहीं | bash, zsh, fish, powershell के लिए स्थिर पूर्णताएँ |
| SDK / प्रोग्रामेटिक पहुंच | Node.js / Bun के लिए `@envsec/sdk` | `require('dotenv').config()` — मुख्य उपयोग मामला | 1Password SDKs (Node.js, Python, Go, आदि) |
| टीम / बहु-उपयोगकर्ता | GPG साझाकरण (मैनुअल) | एन्क्रिप्टेड `.env` के साथ Git-आधारित साझाकरण (dotenvx) | अंतर्निहित टीम प्रबंधन, RBAC, ऑडिट लॉग |
<!-- | CI/CD एकीकरण | मानक CLI — जहाँ भी Node.js चलता है वहाँ काम करता है | किसी भी CI पाइपलाइन में `dotenvx run` | सेवा खाते, मूल CI/CD एकीकरण | -->
| बायोमेट्रिक प्रमाणीकरण | OS बायोमेट्रिक्स विरासत में मिलता है (जैसे macOS Keychain अनलॉक) | कोई नहीं | ऐप एकीकरण के माध्यम से फिंगरप्रिंट / Touch ID |
| मेटाडेटा ट्रैकिंग | SQLite (कुंजी नाम, टाइमस्टैम्प — कभी मान नहीं) | कोई नहीं | क्लाउड-आधारित आइटम इतिहास और ऑडिट लॉग |

संक्षेप में: dotenv सबसे सरल दृष्टिकोण है (डिस्क पर फ़ाइलें), 1Password CLI क्लाउड सिंक और RBAC के साथ टीमों के लिए सबसे अधिक सुविधा-संपन्न है, और envsec बीच में बैठता है — शून्य खातों, शून्य क्लाउड निर्भरताओं के साथ OS-मूल एन्क्रिप्शन प्रदान करता है, और एक डेवलपर-केंद्रित वर्कफ़्लो जो `.env` फ़ाइलों की क्षमता से परे जाता है।

## यह कैसे काम करता है

सीक्रेट मूल OS क्रेडेंशियल स्टोर में संग्रहीत होते हैं। बैकएंड प्लेटफ़ॉर्म के आधार पर स्वचालित रूप से चुना जाता है:

| OS      | बैकएंड                        | टूल / API                          |
|---------|--------------------------------|-------------------------------------|
| macOS   | Keychain                       | `security` CLI                      |
| Linux   | Secret Service API (D-Bus)     | `secret-tool` (libsecret)           |
| Windows | Credential Manager             | `cmdkey` + PowerShell (advapi32)    |

मेटाडेटा (कुंजी नाम, टाइमस्टैम्प) `~/.envsec/store.sqlite` पर एक SQLite डेटाबेस में रखा जाता है (`--db` या `ENVSEC_DB` के माध्यम से कॉन्फ़िगर करने योग्य)। कुंजियों में कम से कम एक डॉट विभाजक होना चाहिए (जैसे, `service.account`) जो क्रेडेंशियल स्टोर की सेवा/खाता संरचना से मेल खाता है।

## सुरक्षा

envsec एक सरल सिद्धांत के आसपास बनाया गया है: आपके सीक्रेट आपके OS में होने चाहिए, dotfiles में नहीं। हर डिज़ाइन निर्णय उसी नींव से शुरू होता है।

### envsec आपके सीक्रेट की सुरक्षा कैसे करता है

**OS-मूल एन्क्रिप्शन, शून्य कस्टम क्रिप्टो।** सीक्रेट मान सीधे macOS Keychain, GNOME Keyring / KDE Wallet, या Windows Credential Manager में संग्रहीत होते हैं। envsec कभी भी अपना स्वयं का एन्क्रिप्शन नहीं बनाता — यह आपके ऑपरेटिंग सिस्टम द्वारा पहले से प्रदान किए गए युद्ध-परीक्षित क्रेडेंशियल स्टोर को सौंपता है, जो आपके उपयोगकर्ता सत्र और (macOS पर) लॉगिन keychain द्वारा संरक्षित होते हैं।

**पूर्ण Unicode समर्थन।** सीक्रेट मानों में कोई भी Unicode वर्ण हो सकते हैं, जिसमें इमोजी और उच्चारित अक्षर शामिल हैं। मान OS क्रेडेंशियल स्टोर में संग्रहीत होने से पहले base64-एन्कोडेड होते हैं, जिससे प्लेटफ़ॉर्म-विशिष्ट एन्कोडिंग विषमताओं (जैसे macOS `security` CLI द्वारा गैर-ASCII आउटपुट का hex-एन्कोडिंग) से बचा जाता है। पिछड़ी संगतता के लिए लीगेसी प्लेनटेक्स्ट सीक्रेट पारदर्शी रूप से पढ़े जाते हैं।

**सीक्रेट कभी भी प्लेनटेक्स्ट के रूप में डिस्क को स्पर्श नहीं करते।** मान सीधे आपके टर्मिनल से OS क्रेडेंशियल स्टोर में जाते हैं। वे कभी भी कॉन्फ़िगरेशन फ़ाइलों, लॉग, या मध्यवर्ती भंडारण में नहीं लिखे जाते।

**टर्मिनल आउटपुट में कोई सीक्रेट नहीं।** `list` और `search` कमांड केवल कुंजी नाम प्रदर्शित करते हैं — मान कभी प्रिंट नहीं होते। यह सीक्रेट को स्क्रॉलबैक बफ़र, स्क्रीन रिकॉर्डिंग, और कंधे-झाँकने की सीमा से बाहर रखता है।

**सुरक्षित कमांड निष्पादन।** `run` कमांड सीक्रेट को कमांड स्ट्रिंग में इंटरपोलेट करने के बजाय चाइल्ड प्रोसेस के पर्यावरण वेरिएबल्स के रूप में इंजेक्ट करता है। इसका मतलब है कि सीक्रेट मान `ps` आउटपुट या शेल इतिहास में दिखाई नहीं देते। यदि कोई संदर्भित सीक्रेट गायब है, तो कमांड पूरी तरह से अवरुद्ध हो जाता है — अधूरे क्रेडेंशियल्स के साथ कोई आंशिक निष्पादन नहीं।

**इनपुट सत्यापन और इंजेक्शन रोकथाम।** कॉन्टेक्स्ट नामों को एक सख्त अनुमतिसूची (अल्फ़ान्यूमेरिक, डॉट्स, हाइफ़न, अंडरस्कोर) के खिलाफ सत्यापित किया जाता है, जिसमें पथ ट्रैवर्सल और प्रोटोटाइप प्रदूषण जाँच शामिल हैं। सभी SQLite क्वेरीज़ बाइंड पैरामीटर के साथ तैयार स्टेटमेंट का उपयोग करती हैं, जिससे SQL इंजेक्शन रोका जाता है। Windows पर PowerShell तर्क कमांड इंजेक्शन से बचाने के लिए एस्केप किए जाते हैं।

**प्रतिबंधात्मक फ़ाइल अनुमतियाँ।** मेटाडेटा निर्देशिका (`~/.envsec/`) `0700` अनुमतियों के साथ और SQLite डेटाबेस `0600` के साथ बनाई जाती है, जिससे स्वामी उपयोगकर्ता तक पहुंच सीमित होती है।

### ज्ञात सीमाएँ और सुधार के क्षेत्र

हम इस बारे में स्पष्ट होने में विश्वास करते हैं कि envsec अभी तक क्या कवर नहीं करता। ये वास्तविक व्यापार-नापसंद हैं, बग नहीं — और इन्हें समझने से आपको सूचित निर्णय लेने में मदद मिलती है।

**मेटाडेटा दृश्यमान है।** `~/.envsec/store.sqlite` पर SQLite डेटाबेस कुंजी नाम, कॉन्टेक्स्ट नाम, और टाइमस्टैम्प संग्रहीत करता है — कभी सीक्रेट मान नहीं, लेकिन यह प्रकट करने के लिए पर्याप्त है कि *कौन से* सीक्रेट मौजूद हैं। सहेजे गए कमांड टेम्पलेट (`{key}` प्लेसहोल्डर के साथ) भी वहाँ संग्रहीत होते हैं। यदि मेटाडेटा गोपनीयता आपके लिए मायने रखती है, तो सुनिश्चित करें कि आपकी होम निर्देशिका एक एन्क्रिप्टेड वॉल्यूम पर है।

**`env-file` निर्यात प्लेनटेक्स्ट हैं।** `env-file` कमांड सीक्रेट मानों को डिस्क पर एक `.env` फ़ाइल में लिखता है। यह स्वाभाविक रूप से संवेदनशील है — आउटपुट फ़ाइल को तदनुसार व्यवहार करें और इसे कभी भी संस्करण नियंत्रण में कमिट न करें। इसे एक सुविधा पुल के रूप में मानें, भंडारण तंत्र के रूप में नहीं।

**शेल निष्पादन में अंतर्निहित जोखिम होता है।** `run` कमांड आपके कमांड टेम्पलेट को `/bin/sh` (या Windows पर `cmd.exe`) के माध्यम से पास करता है। यदि टेम्पलेट स्वयं अविश्वसनीय इनपुट से आता है, तो शेल इंजेक्शन संभव है। केवल उन कमांड टेम्पलेट्स को चलाएं जिन्हें आपने लिखा है या जिन पर आप भरोसा करते हैं।

**कोई क्रॉस-कॉन्टेक्स्ट एक्सेस नियंत्रण नहीं।** आपके OS उपयोगकर्ता के रूप में चलने वाली कोई भी प्रक्रिया सभी कॉन्टेक्स्ट में सभी सीक्रेट पढ़ सकती है। envsec OS-स्तरीय उपयोगकर्ता अलगाव पर निर्भर करता है — यह कॉन्टेक्स्ट के बीच अपनी स्वयं की प्राधिकरण परत नहीं जोड़ता।

**Linux हेडलेस वातावरण।** Linux पर, envsec एक सक्रिय D-Bus सत्र और एक keyring डेमॉन (जैसे `gnome-keyring-daemon`) पर निर्भर करता है। ग्राफ़िकल सत्र के बिना कंटेनरों या हेडलेस सर्वरों में, keyring अनुपलब्ध हो सकता है या कमज़ोर सुरक्षा के साथ सीक्रेट संग्रहीत कर सकता है।

**एन्क्रिप्शन आपके OS पर निर्भर करता है।** envsec मूल क्रेडेंशियल स्टोर द्वारा प्रदान किए गए अतिरिक्त आराम-पर एन्क्रिप्शन नहीं जोड़ता। पूर्ण-डिस्क एन्क्रिप्शन के बिना सिस्टम पर, भौतिक पहुंच वाला एक हमलावर संभावित रूप से keychain से सीक्रेट निकाल सकता है। सबसे मजबूत सुरक्षा के लिए हम पूर्ण-डिस्क एन्क्रिप्शन (FileVault, LUKS, BitLocker) सक्षम करने की अनुशंसा करते हैं।

## विकास

### पूर्वापेक्षाएँ

- Node.js >= 22
- pnpm

कोर, SDK, CLI, और TUI पैकेज Effect 4 का उपयोग करते हैं और वर्तमान में
`4.0.0-rc.112` पर पिन किए गए हैं। जब तक Effect 4 रिलीज़-उम्मीदवार स्थिति में रहता है, वर्कस्पेस में Effect और `@effect/platform-node` संस्करणों को संरेखित रखें।

### सेटअप```bash
git clone https://github.com/davidnussio/envsec.git
cd envsec
pnpm install
pnpm run build
```
### प्रोजेक्ट संरचना```
packages/
  cli/     → envsec CLI (published as `envsec`)
  sdk/     → Node.js/Bun SDK (published as `@envsec/sdk`)
  core/    → Core engine, shared by CLI and SDK (published as `@envsec/core`)
  tui/     → Interactive terminal UI (published as `@envsec/tui`)
apps/
  website/ → Documentation website
```
### सामान्य कमांड```bash
# Build all packages
pnpm run build

# Lint and format check (all packages)
pnpm run check

# Auto-fix lint and formatting
pnpm run fix

# Run package unit and contract tests
pnpm run test:unit

# Run the CLI end-to-end suite with isolated database and credential fixtures
pnpm --filter envsec test

# Release (build + changeset publish)
pnpm run release
```
E2E सुइट कभी भी नेटिव क्रेडेंशियल स्टोर तक पहुंच नहीं करता। macOS या Linux पर वास्तविक OS एडेप्टर का परीक्षण करने के लिए, पहले बिल्ड करें और स्पष्ट रूप से ऑप्ट-इन करें:```bash
ENVSEC_E2E_CLI="$PWD/packages/cli/dist/main.js" \
  ENVSEC_E2E_ISOLATED=0 \
  pnpm --filter envsec test
```
Native E2E परीक्षण समर्पित `test.e2e*` संदर्भों का उपयोग करते हैं और बाद में उन्हें हटा देते हैं।

### स्थानीय रूप से बिना इंस्टॉल किए चलाना

स्थानीय बिल्ड को वैश्विक रूप से इंस्टॉल किए हुए की तरह उपयोग करने के लिए एक अस्थायी alias बनाएं:```bash
# Bash / Zsh
alias envsec="node $(pwd)/packages/cli/dist/main.js"

# Fish
alias envsec "node (pwd)/packages/cli/dist/main.js"
```
### शेल कम्प्लीशन का स्थानीय रूप से परीक्षण

बिल्ड करने और alias सेट करने के बाद, अपने वर्तमान सत्र में कम्प्लीशन लोड करें:```bash
# Bash
alias envsec="node $(pwd)/packages/cli/dist/main.js"
eval "$(envsec --completions bash)"

# Zsh
alias envsec="node $(pwd)/packages/cli/dist/main.js"
eval "$(envsec --completions zsh)"

# Fish
alias envsec "node (pwd)/packages/cli/dist/main.js"
envsec --completions fish | source
```
फिर `envsec -c ` के बाद TAB दबाएँ ताकि आपके कॉन्टेक्स्ट दिखें, या `envsec -c myapp.dev get ` के बाद TAB दबाएँ ताकि सीक्रेट कुंजियाँ दिखें।

### टेस्ट चलाना

एंड-टू-एंड इंटीग्रेशन टेस्ट पूरे CLI जीवनचक्र (add, get, list, search, env-file, load, delete, run, cmd, audit, share, completions) को कवर करते हैं।```bash
# Build first
pnpm run build

# macOS / Linux
bash packages/cli/test/e2e-test.sh

# Windows (PowerShell)
pwsh packages/cli/test/e2e-test.ps1
```
CI स्वचालित रूप से `main` पर push/PR होने पर GitHub Actions के माध्यम से चलता है, macOS और Ubuntu पर `e2e-test.sh` और Windows पर `e2e-test.ps1` निष्पादित करता है।

## License

MIT