# MCP ಸರ್ವರ್‌ಗಳು, ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮತ್ತು ಇತಿಹಾಸವನ್ನು ಹಂಚಿಕೊಳ್ಳಿ

> ಪ್ರತಿ ಲಾಗಿನ್ ಪ್ರತ್ಯೇಕವಾಗಿಟ್ಟು, ccam MCP ಸರ್ವರ್‌ಗಳು, settings.json, CLAUDE.md, agents, skills ಮತ್ತು ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು Claude Code ಖಾತೆಗಳ ನಡುವೆ ಹೇಗೆ ಹಂಚುತ್ತದೆ.

Source: https://ccam.dev/kn/docs/sharing/ · Updated 2026-10-19

ಪ್ರತಿ ಖಾತೆಯ ಲಾಗಿನ್ ಅದರದೇ ಆಗಿರುತ್ತದೆ. ಉಳಿದ ಎಲ್ಲವನ್ನೂ ಐಟಂವಾರು ಹಂಚಿಕೊಳ್ಳಬಹುದು: ccam ಖಾತೆಯ ಫೈಲ್ ಅಥವಾ ಫೋಲ್ಡರ್ ಅನ್ನು ಹಂಚಿಕೆಯ ಗುಂಪಿನ ಫೋಲ್ಡರ್‌ಗೆ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ. ಹೀಗಾಗಿ ಒಂದು ಖಾತೆಯಲ್ಲಿ ಮಾಡಿದ ಬದಲಾವಣೆ ಆ ಗುಂಪಿನ ಎಲ್ಲಾ ಖಾತೆಗಳಲ್ಲೂ ಕಾಣಿಸುತ್ತದೆ.

## ಏನನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು

| ಐಟಂ | ಆಯ್ಕೆ | ಏನು ಹಂಚಿಕೆಯಾಗುತ್ತದೆ |
| --- | --- | --- |
| MCP ಸರ್ವರ್‌ಗಳು | `--mcp` | ಗುಂಪಿನ `mcp.json`, ಆರಂಭದಲ್ಲಿ Claude Code ಗೆ ರವಾನೆಯಾಗುತ್ತದೆ |
| ಸೆಟ್ಟಿಂಗ್‌ಗಳು | `--settings` | `settings.json`: ಅನುಮತಿಗಳು, hooks, ಮಾಡೆಲ್, ಸ್ಟೇಟಸ್ ಲೈನ್ |
| ಜಾಗತಿಕ ಮೆಮೊರಿ | `--memory` | `CLAUDE.md` |
| ವಿಸ್ತರಣೆಗಳು | `--extensions` | `agents/`, `commands/`, `skills/`, `plugins/`, `output-styles/`, `rules/` |
| ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸ | `--history` | `projects/` ಮತ್ತು `history.jsonl` |

ಹೊಸ ಖಾತೆಗಳು ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲವನ್ನೂ ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ.

ಲಾಗಿನ್ ಫೈಲ್‌ಗಳಾದ `.credentials.json` ಮತ್ತು `.claude.json` ಎಂದಿಗೂ ಹಂಚಿಕೆಯಾಗುವುದಿಲ್ಲ. ccam ಒಂದು ನಿಗದಿತ ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪಾತ್‌ಗಳನ್ನು ಮಾತ್ರ ಲಿಂಕ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಈ ಎರಡು ಆ ಪಟ್ಟಿಯಲ್ಲಿಲ್ಲ.

## ಗುಂಪುಗಳು

`on` ಎಂದರೆ `default` ಗುಂಪು. ನೀವು ಒಂದು ಹೆಸರನ್ನೂ ನೀಡಬಹುದು. ಆಗ ಕೆಲವು ಖಾತೆಗಳು ಮಾತ್ರ ಒಂದು ಐಟಂ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ:

```sh
ccam share work --history team
ccam share side --history team
```

ಈಗ `work` ಮತ್ತು `side` ಪರಸ್ಪರ ಸಂಭಾಷಣೆಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ, ಆದರೆ ನಿಮ್ಮ ಇತರ ಖಾತೆಗಳೊಂದಿಗೆ ಅಲ್ಲ.

