# Claude Code ಆರಂಭಿಸುವುದು

> ccam <name|number>, ccam run ಅಥವಾ ccam ಪಿಕರ್ ಮೂಲಕ ಯಾವುದೇ ಖಾತೆಯಾಗಿ Claude Code ಆರಂಭಿಸಿ; ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಬದಲಾವಣೆ ಇಲ್ಲದೆ claude ಗೆ ಹೋಗುತ್ತವೆ, ಮತ್ತು --dry-run ಕಮಾಂಡ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ.

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

`ccam work` `work` ಖಾತೆಯಾಗಿ Claude Code ಅನ್ನು ಆರಂಭಿಸುತ್ತದೆ, ಮತ್ತು ಹೆಸರಿನ ನಂತರದ ಎಲ್ಲವೂ ಇದ್ದಂತೆಯೇ `claude` ಗೆ ಹೋಗುತ್ತದೆ. ನೀವು `claude` ಎಂದು ಟೈಪ್ ಮಾಡುವ ಎಲ್ಲೆಡೆ ಇದನ್ನು ಬಳಸಿ: ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಅಥವಾ ಪೈಪ್ ಮೂಲಕ ಇನ್‌ಪುಟ್ ನೀಡುವಾಗ.

## ಬಳಕೆ

```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 ನ ಸಹಾಯವನ್ನು ತೋರಿಸುತ್ತದೆ. ಹೆಸರಿನ ನಂತರ `--` ಐಚ್ಛಿಕ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇನ್‌ಪುಟ್, ಎಕ್ಸಿಟ್ ಕೋಡ್ ಮತ್ತು ಸಿಗ್ನಲ್‌ಗಳು `claude` ನಲ್ಲಿ ಇರುವಂತೆಯೇ ವರ್ತಿಸುತ್ತವೆ.

ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ `-` ನಿಂದ ಆರಂಭವಾಗಿ ccam ನ ಸ್ವಂತ ಫ್ಲ್ಯಾಗ್‌ಗಳಲ್ಲಿ ಒಂದಲ್ಲದಿದ್ದರೆ, ccam ಎಲ್ಲಾ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಡೀಫಾಲ್ಟ್ ಖಾತೆಯನ್ನು ಆರಂಭಿಸುತ್ತದೆ. ಡೀಫಾಲ್ಟ್ ಎಂದರೆ `ccam use` ಮೂಲಕ ಹೊಂದಿಸಿದ ಖಾತೆ, ಅಥವಾ ನೀವು ಹೊಂದಿಸದಿದ್ದರೆ ಅತ್ಯಂತ ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಖಾತೆ.

### ಪಿಕರ್

ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಿಲ್ಲದ `ccam`, ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಟರ್ಮಿನಲ್ ಆಗಿದ್ದಾಗ ಪಿಕರ್ ಅನ್ನು ತೆರೆಯುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ `ccam list` ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಅದು ಪ್ರತಿ ಖಾತೆಯ ಸಂಖ್ಯೆ, ಇಮೇಲ್, 5 ಗಂಟೆಯ ಬಳಕೆ, ಕೊನೆಯ ಬಳಕೆ ಮತ್ತು ಹಂಚಿಕೊಂಡ ಐಟಂಗಳನ್ನು ತೋರಿಸುತ್ತದೆ; ಪ್ರತಿ ಖಾತೆ ಉತ್ತರಿಸಿದಂತೆ ಬಳಕೆ ತುಂಬಿಕೊಳ್ಳುತ್ತದೆ.

| ಕೀ | ಏನು ಮಾಡುತ್ತದೆ |
| --- | --- |
| `Enter` | ಆಯ್ಕೆಮಾಡಿದ ಖಾತೆಯಾಗಿ Claude Code ಆರಂಭಿಸುತ್ತದೆ |
| `1` ರಿಂದ `9` | ಆ ಸಂಖ್ಯೆಯ ಖಾತೆಯನ್ನು ಆರಂಭಿಸುತ್ತದೆ |
| `Up`/`Down`, `k`/`j` | ಆಯ್ಕೆಯನ್ನು ಸರಿಸುತ್ತದೆ |
| `a` | ಪಿಕರ್ ಮುಚ್ಚಿ `ccam add` ವಿಜಾರ್ಡ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ |
| `s` | ಆಯ್ಕೆಮಾಡಿದ ಖಾತೆಯ ಹಂಚಿಕೊಂಡ ಐಟಂಗಳನ್ನು ಸಂಪಾದಿಸುತ್ತದೆ (`Space` ಅಥವಾ `x` ಆನ್/ಆಫ್ ಮಾಡುತ್ತದೆ, `Enter` ಅನ್ವಯಿಸುತ್ತದೆ, `Esc` ಹಿಂದಕ್ಕೆ ಹೋಗುತ್ತದೆ) |
| `d` | ಆಯ್ಕೆಮಾಡಿದ ಖಾತೆಯನ್ನು ಡೀಫಾಲ್ಟ್ ಮಾಡುತ್ತದೆ |
| `r` | ಅಲ್ಪಾವಧಿ ಕ್ಯಾಶ್ ಇಲ್ಲದೆ ಬಳಕೆಯನ್ನು ಮತ್ತೆ ಪಡೆಯುತ್ತದೆ |
| `q`, `Esc`, `Ctrl+C` | ನಿರ್ಗಮಿಸುತ್ತದೆ |

ಪಿಕರ್ ಕಾರ್ಯ ನಡೆಸುವ ಮೊದಲು ಮುಚ್ಚುತ್ತದೆ, ಹೀಗಾಗಿ Claude Code ಆರಂಭವಾಗುವ ಮೊದಲು ಟರ್ಮಿನಲ್ ಮೊದಲಿನ ಸ್ಥಿತಿಗೆ ಮರಳುತ್ತದೆ. `d` ಅಥವಾ ಹಂಚಿಕೆ ಬದಲಾವಣೆಯ ನಂತರ ಅದು ಮತ್ತೆ ತೆರೆಯುತ್ತದೆ. ಹಂಚಿಕೆ ಬದಲಾವಣೆ, `ccam share` ನಂತೆಯೇ, ಯೋಜನೆಯನ್ನು ತೋರಿಸಿ ಮೊದಲು ಕೇಳುತ್ತದೆ.

## ಆಯ್ಕೆಗಳು

| ಆಯ್ಕೆ | ಏನು ಮಾಡುತ್ತದೆ | ಡೀಫಾಲ್ಟ್ |
| --- | --- | --- |
| `--dry-run` | ccam ರನ್ ಮಾಡುವ ಪರಿಸರ ಮತ್ತು ಕಮಾಂಡ್ ಅನ್ನು ಮುದ್ರಿಸಿ ನಿರ್ಗಮಿಸುತ್ತದೆ | ಆಫ್ |
| `-v`, `--version` | `ccam <version>` ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ (ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಮಾತ್ರ) | |
| `-h`, `--help` | ccam ನ ಸಹಾಯ, `ccam --help` ಅಥವಾ `ccam run --help` ಆಗಿ | |

ಆರ್ಗ್ಯುಮೆಂಟ್ ನಿಯಮಗಳು:

- ccam ತನ್ನ ಸ್ವಂತ ಫ್ಲ್ಯಾಗ್‌ಗಳನ್ನು ಖಾತೆಯ ಹೆಸರಿನ ಮೊದಲು ಮಾತ್ರ ಓದುತ್ತದೆ. ಹೆಸರಿನ ನಂತರ, `--dry-run` ಮತ್ತು `--help` ಸೇರಿದಂತೆ ಪ್ರತಿ ಆರ್ಗ್ಯುಮೆಂಟ್ Claude Code ಗೆ ಸೇರಿದ್ದು.
- `--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>` ಎಂದಿಗೂ ಅಸ್ಪಷ್ಟವಾಗುವುದಿಲ್ಲ.

ಡ್ರೈ ರನ್ ನೀವು ಶೆಲ್‌ಗೆ ಪೇಸ್ಟ್ ಮಾಡಬಹುದಾದ ಒಂದು ಸಾಲನ್ನು ಮುದ್ರಿಸುತ್ತದೆ:

```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` ವರೆಗೆ ಅದೇ ಹಂತಗಳನ್ನು ನಡೆಸುತ್ತದೆ:

ಪ್ರತಿ ಹಂತ ನಡೆಯುವಾಗ ಅದರ ಚೌಕ ಬೆಳಗುತ್ತದೆ, ಮತ್ತು ಕೆಳಗಿನ ಸಾಲುಗಳು Claude Code ಆರಂಭವಾಗುವ ಪರಿಸರ ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು.

1. `cmd/ccam/main.go` `app.Main` ಅನ್ನು ಕರೆಯುತ್ತದೆ. ccam ಬೇರೆ ಹೆಸರಿನಲ್ಲಿ ಆರಂಭವಾಗಿದ್ದರೆ, ಅದು ಒಂದು [ಶಾರ್ಟ್‌ಕಟ್](https://ccam.dev/kn/features/shortcuts.md) ಮತ್ತು ನೇರವಾಗಿ ಲಾಂಚರ್‌ಗೆ ಹೋಗುತ್ತದೆ.
2. cobra ತೊಡಗುವ ಮೊದಲೇ `app.parse` `os.Args` ಅನ್ನು ನೋಡುತ್ತದೆ. ಕೇವಲ `ccam` (ಪಿಕರ್), ccam ಕಮಾಂಡ್ ಹೆಸರು (`config.Reserved`), `-h`/`--help` ಮತ್ತು `-v`/`--version` ಮಾತ್ರ `cli.Execute` ಗೆ ಹೋಗುತ್ತವೆ. ಉಳಿದೆಲ್ಲವೂ ಆರಂಭ.
3. `launcher.Launch` `~/.config/ccam/config.toml` ಅನ್ನು ಓದುತ್ತದೆ, ಅದು ಪಾರ್ಸ್ ಮಾಡುವ ಏಕೈಕ ಫೈಲ್.
4. `launcher.Prepare` ಹೆಸರು ಅಥವಾ ಸಂಖ್ಯೆಯಿಂದ ಖಾತೆಯನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ, ಮುಂದಿರುವ ಒಂದು `--` ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಮತ್ತು `ResolveClaude` ಮೂಲಕ `claude` ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ. PATH ಹುಡುಕಾಟವನ್ನು ಫೈಲ್‌ನ ಮಾರ್ಪಾಡು ಸಮಯದೊಂದಿಗೆ `~/.local/state/ccam/claude-path` ನಲ್ಲಿ ಕ್ಯಾಶ್ ಮಾಡಲಾಗುತ್ತದೆ, ಹೀಗಾಗಿ ccam ಪ್ರತಿ ಆರಂಭದಲ್ಲೂ `PATH` ಅನ್ನು ಹುಡುಕುವುದಿಲ್ಲ. ಫೈಲ್ ಬದಲಾದರೆ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ ಹೊಸ ಹುಡುಕಾಟ ನಡೆಯುತ್ತದೆ. `config.toml` ನಲ್ಲಿರುವ `claude_bin` ಪಾತ್ ಅನ್ನು ಇದ್ದಂತೆಯೇ ಬಳಸಲಾಗುತ್ತದೆ. ccam ಸ್ವತಃ ccam ಆಗಿರುವ `claude` ಅನ್ನು inode ಮೂಲಕ ಹೋಲಿಸಿ ನಿರಾಕರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಅದು ಲೂಪ್ ಆಗುತ್ತದೆ.
5. `checkLinks` ಖಾತೆಯ ಫೋಲ್ಡರ್ `~/.local/share/ccam/profiles/<name>/` ಅನ್ನು ಅದರ ಹಂಚಿಕೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ `share.Check` ಬಳಸಿ ಹೋಲಿಸುತ್ತದೆ; ಅದು `lstat` ಮತ್ತು `readlink` ಅನ್ನು ಮಾತ್ರ ಕರೆಯುತ್ತದೆ, ಪ್ರತಿ ಐಟಂಗೆ ಒಂದು ಅಥವಾ ಎರಡು ಸಿಸ್ಟಮ್ ಕಾಲ್‌ಗಳು. ಇಲ್ಲದ ಲಿಂಕ್ ಅನ್ನು ಅಲ್ಲೇ ರಚಿಸಲಾಗುತ್ತದೆ. ಡೇಟಾ ಕಳೆದುಹೋಗಬಹುದಾದ ಯಾವುದಾದರೂ ಆರಂಭವನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.
6. `applyMCP` ಹಂಚಿಕೊಂಡ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ (ಕೆಳಗೆ ನೋಡಿ).
7. `session.Register` ಸೆಷನ್ ಅನ್ನು ದಾಖಲಿಸುತ್ತದೆ. ccam ತನ್ನ PID ಹೆಸರಿನ, ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭ ಸಮಯವನ್ನು ಹೊಂದಿರುವ ಒಂದು ಗುರುತನ್ನು `$XDG_RUNTIME_DIR/ccam/profile-<name>/<pid>` ಗೆ ಬರೆಯುತ್ತದೆ (ಅಥವಾ `XDG_RUNTIME_DIR` ಇಲ್ಲದಿದ್ದರೆ `~/.local/state/ccam/locks/` ಗೆ). ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಖಾತೆಗೆ, `historyCheck` ಮೊದಲು `history-<group>-<hash>` ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸೆಷನ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ (ಹ್ಯಾಶ್ ಈಗಿನ ಫೋಲ್ಡರ್‌ನದು), ಮತ್ತು ಅಲ್ಲಿಯೂ ನೋಂದಾಯಿಸುತ್ತದೆ. `exec` PID ಅನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಹೀಗಾಗಿ ಆ ಗುರುತು ನಂತರ Claude Code ಪ್ರಕ್ರಿಯೆಯನ್ನೇ ಸೂಚಿಸುತ್ತದೆ. ಹಿಡಿದಿಟ್ಟ ಲಾಕ್ ಬದಲು ಗುರುತು ಏಕೆಂದರೆ, Claude Code ಆರಂಭಿಸುವ ಪ್ರಕ್ರಿಯೆಗಳು ಲಾಕ್ ಅನ್ನು ಪಡೆದು ಸೆಷನ್ ಮುಗಿದ ನಂತರವೂ ಅದನ್ನು ಇಟ್ಟುಕೊಳ್ಳುತ್ತವೆ.
8. `Plan.Exec` ಟರ್ಮಿನಲ್ ಶೀರ್ಷಿಕೆಯನ್ನು `claude · <name>` ಗೆ ಹೊಂದಿಸುತ್ತದೆ (ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಎರರ್ ಟರ್ಮಿನಲ್ ಆಗಿದ್ದಾಗ), ಆರಂಭದ ಸಮಯವನ್ನು `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 ಪ್ರಕ್ರಿಯೆಯನ್ನು `claude` ನಿಂದ ಬದಲಾಯಿಸುತ್ತದೆ. ಹೀಗಾಗಿ ccam ಮೆಮೊರಿಯಲ್ಲಿ ಉಳಿಯುವುದಿಲ್ಲ, ಕೀಸ್ಟ್ರೋಕ್‌ಗಳು, ಸಿಗ್ನಲ್‌ಗಳು ಮತ್ತು ಎಕ್ಸಿಟ್ ಕೋಡ್ Claude Code ನದೇ ಆಗಿರುತ್ತವೆ, ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಎಂದಿಗೂ ಶೆಲ್ ಸ್ಟ್ರಿಂಗ್ ಆಗದೆ ಅರೇ ಆಗಿಯೇ ಉಳಿಯುತ್ತವೆ. ಸೆಷನ್ ನಂತರದ ಕೆಲಸ, ಉದಾಹರಣೆಗೆ `claude mcp add` ಮೂಲಕ ಸೇರಿಸಿದ ಸರ್ವರ್‌ಗಳನ್ನು ಗಮನಿಸುವುದು, ಮುಂದಿನ ಆರಂಭದಲ್ಲಿ ನಡೆಯುತ್ತದೆ: ccam `.claude.json` ನ ಮಾರ್ಪಾಡು ಸಮಯವನ್ನು `~/.local/state/ccam/mcp/<name>/seen` ಜೊತೆ ಹೋಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಬದಲಾದಾಗ ಮಾತ್ರ ಫೈಲ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ.

