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

ಕೊನೆಯ ಬಾರಿ ನವೀಕರಿಸಿದ್ದು ಅಕ್ಟೋಬರ್ 19, 2026
ccam 0.6.0 ಮತ್ತು Claude Code 2.1.302 ನೊಂದಿಗೆ ಪರಿಶೀಲಿಸಲಾಗಿದೆ

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

ಬಳಕೆ

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> ಎಂದಿಗೂ ಅಸ್ಪಷ್ಟವಾಗುವುದಿಲ್ಲ.

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

$ 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 ಆರಂಭವಾಗುವ ಪರಿಸರ ಮತ್ತು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು.

cmd/ccam/main.go app.Main ಅನ್ನು ಕರೆಯುತ್ತದೆ. ccam ಬೇರೆ ಹೆಸರಿನಲ್ಲಿ ಆರಂಭವಾಗಿದ್ದರೆ, ಅದು ಒಂದು ಶಾರ್ಟ್‌ಕಟ್ ಮತ್ತು ನೇರವಾಗಿ ಲಾಂಚರ್‌ಗೆ ಹೋಗುತ್ತದೆ.
cobra ತೊಡಗುವ ಮೊದಲೇ app.parse os.Args ಅನ್ನು ನೋಡುತ್ತದೆ. ಕೇವಲ ccam (ಪಿಕರ್), ccam ಕಮಾಂಡ್ ಹೆಸರು (config.Reserved), -h/--help ಮತ್ತು -v/--version ಮಾತ್ರ cli.Execute ಗೆ ಹೋಗುತ್ತವೆ. ಉಳಿದೆಲ್ಲವೂ ಆರಂಭ.
launcher.Launch ~/.config/ccam/config.toml ಅನ್ನು ಓದುತ್ತದೆ, ಅದು ಪಾರ್ಸ್ ಮಾಡುವ ಏಕೈಕ ಫೈಲ್.
launcher.Prepare ಹೆಸರು ಅಥವಾ ಸಂಖ್ಯೆಯಿಂದ ಖಾತೆಯನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ, ಮುಂದಿರುವ ಒಂದು -- ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಮತ್ತು ResolveClaude ಮೂಲಕ claude ಎಕ್ಸಿಕ್ಯೂಟಬಲ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ. PATH ಹುಡುಕಾಟವನ್ನು ಫೈಲ್‌ನ ಮಾರ್ಪಾಡು ಸಮಯದೊಂದಿಗೆ ~/.local/state/ccam/claude-path ನಲ್ಲಿ ಕ್ಯಾಶ್ ಮಾಡಲಾಗುತ್ತದೆ, ಹೀಗಾಗಿ ccam ಪ್ರತಿ ಆರಂಭದಲ್ಲೂ PATH ಅನ್ನು ಹುಡುಕುವುದಿಲ್ಲ. ಫೈಲ್ ಬದಲಾದರೆ ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ ಹೊಸ ಹುಡುಕಾಟ ನಡೆಯುತ್ತದೆ. config.toml ನಲ್ಲಿರುವ claude_bin ಪಾತ್ ಅನ್ನು ಇದ್ದಂತೆಯೇ ಬಳಸಲಾಗುತ್ತದೆ. ccam ಸ್ವತಃ ccam ಆಗಿರುವ claude ಅನ್ನು inode ಮೂಲಕ ಹೋಲಿಸಿ ನಿರಾಕರಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಅದು ಲೂಪ್ ಆಗುತ್ತದೆ.
checkLinks ಖಾತೆಯ ಫೋಲ್ಡರ್ ~/.local/share/ccam/profiles/<name>/ ಅನ್ನು ಅದರ ಹಂಚಿಕೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ share.Check ಬಳಸಿ ಹೋಲಿಸುತ್ತದೆ; ಅದು lstat ಮತ್ತು readlink ಅನ್ನು ಮಾತ್ರ ಕರೆಯುತ್ತದೆ, ಪ್ರತಿ ಐಟಂಗೆ ಒಂದು ಅಥವಾ ಎರಡು ಸಿಸ್ಟಮ್ ಕಾಲ್‌ಗಳು. ಇಲ್ಲದ ಲಿಂಕ್ ಅನ್ನು ಅಲ್ಲೇ ರಚಿಸಲಾಗುತ್ತದೆ. ಡೇಟಾ ಕಳೆದುಹೋಗಬಹುದಾದ ಯಾವುದಾದರೂ ಆರಂಭವನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.
applyMCP ಹಂಚಿಕೊಂಡ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ (ಕೆಳಗೆ ನೋಡಿ).
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 ಆರಂಭಿಸುವ ಪ್ರಕ್ರಿಯೆಗಳು ಲಾಕ್ ಅನ್ನು ಪಡೆದು ಸೆಷನ್ ಮುಗಿದ ನಂತರವೂ ಅದನ್ನು ಇಟ್ಟುಕೊಳ್ಳುತ್ತವೆ.
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 ಗೆ ಬರೆಯುತ್ತದೆ, ಮತ್ತು ಖಾತೆ ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

Remote Control

ccam work rc (ಅಥವಾ ccam work remote-control) Claude Code ನ Remote Control ಅನ್ನು work ಆಗಿ ಆರಂಭಿಸುತ್ತದೆ. claude remote-control ತನ್ನ ಉಪ-ಕಮಾಂಡ್‌ಗಿಂತ ಮೊದಲು --mcp-config ಅನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಯಾವುದನ್ನೂ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ, ಮತ್ತು ಅದರ ಸೆಷನ್‌ಗಳು MCP ಸರ್ವರ್‌ಗಳನ್ನು ಖಾತೆಯ .claude.json ನಿಂದ ಮಾತ್ರ ಓದುತ್ತವೆ. ಹೀಗಾಗಿ ಇಲ್ಲಿ ಫ್ಲ್ಯಾಗ್ ವಿಧಾನ ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ:

