jitpass - जस्ट-इन-टाइम पासवर्ड

आपकी डेवलपमेंट मशीन के लिए जस्ट-इन-टाइम क्रेडेंशियल्स।

दस्तावेज़ीकरण · त्वरित आरंभ · समर्थित उपकरण · कमांड संदर्भ · सुरक्षा

स्थिति: केवल macOS (Apple Silicon), और अभी भी विकास में है।

jit क्या है (30 सेकंड)

आपके रहस्य आपकी मशीन पर हर जगह सादे पाठ में रहते हैं: .env फ़ाइलें, ~/.aws/credentials, ~/.zshrc एक्सपोर्ट, .npmrc टोकन, MCP कॉन्फ़िग। आपके रूप में चलने वाली कोई भी चीज़ उन्हें पढ़ सकती है। एक खराब curl | sh, एक संदिग्ध npm install, या आपके एडिटर में अब आपकी पूर्ण अनुमतियों के साथ चलने वाले AI एजेंटों में से एक।

jit प्रत्येक रहस्य को Touch ID द्वारा संरक्षित एक स्थानीय एन्क्रिप्टेड वॉल्ट में ले जाता है, और फ़ाइलों को फिर से लिखता है ताकि आपके उपकरण काम करते रहें। डिस्क पर अब एक डिकॉय है। असली मूल्य केवल मेमोरी में, उस विशिष्ट प्रक्रिया के लिए प्रकट होता है जिसने इसे मांगा था, बायोमेट्रिक प्रॉम्प्ट के बाद। परिणाम: आप एक बार अनलॉक करते हैं, jit किसी उपकरण (या एजेंट) को क्रेडेंशियल सौंपने से पहले पूछता है, और बाकी समय डिस्क पर एक डिकॉय होता है।

Code द्वारा लॉन्च किया गया	claude द्वारा लॉन्च किया गया

यह क्या नहीं करता: यह पहले से समझौता किए गए खाते को सुरक्षित नहीं बनाता, और यह एक बार रहस्य उस प्रक्रिया की मेमोरी में आ जाने पर उसकी रक्षा नहीं करता जिसने इसे मांगा था। सीमाएँ एक पृष्ठ पर, शुरू में ही बताई गई हैं: जानबूझकर की गई सीमाएँ।

यह यांत्रिक रूप से कैसे काम करता है

कोई कर्नेल एक्सटेंशन नहीं, कोई फ़ाइलसिस्टम ड्राइवर नहीं, कोई FUSE नहीं। तीन तंत्र, जो उपकरण जो कर सकता है उसके आधार पर चुने गए हैं:

पर्यावरण चर एक प्रक्रिया में, फिर execve। jit की अपनी छवि आपके कमांड द्वारा प्रतिस्थापित की जाती है, इसलिए मान उस एक प्रक्रिया में रहता है और jit मेमोरी से गायब हो जाता है।
उपकरण का मूल क्रेडेंशियल प्रोटोकॉल, जहाँ एक मौजूद है: AWS credential_process, docker और git क्रेडेंशियल हेल्पर, kubectl exec प्लगइन्स, Terraform का क्रेडेंशियल्स हेल्पर। उपकरण पूछता है, jit उत्तर देता है, कोई फ़ाइल शामिल नहीं होती।
एक नामित-पाइप माउंट, उन उपकरणों के लिए जो केवल एक फ़ाइल पढ़ सकते हैं।

माउंट एक POSIX FIFO है, जो mkfifo(2) के साथ मोड 0600 पर बनाया गया है। एक प्रोग्राम जो open(".env") कहता है वह कर्नेल में तब तक ब्लॉक रहता है जब तक कोई लेखक कनेक्ट नहीं होता। पृष्ठभूमि सेवा वह लेखक है: यह पथ को O_WRONLY के साथ खोलती है, जो रीडर को रिलीज़ करता है, डिक्रिप्टेड बाइट्स को मेमोरी से कर्नेल पाइप बफर में लिखता है, बंद करता है, और अगले रीडर के लिए open(2) पर वापस लूप करता है। कुछ भी डिस्क को स्पर्श नहीं करता। जो लिखा जाता है वह प्रति रीड तय किया जाता है: परिवेशी रीडर के लिए डिकॉय, केवल उस रन के अंदर वास्तविक मान जिसे आपने अधिकृत किया था।

