શેર કરેલા MCP સર્વર

Claude Code user MCP સર્વર .claude.json માં રાખે છે, એ જ ફાઇલ જેમાં એકાઉન્ટનું લૉગિન હોય છે, તેથી આ ફાઇલ એકાઉન્ટ વચ્ચે શેર થઈ શકતી નથી. ccam શેર કરેલા સર્વર એક ગ્રુપ ફાઇલ, mcp.json, માં રાખે છે, અને શરૂઆત વખતે તે ગ્રુપના દરેક એકાઉન્ટને આપે છે. તમારાં બધાં એકાઉન્ટ માટે એક જ વાર સર્વર ઉમેરવા ccam mcp વાપરો, અને કોઈ એક સેશનમાં ઉમેરેલો સર્વર બીજાં એકાઉન્ટમાં ખસેડવા ccam mcp import વાપરો.

ઉપયોગ

ccam mcp add fs -- npx -y @modelcontextprotocol/server-filesystem ~/code   # a local (stdio) server
ccam mcp add ctx --url https://mcp.context7.com/mcp --header 'Authorization: Bearer …'
ccam mcp add docs --url https://example.com/sse --transport sse
ccam mcp add db -e PGHOST=localhost -- pg-mcp                    # with an environment variable
ccam mcp add-json gh '{"type":"http","url":"https://api.githubcopilot.com/mcp/"}'
ccam mcp add tools -g team -- tools-mcp                           # into the group team
ccam mcp list                                                     # every group, and servers only one account has
ccam mcp remove ctx
ccam mcp import work                                              # move work's own servers into its group
ccam mcp import work gh --force                                   # replace the group's different gh

ફેરફાર દરેક એકાઉન્ટની આગલી શરૂઆતથી લાગુ પડે છે; ચાલી રહેલાં સેશન જે સર્વર સાથે શરૂ થયાં હતાં તે જ રાખે છે:

$ ccam mcp add fs -- npx -y @modelcontextprotocol/server-filesystem ~/code
✓ fs added in group default — applies from the next launch
$ ccam mcp list
group default (work, side)
  ctx                  http https://mcp.context7.com/mcp
  fs                   stdio npx -y @modelcontextprotocol/server-filesystem /home/me/code
only in account work: pg

ગ્રુપ પાસે પહેલેથી હોય તેવું નામ ઉમેરવાથી તેની વ્યાખ્યા બદલાય છે અને added ને બદલે updated છપાય છે. સર્વર કોઈ એકાઉન્ટ સુધી ત્યારે જ પહોંચે છે જ્યારે તે એ ગ્રુપ સાથે MCP શેર કરતું હોય (ccam share <name> --mcp on); હજી કોઈ એકાઉન્ટ MCP શેર ન કરતું હોય, ત્યારે add એ જણાવે છે.

ઓપ્શન

add ને -- પછી કમાન્ડ કે --url માંથી એકની જરૂર છે; નહીં તો તે a command to run (after --) or --url is required સાથે નિષ્ફળ જાય છે. --header --url સર્વરને લાગુ પડે છે અને --env કમાન્ડ સર્વરને. add-json claude mcp add-json જેવું જ JSON લે છે, અને વ્યાખ્યા command કે url ધરાવતો ઑબ્જેક્ટ હોવી જોઈએ. import હંમેશાં એ ગ્રુપ વાપરે છે જેના દ્વારા એકાઉન્ટ MCP શેર કરે છે, અને list દરેક ગ્રુપ બતાવે છે, તેથી -g તેમને બદલતું નથી.

તે કેવી રીતે કામ કરે છે

સંકળાયેલી ફાઇલો:

• ~/.local/share/ccam/groups/<group>/mcp.json: શેર કરેલા સર્વર, {"mcpServers": {…}}, એ ફૉર્મેટ જે --mcp-config વાંચે છે. તે fsutil.AtomicWrite અને mode 0600 સાથે લખાય છે, કારણ કે સર્વરની એન્ટ્રીઓમાં ઘણી વાર API key હોય છે.
• ~/.local/share/ccam/profiles/<name>/.claude.json: એકાઉન્ટના સર્વર ધરાવતી Claude Code ની પોતાની ફાઇલ. ccam profile.TopLevelValue scanner વડે ફક્ત તેનું mcpServers મૂલ્ય વાંચે છે અને શરૂઆતના પાથ પર ક્યારેય આખી ફાઇલ parse કરતું નથી.
• ~/.local/state/ccam/mcp/<name>/: seen ફાઇલ, sync-stamp અને .claude.json ના બૅકઅપ.