### ಕಮಾಂಡ್ ಲೈನ್ ಹೇಗೆ ಮಾರ್ಗ ಪಡೆಯುತ್ತದೆ

ಮೂರು ಕಮಾಂಡ್ ಲೈನ್‌ಗಳು, `internal/app` ಮೂಲಕ ಮೂರು ಮಾರ್ಗಗಳು:

ಶಾರ್ಟ್‌ಕಟ್ ಅನ್ನು `argv[0]` ಮೇಲೆ, `ccam <name>` ಅನ್ನು ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಮೇಲೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಎರಡೂ `syscall.Exec` ನಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತವೆ. `ccam usage` ನಂತಹ ccam ಕಮಾಂಡ್ ಮಾತ್ರ cobra ಅನ್ನು ತಲುಪುತ್ತದೆ.

### ಹಂಚಿಕೊಂಡ MCP ಸರ್ವರ್‌ಗಳು

ಡೀಫಾಲ್ಟ್ `flag` ತಂತ್ರದಲ್ಲಿ, ccam ಗುಂಪಿನ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ, ನಿಮ್ಮ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಮೊದಲು ಇರಿಸಿ, Claude Code ಗೆ ರವಾನಿಸುತ್ತದೆ:

ಗುಂಪಿನ `mcp.json` ಇದ್ದರೆ ಮಾತ್ರ `mcp.FlagArgs` ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು `Plan.InsertArgs` ಅದನ್ನು `claude` ನ ತಕ್ಷಣ ನಂತರ ಇರಿಸುತ್ತದೆ. ಆಗ ನಿಮ್ಮದೇ `--mcp-config` ಅಥವಾ `--strict-mcp-config` ಅದರ ಮೇಲೆ ಅನ್ವಯವಾಗುತ್ತದೆ. ಇದು `--mcp-config=<path>` ಎಂಬ ಒಂದೇ ಆರ್ಗ್ಯುಮೆಂಟ್, ಏಕೆಂದರೆ Claude Code ನ `--mcp-config` ಹಲವು ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಎರಡು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ಬರೆದರೆ, ಅದು ನಂತರ ಬರುವ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನೂ ಕಾನ್ಫಿಗ್ ಫೈಲ್ ಎಂದು ಓದುತ್ತದೆ.