कॉलर पहचान समझाती और ऑडिट करती है, यह कभी निर्णय नहीं लेती। प्रक्रिया नाम जाली हो सकते हैं, और तेज़ी से बंद होने वाला FIFO रीडर पहचान से पूरी तरह बच सकता है। प्रॉम्प्ट का उत्तर देने वाला मानव ही द्वार है; प्रक्रिया का नाम केवल आपको बताता है कि क्या उत्तर देना है। पूरा विवरण यह कैसे काम करता है और लाइव माउंट्स में।

इंस्टॉल करें

brew install jitpass/tap/jitpass

यह अनुशंसित मार्ग है, और एक सुरक्षा उपकरण के लिए कारण मायने रखता है। रिलीज़ Apple डेवलपर ID के साथ हस्ताक्षरित और Apple द्वारा नोटराइज़्ड हैं। Homebrew जो डाउनलोड करता है उसे क्वारंटाइन करता है, इसलिए Gatekeeper बाइनरी को उसके नोटराइज़ेशन टिकट के विरुद्ध जाँचता है इससे पहले कि उसे कभी चलने दिया जाए। इसे स्वयं सत्यापित करने के लिए हमारे शब्द पर भरोसा करने के बजाय, jit doctor चलाएँ: इसकी jit पंक्ति signed CZC6BH93GJ रिपोर्ट करती है, वही जाँच jit upgrade कुछ भी इंस्टॉल करने से पहले चलाता है।

Homebrew के बिना (कमज़ोर मार्ग, और क्यों)

curl -sL https://dl.jitpass.com/jitpass/jit/releases/latest/download/jitpass_darwin_arm64.tar.gz | tar -xz jit
shasum -a 256 jit   # रिलीज़ पेज पर checksums.txt से तुलना करें
codesign -dv --verify --verbose=2 ./jit   # अपेक्षा: Developer ID, TeamIdentifier=CZC6BH93GJ
sudo mv jit /usr/local/bin/

यह उन लोगों के लिए है जिनके पास Homebrew नहीं है, और यह वास्तव में कमज़ोर मार्ग है: curl कोई क्वारंटाइन बिट सेट नहीं करता, इसलिए Gatekeeper कभी नोटराइज़ेशन टिकट से परामर्श नहीं करता, और go install के लिए भी यही सच है। बाइनरी अभी भी हस्ताक्षरित और अभी भी नोटराइज़्ड है, इसलिए उपरोक्त दो पंक्तियाँ आपको इसे चलाने से पहले दोनों की जाँच करने देती हैं, लेकिन आपको वास्तव में उन्हें चलाना होगा। यदि आपके पास Homebrew है, तो Homebrew का उपयोग करें।

केवल Apple Silicon। Intel Mac पर, स्रोत से बनाएँ: go install github.com/jitpass/jit/cmd/jit@latest।

एक मार्ग चुनें। यदि आपने पहले tarball से इंस्टॉल किया था और Homebrew पर स्विच कर रहे हैं, तो brew install के बाद पुरानी कॉपी हटा दें (sudo rm /usr/local/bin/jit); अन्यथा दो jit PATH पर अलग-अलग अपग्रेड होते रहेंगे, और jit doctor इसे फ़्लैग करेगा।

अपग्रेड करना: brew upgrade jitpass, या jit upgrade: एक सत्यापित सेल्फ-अपडेट (Developer-ID हस्ताक्षर और चेकसम दोनों स्वैप से पहले जाँचे जाते हैं, सेवा पुनः आरंभ होती है)। किसी भी तरह आपका वॉल्ट अछूता रहता है।

Homebrew बाइनरी के साथ शेल कम्प्लीशन इंस्टॉल करता है, इसलिए jit <TAB> सबकमांड, फ़्लैग, वॉल्ट पथ और रैप करने योग्य उपकरण नामों को आउट ऑफ़ द बॉक्स पूरा करता है। Tarball या स्रोत से इंस्टॉल किया गया हो, इसे स्वयं जोड़ें:

echo 'source <(jit completion zsh)' >> ~/.zshrc && exec zsh

