ఇప్పటికే ఉన్న సెటప్‌ను కాపీ చేయడం

ccam కంటే ముందు మీరు Claude Code ఉపయోగించి ఉంటే, మీ సెటప్ ~/.claude, ~/.claude.json లో ఉంటుంది. ccam migrate దాన్ని ఒక షేర్ గ్రూప్‌లోకి కాపీ చేస్తుంది, కాబట్టి ఆ గ్రూప్ ద్వారా ఆ అంశాలను షేర్ చేసే ప్రతి ఖాతా మీకు ఇప్పటికే ఉన్న సెటప్‌తో మొదలవుతుంది. మూల ఫోల్డర్ చదవబడుతుంది మాత్రమే, సాధారణ claude మునుపటిలాగే పనిచేస్తుంది. మీ మొదటి ccam add తర్వాత దీన్ని ఒకసారి రన్ చేయండి, ఏదైనా ఖాతా MCP సర్వర్లను షేర్ చేయడం మొదలుపెట్టినప్పుడల్లా మళ్లీ రన్ చేయండి.

వినియోగం

ccam migrate                         # ~/.claude into group default, checklist on a terminal
ccam --dry-run migrate               # show the plan, copy nothing
ccam migrate --settings --mcp        # only these items, no checklist
ccam migrate --history --yes         # conversation history only, no questions
ccam migrate ~/.claude-work --group work

టెర్మినల్‌లో, అంశాల ఫ్లాగ్‌లు లేకుండా, --yes లేకుండా, ccam ముందుగా ఒక చెక్‌లిస్ట్‌ను చూపిస్తుంది:

 Copy into group default

 From /home/me/.claude
 ? Choose what to copy (Space to toggle)
 › [x] MCP servers
   [x] settings.json
   [x] global CLAUDE.md
   [x] agents, commands, skills
   [ ] conversation history

 Enter show the plan · Esc cancel

Space (లేదా x) కర్సర్ కింద ఉన్న అంశాన్ని మార్చుతుంది, బాణం కీలు లేదా j/k కదిలిస్తాయి, Enter ప్లాన్‌ను చూపిస్తుంది, Esc, q లేదా Ctrl+C Cancelled. అని ప్రింట్ చేస్తాయి. మూల ఫోల్డర్‌లో ఏమీ లేని అంశాలకు not found అని గుర్తు ఉంటుంది. మీరు అన్నింటి టిక్ తీసేస్తే, ccam Nothing selected. అని ప్రింట్ చేసి ఆగుతుంది.

ఆపై ccam ప్రణాళికను ప్రింట్ చేసి, కాపీ చేసే ముందు అడుగుతుంది:

$ ccam migrate --yes
Copy from /home/me/.claude into group default (/home/me/.local/share/ccam/groups/default):
  mcp         ~/.claude.json  new: fs, linear
              sign-ins        linear → personal; skipped: work (not logged in yet)
  settings    settings.json   new: 61 B
  memory      CLAUDE.md       new: 11 B
  extensions  agents/         add 1 file the group lacks (6 B)
              skills/         add 1 file the group lacks (13 B)
              not found, skipped: commands/, plugins/, output-styles/, rules/
  Conversation history (projects/, history.jsonl) is not included; add --history to copy it.
✓ Copied into group default: 2 MCP servers, settings.json, CLAUDE.md, agents/, skills/, MCP sign-ins for personal
MCP sign-ins were not copied to: work (not logged in yet). Sign in to those servers there with /mcp.
Accounts that share these through group default:
  mcp         personal, work
  settings    personal, work
  memory      personal, work
  extensions  personal, work

గ్రూప్ ద్వారా ఒక అంశాన్ని షేర్ చేసే ఖాతాలకు మాత్రమే ఆ గ్రూప్ అందుతుంది, కాబట్టి సారాంశం వాటిని అంశం వారీగా జాబితా చేస్తుంది. షేర్ చేయని ఖాతాల కోసం, ccam షేరింగ్ ఆన్ చేసే ccam share <name> --<item> on కమాండ్‌లను ప్రింట్ చేస్తుంది.

ఆప్షన్లు

