# கணக்குகளுக்கு இடையே பகிர்தல்

> ccam share எப்படி அமைப்புகள், CLAUDE.md, நீட்டிப்புகள், வரலாறு ஆகியவற்றை ஒரு திட்டம், காப்புப்பிரதிகள், முரண்பாட்டுத் தேர்வுகளுடன் ஒரு குழுக் கோப்புறையுடன் இணைக்கிறது, off எப்படி மீண்டும் நகலெடுக்கிறது.

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

ஒவ்வொரு கணக்குக்கும் தனிக் கோப்புறை உண்டு, ஆனால் அதிலுள்ள பெரும்பாலானவை தனியாக இருக்க வேண்டியதில்லை. `ccam share` ஒரு நேரத்தில் ஒரு கணக்குக்கும் ஓர் உருப்படிக்கும் பகிர்வை இயக்குகிறது அல்லது நிறுத்துகிறது: கணக்கின் கோப்போ கோப்புறையோ ஒரு குழுக் கோப்புறைக்கு நகர்த்தப்பட்டு, ஒரு symbolic link-ஆல் மாற்றப்படுகிறது, அதனால் குழுவின் ஒவ்வொரு கணக்கும் ஒரே நகலைப் படித்து எழுதுகிறது. ஒரு கணக்கு எதைப் பகிர்கிறது என்பதை மாற்ற, அல்லது சில கணக்குகளைத் தனிக் குழுவில் வைக்க, `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
```

உருப்படி options இல்லாமல், `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
```