બે વ્યૂહરચના છે, જે ~/.config/ccam/config.toml માં mcp_strategy વડે સેટ થાય છે. ડિફૉલ્ટ flag વ્યૂહરચના છે:

1. launcher.applyMCP એકાઉન્ટનું MCP ગ્રુપ શોધે છે. mcp.FlagArgs એક stat વડે તપાસે છે કે ગ્રુપની mcp.json છે, તેને parse કર્યા વગર.
2. Plan.InsertArgs --mcp-config=<path> ને claude પછી તરત, તમારા પોતાના આર્ગ્યુમેન્ટ્સ પહેલાં મૂકે છે, તેથી તમારું પોતાનું --mcp-config કે --strict-mcp-config તો પણ તેના પર લાગુ પડે છે.
3. mcp.NewLocal તપાસે છે કે છેલ્લી શરૂઆત પછી એકાઉન્ટની .claude.json બદલાઈ છે કે નહીં, અને ત્યારે જ તેના સર્વર parse કરે છે.
4. syscall.Exec ccam ને Claude Code થી બદલે છે.

પાથ બે નહીં, એક આર્ગ્યુમેન્ટ, --mcp-config=<path>, તરીકે આપવામાં આવે છે. Claude Code નું --mcp-config ઘણાં મૂલ્યો લે છે, તેથી claude --mcp-config a.json "prompt" prompt ને બીજી config ફાઇલ તરીકે વાંચે અને MCP config file not found સાથે નિષ્ફળ જાય. એક આર્ગ્યુમેન્ટવાળું સ્વરૂપ ત્યાં જ અટકે છે, અને પછી આવતો prompt કે mcp list જેવો subcommand કામ કરે છે. Claude Code --mcp-config ના સર્વર એકાઉન્ટના પોતાના સર્વર ઉપરાંત લોડ કરે છે; નામ ટકરાય ત્યારે .claude.json ની એન્ટ્રી જીતે છે. flag વ્યૂહરચના ક્યારેય .claude.json માં લખતી નથી.

સેશનની અંદર claude mcp add વડે ઉમેરેલો સર્વર ફક્ત એ એકાઉન્ટની .claude.json માં જાય છે. ccam તે સમયે તેને જોઈ શકતું નથી, કારણ કે Claude Code એ તેની જગ્યા લઈ લીધી છે, તેથી તે આગલી શરૂઆતે તપાસે છે. seen ફાઇલમાં .claude.json નો modification time અને પહેલેથી જણાવેલાં સર્વરનાં નામ હોય છે. સમય જુદો હોય ત્યારે, ccam નામોની ગ્રુપ સાથે સરખામણી કરે છે અને દરેક નવા સર્વર માટે, input ની રાહ જોયા વગર, એક વાર સૂચના છાપે છે:

ccam: MCP servers only account work has: pg
      To share them with other accounts: ccam mcp import work pg

mcp_strategy = "sync" સાથે, સર્વર claude mcp list અને /mcp માં સામાન્ય user સર્વર તરીકે દેખાય છે, અને ccam શરૂઆત પહેલાં તેમને દરેક એકાઉન્ટની .claude.json માં લખે છે:

1. mcp.Sync ગ્રુપની mcp.json ના modification time ની sync-stamp સાથે સરખામણી કરે છે. જો તે બદલાયો ન હોય, તો એકાઉન્ટની .claude.json ખોલવામાં આવતી નથી.
2. તે Claude Code નું પોતાનું lock લે છે, ફાઇલની બાજુનું .claude.json.lock ફોલ્ડર, જે mkdir વડે બને છે. તે 2 સેકન્ડ સુધી રાહ જુએ છે અને Claude Code ની lock library ની જેમ 10 સેકન્ડથી જૂના lock ને stale ગણે છે.
3. તે હાલની .claude.json ને state ફોલ્ડરના backups/ માં સેવ કરે છે અને સૌથી નવા 5 રાખે છે.
4. તે mcpServers માં દરેક ગ્રુપ સર્વર સેટ કરે છે, પહેલાં પોતે લખેલા પણ હવે ગ્રુપમાં ન હોય તેવા સર્વર દૂર કરે છે, એકાઉન્ટના પોતાના સર્વર રાખે છે, અને ફાઇલને તેના મૂળ mode સાથે atomic રીતે લખે છે.
5. તે નવો stamp અને પોતે સંભાળે છે તે નામો નોંધે છે, અને Claude Code --mcp-config વગર શરૂ થાય છે.