అంశాల ఫ్లాగ్ లేకపోతే, టెర్మినల్‌లో చెక్‌లిస్ట్ నిర్ణయిస్తుంది. టెర్మినల్ బయట, లేదా --yes తో, ccam సంభాషణ చరిత్ర తప్ప అన్నీ కాపీ చేస్తుంది. projects/ పెద్దది కావచ్చు కాబట్టి చరిత్ర డిఫాల్ట్‌గా వదిలేయబడుతుంది.

--group on అంటే default. --group off, --group local --group takes a group name, not "off" తో తిరస్కరించబడతాయి. ccam migrate --dry-run ను పాటిస్తుంది, మీరు ఒక ఎంపికను ముందుగా చూడటానికి డ్రై రన్‌లో కూడా చెక్‌లిస్ట్ కనిపిస్తుంది.

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

internal/cli/migrate.go అంశాలను ఎంచుకుంటుంది, ఆపై migrate.Build మూల ఫోల్డర్‌ను, గ్రూప్‌ను చదివి ఒక ప్రణాళికను తిరిగి ఇస్తుంది. మీరు నిర్ధారించిన తర్వాత, Plan.Apply వరకు ఏదీ రాయబడదు.

1. మూలాన్ని కనుగొనడం. లేని, ఫోల్డర్ కాని, లేదా తెలిసిన Claude Code ఎంట్రీ ఏదీ లేని పాత్‌ను checkSource తిరస్కరిస్తుంది. migrate.ClaudeJSON ఫోల్డర్‌కు చెందిన .claude.json ను కనుగొంటుంది: దాని లోపల, లేదా లోపల లేని ~/.claude కోసం, దాని పక్కన ఉన్న ~/.claude.json. CLAUDE_CONFIG_DIR సెట్ కానప్పుడు Claude Code దాన్ని అక్కడే ఉంచుతుంది.
2. అంశాలను పాత్‌లకు మ్యాప్ చేయడం. ప్రతి పాత్ share.Layout నుంచి వస్తుంది, ccam share ఉపయోగించే అదే అనుమతి జాబితా. MCP సర్వర్లు mcp.LocalServers తో .claude.json నుంచి చదవబడతాయి, అది మొత్తం ఫైల్‌ను పార్స్ చేయకుండా profile.TopLevelValue స్కానర్‌ను ఉపయోగిస్తుంది.
3. కాపీ చేయడం, ఎప్పుడూ తరలించకపోవడం. ఫైళ్లు fsutil.AtomicWrite లేదా fsutil.CopyFile తో ~/.local/share/ccam/groups/<group>/ కు వెళ్తాయి; MCP సర్వర్లు గ్రూప్ mcp.json లోకి వెళ్తాయి.

ప్రతి అంశం ఒక మూల పాత్‌ను ఒక గ్రూప్ పాత్‌కు మ్యాప్ చేస్తుంది:

రెండు చరిత్ర వరుసలు --history తో మాత్రమే కాపీ అవుతాయి కాబట్టి అవి గీతలతో ఉన్నాయి. .credentials.json, .claude.json share.Never లో జాబితా చేయబడ్డాయి, ఎప్పుడూ గ్రూప్‌ను చేరవు: వాటిలో ఒకటి ఎప్పుడైనా లేఅవుట్‌లో కనిపిస్తే Build అంతర్గత ఎర్రర్‌ను ఇస్తుంది, ఫోల్డర్ వాక్ వాటిని పేరు ద్వారా దాటవేస్తుంది.

buildEntry ప్రతి పాత్‌కు ఒక స్థితిని ఇస్తుంది, ప్రతి ప్లాన్ లైన్ వివరించేది అదే:

• Missing: మూలంలో లేదు, లేదా ఫోల్డర్ ఆశించిన చోట ఫైల్ ఉంది. ప్రతి అంశానికి ఒకసారి not found, skipped గా జాబితా చేయబడుతుంది.
• Linked: మూల పాత్ ఇప్పటికే గ్రూప్ కాపీకి చేరుతుంది, ఉదాహరణకు మూలం ఒక ccam ప్రొఫైల్ ఫోల్డర్ అయినప్పుడు.
• Same: గ్రూప్‌లో ఇప్పటికే అదే కంటెంట్ ఉంది.
• New: గ్రూప్‌లో అది లేదు, కాబట్టి మొత్తంగా కాపీ అవుతుంది.
• Merge: రెండు వైపులా ఉన్న ఫోల్డర్. copyMissing గ్రూప్‌లో లేని ఫైళ్లను మాత్రమే జోడిస్తుంది; వేరుగా ఉన్న ఫైళ్లు గ్రూప్‌లో ఉన్నట్లే ఉంటాయి, ప్లాన్ group copies kept అని చెబుతుంది. plugins/ కోసం, రిజిస్ట్రీలు installed_plugins.json, known_marketplaces.json మెర్జ్ అవుతాయి, పూర్తి ప్లగిన్ పాత్‌లు గ్రూప్ ఫోల్డర్‌కు చూపేలా మళ్లీ రాయబడతాయి.
• Conflict: రెండు వైపులా వేరే కంటెంట్‌తో ఉన్న ఫైల్. మీరు ప్రతి ఫైల్‌కు ఎంచుకుంటారు: keep group, use mine, అలాగే .json ఫైళ్లకు merge JSON (ఘర్షణ పడే విలువలలో గ్రూప్ గెలిచే డీప్ మెర్జ్) లేదా history.jsonl కు merge by line. నిర్వచనం వేరుగా ఉన్న MCP సర్వర్ కూడా keep group లేదా use mine తో ఘర్షణే. మీరు Enter నొక్కినప్పుడు జాబితాలోని మొదటి ఎంపిక డిఫాల్ట్; --yes ఎప్పుడూ గ్రూప్ కాపీని ఉంచుతుంది.

చెక్‌లిస్ట్ స్వయంగా ccam add ఉపయోగించే checklist కాంపోనెంట్‌పై నిర్మించిన tui.MigratePicker; migrate.Found lstat కాల్స్‌తో, MCP సర్వర్ జాబితాతో లేని అంశాలను గుర్తిస్తుంది.

MCP సైన్-ఇన్‌లు

OAuth తో సైన్ ఇన్ అయ్యే MCP సర్వర్లు తమ టోకెన్‌లను సర్వర్ జాబితాలో కాకుండా లాగిన్ ఫైల్‌లో, mcpOAuth కింద .credentials.json లో ఉంచుతాయి. Claude Code ప్రతి ఎంట్రీకి <name>| తో పాటు సర్వర్ యొక్క type, url, headers యొక్క sha256 హాష్‌లోని మొదటి 16 అక్షరాలను కీగా పెడుతుంది. ఈ కీ ఫోల్డర్‌పై ఆధారపడదు, కాబట్టి సర్వర్ నిర్వచనం ఒకేలా ఉన్నంత వరకు కాపీ చేసిన ఎంట్రీ మరో ఖాతాలో పనిచేస్తుంది. అందుకే internal/migrate/logins.go లోని buildLogins మూలం యొక్క నిర్వచనంతో గ్రూప్‌లో చేరే సర్వర్ల ఎంట్రీలను మాత్రమే కాపీ చేస్తుంది: కొత్తవి, ఇప్పటికే ఒకేలా ఉన్నవి, లేదా మీరు use mine ఎంచుకున్న ఘర్షణ. మీరు ఎక్స్‌టెన్షన్లను కాపీ చేసినప్పుడు, మూలంలో plugins/ ఉంటే, ప్లగిన్ సర్వర్ల సైన్-ఇన్‌లు (plugin: తో మొదలయ్యే కీలు) కూడా వెళ్తాయి.

