---
read_when:
    - बैकग्राउंड exec व्यवहार जोड़ना या संशोधित करना
    - लंबे समय तक चलने वाले exec कार्यों की डीबगिंग
summary: पृष्ठभूमि exec निष्पादन और प्रक्रिया प्रबंधन
title: बैकग्राउंड निष्पादन और प्रक्रिया टूल
x-i18n:
    generated_at: "2026-07-27T20:52:50Z"
    model: gpt-5.6
    postprocess_version: locale-links-v1
    prompt_version: 32
    provider: openai
    source_hash: 37cb65ddf67227e32be972e77d16b9835d592120ecd12e041d05c48536fd2204
    source_path: gateway/background-process.md
    workflow: 16
---

OpenClaw, `exec` टूल के माध्यम से शेल कमांड चलाता है और लंबे समय तक चलने वाले कार्यों को मेमोरी में रखता है। `process` टूल उन बैकग्राउंड सत्रों को प्रबंधित करता है।

## exec टूल

पैरामीटर:

| पैरामीटर    | विवरण                                                                                                                                                |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `command`    | आवश्यक। चलाने के लिए शेल कमांड।                                                                                                                            |
| `workdir`    | कार्यशील डायरेक्टरी; डिफ़ॉल्ट cwd का उपयोग करने के लिए इसे छोड़ दें।                                                                                                            |
| `env`        | कमांड के लिए अतिरिक्त एनवायरनमेंट वेरिएबल।                                                                                                               |
| `yieldMs`    | बैकग्राउंड में भेजने से पहले प्रतीक्षा का समय मिलीसेकंड में (डिफ़ॉल्ट 10000)।                                                                                                 |
| `background` | तुरंत बैकग्राउंड में चलाएँ।                                                                                                                             |
| `timeout`    | टाइमआउट सेकंड में (डिफ़ॉल्ट `tools.exec.timeoutSeconds`); समय समाप्त होने पर प्रोसेस को बंद कर देता है। उस कॉल के लिए exec प्रोसेस टाइमआउट अक्षम करने हेतु `timeout: 0` सेट करें। |
| `pty`        | उपलब्ध होने पर स्यूडो-टर्मिनल में चलाएँ (TTY की आवश्यकता वाले CLI, कोडिंग एजेंट)।                                                                                |
| `elevated`   | यदि एलिवेटेड मोड सक्षम/अनुमत है, तो सैंडबॉक्स के बाहर चलाएँ (डिफ़ॉल्ट रूप से `gateway`, या exec लक्ष्य के `node` होने पर `node`)।                              |
| `host`       | Exec लक्ष्य: `auto`, `sandbox`, `gateway`, या `node`।                                                                                                      |
| `node`       | Node आईडी/नाम, जिसका उपयोग `host: "node"` के साथ होता है।                                                                                                                    |

व्यवहार:

- फ़ोरग्राउंड रन सीधे आउटपुट लौटाते हैं।
- बैकग्राउंड में भेजे जाने पर (स्पष्ट रूप से या `yieldMs` टाइमआउट के माध्यम से), टूल `status: "running"` + `sessionId` और आउटपुट का एक छोटा अंतिम अंश लौटाता है।
- बैकग्राउंड और `yieldMs` रन `tools.exec.timeoutSeconds` इनहेरिट करते हैं, जब तक कॉल में स्पष्ट `timeout` न दिया गया हो।
- सत्र को पोल या साफ़ किए जाने तक आउटपुट मेमोरी में रहता है।
- यदि `process` टूल की अनुमति नहीं है, तो `exec` रन सिंक्रोनस रूप से चलता है और `yieldMs`/`background` को अनदेखा करता है।
- शुरू किए गए exec कमांड को संदर्भ-संवेदी शेल/प्रोफ़ाइल नियमों के लिए `OPENCLAW_SHELL=exec` मिलता है।
- अब शुरू होने वाले लंबे कार्य के लिए: इसे एक बार शुरू करें और कमांड के आउटपुट देने या विफल होने पर स्वचालित पूर्णता वेक (सक्षम होने पर) पर निर्भर रहें।
- यदि स्वचालित पूर्णता वेक उपलब्ध नहीं है, या बिना आउटपुट के सफलतापूर्वक समाप्त होने वाले कमांड की मौन-सफलता की पुष्टि चाहिए, तो `process` से पोल करें।
- रिमाइंडर या विलंबित फ़ॉलो-अप का अनुकरण `sleep` लूप या बार-बार पोल करके न करें — भविष्य के कार्य के लिए Cron का उपयोग करें।

