ಖಾತೆಗಳ ನಡುವೆ ಹಂಚಿಕೆ

ಪ್ರತಿ ಖಾತೆಗೆ ತನ್ನದೇ ಫೋಲ್ಡರ್ ಇರುತ್ತದೆ, ಆದರೆ ಅದರಲ್ಲಿರುವ ಹೆಚ್ಚಿನವು ಪ್ರತ್ಯೇಕವಾಗಿರಬೇಕಾಗಿಲ್ಲ. 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 ಕಾನ್ಫಿಗ್ ಅನ್ನು ಓದುತ್ತದೆ, ಪ್ರತಿ --<item> ಮೌಲ್ಯವನ್ನು config.Share.Set ಮೂಲಕ ಖಾತೆಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಒಂದು ಪ್ರತಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ, ಮತ್ತು ಖಾತೆ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ನಿರಾಕರಿಸುತ್ತದೆ.
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 ಅವುಗಳನ್ನು ಗುಂಪಿನ ಫೋಲ್ಡರ್‌ಗೆ ಸೂಚಿಸುವಂತೆ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಗುಂಪಿನಲ್ಲಿ ಈಗಾಗಲೇ ರಿಜಿಸ್ಟ್ರಿ ಇದ್ದರೆ ಖಾತೆಯ ನಮೂದುಗಳನ್ನು ಅದರೊಳಗೆ ವಿಲೀನಗೊಳಿಸುತ್ತದೆ.

ಐಟಂ ಅನ್ನು ಆಫ್ ಮಾಡಿದಾಗ ಲಿಂಕ್ ಹಿಮ್ಮುಖವಾಗುತ್ತದೆ:

ಲಿಂಕ್ ಗುಂಪುಗಳ ಫೋಲ್ಡರ್‌ನೊಳಗೆ ಸೂಚಿಸಿದರೆ ಮಾತ್ರ 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 ಸರ್ವರ್‌ಗಳು
• ಈಗಿರುವ ಸೆಟಪ್ ಅನ್ನು ನಕಲಿಸಿ
• ಎಲ್ಲಾ ಕಮಾಂಡ್‌ಗಳು