## ಹಂಚಿಕೆಯನ್ನು ಆನ್ ಮಾಡುವುದು

ಒಂದು ಖಾತೆ ಒಂದು ಐಟಂ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಆರಂಭಿಸಿದಾಗ, ccam:

1. ತಾನು ಸ್ಥಳಾಂತರಿಸುವ, ನಕಲಿಸುವ ಅಥವಾ ಲಿಂಕ್ ಮಾಡುವ ಪ್ರತಿ ಫೈಲ್‌ನ ಯೋಜನೆಯನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಆರಂಭಿಸುವ ಮೊದಲು ಕೇಳುತ್ತದೆ;
2. ಗುಂಪು ಇನ್ನೂ ಖಾಲಿಯಾಗಿದ್ದರೆ ಖಾತೆಯ ಫೈಲ್‌ಗಳನ್ನು ಗುಂಪಿನ ಫೋಲ್ಡರ್‌ಗೆ ಸ್ಥಳಾಂತರಿಸುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಗುಂಪಿನಲ್ಲಿ ಇನ್ನೂ ಇಲ್ಲದ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ;
3. ಒಂದೇ ಫೈಲ್ ಬೇರೆ ಬೇರೆಯಾಗಿದ್ದರೆ, ಗುಂಪಿನ ಆವೃತ್ತಿಯನ್ನು ಉಳಿಸಿಕೊಳ್ಳಬೇಕೇ, ನಿಮ್ಮದನ್ನು ಬಳಸಬೇಕೇ, ಅಥವಾ JSON ಅನ್ನು ವಿಲೀನಗೊಳಿಸಬೇಕೇ ಎಂದು ಕೇಳುತ್ತದೆ;
4. ನಿಮ್ಮ ಮೂಲ ಫೈಲ್ ಅನ್ನು ಖಾತೆಯ ಫೋಲ್ಡರ್‌ನೊಳಗಿನ `.ccam-backup/<time>/` ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ;
5. ಮೂಲ ಫೈಲ್‌ನ ಜಾಗದಲ್ಲಿ ಗುಂಪಿಗೆ ಒಂದು ಲಿಂಕ್ ಇರಿಸುತ್ತದೆ.

ಸಂಭಾಷಣೆಯ ಫೈಲ್‌ಗಳಿಗೆ ಅವುಗಳ ಸೆಷನ್ ID ಯ ಹೆಸರು ಇರುತ್ತದೆ. ಹೀಗಾಗಿ ಹಲವು ಖಾತೆಗಳ ಇತಿಹಾಸಗಳು ಯಾವುದೇ ಸಂಘರ್ಷವಿಲ್ಲದೆ ಒಂದಾಗುತ್ತವೆ.

ಖಾತೆಯಾಗಿ Claude Code ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ccam ಹಂಚಿಕೆಯನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಸ್ಥಳಾಂತರಿಸಲಾಗುತ್ತಿರುವ ಫೈಲ್‌ಗಳಿಗೆ ಸೆಷನ್ ಬರೆಯುತ್ತಲೇ ಇರುತ್ತದೆ. ಮೊದಲು ಅದರಿಂದ ನಿರ್ಗಮಿಸಿ.

## ಹಂಚಿಕೆಯನ್ನು ಆಫ್ ಮಾಡುವುದು

```sh
ccam share work --history off
```

ಲಿಂಕ್ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ ಮತ್ತು ಖಾತೆಗೆ ಗುಂಪಿನ ಈಗಿನ ವಿಷಯದ ತನ್ನದೇ ಆದ ಪ್ರತಿ ಸಿಗುತ್ತದೆ. ಬದಲಿಗೆ ಖಾಲಿಯಾಗಿ ಆರಂಭಿಸಲು `--fresh` ಸೇರಿಸಿ. ಗುಂಪು ತನ್ನ ವಿಷಯವನ್ನು ಇತರ ಖಾತೆಗಳಿಗಾಗಿ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ.

## ಈಗಿರುವ ಸೆಟಪ್ ಅನ್ನು ನಕಲಿಸಿ

