फ़ाइलें और फ़ोल्डर

Signal Lab जो कुछ रखता है, वह सब एक ही फ़ोल्डर, डेटा फ़ोल्डर में सादा JSON (या टेक्स्ट) है। सीक्रेट के मान उसमें कभी नहीं होते।

डेटा फ़ोल्डर

Signal Lab कहाँ चलता है	डेटा फ़ोल्डर
डेस्कटॉप ऐप, Windows	आपके उपयोगकर्ता फ़ोल्डर में Documents\SignalLab: C:\Users\<you>\Documents\SignalLab
डेस्कटॉप ऐप, Linux	~/Documents/SignalLab
सर्वर	--data-dir, या SIGNALLAB_DATA_DIR; दोनों के बिना, जिस उपयोगकर्ता के रूप में यह चलता है उसके home फ़ोल्डर में Documents/SignalLab
सर्वर, Docker इमेज	/data, एक वॉल्यूम (compose फ़ाइल में signallab-data)
signallab run	एक अस्थायी फ़ोल्डर, बाहर निकलने पर हटा दिया जाता है — जब तक --data-dir कोई नाम न दे

डेस्कटॉप ऐप सेट होने पर अपने एनवायरनमेंट से SIGNALLAB_DATA_DIR भी लेता है। फ़ोल्डर तब बनाया जाता है जब उसमें पहली बार कुछ लिखा जाता है।

TIP

Windows पर ऐप आपके उपयोगकर्ता फ़ोल्डर के भीतर सीधे Documents फ़ोल्डर उपयोग करता है, भले ही Windows आपके दस्तावेज़ कहीं और (OneDrive) रखता हो।

सर्वर पर, फ़ाइलें सर्वर की मशीन पर लिखी जाती हैं, आपकी मशीन पर नहीं। हेडर में सर्वर बैज अपनी टिप में बताता है कि कहाँ; API इसे app_info के data_dir के रूप में देता है, और /api/files उसमें जो है उसे डाउनलोड करता है।

कमांड लाइन के signallab emulate, signallab send और signallab mcp ऐप की लाइब्रेरी उसी फ़ोल्डर से पढ़ते हैं जिससे डेस्कटॉप ऐप।

उसमें क्या है

फ़ाइल	यह क्या है	कब लिखी जाती है
experiment.json	एडिटर में खुला प्रयोग	हर बदलाव के कुछ ही देर बाद
signals.json	सिग्नल लाइब्रेरी (सिग्नल)	हर बदलाव के कुछ ही देर बाद
emulators.json	एमुलेटर लाइब्रेरी (एमुलेटर)	हर बदलाव के कुछ ही देर बाद
runs/run-<ms>-<job>.json	ख़ुद समाप्त हुए हर रन की एक रिपोर्ट	रन समाप्त होने पर
exports/experiment-<ms>-<16 hex digits>.json	प्रयोग का एक स्नैपशॉट	वर्तमान JSON निर्यात करें
capture-<ms>.jsonl, capture-<ms>.txt	इंस्पेक्टर के फ़्रेम	.jsonl निर्यात करें, .txt निर्यात करें
token	सर्वर का एक्सेस टोकन, केवल उसके उपयोगकर्ता से पढ़ने योग्य	--generate-token, पहली बार शुरू होने पर
.experiment-<hex>.tmp, .signals-<hex>.tmp, .emulators-<hex>.tmp	रास्ते में एक सेव	एक पल के लिए, फिर नाम बदल दिया जाता है

<ms> 1970 से मिलीसेकंड में समय है; <job> रन की जॉब संख्या है। सर्वर पर हर ब्राउज़र उसी experiment.json, उन्हीं लाइब्रेरी और उन्हीं रिपोर्ट पर काम करता है।

फ़ॉर्मैट