### एनवायरनमेंट ओवरराइड

| वेरिएबल                                 | प्रभाव                                                                                                           |
| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| `OPENCLAW_BASH_YIELD_MS`                 | बैकग्राउंड में भेजने से पहले डिफ़ॉल्ट यील्ड (ms)। डिफ़ॉल्ट 10000, सीमा 10-120000।                                       |
| `OPENCLAW_BASH_MAX_OUTPUT_CHARS`         | मेमोरी में आउटपुट की सीमा (वर्ण)।                                                                                    |
| `OPENCLAW_BASH_PENDING_MAX_OUTPUT_CHARS` | प्रत्येक स्ट्रीम के लंबित stdout/stderr की सीमा (वर्ण)।                                                                    |
| `OPENCLAW_BASH_JOB_TTL_MS`               | पूर्ण सत्रों के लिए TTL (ms), 1m-3h तक सीमित।                                                                |
| `OPENCLAW_PROCESS_INPUT_WAIT_IDLE_MS`    | लिखने योग्य बैकग्राउंड सत्रों को इनपुट की प्रतीक्षा में होने की संभावना के रूप में चिह्नित करने से पहले निष्क्रिय आउटपुट सीमा। डिफ़ॉल्ट 15000। |

### कॉन्फ़िगरेशन (एनवायरनमेंट ओवरराइड की तुलना में वरीय)

| कुंजी                                   | डिफ़ॉल्ट | प्रभाव                                                                          |
| ------------------------------------- | ------- | ------------------------------------------------------------------------------- |
| `tools.exec.backgroundMs`             | 10000   | `OPENCLAW_BASH_YIELD_MS` के समान।                                               |
| `tools.exec.timeoutSeconds`           | 1800    | प्रत्येक कॉल का डिफ़ॉल्ट टाइमआउट।                                                       |
| `tools.exec.cleanupMs`                | 1800000 | `OPENCLAW_BASH_JOB_TTL_MS` के समान।                                             |
| `tools.exec.notifyOnExit`             | true    | बैकग्राउंड exec के समाप्त होने पर सिस्टम इवेंट कतारबद्ध करें + Heartbeat का अनुरोध करें।      |
| `tools.exec.notifyOnExitEmptySuccess` | false   | बिना आउटपुट वाले सफल बैकग्राउंड रन के लिए भी पूर्णता इवेंट कतारबद्ध करें। |

## चाइल्ड प्रोसेस ब्रिजिंग

exec/process टूल के बाहर लंबे समय तक चलने वाले चाइल्ड प्रोसेस (CLI का पुनः शुरू होना, Gateway सहायक) शुरू करते समय, चाइल्ड-प्रोसेस ब्रिज सहायक जोड़ें, ताकि समाप्ति सिग्नल आगे भेजे जाएँ और निकास/त्रुटि पर लिसनर अलग हो जाएँ। इससे systemd पर अनाथ प्रोसेस बनने से बचते हैं और सभी प्लेटफ़ॉर्म पर शटडाउन सुसंगत रहता है।

## process टूल

क्रियाएँ:

| क्रिया      | प्रभाव                                                                        |
| ----------- | ----------------------------------------------------------------------------- |
| `list`      | चल रहे + पूर्ण सत्र।                                                  |
| `poll`      | किसी सत्र का नया आउटपुट निकालें (निकास स्थिति भी बताता है)।                    |
| `log`       | एकत्रित आउटपुट और इनपुट-पुनर्प्राप्ति संकेत पढ़ें। `offset` + `limit` का समर्थन करता है। |
| `write`     | stdin भेजें (`data`, वैकल्पिक `eof`)।                                          |
| `send-keys` | PTY-समर्थित सत्र को स्पष्ट कुंजी टोकन या बाइट भेजें।                    |
| `submit`    | PTY-समर्थित सत्र को Enter/कैरिज रिटर्न भेजें।                           |
| `paste`     | शाब्दिक टेक्स्ट भेजें, जिसे वैकल्पिक रूप से ब्रैकेटेड पेस्ट मोड में लपेटा जा सकता है।                |
| `kill`      | बैकग्राउंड सत्र समाप्त करें।                                               |
| `clear`     | पूर्ण सत्र को मेमोरी से हटाएँ।                                        |
| `remove`    | चल रहा हो तो बंद करें, अन्यथा पूर्ण हो चुका हो तो साफ़ करें।                                 |