ccam ಗಿಂತ ಮೊದಲು ನೀವು Claude Code ಬಳಸಿದ್ದರೆ, ನಿಮ್ಮ ಸೆಟ್ಟಿಂಗ್‌ಗಳು `~/.claude` ನಲ್ಲಿವೆ. `ccam migrate` ಅವುಗಳನ್ನು ಒಂದು ಗುಂಪಿಗೆ ನಕಲಿಸುತ್ತದೆ. ಹೀಗಾಗಿ ಆ ಐಟಂಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಪ್ರತಿ ಖಾತೆಗೂ ಅವು ಸಿಗುತ್ತವೆ:

```sh
ccam migrate
```

ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ, ccam ಮೊದಲು ಐಟಂಗಳ ಚೆಕ್‌ಲಿಸ್ಟ್ ತೋರಿಸುತ್ತದೆ. ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲವನ್ನೂ ಗುರುತಿಸಲಾಗಿರುತ್ತದೆ; ಒಂದು ಐಟಂ ಬದಲಾಯಿಸಲು Space ಮತ್ತು ಯೋಜನೆ ನೋಡಲು Enter ಒತ್ತಿ. ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಏನೂ ಇಲ್ಲದ ಐಟಂಗಳನ್ನು `not found` ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ.

ಇದು ನಕಲಿಸುವುದು:

- `settings.json` ಮತ್ತು ಜಾಗತಿಕ `CLAUDE.md`;
- ವಿಸ್ತರಣೆಗಳು `agents/`, `commands/`, `skills/`, `plugins/`, `output-styles/` ಮತ್ತು `rules/`;
- ನಿಮ್ಮ ಬಳಕೆದಾರ MCP ಸರ್ವರ್‌ಗಳು, ಅಂದರೆ `~/.claude.json` ನ `mcpServers` ನಮೂದು, ಗುಂಪಿನ `mcp.json` ಗೆ;
- ಇದು ನಕಲಿಸುವ MCP ಸರ್ವರ್‌ಗಳ ಉಳಿಸಿದ ಸೈನ್-ಇನ್‌ಗಳು (OAuth), ಪ್ರತಿ ಖಾತೆಯ ಸ್ವಂತ ಲಾಗಿನ್ ಫೈಲ್‌ಗೆ;
- ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸ (`projects/` ಮತ್ತು `history.jsonl`), ಆದರೆ ನೀವು `--history` ಸೇರಿಸಿದಾಗ ಮಾತ್ರ.

ಮೂಲ ಫೋಲ್ಡರ್ ಅನ್ನು ಓದಲಾಗುತ್ತದೆ ಅಷ್ಟೇ: ಅದರಲ್ಲಿನ ಯಾವುದನ್ನೂ ಸ್ಥಳಾಂತರಿಸುವುದಿಲ್ಲ, ಲಿಂಕ್ ಮಾಡುವುದಿಲ್ಲ ಅಥವಾ ಬದಲಾಯಿಸುವುದಿಲ್ಲ, ಮತ್ತು ಸಾಮಾನ್ಯ `claude` ಹಿಂದಿನಂತೆಯೇ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಲಾಗಿನ್ ಫೈಲ್‌ಗಳಾದ `.credentials.json` ಮತ್ತು `.claude.json` ಎಂದಿಗೂ ಗುಂಪಿಗೆ ನಕಲಾಗುವುದಿಲ್ಲ.