remoteControl ಖಾತೆಯ ನಂತರ - ನಿಂದ ಆರಂಭವಾಗದ ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು Claude Code ನ ಉಪ-ಕಮಾಂಡ್ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ. ಅದು remote-control ಅಥವಾ rc ಆಗಿದ್ದರೆ, mcp.FlagArgs ಏನನ್ನೂ ಸೇರಿಸುವುದಿಲ್ಲ.
mcp.Synced ಗುಂಪಿನ mcp.json ನ ಮಾರ್ಪಾಡಿನ ಸಮಯವನ್ನು ಖಾತೆಯ sync-stamp ನೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ. .claude.json ನಲ್ಲಿ ಈಗಾಗಲೇ ಗುಂಪಿನ ಪ್ರಸ್ತುತ ಸರ್ವರ್‌ಗಳಿದ್ದರೆ, ಅಥವಾ ಗುಂಪಿನಲ್ಲಿ ಯಾವುದೇ ಸರ್ವರ್ ಇಲ್ಲದಿದ್ದರೆ, Remote Control ಯಾವುದೇ ಪ್ರಶ್ನೆಯಿಲ್ಲದೆ ಆರಂಭವಾಗುತ್ತದೆ.
ಇಲ್ಲದಿದ್ದರೆ ಸೆಷನ್‌ಗಳಿಗೆ ಸಿಗದ ಸರ್ವರ್‌ಗಳ ಹೆಸರುಗಳನ್ನು ccam ತಿಳಿಸಿ ಹೀಗೆ ಕೇಳುತ್ತದೆ:
```
ccam: Remote Control sessions only get MCP servers stored in account work's .claude.json, not the shared MCP servers (ctx, fs).
Copy them into .claude.json (a backup is kept)? [y/N]
```
y ನೀಡಿದರೆ, mcp.Sync ಅವುಗಳನ್ನು sync ವಿಧಾನದಂತೆಯೇ ನಕಲಿಸುತ್ತದೆ: Claude Code ನ ಲಾಕ್ ಅಡಿಯಲ್ಲಿ, ಬ್ಯಾಕಪ್ ನಂತರ, ಖಾತೆಯ ಸ್ವಂತ ಸರ್ವರ್‌ಗಳನ್ನು ಉಳಿಸಿಕೊಂಡು. N ನೀಡಿದರೆ, ಅಥವಾ ಟರ್ಮಿನಲ್ ಇಲ್ಲದಿದ್ದರೆ, Remote Control ಅವುಗಳಿಲ್ಲದೆ ಆರಂಭವಾಗುತ್ತದೆ, ಮತ್ತು ccam mcp_strategy = "sync" ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಅದು ಪ್ರತಿ ಆರಂಭದ ಮೊದಲು ಅವುಗಳನ್ನು ನಕಲಿಸುತ್ತದೆ.

ಸರ್ವರ್‌ಗಳು ನಕಲಾಗುವವರೆಗೆ ccam ಪ್ರತಿ Remote Control ಆರಂಭದಲ್ಲಿ ಕೇಳುತ್ತದೆ, ಮತ್ತು ನಕಲಿನ ನಂತರ ಗುಂಪಿನ mcp.json ಮತ್ತೆ ಬದಲಾದಾಗ ಮಾತ್ರ ಕೇಳುತ್ತದೆ. ನಂತರದ ಸಾಮಾನ್ಯ ಆರಂಭಗಳಲ್ಲಿ .claude.json ನಲ್ಲಿನ ನಕಲು --mcp-config ಮೇಲೆ ಗೆಲ್ಲುತ್ತದೆ, ಹೀಗಾಗಿ ccam mcp add, remove ಮತ್ತು import ಇತರ ಖಾತೆಗಳಲ್ಲಿರುವ ನಕಲುಗಳನ್ನು ನವೀಕರಿಸುತ್ತವೆ (ಹಂಚಿಕೊಂಡ MCP ಸರ್ವರ್‌ಗಳು).

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 ಹೊಂದಿಸಿ:

$ 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 ಮಾಡುವುದಿಲ್ಲ. ಆದರೂ ಅದು ಹಂಚಿಕೆ ಲಿಂಕ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಸಾಮಾನ್ಯ ಆರಂಭದಂತೆಯೇ ಇಲ್ಲದ ಲಿಂಕ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
ccam work rc, work ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, .claude.json ಅನ್ನು ಮುಟ್ಟುವುದಿಲ್ಲ, ಅದನ್ನು ತಿಳಿಸುತ್ತದೆ, ಮತ್ತು ಗುಂಪಿನ ಸರ್ವರ್‌ಗಳಿಲ್ಲದೆ Remote Control ಅನ್ನು ಆರಂಭಿಸುತ್ತದೆ; ಅವುಗಳನ್ನು ನಕಲಿಸಲು ಸೆಷನ್ ಮುಗಿದ ನಂತರ ಮತ್ತೆ ರನ್ ಮಾಡಿ. --dry-run ಇದ್ದಾಗ ಅದು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ, ಆದರೆ ಕೇಳುವುದೂ ಇಲ್ಲ, ನಕಲಿಸುವುದೂ ಇಲ್ಲ.
mcp_strategy = "sync" ಇದ್ದಾಗ, ವಿಫಲವಾದ ಸಿಂಕ್ ccam: MCP sync failed (launching anyway): … ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು Claude Code ಈಗಾಗಲೇ ಇದ್ದ ಸರ್ವರ್‌ಗಳೊಂದಿಗೆ ಆರಂಭವಾಗುತ್ತದೆ.