# Claude Code सुरू करणे

> ccam <name|number>, ccam run किंवा ccam picker ने कोणत्याही खात्याने Claude Code सुरू करा; आर्ग्युमेंट्स न बदलता claude ला जातात, आणि --dry-run कमांड दाखवते.

Source: https://ccam.dev/mr/features/launch/ · Updated 2026-10-19

`ccam work` `work` खात्याने Claude Code सुरू करते, आणि नावानंतरचे सर्व काही जसेच्या तसे `claude` ला जाते. जिथे तुम्ही `claude` टाइप केले असते तिथे ते वापरा: टर्मिनलमध्ये, script मध्ये, किंवा pipe ने input देऊन.

## वापर

```sh
ccam work                        # Claude Code as the account work
ccam 2                           # the account with number 2 (see ccam list)
ccam work --resume               # claude --resume, as work
ccam work -p "fix the tests" --output-format json
cat log.txt | ccam work -p "find the cause"
ccam -p "summarise"              # no name: the default account
ccam use work                    # make work the default account
ccam run work --continue         # same as ccam work --continue
ccam                             # the picker on a terminal, the list otherwise
ccam --dry-run work -p hi        # print the command instead of running it
```

खात्याचे नाव किंवा `ccam list` मधील त्याचा क्रमांक द्या. नावानंतरचे आर्ग्युमेंट्स ccam वाचत नाही, त्यामुळे `ccam work --help` Claude Code ची मदत दाखवते. नावानंतर `--` लावणे ऐच्छिक आहे. standard input, exit code आणि signals `claude` प्रमाणेच वागतात.

पहिला आर्ग्युमेंट `-` ने सुरू होत असेल आणि तो ccam च्या स्वतःच्या flags पैकी नसेल, तर ccam सर्व आर्ग्युमेंट्ससह डीफॉल्ट खाते सुरू करते. डीफॉल्ट म्हणजे `ccam use` ने सेट केलेले खाते, किंवा तुम्ही ते सेट केले नसेल तर सर्वात लहान क्रमांकाचे खाते.

### Picker

standard input आणि output टर्मिनल असताना आर्ग्युमेंट्सशिवाय `ccam` picker उघडते, आणि इतर वेळी `ccam list` छापते. ते प्रत्येक खात्याचा क्रमांक, ईमेल, 5 तासांचा वापर, शेवटचा वापर आणि शेअर केलेले आयटम दाखवते; प्रत्येक खाते उत्तर देईल तसा वापर भरला जातो.

| की | काय करते |
| --- | --- |
| `Enter` | निवडलेल्या खात्याने Claude Code सुरू करा |
| `1` to `9` | त्या क्रमांकाचे खाते सुरू करा |
| `Up`/`Down`, `k`/`j` | निवड हलवा |
| `a` | picker बंद करून `ccam add` विझार्ड चालवा |
| `s` | निवडलेल्या खात्याचे शेअर केलेले आयटम बदला (`Space` किंवा `x` टॉगल करते, `Enter` लागू करते, `Esc` मागे जाते) |
| `d` | निवडलेले खाते डीफॉल्ट करा |
| `r` | छोट्या cache शिवाय वापर पुन्हा आणा |
| `q`, `Esc`, `Ctrl+C` | बाहेर पडा |

picker काही करण्यापूर्वी बंद होतो, त्यामुळे Claude Code सुरू होण्यापूर्वी टर्मिनल पूर्ववत होतो. `d` किंवा शेअरिंगमधील बदलानंतर तो पुन्हा उघडतो. शेअरिंगमधील बदल `ccam share` प्रमाणेच आधी योजना दाखवतो आणि विचारतो.

## पर्याय

| पर्याय | काय करतो | डीफॉल्ट |
| --- | --- | --- |
| `--dry-run` | ccam चालवेल ते environment आणि कमांड छापा, मग बाहेर पडा | बंद |
| `-v`, `--version` | `ccam <version>` छापा (फक्त पहिला आर्ग्युमेंट म्हणून) | |
| `-h`, `--help` | ccam ची मदत, `ccam --help` किंवा `ccam run --help` म्हणून | |

