# MCP सर्व्हर, सेटिंग्ज आणि इतिहास शेअर करा

> प्रत्येक लॉगिन वेगळे ठेवून ccam MCP सर्व्हर, settings.json, CLAUDE.md, agents, skills आणि संभाषण इतिहास Claude Code खात्यांमध्ये कसे शेअर करते.

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

प्रत्येक खात्याचे लॉगिन स्वतःचे राहते. बाकी सर्व काही आयटमनुसार शेअर करता येते: ccam खात्याची फाइल किंवा फोल्डर एका शेअर केलेल्या गट फोल्डरशी लिंक करते, त्यामुळे एका खात्यात केलेला बदल त्या गटातील सर्व खात्यांत दिसतो.

## काय शेअर करता येते

| आयटम | पर्याय | काय शेअर होते |
| --- | --- | --- |
| MCP सर्व्हर | `--mcp` | गटाची `mcp.json`, जी सुरू करताना Claude Code ला दिली जाते |
| सेटिंग्ज | `--settings` | `settings.json`: परवानग्या, hooks, मॉडेल, स्टेटस लाइन |
| global memory | `--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 merge करायचे हे विचारते;
4. तुमची मूळ फाइल खात्याच्या फोल्डरमधील `.ccam-backup/<time>/` मध्ये ठेवते;
5. मूळ फाइलच्या जागी गटाची लिंक ठेवते.

संभाषण फाइल्सना त्यांच्या session ID वरून नावे दिली जातात, त्यामुळे अनेक खात्यांचे इतिहास कोणत्याही conflict शिवाय एकत्र होतात.

Claude Code त्या खात्याने चालू असताना ccam शेअरिंग बदलत नाही, कारण session हलवल्या जाणाऱ्या फाइल्समध्ये लिहीत राहते. आधी ते बंद करा.

## शेअरिंग बंद करणे

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

लिंक काढली जाते आणि खात्याला गटाच्या सध्याच्या मजकुराची स्वतःची प्रत मिळते. त्याऐवजी रिकाम्याने सुरुवात करायची असेल तर `--fresh` जोडा. गट इतर खात्यांसाठी आपला मजकूर ठेवतो.

## आधीचा सेटअप कॉपी करा

तुम्ही ccam आधी Claude Code वापरले असेल, तर तुमची सेटिंग्ज `~/.claude` मध्ये आहेत. `ccam migrate` ती एका गटात कॉपी करते, म्हणजे ते आयटम शेअर करणाऱ्या प्रत्येक खात्याला ती मिळतात:

```sh
ccam migrate
```

टर्मिनलवर ccam आधी आयटम्सची एक चेकलिस्ट दाखवते. संभाषण इतिहास सोडून सर्व काही निवडलेले असते; एखादा आयटम बदलण्यासाठी Space दाबा आणि योजना पाहण्यासाठी Enter दाबा. ज्या आयटम्ससाठी फोल्डरमध्ये काहीच नाही त्यांच्यावर `not found` असे चिन्ह असते.

ते काय कॉपी करते:

- `settings.json` आणि global `CLAUDE.md`;
- एक्स्टेंशन्स `agents/`, `commands/`, `skills/`, `plugins/`, `output-styles/` आणि `rules/`;
- तुमचे user MCP सर्व्हर, म्हणजे `~/.claude.json` मधील `mcpServers` नोंद, गटाच्या `mcp.json` मध्ये;
- ते कॉपी करत असलेल्या MCP सर्व्हरची सेव्ह केलेली साइन-इन्स (OAuth), प्रत्येक खात्याच्या स्वतःच्या लॉगिन फाइलमध्ये;
- संभाषण इतिहास (`projects/` आणि `history.jsonl`), पण फक्त तुम्ही `--history` जोडल्यावर.

स्रोत फोल्डर फक्त वाचला जातो: त्यातील काहीही हलवले, लिंक केले किंवा बदलले जात नाही, आणि साधे `claude` आधीसारखेच चालत राहते. `.credentials.json` आणि `.claude.json` या लॉगिन फाइल्स गटात कधीच कॉपी होत नाहीत.

OAuth ने साइन इन करणारे MCP सर्व्हर आपले tokens सर्व्हर यादीत नाही, तर लॉगिनमध्ये ठेवतात. तुम्हाला त्यांच्यात पुन्हा साइन इन करावे लागू नये म्हणून, गटामार्फत सर्व्हर मिळणाऱ्या प्रत्येक खात्याच्या लॉगिन फाइलमध्ये 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 फाइल्स merge देखील करता येतात, आणि `history.jsonl` ओळीनुसार. गटाच्या आधीच्या प्रती गट फोल्डरमधील `.ccam-backup/<time>/` मध्ये जतन होतात.

| पर्याय | परिणाम |
| --- | --- |
| `--settings`, `--memory`, `--extensions`, `--mcp`, `--history` | चेकलिस्टशिवाय फक्त तुम्ही नाव दिलेले आयटम कॉपी करा; त्यांच्याशिवाय आणि टर्मिनलबाहेर, संभाषण इतिहास सोडून सर्व काही |
| `-g`, `--group <group>` | `default` ऐवजी या गटात कॉपी करा |
| `-y`, `--yes` | न विचारता कॉपी करा; फाइल वेगळी असल्यास गटाची प्रत ठेवा |

काहीही कॉपी न करता योजना पाहण्यासाठी कमांडच्या आधी `--dry-run` लिहा, जसे `ccam --dry-run migrate`. दुसऱ्या फोल्डरमधून कॉपी करण्यासाठी त्याचे नाव द्या: `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
```

session मध्ये `claude mcp add` ने जोडलेला सर्व्हर फक्त त्याच खात्यासाठी साठवला जातो. पुढच्या वेळी तुम्ही ते खाते सुरू कराल तेव्हा ccam त्या सर्व्हरचे नाव आणि तो गटात हलवणारी कमांड सांगते:

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

गटात त्याच नावाचा वेगळा सर्व्हर आधीच असेल, तर ccam तो वगळते आणि तसे सांगते. `--force` गटाचा सर्व्हर बदलते आणि जुनी `mcp.json` गटाच्या `.ccam-backup/` फोल्डरमध्ये ठेवते.

OAuth ने साइन इन करणारे MCP सर्व्हर आपले tokens खात्याच्या लॉगिनसोबत साठवतात, म्हणून प्रत्येक खात्यात त्यांना एकदा अधिकृत करा, किंवा `ccam migrate` ने `~/.claude` मधून साइन-इन्स कॉपी करा.

सर्व्हर `claude mcp list` आणि `/mcp` मध्ये साध्या user सर्व्हरप्रमाणे दिसावेत असे वाटत असेल, तर `~/.config/ccam/config.toml` मध्ये `mcp_strategy = "sync"` सेट करा. मग ccam सुरू करण्यापूर्वी ते प्रत्येक खात्याच्या `.claude.json` मध्ये लिहिते, Claude Code च्या स्वतःच्या file lock खाली आणि बॅकअपसह.

## एकाच फोल्डरमध्ये दोन खाती

संभाषण इतिहास शेअर करणारी खाती त्याच फाइल्समध्ये लिहितात. ज्या फोल्डरमध्ये त्याच गटातील दुसरे खाते आधीच चालू आहे तिथे तुम्ही दुसरे Claude Code सुरू केले, तर ccam तुम्हाला सावध करते आणि पुढे जायचे का ते विचारते.

## काही बिघडल्यास

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

एखादा शेअर केलेला पाथ साधी फाइल बनला असेल, उदाहरणार्थ तुम्ही हाताने बॅकअप परत आणल्यावर, तर ccam Claude Code सुरू करण्यापूर्वी थांबते आणि `ccam doctor --fix` कडे निर्देश करते, जे ती फाइल गटात merge करते आणि बॅकअप ठेवते.