OAuth ಮೂಲಕ ಸೈನ್ ಇನ್ ಆಗುವ MCP ಸರ್ವರ್‌ಗಳು ತಮ್ಮ ಟೋಕನ್‌ಗಳನ್ನು ಸರ್ವರ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಲ್ಲ, ಲಾಗಿನ್‌ನಲ್ಲಿ ಇಡುತ್ತವೆ. ನೀವು ಅವುಗಳಿಗೆ ಮತ್ತೆ ಸೈನ್ ಇನ್ ಮಾಡಬೇಕಾಗದಂತೆ, ಗುಂಪಿನ ಮೂಲಕ ಸರ್ವರ್‌ಗಳನ್ನು ಪಡೆಯುವ ಪ್ರತಿ ಖಾತೆಯ ಲಾಗಿನ್ ಫೈಲ್‌ಗೆ ccam ಆ ಸೈನ್-ಇನ್‌ಗಳನ್ನು ನಕಲಿಸುತ್ತದೆ, ಖಾತೆಯಲ್ಲಿ ಈಗಾಗಲೇ ತನ್ನದೇ ಸೈನ್-ಇನ್‌ಗಳು ಇಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ. ರನ್ ಆಗುತ್ತಿರುವ, ಇನ್ನೂ ಲಾಗಿನ್ ಆಗದ, `ccam import` ಮೂಲಕ ಇದ್ದಲ್ಲೇ ನೋಂದಾಯಿಸಿದ, ಅಥವಾ ತಮ್ಮ ಲಾಗಿನ್ ಅನ್ನು macOS Keychain ನಲ್ಲಿ ಇಡುವ ಖಾತೆಗಳನ್ನು ಅದು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳ ಹೆಸರುಗಳನ್ನು ತಿಳಿಸುತ್ತದೆ; ಆ ಖಾತೆಗಳಲ್ಲಿ `/mcp` ಮೂಲಕ ಸರ್ವರ್‌ಗಳಿಗೆ ಸೈನ್ ಇನ್ ಮಾಡಿ. ನಂತರ MCP ಸರ್ವರ್‌ಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುವ ಖಾತೆಗೆ, ನೀವು `ccam migrate` ಅನ್ನು ಮತ್ತೆ ರನ್ ಮಾಡಿದಾಗ ಸೈನ್-ಇನ್‌ಗಳು ಸಿಗುತ್ತವೆ.

ಏನನ್ನಾದರೂ ನಕಲಿಸುವ ಮೊದಲು ccam ಯೋಜನೆಯನ್ನು ಮುದ್ರಿಸಿ ಕೇಳುತ್ತದೆ:

```console
$ ccam migrate
Copy from /home/me/.claude into group default (/home/me/.local/share/ccam/groups/default):
  mcp         ~/.claude.json  new: context7, fs
  settings    settings.json   new: 80 B
  memory      CLAUDE.md       new: 31 B
  extensions  agents/         add 1 file the group lacks (17 B)
              commands/       add 1 file the group lacks (15 B)
              skills/         add 1 file the group lacks (32 B)
              not found, skipped: plugins/, output-styles/, rules/
  Conversation history (projects/, history.jsonl) is not included; add --history to copy it.
Copy these into group default? [y/N] y
✓ Copied into group default: 2 MCP servers, settings.json, CLAUDE.md, agents/, commands/, skills/
Accounts that share these through group default:
  mcp         personal
  settings    personal
  memory      personal
  extensions  personal
```

ಕೊನೆಯಲ್ಲಿ, ಗುಂಪಿನ ಮೂಲಕ ಪ್ರತಿ ಐಟಂ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಖಾತೆಗಳನ್ನು ccam ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಕೆಲವು ಖಾತೆಗಳು ಹಂಚಿಕೊಳ್ಳದಿದ್ದರೆ, ಅವುಗಳಿಗೆ ಹಂಚಿಕೆಯನ್ನು ಆನ್ ಮಾಡುವ `ccam share` ಕಮಾಂಡ್‌ಗಳನ್ನು ಅದು ಮುದ್ರಿಸುತ್ತದೆ.

ಗುಂಪಿನಲ್ಲಿ ಈಗಾಗಲೇ ಒಂದು ಫೈಲ್‌ನ ಬೇರೆ ನಕಲು ಇದ್ದರೆ, ಹಂಚಿಕೆಯನ್ನು ಆನ್ ಮಾಡುವಾಗಿನಂತೆಯೇ ccam ಕೇಳುತ್ತದೆ: ಗುಂಪಿನ ನಕಲನ್ನು ಉಳಿಸಿಕೊಳ್ಳಬೇಕೇ ಅಥವಾ ನಿಮ್ಮದನ್ನು ಬಳಸಬೇಕೇ. `settings.json` ಮತ್ತು ಇತರ JSON ಫೈಲ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಲೂ ಬಹುದು, ಮತ್ತು `history.jsonl` ಅನ್ನು ಸಾಲುವಾರು ವಿಲೀನಗೊಳಿಸಬಹುದು. ಗುಂಪಿನ ಹಿಂದಿನ ನಕಲುಗಳನ್ನು ಗುಂಪಿನ ಫೋಲ್ಡರ್‌ನೊಳಗಿನ `.ccam-backup/<time>/` ನಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ.