टिप्पणियाँ:

- केवल बैकग्राउंड सत्र सूचीबद्ध/संग्रहित होते हैं — केवल मेमोरी में, डिस्क पर नहीं। प्रोसेस पुनः शुरू होने पर सत्र खो जाते हैं।
- लाइव बैकग्राउंड सत्र सहयोगात्मक होस्ट निलंबन और सुरक्षित Gateway पुनः आरंभ को तब तक रोकता है, जब तक प्रोसेस स्वामी उसके वास्तविक निकास की पुष्टि न कर दे।
- `process remove` समाप्ति का अनुरोध करने के तुरंत बाद चल रहे सत्र को छिपा सकता है; निकास की पुष्टि होने तक निलंबन और पुनः आरंभ अवरुद्ध रहते हैं।
- सत्र लॉग चैट इतिहास में केवल तभी सहेजे जाते हैं, जब आप `process poll`/`log` चलाते हैं और टूल परिणाम रिकॉर्ड किया जाता है।
- `process` प्रत्येक एजेंट के दायरे में है; यह केवल उस एजेंट द्वारा शुरू किए गए सत्र देखता है।
- स्वचालित पूर्णता वेक उपलब्ध न होने पर स्थिति, लॉग या पूर्णता पुष्टि के लिए `poll`/`log` का उपयोग करें।
- इंटरैक्टिव CLI को पुनर्प्राप्त करने से पहले `log` का उपयोग करें, ताकि वर्तमान ट्रांसक्रिप्ट, stdin स्थिति और इनपुट-प्रतीक्षा संकेत एक साथ दिखाई दें।
- जब इनपुट या हस्तक्षेप की आवश्यकता हो, तब `write`/`send-keys`/`submit`/`paste`/`kill` का उपयोग करें।
- `process list` में त्वरित स्कैन के लिए व्युत्पन्न `name` (कमांड क्रिया + लक्ष्य) शामिल होता है।
- `process list`, `poll`, और `log` केवल तभी `waitingForInput` रिपोर्ट करते हैं, जब सत्र में अभी भी लिखने योग्य stdin हो और वह इनपुट-प्रतीक्षा सीमा से अधिक समय तक निष्क्रिय रहा हो (डिफ़ॉल्ट 15000 ms, `OPENCLAW_PROCESS_INPUT_WAIT_IDLE_MS`)।
- `process log` पंक्ति-आधारित `offset`/`limit` का उपयोग करता है। दोनों को छोड़ने पर, यह पेजिंग संकेत के साथ अंतिम 200 पंक्तियाँ लौटाता है। जब `offset` सेट हो और `limit` न हो, तो यह `offset` से अंत तक लौटाता है (200 तक सीमित नहीं)।
- `poll` का `timeout` लौटने से पहले उतने मिलीसेकंड तक प्रतीक्षा करता है; 30000 से अधिक मान 30000 तक सीमित किए जाते हैं।
- पोलिंग माँग पर स्थिति जानने के लिए है, प्रतीक्षा-लूप शेड्यूलिंग के लिए नहीं। यदि कार्य बाद में होना चाहिए, तो Cron का उपयोग करें।

## उदाहरण

कोई लंबा कार्य चलाएँ और बाद में पोल करें:

```json
{ "tool": "exec", "command": "sleep 5 && echo done", "yieldMs": 1000 }
```

```json
{ "tool": "process", "action": "poll", "sessionId": "<id>" }
```

इनपुट भेजने से पहले किसी इंटरैक्टिव सत्र का निरीक्षण करें:

```json
{ "tool": "process", "action": "log", "sessionId": "<id>" }
```

तुरंत बैकग्राउंड में शुरू करें:

```json
{ "tool": "exec", "command": "npm run build", "background": true }
```

stdin भेजें:

```json
{ "tool": "process", "action": "write", "sessionId": "<id>", "data": "y\n" }
```

PTY कुंजियाँ भेजें:

```json
{ "tool": "process", "action": "send-keys", "sessionId": "<id>", "keys": ["C-c"] }
```

वर्तमान पंक्ति सबमिट करें:

```json
{ "tool": "process", "action": "submit", "sessionId": "<id>" }
```

शाब्दिक टेक्स्ट पेस्ट करें:

```json
{ "tool": "process", "action": "paste", "sessionId": "<id>", "text": "line1\nline2\n" }
```

## संबंधित

- [Exec टूल](/hi/tools/exec)
- [Exec अनुमोदन](/hi/tools/exec-approvals)