`config.toml` ನಲ್ಲಿ `mcp_strategy = "sync"` ಇದ್ದರೆ, ccam ಬದಲಿಗೆ ಸರ್ವರ್‌ಗಳನ್ನು ಖಾತೆಯ `.claude.json` ಗೆ ಬರೆಯುತ್ತದೆ, ಮತ್ತು ಖಾತೆ ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

### 10 ms ಮಿತಿ

Claude Code ಆರಂಭವಾಗುವ ಮೊದಲು ccam ಗರಿಷ್ಠ 10 ms (p95) ಸೇರಿಸುತ್ತದೆ. ಆರಂಭದ ಮಾರ್ಗ ಎಂದಿಗೂ cobra ಕಮಾಂಡ್ ಟ್ರೀ ಅನ್ನು ನಿರ್ಮಿಸುವುದಿಲ್ಲ, Bubble Tea ಅನ್ನು ಆರಂಭಿಸುವುದಿಲ್ಲ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕ ತೆರೆಯುವುದಿಲ್ಲ, ಮತ್ತು ಪ್ಯಾಕೇಜ್ `init()` ಫಂಕ್ಷನ್‌ಗಳು ಒಟ್ಟು 5 ms ಗಿಂತ ಹೆಚ್ಚು ತೆಗೆದುಕೊಂಡರೆ `TestPackageInitIsCheap` ವಿಫಲವಾಗುತ್ತದೆ. `scripts/perf-check.sh` `hyperfine` ಮೂಲಕ `ccam --dry-run work`, `ccam work` ಮತ್ತು ಒಂದು ಶಾರ್ಟ್‌ಕಟ್ ಅನ್ನು ಅಳೆಯುತ್ತದೆ ಮತ್ತು 10 ms ಮೀರಿದರೆ ವಿಫಲವಾಗುತ್ತದೆ, ಮತ್ತು `internal/launcher` ನಲ್ಲಿರುವ `BenchmarkLaunchPath` ಹಂತಗಳನ್ನು ಲೂಪ್‌ನಲ್ಲಿ ನಡೆಸುತ್ತದೆ. ಪ್ರತಿ ಹಂತದ ಸಮಯವನ್ನು ನೋಡಲು `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 add <name>` ಮೂಲಕ ಒಂದನ್ನು ಸೇರಿಸಲು ccam ಕೇಳುತ್ತದೆ.
- ಹಂಚಿಕೊಂಡ ಪಾತ್ ಸಾಮಾನ್ಯ ಫೈಲ್ ಆಗಿದ್ದರೆ ಅಥವಾ ತಪ್ಪು ಸ್ಥಳಕ್ಕೆ ತೋರಿಸಿದರೆ, ccam `stopped because of share link problems:` ಎಂದು ನಿಂತು, ಅವುಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ, `ccam doctor --fix` ರನ್ ಮಾಡಲು ಕೇಳುತ್ತದೆ. ಆರಂಭದ ಮಾರ್ಗದಲ್ಲಿ ಅದು ಡೇಟಾವನ್ನು ಸ್ಥಳಾಂತರಿಸುವುದಿಲ್ಲ.
- ಈ ಖಾತೆಯೊಂದಿಗೆ ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸ ಹಂಚಿಕೊಳ್ಳುವ (ಅದೇ ಗುಂಪು) ಇನ್ನೊಂದು Claude Code ಅದೇ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ, ಇತಿಹಾಸ ಬೆರೆಯಬಹುದು ಎಂದು ccam ಎಚ್ಚರಿಸಿ `Run anyway? [y/N]` ಎಂದು ಕೇಳುತ್ತದೆ. ಟರ್ಮಿನಲ್ ಇಲ್ಲದಿದ್ದರೆ ಅದು ಎಚ್ಚರಿಕೆ ತೋರಿಸಿ ಮುಂದುವರಿಯುತ್ತದೆ.
- `--dry-run` MCP ಸಿಂಕ್, ಹೊಸ ಸರ್ವರ್ ಸೂಚನೆ, ಇತಿಹಾಸ ಪರಿಶೀಲನೆ, ಸೆಷನ್ ಗುರುತು, ಶೀರ್ಷಿಕೆ ಮತ್ತು ಕೊನೆಯ ಬಳಕೆಯ ಸಮಯವನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ, ಮತ್ತು exec ಮಾಡುವುದಿಲ್ಲ. ಆದರೂ ಅದು ಹಂಚಿಕೆ ಲಿಂಕ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಸಾಮಾನ್ಯ ಆರಂಭದಂತೆಯೇ ಇಲ್ಲದ ಲಿಂಕ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
- `mcp_strategy = "sync"` ಇದ್ದಾಗ, ವಿಫಲವಾದ ಸಿಂಕ್ `ccam: MCP sync failed (launching anyway): …` ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು Claude Code ಈಗಾಗಲೇ ಇದ್ದ ಸರ್ವರ್‌ಗಳೊಂದಿಗೆ ಆರಂಭವಾಗುತ್ತದೆ.

## ಸಂಬಂಧಿತ

- [ಶಾರ್ಟ್‌ಕಟ್ ಕಮಾಂಡ್‌ಗಳು](https://ccam.dev/kn/features/shortcuts.md)
- [ಖಾತೆಗಳ ನಿರ್ವಹಣೆ](https://ccam.dev/kn/features/accounts.md)
- [ಕಮಾಂಡ್ ಉಲ್ಲೇಖ](https://ccam.dev/kn/docs/commands.md)
- [MCP ಸರ್ವರ್‌ಗಳು, ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮತ್ತು ಇತಿಹಾಸವನ್ನು ಹಂಚಿಕೊಳ್ಳಿ](https://ccam.dev/kn/docs/sharing.md)
- [CLAUDE_CONFIG_DIR ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ](https://ccam.dev/kn/guides/claude-config-dir.md)