किसी भी तरह, jit doctor आपको बताता है कि कम्प्लीशन आपके शेल तक पहुँच रहा है या नहीं।

आप वास्तव में इसका उपयोग कैसे करते हैं

jit scan                            # केवल पढ़ने के लिए। यह जिस भी फ़ाइल को स्कैन करता है उसे नहीं बदलता, कोई वास्तविक मान प्रिंट नहीं करता।
jit vault init                      # वॉल्ट बनाएँ (मास्टर कुंजी आपके लॉगिन कीचेन में)
jit migrate --dry-run               # पूरी मशीन-व्यापी सुधार योजना का पूर्वावलोकन करें
jit migrate                         # इसे लागू करें: योजना दिखाता है, [y/N] पूछता है, एक Touch ID
jit migrate ~/code/myapp            # या केवल एक प्रोजेक्ट ठीक करें
jit run -- npm run dev              # अपना उपकरण चलाएँ; वास्तविक मान केवल उस प्रक्रिया में इंजेक्ट किए जाते हैं

jit scan बिना किसी पथ के आपकी पूरी होम निर्देशिका को स्कैन करता है, इसलिए बड़ी निर्देशिका पर इसे एक पल दें। सीधे एक स्थान पर जाने के लिए, इसे एक पथ पर इंगित करें: jit scan ~/.aws।

दिन-प्रतिदिन यह ज़्यादातर jit run -- <cmd> है। उन CLI के लिए जो अपना स्वयं का लॉगिन टोकन रखते हैं (gh, glab, stripe, और अधिक) आप एक बार jit wrap gh करते हैं और फिर हमेशा की तरह सामान्य रूप से gh टाइप करते रहते हैं।

निश्चित नहीं कि किसी चीज़ को jit wrap, jit migrate, या कुछ भी चाहिए? आपको जानने की आवश्यकता नहीं है। jit scan जो कुछ भी पाता है उसे विभाजित करता है कि jit क्या सुरक्षित करेगा (एक कमांड - रैप्स सहित) और क्या केवल आप ठीक कर सकते हैं, और बिना किसी तर्क के jit migrate उस पूरी योजना को चलाता है:

$ jit scan
  आपके रहस्य: 7 — jit द्वारा संरक्षित 0 (0%)
  ▱▱▱▱▱▱▱▱▱▱  से 100%: एक कमांड +71% · 2 रहस्य केवल आप ठीक कर सकते हैं +29%

  jit इनकी रक्षा करेगा — 4 फ़ाइलों में 5 रहस्य, 0% → 71%
      → jit migrate
        ~/.zshrc            STRIPE_API_KEY, DB_PASSWORD
        ~/.config/gh/hosts.yml  GitHub CLI टोकन · gh रैप करता है
        ...

  केवल आप इनकी रक्षा कर सकते हैं — 2 रहस्य, 71% → 100%

    [रोटेट करें, फिर हर कॉपी हटाएँ]
    ! 2 फ़ाइलों में एक प्रोडक्शन डेटाबेस पासवर्ड
      → इसे अभी रोटेट करें, फिर हर कॉपी हटाएँ

(jit scan --full अभी भी गंभीरताओं के साथ क्लासिक प्रति-श्रेणी सूची देता है, जिसमें रैप करने योग्य CLI टोकन अनुभाग शामिल है।)

आपके रोज़मर्रा के उपकरण

क्रेडेंशियल को एक बार माइग्रेट करें, फिर उपकरण का उपयोग उसी तरह करते रहें जैसे आप हमेशा करते हैं।

# AWS (और Terraform, और हर AWS SDK)
jit migrate ~/.aws/credentials       # कुंजियाँ वॉल्ट में चली जाती हैं; कोई सादा-पाठ फ़ाइल नहीं बचती
aws s3 ls                            # मांग पर वॉल्ट से हल होता है। कोई उपसर्ग नहीं, कोई फ़्लैग नहीं।
terraform apply                      # समान क्रेड्स, समान कमांड

# GCP एप्लिकेशन-डिफ़ॉल्ट क्रेडेंशियल्स (एक मशीन-व्यापी क्रेडेंशियल)
jit migrate ~/.config/gcloud/application_default_credentials.json
terraform apply                      # google प्रदाता ADC पढ़ता है; Touch ID प्रॉम्प्ट के बाद काम करता है