| ಆಯ್ಕೆ | ಪರಿಣಾಮ |
| --- | --- |
| `--settings`, `--memory`, `--extensions`, `--mcp`, `--history` | ನೀವು ಹೆಸರಿಸಿದ ಐಟಂಗಳನ್ನು ಮಾತ್ರ, ಚೆಕ್‌ಲಿಸ್ಟ್ ಇಲ್ಲದೆ ನಕಲಿಸುತ್ತದೆ; ಅವು ಇಲ್ಲದಿದ್ದರೆ ಮತ್ತು ಟರ್ಮಿನಲ್‌ನ ಹೊರಗೆ, ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲವನ್ನೂ |
| `-g`, `--group <group>` | `default` ಬದಲು ಈ ಗುಂಪಿಗೆ ನಕಲಿಸುತ್ತದೆ |
| `-y`, `--yes` | ಕೇಳದೆ ನಕಲಿಸುತ್ತದೆ; ಫೈಲ್ ಬೇರೆಯಾಗಿದ್ದಾಗ, ಗುಂಪಿನ ನಕಲನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ |

ಏನನ್ನೂ ನಕಲಿಸದೆ ಯೋಜನೆಯನ್ನು ಮಾತ್ರ ನೋಡಲು, `ccam --dry-run migrate` ನಲ್ಲಿರುವಂತೆ ಕಮಾಂಡ್‌ನ ಮುಂದೆ `--dry-run` ಇರಿಸಿ. ಇನ್ನೊಂದು ಫೋಲ್ಡರ್‌ನಿಂದ ನಕಲಿಸಲು, ಅದರ ಹೆಸರನ್ನು ನೀಡಿ: `ccam migrate ~/.claude-work --group work`.

## MCP ಸರ್ವರ್‌ಗಳು

Claude Code MCP ಸರ್ವರ್‌ಗಳನ್ನು ಲಾಗಿನ್ ಜೊತೆಗೆ `.claude.json` ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ ಆ ಫೈಲ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ. ccam ಹಂಚಿಕೊಂಡ ಸರ್ವರ್‌ಗಳನ್ನು ಗುಂಪಿನ `mcp.json` ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ ಮತ್ತು Claude Code ಅನ್ನು `--mcp-config=<group>/mcp.json` ನೊಂದಿಗೆ ಆರಂಭಿಸುತ್ತದೆ. ನಿಮ್ಮದೇ `--mcp-config` ಆಯ್ಕೆಗಳು ಅದರ ಮೇಲೆ ಇನ್ನೂ ಅನ್ವಯವಾಗುತ್ತವೆ.

```sh
ccam mcp add fs -- npx -y @modelcontextprotocol/server-filesystem ~/code
ccam mcp list
```

ಸೆಷನ್‌ನೊಳಗೆ `claude mcp add` ಮೂಲಕ ನೀವು ಸೇರಿಸುವ ಸರ್ವರ್ ಆ ಖಾತೆಗೆ ಮಾತ್ರ ಉಳಿಸಲ್ಪಡುತ್ತದೆ. ಮುಂದಿನ ಬಾರಿ ನೀವು ಆ ಖಾತೆಯನ್ನು ಆರಂಭಿಸಿದಾಗ, ccam ಆ ಸರ್ವರ್‌ನ ಹೆಸರನ್ನು ಮತ್ತು ಅದನ್ನು ಗುಂಪಿಗೆ ಸ್ಥಳಾಂತರಿಸುವ ಕಮಾಂಡ್ ಅನ್ನು ತಿಳಿಸುತ್ತದೆ:

```sh
ccam mcp import work gh
```