options உடன், ccam ஒரு திட்டத்தை அச்சிட்டு, குழுவின் நகலிலிருந்து வேறுபடும் ஒவ்வொரு கோப்பைப் பற்றியும் கேட்டு, எதையும் மாற்றும் முன் `Proceed? [y/N]` என்று கேட்கும். புதிய கணக்கு உரையாடல் வரலாற்றைத் தவிர மற்ற அனைத்தையும் பகிரும்; [MCP சர்வர்கள், அமைப்புகள், வரலாற்றைப் பகிர்தல்](https://ccam.dev/ta/docs/sharing.md) ஒவ்வொரு உருப்படியையும் பயனரின் பார்வையில் விளக்குகிறது.

## Options

| Option | என்ன செய்யும் | இயல்புநிலை |
| --- | --- | --- |
| `--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` | பகிர்வை நிறுத்தும்போது, குழுவின் உள்ளடக்கத்தை நகலெடுப்பதற்குப் பதிலாகக் காலியாகத் தொடங்கும் | off |
| `--prefer <group\|mine\|merge>` | முரண்பாடுகளை எப்படி முடிவு செய்வது | கேட்கும்; `--yes` உடன், ஒவ்வொரு உருப்படியின் இயல்புநிலை |
| `-y`, `--yes` | கேட்காமல் இயங்கும்; முரண்பாடுகள் `--prefer`-ஐப் பின்பற்றும் | off |
| `-h`, `--help` | `share`-க்கான உதவி | |
| `--dry-run` (global) | மதிக்கப்படும்: முரண்பாடுகளைப் பற்றிக் கேட்டு, திட்டத்தை அச்சிடும், எதையும் மாற்றாது | off |

`on` மதிப்பு `default` குழுவைக் குறிக்கும், `off` என்றால் local (பகிரப்படாதது), வேறு எந்த மதிப்பும் ஒரு குழுவின் பெயர். குழுப் பெயர்கள் `~/.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-ஐப் படித்து, ஒவ்வொரு `--<item>` மதிப்பையும் `config.Share.Set` மூலம் கணக்கின் அமைப்புகளின் ஒரு நகலுக்குப் பொருத்துகிறது, கணக்கு இயங்கிக்கொண்டிருந்தால் மறுக்கிறது.
2. `share.Build` தற்போதைய அமைப்புகளை இலக்குடன் ஒப்பிட்டு, படிகளைப் பட்டியலிடுகிறது. அது வட்டைப் படிக்க மட்டுமே செய்கிறது: `share.Layout`-இல் உள்ள ஒவ்வொரு பாதைக்கும் `os.Lstat` மற்றும் `os.Readlink`. திட்டம் என்பது செயல்பாடுகளின் பட்டியல்: காலியான குழு இடத்துக்கு நகர்த்துதல் (adopt), குழுவிடம் இல்லாத கோப்புகளை நகர்த்துதல் (merge dir), தீர்க்கப்பட்ட முரண்பாட்டைக் குழுவுக்குள் எழுதுதல், காப்புப்பிரதி, இணைப்பை நீக்குதல், இணைத்தல், மீண்டும் நகலெடுத்தல், plugin பாதைகளை மாற்றி எழுதுதல், plugin registry-ஐ ஒன்றிணைத்தல்.
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`-ஐப் பெயரிடுகிறது, அவற்றில் ஏதேனும் ஒன்று layout-இல் தோன்றினால் `Build` ஓர் உள் பிழையுடன் நின்றுவிடும். `mcp` உருப்படிக்குப் பாதைகள் இல்லை: சர்வர் பட்டியல் `.claude.json`-க்குள் இருக்கிறது, அதனால் [MCP பகிர்வு](https://ccam.dev/ta/features/mcp.md) அதற்குப் பதிலாகக் குழுவின் `mcp.json` வழியாக வேலை செய்கிறது, `--mcp` அமைப்பை மட்டுமே மாற்றுகிறது.

`side` வரலாற்றைப் பகிரத் தொடங்கும்போது, குழுவிடம் ஏற்கெனவே உள்ளடக்கம் இருந்தால், `projects/` என்ற ஒரு கோப்புறைக்கு நடப்பது இதுதான்:

அந்தப் பாதையில் குழுவிடம் இன்னும் எதுவும் இல்லையென்றால், அதைப் பகிரும் முதல் கணக்கு இதுவே, அதன் கோப்புறை காப்புப்பிரதி இல்லாமல் அப்படியே அங்கே நகர்த்தப்படும். இல்லையென்றால் `mergeDir` குழுவிடம் இல்லாத ஒவ்வொரு கோப்பையும் குழுவுக்குள் நகர்த்துகிறது, இரு பக்கங்களிலும் உள்ள கோப்புகள் கணக்கின் கோப்புறையிலேயே இருக்கும், அதனால் குழுவின் பதிப்பு வைக்கப்படுகிறது. பிறகு கணக்கின் கோப்புறை, கணக்குக் கோப்புறைக்குள் `.ccam-backup/<time>/`-க்குச் செல்கிறது, `os.Symlink` அதன் இடத்தில் ஓர் இணைப்பை வைக்கிறது. உரையாடல் கோப்புகள் அவற்றின் session ID-யின் பெயரில் உள்ளன, அதனால் பல கணக்குகளின் வரலாறுகள் முரண்பாடின்றி ஒன்றிணையும்.

நகர்த்துதல் `rename(2)`-ஐப் பயன்படுத்துகிறது, file systems-க்கு இடையே நகலெடுத்து நீக்குவதற்குத் திரும்புகிறது. நகர்த்தப்பட்ட மரத்துக்குள் இருந்து அதற்கு வெளியே சுட்டிய relative link ஒரு absolute link ஆக மாற்றி எழுதப்படும் (`fsutil.PortableLink`), அதனால் புதிய இடத்திலிருந்தும் அது சரியாகத் தீர்க்கப்படும். `plugins/` registries (`installed_plugins.json`, `known_marketplaces.json`) கணக்குக் கோப்புறை வழியான absolute பாதைகளைச் சேமிக்கின்றன; ccam அவற்றைக் குழுவின் கோப்புறைக்குத் திருப்பி, குழுவிடம் ஏற்கெனவே ஒரு registry இருந்தால், கணக்கின் உள்ளீடுகளை அதனுடன் ஒன்றிணைக்கிறது.

ஓர் உருப்படியை நிறுத்துவது இணைப்பைத் தலைகீழாக்குகிறது:

இணைப்பு 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`) objects-ஐ recursive ஆக ஒன்றிணைக்கிறது, arrays-ஐ நகல்கள் இல்லாமல் இணைக்கிறது, இரு பக்கங்களும் ஒரே key-ஐ வேறுபட்ட மதிப்புகளுடன் அமைத்தால் குழுவின் மதிப்பை வைத்திருக்கிறது, அதனால் மற்ற கணக்குகள் நடத்தையில் எந்த மாற்றத்தையும் காணாது. `merge by line` குழுவின் வரிகளை வைத்துக்கொண்டு, அதில் இல்லாத உங்கள் வரிகளைச் சேர்க்கிறது. `keep group` தவிர ஒவ்வொரு தேர்வும் முதலில் குழுவின் நகலைக் கணக்குக் கோப்புறையில் `.ccam-backup/<time>/group/`-க்குச் சேமித்து, பிறகு முடிவை `fsutil.AtomicWrite` மூலம் எழுதுகிறது. உங்கள் சொந்தக் கோப்பு எப்போதும் காப்புப்பிரதிக்குச் செல்லும்.

`--prefer group`, `mine` அல்லது `merge` கேட்காமல் ஒவ்வொரு முரண்பாட்டையும் முடிவு செய்யும்; `merge` என்றால் கோப்பு வழங்குவதைப் பொறுத்து `merge JSON` அல்லது `merge by line`, இரண்டையும் வழங்காத கோப்பு இயல்புநிலையை வைத்திருக்கும். `--yes` மட்டும் கொடுத்தால் ஒவ்வொரு கோப்பின் இயல்புநிலையும் எடுக்கப்படும்.

ஒவ்வொரு தொடக்கத்திலும், `share.Check` layout-இல் உள்ள ஒவ்வொரு பாதையையும் அமைப்புடன் `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 repository-க்கு, குழு காலியாக இருந்தால், ccam இணைப்பின் இலக்கைக் குழுவுக்குள் நகலெடுத்து, இணைப்பையே காப்புப்பிரதிக்கு நகர்த்தும். இலக்கு தொடப்படாது.
- **உள்நுழைவுக் கோப்புகள்.** `.credentials.json` மற்றும் `.claude.json` ஒருபோதும் குழுவுடன் இணைக்கப்படவோ, நகர்த்தப்படவோ, நகலெடுக்கப்படவோ மாட்டாது.
- **ஒரே கோப்புறையில் இரண்டு கணக்குகள்.** வரலாற்றைப் பகிரும் கணக்குகள் ஒரே கோப்புகளில் எழுதுகின்றன. அதே வரலாற்றுக் குழுவின் இரண்டாவது கணக்கு, ஏற்கெனவே ஒன்று இயங்கும் கோப்புறையில் தொடங்கினால், ccam எச்சரித்துத் தொடரும் முன் கேட்கும்.

## தொடர்புடையவை

- [MCP சர்வர்கள், அமைப்புகள், வரலாற்றைப் பகிர்தல்](https://ccam.dev/ta/docs/sharing.md)
- [பகிரப்பட்ட MCP சர்வர்கள்](https://ccam.dev/ta/features/mcp.md)
- [ஏற்கெனவே உள்ள அமைப்பை நகலெடுத்தல்](https://ccam.dev/ta/features/migrate.md)
- [எல்லாக் கட்டளைகளும்](https://ccam.dev/ta/docs/commands.md)