# Docker / docker-compose
jit migrate ~/.docker/config.json    # रजिस्ट्री लॉगिन वॉल्ट में चले जाते हैं
jit run -- docker compose up         # jit उन्हें इस रन के लिए इंजेक्ट करता है
docker login ghcr.io                 # अभी भी काम करता है; हेल्पर वॉल्ट में संग्रहीत करता है

# शेल एक्सपोर्ट जो पहले ~/.zshrc में रहते थे
jit migrate ~/.zshrc                 # एक-पंक्ति हुक छोड़ता है; नए शेल में केवल वेरिएबल होते हैं
./deploy.sh                          # जो स्क्रिप्ट उन वेरिएबल्स को पढ़ती हैं वे अपरिवर्तित काम करती हैं

# टोकन जो आपने एक बार प्रॉम्प्ट पर टाइप किए थे, अब आपके शेल इतिहास में बैठे हैं
jit migrate ~/.zsh_history           # प्रत्येक वॉल्ट में चला जाता है; आपके कमांड रहते हैं, रहस्य नहीं
jit guard history                    # और अगले को बिल्कुल भी रिकॉर्ड होने से रोकें (zsh)
                                     # (बिना तर्क के `jit migrate` भी यह प्रदान करता है, उस योजना में जिसे आप पुष्टि करने के लिए कहते हैं)

# एक CLI जो अपना स्वयं का टोकन रखता है (gh, stripe, glab)
jit wrap gh                          # एक बार
gh pr list                           # टोकन प्रति कॉल इंजेक्ट किया जाता है, हमेशा के लिए

पहली बार जब प्रत्येक उपकरण वास्तविक क्रेडेंशियल के लिए पहुँचता है, jit एक बार पूछता है और आपका उत्तर तब तक याद रखता है जब तक वॉल्ट लॉक नहीं हो जाता। देखें दो Touch ID क्षण यह कैसे वॉल्ट अनलॉक के ऊपर बैठता है, --trust क्या करता है, और कैसे प्रति-उपकरण प्रॉम्प्ट बंद करें।

कुछ उपकरणों को कोई सेटअप की आवश्यकता क्यों नहीं होती जबकि अन्य jit run लेते हैं? एक नियम: क्या उपकरण स्वयं jit से रहस्य माँग सकता है? AWS (credential_process के माध्यम से), आपका शेल लॉगिन पर, और docker के रजिस्ट्री लॉगिन (क्रेडेंशियल हेल्पर के माध्यम से) सभी कर सकते हैं, इसलिए आप कुछ भी अतिरिक्त नहीं टाइप करते। जो उपकरण केवल रनटाइम पर एक फ़ाइल पढ़ते हैं (docker compose, सादे SDK) नहीं पूछ सकते, इसलिए jit run उन्हें मान सौंपता है।

मशीन-वैश्विक क्रेडेंशियल फ़ाइलें (GCP ADC, sops, npm, netrc) उसी रोज़मर्रा के तरीके से काम करती हैं: अपना उपकरण चलाएँ और प्रति-प्रक्रिया प्रॉम्प्ट को स्वीकृत करें। jit run --with <name> केवल तब जोड़ें जब आप इसे स्पष्ट चाहते हैं: स्क्रिप्ट और CI के लिए जहाँ उत्तर देने के लिए कोई प्रॉम्प्ट नहीं है, या जब आप एक कठोर द्वार चाहते हैं जिस तक किसी प्रोजेक्ट का अपना कॉन्फ़िग कभी नहीं पहुँच सकता। समर्थित उपकरण सूचीबद्ध करता है कि प्रत्येक उपकरण के लिए वास्तव में क्या टाइप करना है, और प्रत्येक कैसे वितरित किया जाता है।

दो Touch ID क्षण, एक नहीं

jit दो अलग-अलग क्षणों में आपकी फिंगरप्रिंट पूछता है, दो अलग-अलग काम करते हुए:

