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

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

వినియోగం

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 ప్రస్తుత స్థితిని ప్రింట్ చేస్తుంది:

$ 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 సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి ప్రతి అంశాన్ని వినియోగదారు వైపు నుంచి వివరిస్తుంది.

ఆప్షన్లు

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 షేరింగ్ బదులుగా గ్రూప్ 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 ను అందిస్తాయి. మొదటి ఎంపిక డిఫాల్ట్:

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 మాత్రమే ఉపయోగించి సెట్టింగ్‌తో పోలుస్తుంది, అందువల్ల ప్రారంభ మార్గానికి సరిపడేంత తేలికగా ఉంటుంది. కోల్పోయేది ఏమీ లేదు కాబట్టి, లేని లింక్ అక్కడికక్కడే సృష్టించబడుతుంది. లింక్ ఉండాల్సిన చోట అసలు ఫైల్, తప్పు చోటికి లింక్, లేదా పాతబడిన లింక్ ప్రారంభాన్ని ఆపుతుంది:

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 సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి
• షేర్ చేసిన MCP సర్వర్లు
• ఇప్పటికే ఉన్న సెటప్‌ను కాపీ చేయండి
• అన్ని కమాండ్‌లు