એકાઉન્ટનું કોઈ સેશન ચાલતું હોય ત્યારે sync ccam: account work is already running, skipping MCP sync સાથે છોડી દેવાય છે, કારણ કે Claude Code ચાલતી વખતે .claude.json ફરીથી લખે છે. નિષ્ફળ sync ccam: MCP sync failed (launching anyway): … છાપે છે અને તો પણ શરૂ કરે છે. સેશનની અંદર ઉમેરેલા સર્વરની સૂચના ફક્ત flag વ્યૂહરચનામાં જ છે.

ccam mcp import એકાઉન્ટના પોતાના સર્વર તેના ગ્રુપમાં ખસેડે છે:

ccam mcp.LocalServers વડે એકાઉન્ટના સર્વર વાંચે છે અને mcp.SameDef વડે દરેકની એ જ નામના ગ્રુપ સર્વર સાથે સરખામણી કરે છે, જે key ના ક્રમ અને spacing ને અવગણે છે. ગ્રુપમાં ન હોય કે એ જ વ્યાખ્યા સાથે હોય તેવો સર્વર કૉપિ થાય છે. જુદો સર્વર છોડી દેવાય છે, કારણ કે બીજું દરેક એકાઉન્ટ ગ્રુપની વ્યાખ્યા વાપરે છે:

Skipped gh: group default already has a different gh (`ccam mcp import work gh --force` replaces it)
✓ Copied to group default: pg
✓ Removed account work's own entries (.claude.json backed up)

--force સાથે ગ્રુપનો સર્વર બદલાય છે, અને અગાઉની mcp.json પહેલાં ગ્રુપ ફોલ્ડરની અંદર .ccam-backup/<time>/mcp.json માં સેવ થાય છે. પછી mcp.RemoveLocal એ જ lock હેઠળ અને state ફોલ્ડરમાં બૅકઅપ લીધા પછી, કૉપિ થયેલી એન્ટ્રીઓ એકાઉન્ટની .claude.json માંથી દૂર કરે છે. આ જરૂરી છે, કારણ કે નામ ટકરાય ત્યારે એકાઉન્ટની એન્ટ્રી ગ્રુપની એન્ટ્રી પર જીતે. --keep-local તેમને રહેવા દે છે.

સલામતી અને ખાસ કિસ્સા

• સાઇન-ઇન. OAuth થી સાઇન ઇન કરતા સર્વર તેમના ટોકન સર્વર યાદીમાં નહીં, પણ દરેક એકાઉન્ટની .credentials.json (mcpOAuth) માં રાખે છે, તેથી સર્વર શેર કરવાથી તેનું સાઇન-ઇન શેર થતું નથી. દરેક એકાઉન્ટમાં /mcp વડે એક વાર સાઇન ઇન કરો, અથવા ccam migrate વડે ~/.claude માંથી સાઇન-ઇન કૉપિ કરો. ગ્રુપને ક્યારેય લૉગિન ફાઇલ મળતી નથી.
• ચાલતાં એકાઉન્ટ. import ગ્રુપમાં કૉપિ કરે છે પણ ચાલતા એકાઉન્ટની પોતાની એન્ટ્રીઓ રહેવા દે છે અને તે જણાવે છે; સેશન પૂરું થયા પછી તેને ફરી ચલાવો. sync ચાલતાં એકાઉન્ટ છોડી દે છે.
• તૂટેલી ફાઇલો. જો .claude.json માન્ય JSON ન હોય, તો sync તેને અડ્યા વગર રહેવા દે છે અને ભૂલ બતાવે છે. જો 2 સેકન્ડમાં lock ન લઈ શકાય, તો ccam could not lock … (Claude Code is writing the file) બતાવે છે.
• MCP શેર ન કરતાં એકાઉન્ટ. import ઇનકાર કરે છે અને પહેલાં ccam share side --mcp on ચલાવવા કહે છે.
• ગ્રુપનાં નામ. -g ફક્ત ગ્રુપનું નામ લે છે; તે groups/ હેઠળ ફોલ્ડર બને છે, તેથી ../x જેવાં નામનો ઇનકાર થાય છે.

સંબંધિત

• એકાઉન્ટ વચ્ચે શેરિંગ
• MCP સર્વર, સેટિંગ્સ અને ઇતિહાસ શેર કરો
• હાલનું સેટઅપ કૉપિ કરો
• બધા કમાન્ડ