अपना वॉल्ट अनलॉक करना। लॉक होने के बाद पहली बार jit का उपयोग करने पर, एक Touch ID पूरे सत्र के लिए वॉल्ट खोलता है (5 मिनट की गतिविधि, फिर यह फिर से लॉक हो जाता है; और 8 घंटे से अधिक कभी नहीं, चाहे आप कितने भी व्यस्त हों)। आप एक बार अनलॉक करते हैं, प्रति कमांड नहीं।
किसी उपकरण को क्रेडेंशियल सौंपना। उसके ऊपर, पहली बार जब कोई दिया गया उपकरण वास्तविक क्रेडेंशियल के लिए पहुँचता है, jit सौंपने से पहले पूछता है और नाम बताता है कि कौन पूछ रहा है। यही एक ऐसे प्रोग्राम को रोकता है जिसे आपने नहीं चलाया था, वॉल्ट खुले रहते हुए चुपचाप आपकी कुंजियों का उपयोग करने से।

$ aws s3 ls
  Touch ID  ->  अपना वॉल्ट अनलॉक करें              # द्वार 1: वॉल्ट को 5 मिनट के लिए खोलता है
  Touch ID  ->  aws आपका aws क्रेडेंशियल चाहता है   # द्वार 2: यह उपकरण, यह क्रेडेंशियल
  ...आपके बकेट...

$ aws s3 cp ./file s3://bucket/   # समान उपकरण, समान सत्र: कोई प्रॉम्प्ट नहीं

$ terraform apply
  Touch ID  ->  terraform आपका aws क्रेडेंशियल चाहता है   # एक अलग उपकरण: यह अपने आप पूछता है

द्वार 2 ही एक अनलॉक किए गए वॉल्ट को सबके लिए खुला होने से रोकता है: भले ही आपने स्वयं aws का उपयोग किया हो, एक संदिग्ध npm install जो उन्हीं कुंजियों के लिए पहुँचता है फिर भी एक प्रॉम्प्ट ट्रिगर करता है जो उसका नाम बताता है, ताकि आप ना कह सकें।

दूसरा द्वार नहीं चाहते? इसे बंद करें; वॉल्ट लॉक रहता है (इसे बंद करना स्वयं एक Touch ID लेता है, क्योंकि यह उस विंडो को फिर से खोलता है जिसे यह बंद करता है):

jit service consent off   # वॉल्ट अनलॉक होने पर उपकरण चुपचाप हल होते हैं
jit service consent on    # प्रति उपकरण फिर से पूछें (डिफ़ॉल्ट)

कुछ ऐसा शुरू कर रहे हैं जिसे एक साथ कई क्रेडेंशियल्स चाहिए? jit run --trust -- terraform apply उस पूरे रन के उपकरणों को एक ही इशारे में स्वीकृत करता है। पूरा विवरण: प्रति-प्रक्रिया सहमति।

कीबोर्ड छोड़ रहे हैं? `jit grant`

दोनों द्वार मानते हैं कि उत्तर देने के लिए एक मानव मौजूद है। रात भर काम करने वाला एक AI एजेंट, एक लंबा बिल्ड, एक निर्धारित कार्य: स्क्रीन लॉक होती है, सत्र गिर जाता है, और रन एक प्रॉम्प्ट पर रुक जाता है जिसे कोई नहीं देखेगा। एक प्रक्रिया अनुदान आपके निर्णय को हटाने के बजाय पहले ले जाता है - एक Touch ID, जब आप अभी भी मौजूद हैं, जो ठीक वही नाम बताता है जिस पर आप हस्ताक्षर कर रहे हैं:

$ jit grant --process claude --profile jamf --for 8h
  Touch ID  ->  iTerm2 के तहत claude को 2 रहस्य (jamf) का उपयोग 8h के लिए बिना निगरानी के करने दें
✓ अनुदानित g-7f3a2c81   claude -> jamf   17:42 तक
  └ iTerm2 के तहत claude को कवर करता है: 1 अभी चल रहा है, 17:42 से पहले शुरू किया गया कोई भी

