# ఖాతాల మధ్య షేరింగ్

> ccam share ప్రణాళిక, బ్యాకప్‌లు, ఘర్షణ ఎంపికలతో సెట్టింగ్‌లు, CLAUDE.md, ఎక్స్‌టెన్షన్లు, చరిత్రను ఒక గ్రూప్ ఫోల్డర్‌కు ఎలా లింక్ చేస్తుంది, off ఎలా తిరిగి కాపీ చేస్తుంది.

Source: https://ccam.dev/te/features/share/ · Updated 2026-10-19

ప్రతి ఖాతాకు సొంత ఫోల్డర్ ఉంటుంది, కానీ అందులోని చాలా వరకు వేరుగా ఉండాల్సిన అవసరం లేదు. `ccam share` ఒకసారి ఒక ఖాతాకు, ఒక అంశానికి షేరింగ్‌ను ఆన్ లేదా ఆఫ్ చేస్తుంది: ఖాతా ఫైల్ లేదా ఫోల్డర్ ఒక గ్రూప్ ఫోల్డర్‌లోకి తరలించబడి సింబాలిక్ లింక్‌తో భర్తీ అవుతుంది, కాబట్టి గ్రూప్‌లోని ప్రతి ఖాతా ఒకే కాపీని చదువుతుంది, అందులోనే రాస్తుంది. ఒక ఖాతా ఏమి షేర్ చేస్తుందో మార్చడానికి, లేదా కొన్ని ఖాతాలను వాటి సొంత గ్రూప్‌లో పెట్టడానికి `ccam add` తర్వాత దీన్ని ఉపయోగించండి.

## వినియోగం

```sh
ccam share work                       # show what work shares, and with which group
ccam share work --history on          # share conversation history with the default group
ccam share side --history team        # share it with the group team instead
ccam share work --settings off        # give work its own copy of settings.json again
ccam share work --memory off --fresh  # stop sharing CLAUDE.md and start with no file
ccam share work --settings on --yes --prefer merge   # no questions; merge JSON on conflicts
ccam --dry-run share work --history on               # print the plan, change nothing
```

అంశాల ఆప్షన్లు లేకుండా, `ccam share` ప్రస్తుత స్థితిని ప్రింట్ చేస్తుంది:

```console
$ ccam share work
Sharing for work
  MCP servers                        shared (group default)  --mcp
  settings.json                      shared (group default)  --settings
  global CLAUDE.md                   shared (group default)  --memory
  agents, commands, skills, plugins  shared (group default)  --extensions
  conversation history               local                   --history
```