आर्ग्युमेंट्सचे नियम:

- ccam आपले स्वतःचे flags फक्त खात्याच्या नावाआधी वाचते. नावानंतरचा प्रत्येक आर्ग्युमेंट Claude Code चा असतो, `--dry-run` आणि `--help` सुद्धा.
- `--dry-run` `ccam --dry-run work`, `ccam run --dry-run work` आणि `ccam --dry-run` (डीफॉल्ट खाते) असे चालते. तो पाळला जातो, नाकारला जात नाही.
- `ccam run <name|number> [claude args]` हे `ccam <name>` चे लांब रूप आहे. नावाशिवाय `ccam run` डीफॉल्ट खाते वापरते.
- खात्यांची नावे `add`, `list`, `run` किंवा `usage` सारखी ccam कमांड्सची नावे असू शकत नाहीत, त्यामुळे `ccam <word>` कधीच संदिग्ध होत नाही.

dry run एक ओळ छापतो, जी तुम्ही shell मध्ये paste करू शकता:

```console
$ ccam --dry-run work -p "fix the tests"
CLAUDE_CONFIG_DIR=/home/me/.local/share/ccam/profiles/work /home/me/.local/bin/claude --mcp-config=/home/me/.local/share/ccam/groups/default/mcp.json -p 'fix the tests'
```

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

प्रत्येक वेळी सुरू करताना, कमांड लाइनपासून `exec` पर्यंत तेच टप्पे होतात:

प्रत्येक टप्पा चालताना त्याचा box उजळतो, आणि खालच्या ओळी म्हणजे Claude Code ज्या environment आणि आर्ग्युमेंट्ससह सुरू होते ते.