सब UTF-8 में JSON हैं, इंडेंटेशन के साथ लिखे जाते हैं ताकि वे अच्छी तरह पढ़े और diff हों। हर एक में एक version होता है; पुराने संस्करण की फ़ाइल खोले जाने पर पढ़ी और माइग्रेट की जाती है, और अगली बार सहेजे जाने पर वर्तमान संस्करण में वापस लिखी जाती है — जिसके बाद कोई पुराना Signal Lab उसे नहीं खोल सकता।

experiment.json

प्रयोग दस्तावेज़, संस्करण 9 — वही JSON जो वर्तमान JSON निर्यात करें लिखता है और JSON खोलें… पढ़ता है:

{
  "version": 9,
  "name": "HTTP check",
  "params": [],
  "profiles": [],
  "profile": null,
  "seed": null,
  "cookies": true,
  "nodes": [ { "id": "start", "type": "start", "x": 40, "y": 80 }, … ],
  "edges": [ { "from": "start", "to": "request", "port": "next" }, … ]
}

• अधिकतम 4 MiB, और 1 से 64 नोड (doc.node_count)।
• संस्करण 1 से 8 खोलने पर माइग्रेट किए जाते हैं। संस्करण 8 से पहले की फ़ाइल cookies बंद रखते हुए खुलती है, इसलिए वह वैसे ही चलती है जैसे चलती थी; हर संस्करण ने जो दूसरी सेटिंग्स जोड़ीं (2 में parameters, 3 में profiles, 4 में retries, 5 में repeats और loops, 6 में emulators, 7 में impairments, 8 में WebSocket और HTTP प्रमाणीकरण, 9 में load) वे खाली शुरू होती हैं।
• इस Signal Lab को ज्ञात से नए संस्करण को खोलने के बजाय अस्वीकार किया जाता है (doc.version_unsupported), ऐसा न हो कि जो वह पढ़ न सके उसके बिना खोल दिया जाए।
• जो फ़ाइल पार्स न हो, उसकी सूचना उसके पथ, पंक्ति और कॉलम के साथ दी जाती है, और उसे कभी बदला नहीं जाता।
• यह एक अस्थायी फ़ाइल में लिखी और नाम-बदल कर रखी जाती है, इसलिए विफल लेखन पिछली वाली को छोड़ जाता है।

नोड, parameters और profiles क्या हैं: प्रयोग, नोड, डेटा।

signals.json

सिग्नल लाइब्रेरी, संस्करण 2:

{
  "version": 2,
  "signals": [
    {
      "id": "…",
      "name": "Go cue",
      "group": "Stage/Cues",
      "note": "",
      "body": { "transport": "osc", "target": "127.0.0.1:9000", "address": "/cue/go", "args": [ { "type": "int", "value": 1 } ] }
    }
  ],
  "folders": [ "Stage", "Stage/Cues" ]
}

• group सिग्नल का फ़ोल्डर / पथ के रूप में है; खाली का अर्थ शीर्ष स्तर है। folders (संस्करण 2 में जोड़ा गया) हर फ़ोल्डर की सूची देता है, खाली वाले भी शामिल, और जब कोई न हो तो छोड़ दिया जाता है। संस्करण 1 की फ़ाइल वैसे ही पढ़ी जाती है, खाली फ़ोल्डरों के बिना।
• body या तो osc, udp, http या mqtt होता है; उनके फ़ील्ड signals_save में हैं।
• जब फ़ाइल न हो, तो स्टार्टर सेट लिखा जाता है — हर लक्ष्य 127.0.0.1 पर — और इंटरफ़ेस की भाषा में नाम-बदल दिया जाता है।
• जो फ़ाइल पार्स न हो, उसकी सूचना उसके पथ, पंक्ति और कॉलम के साथ दी जाती है (signals.json_invalid) और उसे स्टार्टर सेट से कभी नहीं बदला जाता: उसे ठीक करें या मिटाएँ। जब तक वह न पढ़े, कोई लाइब्रेरी नहीं लिखता — सेव उसी त्रुटि के साथ अस्वीकार होता है और फ़ाइल जैसी है वैसी रहती है — जब तक फ़ाइल फिर से लोड करें उसे दोबारा न पढ़े। सेव उसी फ़ोल्डर की अस्थायी फ़ाइल से होकर जाता है, इसलिए बीच में कटा लेखन पिछली फ़ाइल छोड़ जाता है।