ఆప్షన్లతో, ccam ఒక ప్రణాళికను ప్రింట్ చేసి, గ్రూప్ కాపీ నుంచి వేరుగా ఉన్న ప్రతి ఫైల్ గురించి అడిగి, ఏదైనా మార్చే ముందు `Proceed? [y/N]` అని అడుగుతుంది. కొత్త ఖాతా సంభాషణ చరిత్ర తప్ప అన్నింటినీ షేర్ చేస్తుంది; [MCP సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి](https://ccam.dev/te/docs/sharing.md) ప్రతి అంశాన్ని వినియోగదారు వైపు నుంచి వివరిస్తుంది.

## ఆప్షన్లు

| ఆప్షన్ | ఏమి చేస్తుంది | డిఫాల్ట్ |
| --- | --- | --- |
| `--mcp <on\|off\|group>` | MCP సర్వర్లు | మారదు |
| `--settings <on\|off\|group>` | `settings.json` | మారదు |
| `--memory <on\|off\|group>` | గ్లోబల్ `CLAUDE.md` | మారదు |
| `--extensions <on\|off\|group>` | `agents/`, `commands/`, `skills/`, `plugins/`, `output-styles/`, `rules/` | మారదు |
| `--history <on\|off\|group>` | `projects/`, `history.jsonl` | మారదు |
| `--fresh` | షేరింగ్ ఆఫ్ చేసేటప్పుడు, గ్రూప్ కంటెంట్‌ను కాపీ చేయకుండా ఖాళీగా మొదలుపెడుతుంది | ఆఫ్ |
| `--prefer <group\|mine\|merge>` | ఘర్షణలను ఎలా నిర్ణయించాలి | అడుగుతుంది; `--yes` తో, ప్రతి అంశం యొక్క డిఫాల్ట్ |
| `-y`, `--yes` | అడగకుండా రన్ చేస్తుంది; ఘర్షణలు `--prefer` ను అనుసరిస్తాయి | ఆఫ్ |
| `-h`, `--help` | `share` కోసం సహాయం | |
| `--dry-run` (గ్లోబల్) | పాటిస్తుంది: ఘర్షణల గురించి అడుగుతుంది, ప్రణాళికను ప్రింట్ చేస్తుంది, ఏదీ మార్చదు | ఆఫ్ |

`on` విలువ అంటే `default` గ్రూప్, `off` అంటే లోకల్ (షేర్ కాదు), మరేదైనా విలువ గ్రూప్ పేరు. గ్రూప్ పేర్లు `~/.local/share/ccam/groups/` కింద ఫోల్డర్ పేర్లు అవుతాయి, కాబట్టి `ccam share side --history ../x` `invalid group name: "../x"` తో విఫలమవుతుంది. ఖాతాను పేరు లేదా నంబర్ ద్వారా ఇవ్వవచ్చు, మీరు పేర్కొన్న అంశాలు మాత్రమే మారతాయి.

## ఇది ఎలా పనిచేస్తుంది

సంబంధిత ఫైళ్లు:

- `~/.config/ccam/config.toml`: ప్రతి ఖాతా యొక్క `[profile.share]` టేబుల్, ఒక్కో అంశానికి ఒక విలువ.
- `~/.local/share/ccam/profiles/<name>/`: ఖాతా యొక్క `CLAUDE_CONFIG_DIR`.
- `~/.local/share/ccam/groups/<group>/`: షేర్ చేసిన కాపీలు.

1. `internal/cli/share.go` కాన్ఫిగ్‌ను చదివి, `config.Share.Set` తో ప్రతి `--<item>` విలువను ఖాతా సెట్టింగ్‌ల కాపీకి వర్తింపజేసి, ఖాతా రన్ అవుతుంటే తిరస్కరిస్తుంది.
2. `share.Build` ప్రస్తుత సెట్టింగ్‌లను లక్ష్యంతో పోల్చి దశలను జాబితా చేస్తుంది. ఇది డిస్క్‌ను చదువుతుంది మాత్రమే: `share.Layout` లోని ప్రతి పాత్‌కు `os.Lstat`, `os.Readlink`. ప్రణాళిక అనేది ఆపరేషన్ల జాబితా: ఖాళీ గ్రూప్ స్థానంలోకి తరలించడం (adopt), గ్రూప్‌లో లేని ఫైళ్లను తరలించడం (merge dir), పరిష్కరించిన ఘర్షణను గ్రూప్‌లో రాయడం, బ్యాకప్, అన్‌లింక్, లింక్, తిరిగి కాపీ, ప్లగిన్ పాత్‌లను మళ్లీ రాయడం, ప్లగిన్ రిజిస్ట్రీని మెర్జ్ చేయడం.
3. ఘర్షణలు ప్రాంప్ట్ ద్వారా లేదా `--prefer` ద్వారా నిర్ణయించబడతాయి.
4. `Plan.Describe` ప్రణాళికను ప్రింట్ చేస్తుంది, ccam అడుగుతుంది.
5. ఏదైనా తరలించే ముందు లక్ష్య సెట్టింగ్‌లు `config.toml` లో రాయబడతాయి. `Plan.Apply` మధ్యలో ఆగితే, `ccam doctor --fix`, మళ్లీ రన్ చేయడం సేవ్ చేసిన లక్ష్యం వైపు తమ ప్రణాళికను నిర్మించి మార్పును పూర్తి చేస్తాయి.
6. `Plan.Apply` దశలను క్రమంగా రన్ చేస్తుంది. ప్రతి దశ డేటాను గ్రూప్‌లోకి లేదా బ్యాకప్ ఫోల్డర్‌లోకి తరలిస్తుంది; ఏదీ తొలగించబడదు.

`share.Layout` అనేది ప్రతి అంశం కవర్ చేసే పాత్‌ల అనుమతి జాబితా. అందులో లేనిది ఏదీ ఎప్పుడూ గ్రూప్‌ను చేరదు. `share.Never` `.credentials.json`, `.claude.json` ను పేర్కొంటుంది, వాటిలో ఏదైనా ఎప్పుడైనా లేఅవుట్‌లో కనిపిస్తే `Build` అంతర్గత ఎర్రర్‌తో ఆగుతుంది. `mcp` అంశానికి పాత్‌లు లేవు: సర్వర్ జాబితా `.claude.json` లోపల ఉంటుంది, కాబట్టి [MCP షేరింగ్](https://ccam.dev/te/features/mcp.md) బదులుగా గ్రూప్ `mcp.json` ద్వారా పనిచేస్తుంది, `--mcp` సెట్టింగ్‌ను మాత్రమే మారుస్తుంది.

`side` చరిత్రను ఆన్ చేసినప్పుడు, గ్రూప్‌లో ఇప్పటికే కంటెంట్ ఉంటే, `projects/` అనే ఒక ఫోల్డర్‌కు జరిగేది ఇది:

ఆ పాత్ వద్ద గ్రూప్‌లో ఇంకా ఏమీ లేకపోతే, దాన్ని షేర్ చేసే మొదటి ఖాతా ఇదే, దాని ఫోల్డర్ బ్యాకప్ లేకుండా ఉన్నది ఉన్నట్లుగా అక్కడికి తరలించబడుతుంది. లేకపోతే `mergeDir` గ్రూప్‌లో లేని ప్రతి ఫైల్‌ను గ్రూప్‌లోకి తరలిస్తుంది, రెండు వైపులా ఉన్న ఫైళ్లు ఖాతా ఫోల్డర్‌లోనే ఉంటాయి, కాబట్టి గ్రూప్ వెర్షన్ ఉంచబడుతుంది. ఆపై ఖాతా ఫోల్డర్ ఖాతా ఫోల్డర్‌లోని `.ccam-backup/<time>/` కు వెళ్తుంది, `os.Symlink` దాని స్థానంలో లింక్‌ను పెడుతుంది. సంభాషణ ఫైళ్లకు వాటి సెషన్ ID పేరు ఉంటుంది, కాబట్టి అనేక ఖాతాల చరిత్రలు ఘర్షణ లేకుండా కలిసిపోతాయి.

తరలించడం `rename(2)` ను ఉపయోగిస్తుంది, ఫైల్ సిస్టమ్‌ల మధ్య అయితే కాపీ చేసి తొలగించడానికి మారుతుంది. తరలించిన ట్రీ లోపల ఉండి దాని బయటికి చూపే రిలేటివ్ లింక్ పూర్తి లింక్‌గా మళ్లీ రాయబడుతుంది (`fsutil.PortableLink`), కాబట్టి కొత్త స్థానం నుంచి కూడా అది సరిగ్గా చేరుతుంది. `plugins/` రిజిస్ట్రీలు (`installed_plugins.json`, `known_marketplaces.json`) ఖాతా ఫోల్డర్ ద్వారా వెళ్లే పూర్తి పాత్‌లను నిల్వ చేస్తాయి; ccam వాటిని గ్రూప్ ఫోల్డర్‌కు చూపేలా మారుస్తుంది, గ్రూప్‌లో ఇప్పటికే రిజిస్ట్రీ ఉంటే, ఖాతా ఎంట్రీలను అందులో మెర్జ్ చేస్తుంది.

ఒక అంశాన్ని ఆఫ్ చేయడం లింక్‌ను తిరగబెడుతుంది:

లింక్ groups ఫోల్డర్ లోపలికి చూపిస్తేనే ccam దాన్ని తీసివేస్తుంది, ఆపై `CopyTree` తో గ్రూప్ ప్రస్తుత కంటెంట్‌ను ఖాతాలోకి కాపీ చేస్తుంది. `--fresh` తో కాపీ దాటవేయబడుతుంది, ఆ పాత్ వద్ద ఖాతా ఏమీ లేకుండా మొదలవుతుంది. ఇతర ఖాతాల కోసం గ్రూప్ తన కంటెంట్‌ను ఉంచుకుంటుంది. ఒక అంశాన్ని ఒక గ్రూప్ నుంచి మరో గ్రూప్‌కు తరలిస్తే దాన్ని అన్‌లింక్ చేసి కొత్త గ్రూప్‌కు లింక్ చేస్తుంది, పాత గ్రూప్ అలాగే ఉంటుంది; ప్రణాళిక `Note:` లైన్‌లో ఆ విషయం చెబుతుంది.

రెండు వైపులా వేరే కంటెంట్‌తో ఉన్న ఒకే ఫైల్ ఘర్షణ:

`share.NewConflict` ఫైల్‌కు సరిపోయే ఎంపికలను జాబితా చేస్తుంది. `history.jsonl` `merge by line`, `keep group`, `use mine` ను అందిస్తుంది, మెర్జ్ మొదటిది. ఇతర `.json` ఫైళ్లు `keep group`, `use mine`, `merge JSON` ను అందిస్తాయి. మిగతావి `keep group`, `use mine` ను అందిస్తాయి. మొదటి ఎంపిక డిఫాల్ట్:

```console
history.jsonl differs from the group's copy.
  mine:  ~/.local/share/ccam/profiles/side/history.jsonl
  group: ~/.local/share/ccam/groups/default/history.jsonl
  1) merge by line
  2) keep group
  3) use mine
Choice [1]:
```

`merge JSON` (`MergeJSONBytes`) ఆబ్జెక్ట్‌లను రికర్సివ్‌గా మెర్జ్ చేస్తుంది, అర్రేలను నకళ్లు లేకుండా కలుపుతుంది, రెండు వైపులా ఒకే కీని వేరుగా సెట్ చేస్తే గ్రూప్ విలువను ఉంచుతుంది, కాబట్టి ఇతర ఖాతాల ప్రవర్తనలో మార్పు ఉండదు. `merge by line` గ్రూప్ లైన్లను ఉంచి, ఆపై అందులో లేని మీ లైన్లను జోడిస్తుంది. `keep group` తప్ప ప్రతి ఎంపిక ముందుగా గ్రూప్ కాపీని ఖాతా ఫోల్డర్‌లోని `.ccam-backup/<time>/group/` లో సేవ్ చేసి, ఆపై ఫలితాన్ని `fsutil.AtomicWrite` తో రాస్తుంది. మీ సొంత ఫైల్ ఎప్పుడూ బ్యాకప్‌కు వెళ్తుంది.

`--prefer group`, `mine` లేదా `merge` ప్రతి ఘర్షణను అడగకుండా నిర్ణయిస్తాయి; `merge` అంటే ఫైల్ అందించే దాన్ని బట్టి `merge JSON` లేదా `merge by line`, రెండూ అందించని ఫైల్ డిఫాల్ట్‌ను ఉంచుతుంది. `--yes` ఒక్కటే ఉంటే ప్రతి ఫైల్ డిఫాల్ట్‌ను తీసుకుంటుంది.

ప్రతి ప్రారంభంలో, `share.Check` లేఅవుట్‌లోని ప్రతి పాత్‌ను `lstat`, `readlink` మాత్రమే ఉపయోగించి సెట్టింగ్‌తో పోలుస్తుంది, అందువల్ల ప్రారంభ మార్గానికి సరిపడేంత తేలికగా ఉంటుంది. కోల్పోయేది ఏమీ లేదు కాబట్టి, లేని లింక్ అక్కడికక్కడే సృష్టించబడుతుంది. లింక్ ఉండాల్సిన చోట అసలు ఫైల్, తప్పు చోటికి లింక్, లేదా పాతబడిన లింక్ ప్రారంభాన్ని ఆపుతుంది:

```console
ccam: stopped because of share link problems:
  ~/.local/share/ccam/profiles/work/CLAUDE.md: set to shared but is a real file, not a link
Repair them with `ccam doctor --fix`, then run again
```

`ccam doctor --fix` సేవ్ చేసిన సెట్టింగ్‌లను రెండు వైపులా ఇచ్చి `share.Build` ను రన్ చేస్తుంది, అది ప్రతి దశను డిస్క్‌లో ఉన్నదాని నుంచి తయారు చేస్తుంది, ఘర్షణలలో గ్రూప్ కంటెంట్‌ను ఉంచుతుంది, తాను భర్తీ చేసే దేనినైనా బ్యాకప్ చేస్తుంది.

## భద్రత, ప్రత్యేక సందర్భాలు

- **రన్ అవుతున్న ఖాతాలు.** Claude Code ఆ ఖాతాగా రన్ అవుతున్నప్పుడు ccam షేరింగ్‌ను మార్చడానికి నిరాకరిస్తుంది (`account work is running; quit it first, then change its sharing`), ఎందుకంటే సెషన్ తరలిస్తున్న ఫైళ్లలోనే రాస్తూ ఉంటుంది, ఈలోగా అది జోడించే లైన్లు కోల్పోతాయి. `--dry-run` అయినా ప్రణాళికను ప్రింట్ చేస్తుంది.
- **బ్యాకప్‌లు.** ప్రతి ప్రణాళికకు ఖాతా ఫోల్డర్‌లో సొంత `.ccam-backup/<time>/` ఫోల్డర్ ఉంటుంది, రెండు ప్రణాళికలు ఒకే సెకనులో మొదలైతే నంబర్ ఉన్న ప్రత్యయంతో. ccam వాటిని ఎప్పుడూ తొలగించదు.
- **పాక్షిక వైఫల్యాలు.** ఏదైనా దశ విఫలమైతే, ccam ఎర్రర్‌ను, అసలు ఫైళ్లు ఎక్కడ ఉన్నాయో ప్రింట్ చేసి, `ccam doctor --fix` తో పూర్తి చేయమని చెబుతుంది. లక్ష్యం ఇప్పటికే సేవ్ అయింది, కాబట్టి సరిచేయడం దాని వైపు కొనసాగుతుంది.
- **మీ సొంత లింక్‌లు.** ఒక పాత్ ఇప్పటికే మీరు చేసిన లింక్ అయితే, ఉదాహరణకు dotfiles రిపోజిటరీకి, గ్రూప్ ఖాళీగా ఉంటే, ccam లింక్ లక్ష్యాన్ని గ్రూప్‌లోకి కాపీ చేసి, లింక్‌ను బ్యాకప్‌కు తరలిస్తుంది. లక్ష్యాన్ని ముట్టుకోదు.
- **లాగిన్ ఫైళ్లు.** `.credentials.json`, `.claude.json` ఎప్పుడూ గ్రూప్‌లోకి లింక్ చేయబడవు, తరలించబడవు, కాపీ చేయబడవు.
- **ఒకే ఫోల్డర్‌లో రెండు ఖాతాలు.** చరిత్రను షేర్ చేసే ఖాతాలు ఒకే ఫైళ్లలో రాస్తాయి. అదే చరిత్ర గ్రూప్‌లోని ఒక ఖాతా ఇప్పటికే రన్ అవుతున్న ఫోల్డర్‌లో రెండో ఖాతా ప్రారంభమైనప్పుడు, ccam హెచ్చరించి కొనసాగించే ముందు అడుగుతుంది.

## సంబంధిత పేజీలు

- [MCP సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి](https://ccam.dev/te/docs/sharing.md)
- [షేర్ చేసిన MCP సర్వర్లు](https://ccam.dev/te/features/mcp.md)
- [ఇప్పటికే ఉన్న సెటప్‌ను కాపీ చేయండి](https://ccam.dev/te/features/migrate.md)
- [అన్ని కమాండ్‌లు](https://ccam.dev/te/docs/commands.md)