ಗುಂಪಿನಲ್ಲಿ ಈಗಾಗಲೇ ಅದೇ ಹೆಸರಿನ ಬೇರೆ ಸರ್ವರ್ ಇದ್ದರೆ, ccam ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ತಿಳಿಸುತ್ತದೆ. `--force` ಗುಂಪಿನ ಸರ್ವರ್ ಅನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಹಳೆಯ `mcp.json` ಅನ್ನು ಗುಂಪಿನ `.ccam-backup/` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.

OAuth ಮೂಲಕ ಸೈನ್ ಇನ್ ಆಗುವ MCP ಸರ್ವರ್‌ಗಳು ತಮ್ಮ ಟೋಕನ್‌ಗಳನ್ನು ಖಾತೆಯ ಲಾಗಿನ್ ಜೊತೆ ಸಂಗ್ರಹಿಸುತ್ತವೆ. ಆದ್ದರಿಂದ ಪ್ರತಿ ಖಾತೆಯಲ್ಲೂ ಅವುಗಳನ್ನು ಒಮ್ಮೆ ಅಧಿಕೃತಗೊಳಿಸಿ, ಅಥವಾ `ccam migrate` ಮೂಲಕ `~/.claude` ನಿಂದ ಸೈನ್-ಇನ್‌ಗಳನ್ನು ನಕಲಿಸಿ.

ಸರ್ವರ್‌ಗಳು `claude mcp list` ಮತ್ತು `/mcp` ನಲ್ಲಿ ಸಾಮಾನ್ಯ ಬಳಕೆದಾರ ಸರ್ವರ್‌ಗಳಾಗಿ ಕಾಣಬೇಕು ಎಂದು ನೀವು ಬಯಸಿದರೆ, `~/.config/ccam/config.toml` ನಲ್ಲಿ `mcp_strategy = "sync"` ಹೊಂದಿಸಿ. ಆಗ ccam ಆರಂಭಿಸುವ ಮೊದಲು ಅವುಗಳನ್ನು ಪ್ರತಿ ಖಾತೆಯ `.claude.json` ನಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ಇದನ್ನು Claude Code ನ ಸ್ವಂತ ಫೈಲ್ ಲಾಕ್ ಅಡಿಯಲ್ಲಿ ಮತ್ತು ಬ್ಯಾಕಪ್‌ನೊಂದಿಗೆ ಮಾಡುತ್ತದೆ.

## ಒಂದೇ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಎರಡು ಖಾತೆಗಳು

ಸಂಭಾಷಣೆಯ ಇತಿಹಾಸವನ್ನು ಹಂಚಿಕೊಳ್ಳುವ ಖಾತೆಗಳು ಒಂದೇ ಫೈಲ್‌ಗಳಿಗೆ ಬರೆಯುತ್ತವೆ. ಅದೇ ಗುಂಪಿನ ಇನ್ನೊಂದು ಖಾತೆ ಈಗಾಗಲೇ ರನ್ ಆಗುತ್ತಿರುವ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ನೀವು ಎರಡನೇ Claude Code ಆರಂಭಿಸಿದರೆ, ccam ನಿಮ್ಮನ್ನು ಎಚ್ಚರಿಸುತ್ತದೆ ಮತ್ತು ಮುಂದುವರಿಯಬೇಕೇ ಎಂದು ಕೇಳುತ್ತದೆ.

## ಏನಾದರೂ ಕೆಟ್ಟುಹೋದಾಗ

```sh
ccam doctor
ccam doctor --fix
```

ಹಂಚಿಕೊಂಡ ಪಾತ್ ಒಂದು ಸಾಮಾನ್ಯ ಫೈಲ್ ಆಗಿಬಿಟ್ಟಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ ನೀವು ಕೈಯಾರೆ ಬ್ಯಾಕಪ್ ಅನ್ನು ಮರುಸ್ಥಾಪಿಸಿದ ನಂತರ, ccam Claude Code ಆರಂಭಿಸುವ ಮೊದಲೇ ನಿಲ್ಲುತ್ತದೆ ಮತ್ತು `ccam doctor --fix` ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಅದು ಆ ಫೈಲ್ ಅನ್ನು ಗುಂಪಿನೊಂದಿಗೆ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಬ್ಯಾಕಪ್ ಇರಿಸುತ್ತದೆ.