emulators.json

एमुलेटर लाइब्रेरी, संस्करण 1:

{
  "version": 1,
  "emulators": [
    { "id": "demo-api", "note": "…", "emulator": { "name": "Demo API", "bind": "127.0.0.1:8080", "protocol": "http", "routes": [ … ] } }
  ]
}

हर प्रविष्टि एक id और note वाला एमुलेटर दस्तावेज़ है; दस्तावेज़ का वर्णन एमुलेटर में है। सिग्नल की तरह, न होने पर फ़ाइल को स्टार्टर सेट मिलता है (हर एक 127.0.0.1 से बँधा), और टूटी फ़ाइल की सूचना दी जाती है (emulators.json_invalid), कभी बदली नहीं जाती। यह अस्थायी फ़ाइल से होकर लिखी जाती है। signallab emulate अपनी एक फ़ाइल भी पढ़ता है जिसमें एक एमुलेटर, उनकी सूची, या इस जैसी एक लाइब्रेरी होती है।

रन रिपोर्ट

runs/run-<started ms>-<job>.json, रिपोर्ट संस्करण 5: पास हुए या विफल हुए हर रन के लिए एक फ़ाइल, कभी ऊपर नहीं लिखी जाती (उसी नाम के दूसरे रन में -2, -3… जुड़ जाते हैं)। रोका गया रन कोई नहीं सहेजता।

फ़ील्ड	यह क्या है
version	5
experiment	प्रयोग का नाम
document_version	जो दस्तावेज़ चला उसका संस्करण
seed, profile	जिनके साथ वह चला
overrides	केवल इस रन के लिए दिए गए मान
params	उसने उपयोग किया हर parameter मान
started_ms, ended_ms	1970 से मिलीसेकंड
outcome	passed या failed
error	उसकी पहली विफलता, या null
steps	हर चरण, experiment://step की तरह
emulators	हर एमुलेटर नोड को क्या मिला और उसने क्या जवाब दिया (संस्करण 3 से); कोई न हो तो छोड़ दिया जाता है
impairments	हर नेटवर्क बाधा नोड के रिले ने क्या किया, चरण-दर-चरण (संस्करण 4 से); कोई न हो तो छोड़ दिया जाता है

load चरण के मापन उसके अंतिम चरण पर होते हैं (संस्करण 5 से)। टाइमलाइन का रन इतिहास और तुलना करें ये फ़ाइलें पढ़ते हैं; जो रिपोर्ट पढ़ी न जा सके, उसे सूची से छोड़ दिया जाता है। देखें रन और रिपोर्ट।

एक्सपोर्ट

• exports/experiment-…json: प्रयोग दस्तावेज़, ऊपर जैसा। हर एक्सपोर्ट एक नई फ़ाइल है।
• capture-….jsonl: हर पंक्ति पर एक इंस्पेक्टर फ़्रेम, अपने रखे हुए बाइट data में, base64।
• capture-….txt: पढ़ने के लिए फ़्रेम, हर एक hex dump के साथ।

सर्वर पर, इंस्पेक्टर का एक्सपोर्ट बनते ही आपके कंप्यूटर पर डाउनलोड हो जाता है; प्रयोग का एक्सपोर्ट डाउनलोड करें देता है, और टाइमलाइन में रन का रिपोर्ट सहेजी गई एक लिंक है जो उसकी रिपोर्ट डाउनलोड करता है।

सीक्रेट इन फ़ाइलों में नहीं हैं

प्रयोग किसी सीक्रेट का नाम लेता है — {{secret.API_TOKEN}} — और केवल नाम लिखा जाता है। मान रखा जाता है:

Signal Lab कहाँ चलता है	सीक्रेट के मान कहाँ हैं
डेस्कटॉप ऐप, Windows	Windows Credential Manager, SignalLab के अंतर्गत (एडिटर में सीक्रेट)
डेस्कटॉप ऐप, Linux	कहीं नहीं: सीक्रेट सहेजे नहीं जा सकते (secret.unsupported)
सर्वर	केवल पढ़ने योग्य: एनवायरनमेंट वैरिएबल SIGNALLAB_SECRET_<NAME>, या --secrets-dir में फ़ाइल <NAME> (डिफ़ॉल्ट /run/secrets/signallab)
signallab	वही फ़ाइलें और वैरिएबल, या --secrets system के साथ सिस्टम का स्टोर

WARNING

जो आप सीधे किसी फ़ील्ड में टाइप करते हैं, वह जैसा टाइप किया वैसा ही रखा जाता है। HTTP सिग्नल के क्रेडेंशियल में कोई पासवर्ड, MQTT ब्रोकर एमुलेटर का पासवर्ड, किसी हेडर में पेस्ट किया टोकन — सब signals.json, emulators.json या experiment.json में, और उनके एक्सपोर्ट में, सादा टेक्स्ट होते हैं। जो कुछ आप साझा फ़ोल्डर में न रखना चाहें, उसके लिए प्रयोग में {{secret.NAME}} उपयोग करें।

इंटरफ़ेस की सेटिंग्स

इंटरफ़ेस जो याद रखता है — उसकी भाषा, हर स्क्रीन पर आख़िरी बार टाइप किए मान, कौन-सा पैन खुला है और कितना बड़ा, कुकी रखें, आख़िरी बार अपडेट कब खोजे गए, और अपडेट के लिए इंस्टॉल की रैंडम संख्या — वह इंटरफ़ेस ख़ुद रखता है, डेटा फ़ोल्डर में नहीं: डेस्कटॉप पर ऐप के अपने स्टोर में, सर्वर के पेज के लिए ब्राउज़र के साइट स्टोर में (प्रति ब्राउज़र)। HTTP स्क्रीन के क्रेडेंशियल वहाँ नहीं रखे जाते।

Signal Lab कोई लॉग फ़ाइल नहीं लिखता; देखें समस्या-निवारण।

बैकअप, संपादन, ले जाना

• बैकअप पूरा फ़ोल्डर कॉपी करके लें। उसमें सब कुछ आत्मनिर्भर JSON है; सीक्रेट के मान उसमें नहीं हैं, इसलिए नई मशीन पर उन्हें फिर सेट करें।
• संपादन signals.json, emulators.json और experiment.json को Signal Lab बंद रहते (या सर्वर पर, जब कोई पेज खुला न हो) हाथ से करें: ऐप पूरी फ़ाइल अपने पास मौजूद चीज़ से लिखता है, इसलिए चलते समय किया बदलाव उसके अगले सेव से ओवरराइट हो जाता है। ग़लती की सूचना फ़ाइल अगली बार पढ़े जाने पर पंक्ति और कॉलम के साथ दी जाती है, कभी चुपचाप बदली नहीं जाती — signals.json के लिए, तब भी जब ऐप उसमें सहेजता है: वह सेव अस्वीकार हो जाता है और फ़ाइल जैसी आपने छोड़ी वैसी रहती है।
• मिटाएँ runs/, exports/ और capture-* फ़ाइलें कभी भी। signals.json या emulators.json मिटाने से स्टार्टर सेट वापस आ जाता है; experiment.json मिटाने से स्टार्टर प्रयोग वापस आ जाता है।
• ले जाएँ फ़ोल्डर को कॉपी करके और Signal Lab को नई जगह की ओर इंगित करके: सर्वर के लिए --data-dir, डेस्कटॉप ऐप के लिए SIGNALLAB_DATA_DIR.
• साझा करें किसी प्रयोग को एक्सपोर्ट करके, या उसके JSON को उस प्रोजेक्ट के बगल commit करके जिसका वह परीक्षण करता है; signallab run उसे वहीं से चलाता है।