ఎంట్రీలు అందుకునే ప్రతి ఖాతా సొంత .credentials.json లోకి, 0600 మోడ్‌తో fsutil.AtomicWrite ద్వారా వెళ్తాయి. అవి ఎప్పుడూ గ్రూప్‌లోకి వెళ్లవు. ఒక ఖాతా లక్ష్య గ్రూప్ ద్వారా mcp (లేదా, ప్లగిన్ సర్వర్ల కోసం, extensions) ను షేర్ చేస్తేనే వాటిని అందుకుంటుంది, దానిలో లేని కీలు మాత్రమే జోడించబడతాయి: దానికి ఇప్పటికే ఉన్న, బహుశా కొత్తవైన, ఎంట్రీలు ఉంచబడతాయి. ప్లాన్ లైన్ sign-ins సర్వర్లను, అందుకునే ఖాతాలను, దాటవేసిన వాటిని జాబితా చేస్తుంది. ఒక ఖాతా ఇలా ఉన్నప్పుడు ccam దాన్ని దాటవేసి, కారణంతో దాని పేరు చెబుతుంది:

• ccam import తో ఉన్న చోటే నమోదైంది, ఎందుకంటే సాధారణ claude దాని లాగిన్ ఫైల్‌ను ఉపయోగిస్తూ ఉండవచ్చు;
• రన్ అవుతోంది, ఎందుకంటే Claude Code దాని లాగిన్ ఫైల్‌ను మళ్లీ రాస్తుంది (రాసే ముందు మళ్లీ తనిఖీ చేయబడుతుంది, started meanwhile గా నివేదించబడుతుంది);
• ఇంకా లాగిన్ కాలేదు;
• లాగిన్‌ను macOS Keychain లో ఉంచుతుంది, ccam దానిలో రాయదు.

దాటవేసిన ఖాతాలో /mcp తో సర్వర్లకు సైన్ ఇన్ చేయండి. తర్వాత MCP సర్వర్లను షేర్ చేయడం మొదలుపెట్టే ఖాతాకు, మీరు ccam migrate ను మళ్లీ రన్ చేసినప్పుడు సైన్-ఇన్‌లు అందుతాయి; సారాంశం Then run `ccam migrate` again to give them the MCP sign-ins too. తో ఆ విషయం చెబుతుంది.

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

• మూలం చదవబడుతుంది మాత్రమే. అందులోని ఏ ఫైల్ తరలించబడదు, లింక్ చేయబడదు, మార్చబడదు, మూల లాగిన్‌లో ఎప్పుడూ రాయబడదు, Keychain నుంచి చదవబడే అవకాశం ఉన్న macOS లో కూడా.
• use mine, మెర్జ్, లేదా ఇప్పటికే ఉన్న mcp.json లో కొత్త MCP సర్వర్ల ద్వారా గ్రూప్ ఫైల్ భర్తీ అయ్యే ముందు, గ్రూప్ కాపీ <group>/.ccam-backup/<time>/ లో సేవ్ అవుతుంది. ఫోల్డర్ పేరు ప్రతి రన్‌కు ప్రత్యేకం, కాబట్టి ఒకే సెకనులో జరిగే రెండు రన్‌లు ఒకదాని బ్యాకప్‌లను మరొకటి ఓవర్‌రైట్ చేయవు. సారాంశం పాత్‌ను ప్రింట్ చేస్తుంది.
• --yes తో, ప్రతి ఘర్షణ గ్రూప్ కాపీని ఉంచుతుంది, బదులుగా ఎలా ఎంచుకోవాలో ccam చెబుతుంది: అదే కమాండ్‌ను --yes లేకుండా రన్ చేయండి.
• ఏదీ మారకపోతే, ccam Nothing to copy. అని ప్రింట్ చేస్తుంది; ప్రతి ఘర్షణ గ్రూప్ కాపీని ఉంచితే, Nothing to copy: the group keeps its own copies.
• కాపీ మధ్యలో విఫలమైతే, ccam The source folder was not changed. Group files replaced so far are saved in తో, దాని తర్వాత బ్యాకప్ ఫోల్డర్‌తో ఆగుతుంది.
• మూలం లేకపోతే no Claude Code folder at <path>. Give the folder to copy from: ccam migrate <folder> తో ముగుస్తుంది.

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

• MCP సర్వర్లు, సెట్టింగ్‌లు, చరిత్రను షేర్ చేయండి
• తనిఖీ చేయడం, సరిచేయడం
• అనేక Claude Code ఖాతాలు
• CLAUDE_CONFIG_DIR