1. `cmd/ccam/main.go` `app.Main` बोलावते. ccam दुसऱ्या नावाने सुरू झाले असेल, तर तो [शॉर्टकट](https://ccam.dev/mr/features/shortcuts.md) आहे आणि थेट launcher कडे जातो.
2. cobra सहभागी होण्यापूर्वी `app.parse` `os.Args` पाहते. फक्त एकटे `ccam` (picker), ccam कमांडचे नाव (`config.Reserved`), `-h`/`--help` आणि `-v`/`--version` `cli.Execute` कडे जातात. बाकी सर्व काही म्हणजे Claude Code सुरू करणे.
3. `launcher.Launch` `~/.config/ccam/config.toml` वाचते, ही एकमेव फाइल जी ते parse करते.
4. `launcher.Prepare` नाव किंवा क्रमांकावरून खाते शोधते, सुरुवातीचा एक `--` काढते, आणि `ResolveClaude` ने `claude` executable शोधते. PATH मधील शोध फाइलच्या modification time सह `~/.local/state/ccam/claude-path` मध्ये cache होतो, त्यामुळे ccam प्रत्येक वेळी `PATH` शोधत नाही. फाइल बदलली किंवा नसली तर नवीन शोध होतो. `config.toml` मधील `claude_bin` पाथ जसाच्या तसा वापरला जातो. जो `claude` स्वतः ccam आहे, तो ccam inode ने तुलना करून नाकारते, कारण त्याने loop होईल.
5. `checkLinks` खात्याचा फोल्डर `~/.local/share/ccam/profiles/<name>/` त्याच्या शेअरिंग सेटिंग्जशी `share.Check` ने तुलना करते, जे फक्त `lstat` आणि `readlink` बोलावते, प्रत्येक आयटमसाठी एक किंवा दोन system calls. नसलेली लिंक तिथल्या तिथे तयार होते. डेटा गमावू शकेल अशी कोणतीही गोष्ट सुरू करणे थांबवते.
6. `applyMCP` शेअर केलेले MCP सर्व्हर जोडते (खाली पाहा).
7. `session.Register` session नोंदवते. ccam आपल्या PID च्या नावाचा, process सुरू झाल्याची वेळ असलेला marker `$XDG_RUNTIME_DIR/ccam/profile-<name>/<pid>` मध्ये लिहिते (`XDG_RUNTIME_DIR` नसल्यास `~/.local/state/ccam/locks/` मध्ये). संभाषण इतिहास शेअर करणाऱ्या खात्यासाठी, `historyCheck` आधी `history-<group>-<hash>` मध्ये चालू session शोधते, जिथे hash सध्याच्या फोल्डरचा असतो, आणि तिथेही नोंदवते. `exec` PID तोच ठेवते, त्यामुळे marker नंतर Claude Code process चेच नाव सांगतो. धरलेले lock नाही तर marker, कारण Claude Code सुरू करत असलेल्या processes ना lock वारसाने मिळेल आणि session संपल्यानंतरही ते राहील.
8. `Plan.Exec` टर्मिनलचे title `claude · <name>` करते (standard error टर्मिनल असताना), सुरू केल्याची वेळ `fsync` शिवाय `~/.local/state/ccam/last-used/<name>` मध्ये लिहिते, आणि `syscall.Exec` बोलावते.

Claude Code खात्याच्या फोल्डरवर सेट केलेल्या `CLAUDE_CONFIG_DIR` सह आणि खात्याच्या नावावर सेट केलेल्या `CCAM_PROFILE` सह चालते. यांची वारसाने मिळालेली कोणतीही मूल्ये ccam काढून टाकते. macOS वर `ccam import` ने नोंदवलेल्या `~/.claude` फोल्डरसाठी ते `CLAUDE_SECURESTORAGE_CONFIG_DIR` रिकाम्या मूल्यावर सेट करते, जेणेकरून ते खाते आणि साधे `claude` एकच Keychain लॉगिन वापरतील.

### exec का

`syscall.Exec` ccam process च्या जागी `claude` ठेवते, त्यामुळे ccam memory मध्ये राहत नाही, keystrokes, signals आणि exit code Claude Code चेच असतात, आणि आर्ग्युमेंट्स array राहतात, कधीच shell string बनत नाहीत. session नंतरचे काम, जसे `claude mcp add` ने जोडलेले सर्व्हर लक्षात घेणे, पुढच्या वेळी सुरू करताना होते: ccam `.claude.json` च्या modification time ची `~/.local/state/ccam/mcp/<name>/seen` शी तुलना करते आणि फाइल बदलली असेल तरच ती parse करते.

### कमांड लाइन कुठे जाते

तीन कमांड लाइन्स, `internal/app` मधून तीन मार्ग:

शॉर्टकट `argv[0]` वरून ओळखला जातो, `ccam <name>` पहिल्या आर्ग्युमेंटवरून, आणि दोन्ही `syscall.Exec` मध्ये संपतात. फक्त `ccam usage` सारखी ccam कमांड cobra पर्यंत पोहोचते.

### शेअर केलेले MCP सर्व्हर

डीफॉल्ट `flag` strategy सह, ccam गटाचे MCP सर्व्हर Claude Code ला एक आर्ग्युमेंट म्हणून, तुमच्या आर्ग्युमेंट्सच्या आधी देते:

गटाची `mcp.json` असेल तरच `mcp.FlagArgs` आर्ग्युमेंट परत देते, आणि `Plan.InsertArgs` तो `claude` च्या लगेच नंतर ठेवते. तुमचे स्वतःचे `--mcp-config` किंवा `--strict-mcp-config` त्यावर लागू होत राहतात. तो `--mcp-config=<path>` हा एकच आर्ग्युमेंट आहे, कारण Claude Code चा `--mcp-config` अनेक मूल्ये घेतो: दोन आर्ग्युमेंट्स म्हणून लिहिल्यास तो पुढचा prompt सुद्धा config फाइल म्हणून वाचेल.

`config.toml` मध्ये `mcp_strategy = "sync"` असल्यास, ccam त्याऐवजी सर्व्हर खात्याच्या `.claude.json` मध्ये लिहिते, आणि खाते आधीच चालू असेल तर ते वगळते.

### 10 ms ची मर्यादा

Claude Code सुरू होण्यापूर्वी ccam जास्तीत जास्त 10 ms (p95) जोडते. सुरू करण्याचा मार्ग कधीच cobra कमांड tree तयार करत नाही, Bubble Tea सुरू करत नाही किंवा नेटवर्क कनेक्शन उघडत नाही, आणि package च्या `init()` functions ना एकूण 5 ms पेक्षा जास्त लागल्यास `TestPackageInitIsCheap` अयशस्वी होते. `scripts/perf-check.sh` `hyperfine` ने `ccam --dry-run work`, `ccam work` आणि एक शॉर्टकट मोजते आणि 10 ms पेक्षा जास्त झाल्यास अयशस्वी होते, आणि `internal/launcher` मधील `BenchmarkLaunchPath` हे टप्पे loop मध्ये चालवते. प्रत्येक टप्प्याचा वेळ पाहण्यासाठी `CCAM_TRACE=1` सेट करा:

```console
$ CCAM_TRACE=1 ccam --dry-run work >/dev/null
ccam trace: start                 2.830ms (total 2.830ms)
ccam trace: load config           0.397ms (total 3.227ms)
ccam trace: prepare               0.112ms (total 3.339ms)
ccam trace: check links           0.238ms (total 3.578ms)
ccam trace: prelaunch             0.083ms (total 3.661ms)
```

## सुरक्षितता आणि अपवादात्मक स्थिती

- अज्ञात नाव किंवा क्रमांक `no account "<name>"` ने थांबतो आणि `ccam list` कडे निर्देश करतो. एकही खाते नसल्यास, ccam `ccam add <name>` ने एक जोडायला सांगते.
- एखादा शेअर केलेला पाथ साधी फाइल बनला असेल किंवा चुकीच्या जागी निर्देश करत असेल, तर ccam `stopped because of share link problems:` ने थांबते, त्यांची यादी देते, आणि `ccam doctor --fix` चालवायला सांगते. सुरू करण्याच्या मार्गावर ते डेटा हलवत नाही.
- या खात्याशी संभाषण इतिहास शेअर करणारे (त्याच गटातील) दुसरे Claude Code त्याच फोल्डरमध्ये चालू असेल, तर ccam इतिहास मिसळू शकतो असा इशारा देते आणि `Run anyway? [y/N]` विचारते. टर्मिनल नसताना ते इशारा दाखवते आणि पुढे जाते.
- `--dry-run` MCP sync, नवीन सर्व्हरची सूचना, इतिहासाची तपासणी, session marker, title आणि शेवटच्या वापराची वेळ वगळते, आणि exec करत नाही. तरीही ते शेअर लिंक्स तपासते, आणि सामान्यपणे सुरू करताना होईल तशी नसलेली लिंक तयार करते.
- `mcp_strategy = "sync"` सह sync अयशस्वी झाल्यास `ccam: MCP sync failed (launching anyway): …` छापले जाते आणि Claude Code त्याच्याकडे आधीपासून असलेल्या सर्व्हरसह सुरू होते.

## संबंधित

- [शॉर्टकट कमांड्स](https://ccam.dev/mr/features/shortcuts.md)
- [खाती व्यवस्थापित करणे](https://ccam.dev/mr/features/accounts.md)
- [कमांड संदर्भ](https://ccam.dev/mr/docs/commands.md)
- [MCP सर्व्हर, सेटिंग्ज आणि इतिहास शेअर करा](https://ccam.dev/mr/docs/sharing.md)
- [CLAUDE_CONFIG_DIR कसे काम करते](https://ccam.dev/mr/guides/claude-config-dir.md)