अगले 8 घंटों के लिए, जिस टर्मिनल में आपने वह टाइप किया उसके तहत हर claude (और जो कुछ भी यह लॉन्च करता है) को वे रहस्य बिना किसी प्रॉम्प्ट के मिलते हैं - स्क्रीन लॉक के माध्यम से और सब कुछ, जिसमें बाद में शुरू किए गए सत्र शामिल हैं: एक नया टैब, अगला claude, एक स्क्रिप्ट जो सुबह 3 बजे चलती है। यह आपका टर्मिनल नामित हो रहा है, कोई नाम भरोसेमंद नहीं हो रहा: एक प्रोग्राम जो मशीन पर कहीं और खुद को claude कहता है उस पेड़ से उतरता नहीं है और कुछ भी विरासत में नहीं लेता। अनुदान अपनी समय सीमा पर समाप्त होता है, जब आप उस टर्मिनल को छोड़ देते हैं, या जिस क्षण आप jit grant revoke टाइप करते हैं (जिसे कोई फिंगरप्रिंट नहीं चाहिए - पहुँच हटाना हमेशा मुफ्त है)। एक सटीक प्रक्रिया चाहते हैं, जो बाहर निकलने पर गायब हो जाए? --pid। हर सेव ऑडिट ट्रेल में अपनी घटना के रूप में दर्ज होता है, इसलिए अगली सुबह आप ठीक पढ़ सकते हैं कि आपके एजेंट ने आपके सोते समय क्या छुआ। पूरा विवरण: प्रक्रिया अनुदान।

AI एजेंट और MCP सर्वर

आपके एडिटर में एजेंट आपके रूप में चलता है, आपकी अनुमतियों के साथ, और आपके लिए पूरे दिन फ़ाइलें पढ़ता है। यही इसका पूरा उद्देश्य है, और यही कारण है कि आपके रिपॉजिटरी में एक सादा-पाठ .env अब दो साल पहले की तुलना में एक बहुत अलग जोखिम है। jit एजेंटों को प्रथम श्रेणी के रूप में मानता है, चार मोर्चों पर:

jit migrate ~/.claude.json           # MCP सर्वर कॉन्फ़िग: कुंजियाँ वॉल्ट में चली जाती हैं,
                                     # प्रत्येक सर्वर अब `jit run` के माध्यम से लॉन्च होता है
jit wrap claude                      # AI CLI स्वयं: claude, codex, gemini,
                                     # cursor-agent, copilot, cline, opencode, kiro-cli
jit grant --process claude --profile myapp --for 8h
                                     # इसे रात भर बिना किसी प्रॉम्प्ट के काम करने दें जिसका कोई उत्तर नहीं देता
jit audit --parent claude            # ठीक वही पढ़ें जो आपके सोते समय इसने छुआ

प्रॉम्प्ट एजेंट का नाम बताता है। प्रति-प्रक्रिया सहमति चालू होने पर (डिफ़ॉल्ट), पहली बार जब कोई उपकरण वास्तविक क्रेडेंशियल के लिए पहुँचता है तो आपको एक Touch ID मिलता है जो बताता है कि कौन सा प्रोग्राम पूछ रहा है। यही वह है जो इस पृष्ठ के शीर्ष पर दो स्क्रीनशॉट दिखाते हैं: VS Code और claude द्वारा अनुरोधित एक ही रहस्य, प्रत्येक का नाम। एक एजेंट जो चुपचाप ~/.aws/credentials पढ़ता है वह एक प्रॉम्प्ट है, एक मूक सफलता नहीं।
MCP सर्वर jit run के माध्यम से लॉन्च होते हैं। एक माइग्रेटेड MCP कॉन्फ़िग वॉल्ट पथ रखता है, कुंजियाँ नहीं, इसलिए कॉन्फ़िग फ़ाइल स्वयं डिस्क पर होना सुरक्षित है और उस एजेंट को सौंपना सुरक्षित है जो इसे पढ़ता है।
एक डिकॉय वही है जो एक अनधिकृत पठन को मिलता है। एक एजेंट जो आपके रिपॉजिटरी में .env के लिए grep करता है और इसे ठंडा पढ़ता है उसे प्लेसहोल्डर मान मिलते हैं, और पठन लॉग किया जाता है।
jit audit --parent claude हर रहस्य दिखाता है जो एक एजेंट ने उपयोग किया, हर प्रॉम्प्ट जो इसने ट्रिगर किया, और

jit

सबसे लोकप्रिय