VPSలో OpenCodeను ఎలా ఇన్‌స్టాల్ చేయాలి?

OpenCode అంటే ఏమిటి మరియు మీరు దేనిని సెటప్ చేస్తున్నారు

OpenCode అనేది టెర్మినల్ కోసం రూపొందించబడిన ఒక ఓపెన్ సోర్స్ AI కోడింగ్ ఏజెంట్. మీరు దీనిని ఒక ప్రాజెక్ట్ డైరెక్టరీలో ప్రారంభించినప్పుడు, అది మీ కోడ్‌ను చదివి, మార్పులను ప్రతిపాదించి, ఫైళ్లను ఎడిట్ చేసి, కమాండ్లను రన్ చేస్తుంది; ఇదంతా ఒక టెర్మినల్ యూజర్ ఇంటర్‌ఫేస్ (TUI) ద్వారా జరుగుతుంది. ఇది MIT లైసెన్స్‌ను కలిగి ఉంది, 75 కంటే ఎక్కువ మోడల్ ప్రొవైడర్లకు కనెక్ట్ అవుతుంది, మరియు 2026 మధ్య నాటికి సుమారు 165,000 GitHub స్టార్‌లతో ఇది అత్యధిక స్టార్‌లను పొందిన ఓపెన్ సోర్స్ కోడింగ్ ఏజెంట్‌గా ఉంది. ఒక VPSలో OpenCodeను రన్ చేయడానికి, మీరు దానిని ఒక ప్రత్యేకమైన unprivileged యూజర్ కింద ఇన్‌స్టాల్ చేయాలి, మీ మోడల్ API కీని ఒక ప్రైవేట్ ఫైల్‌లో ఉంచాలి, మరియు మీ కనెక్షన్ కట్ అయినా సెషన్ కొనసాగేలా tmux లోపల దానిని ప్రారంభించాలి. ఈ గైడ్ సరిగ్గా ఆ పద్ధతిలోనే, అదే క్రమంలో ఉంటుంది.

పేర్ల విషయంలో ఒక ముఖ్య గమనిక గందరగోళాన్ని నివారిస్తుంది. అధికారిక రిపోజిటరీ anomalyco/opencode, దీనిని Anomaly టీమ్ (గతంలో SST అని పిలిచేవారు) నిర్వహిస్తోంది, మరియు ఈ ప్రాజెక్ట్ గతంలో sst/opencode వద్ద ఉండేది. GitHubలో opencode-ai/opencode అనే పేరుతో సంబంధం లేని పాత రిపోజిటరీ కూడా ఉంది, కాబట్టి మీరు సరైన ప్రాజెక్ట్ డాక్యుమెంటేషన్‌ను చదువుతున్నారో లేదో సరిచూసుకోండి. అధికారిక వెబ్‌సైట్ opencode.ai.

VPS పై OpenCode ఎందుకు రన్ చేయాలి

కోడింగ్ ఏజెంట్ సెషన్ సుదీర్ఘంగా ఉంటుంది. ఒక refactor లేదా test suite పూర్తి చేయడానికి OpenCode చాలా నిమిషాల సమయం తీసుకోవచ్చు. ఒకవేళ ఇది మీ ల్యాప్‌టాప్‌లో రన్ అవుతుంటే, ల్యాప్‌టాప్ మూసివేసినా లేదా Wi-Fi కనెక్షన్ కట్ అయినా సెషన్ మధ్యలోనే ఆగిపోతుంది. tmux లోపల VPS పై రన్ చేసినప్పుడు, మీరు డిస్‌కనెక్ట్ అయినా ఏజెంట్ తన పనిని కొనసాగిస్తుంది, మీరు తర్వాత తిరిగి కనెక్ట్ అయ్యి అది ఏమి చేసిందో చూసుకోవచ్చు. ఇది tmux తో VPS పై Claude Code రన్ చేయడం వంటి పద్ధతే, మరియు ఏజెంట్‌ను మీ ల్యాప్‌టాప్ నుండి మార్చడం వల్ల కలిగే అతిపెద్ద ప్రయోజనం ఇదే.

రెండవ కారణం ప్లేస్‌మెంట్. మీరు డిప్లాయ్ చేసే కోడ్‌కు VPS దగ్గరగా ఉంటుంది: రిపోజిటరీ, బిల్డ్ టూల్స్, టెస్ట్ డేటాబేస్ మరియు తరచుగా స్టేజింగ్ ఎన్విరాన్‌మెంట్ కూడా అక్కడే లేదా దానికి దగ్గరగా ఉంటాయి. కోడ్‌ను ఎడిట్ చేసి టెస్టులను రన్ చేసే ఏజెంట్, ఆ టెస్టులు వాస్తవంగా ఎక్కడ రన్ అవుతాయో అదే మెషీన్‌పై ఉత్తమంగా పనిచేస్తుంది. మరియు ఆ బాక్స్ మీరు నియంత్రించే సర్వర్ కాబట్టి, మీరు ఏజెంట్‌కు ఒక ప్రత్యేకమైన ఎన్విరాన్‌మెంట్‌ను కేటాయించవచ్చు, దీని గురించి తదుపరి విభాగంలో ఉంది.

మీరు ఇంకా ఒక టూల్‌ను ఎంచుకునే పనిలో ఉంటే, VPS పై కోడింగ్ AI ఏజెంట్‌ను రన్ చేయడం అనే కథనం Aider మరియు Goose వంటి ఇతర టూల్స్‌తో పోలికలను వివరిస్తుంది.

OpenCode కోసం ప్రత్యేక వినియోగదారుని కేటాయించండి

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

బ్యాక్‌గ్రౌండ్ ఏజెంట్ లాగా కాకుండా, OpenCode ఇంటరాక్టివ్‌గా ఉంటుంది, కాబట్టి దాని వినియోగదారునికి ఒక నిజమైన షెల్ మరియు హోమ్ డైరెక్టరీ అవసరం:

sudo useradd --create-home --shell /bin/bash opencode
sudo -iu opencode

మీరు దానితో పని చేయించాలనుకుంటున్న ప్రాజెక్టులను /home/opencode కింద ఉంచండి, వాటిని ఆ వినియోగదారుని ద్వారానే క్లోన్ చేయండి. ఆ ఖాతాకు ఎటువంటి sudo హక్కులను ఇవ్వకండి. ఒకవేళ ఏజెంట్ ఏదైనా విధ్వంసకర కమాండ్‌ను రన్ చేసినా, అది కేవలం ఈ ఖాతాకు చెందిన ఫైళ్లను మాత్రమే పాడు చేయగలదు. అన్‌ప్రివిలేజ్డ్ వినియోగదారునిగా సేవలను రన్ చేయడం వెనుక ఉన్న తర్కం కూడా ఇదే. అలాగే git రిపోజిటరీ లోపల పని చేయండి, ఎందుకంటే ఒక రిపోజిటరీ ఏదైనా తప్పుడు సవరణను డేటా నష్టానికి బదులుగా ఒక git revert గా మారుస్తుంది.

OpenCode ఇన్‌స్టాల్ చేయడం

ఈ ప్రాజెక్ట్ రెండు రకాల ఇన్‌స్టాలేషన్ పద్ధతులను వివరిస్తుంది. ఇన్‌స్టాల్ స్క్రిప్ట్ అత్యంత వేగవంతమైనది, మరియు దీనిని opencode యూజర్‌గా రన్ చేయడం ద్వారా ఫైల్స్ అన్నీ ఆ యూజర్ హోమ్ డైరెక్టరీలోనే ఉంటాయి:

curl -fsSL https://opencode.ai/install | bash

సర్వర్‌పై ఏదైనా సాఫ్ట్‌వేర్ ఇన్‌స్టాల్ చేసేటప్పుడు పాటించే సాధారణ curl | bash పద్ధతి ఇక్కడ కూడా వర్తిస్తుంది: ముందుగా స్క్రిప్ట్‌ను డౌన్‌లోడ్ చేసి, దానిని చదివి, ఆపై రన్ చేయండి. ఇన్‌స్టాలేషన్ తర్వాత, కొత్త షెల్‌ను ప్రారంభించండి. అప్పుడే ఇన్‌స్టాలర్ చేసిన PATH మార్పులు అమల్లోకి వస్తాయి. ఆ తర్వాత బైనరీ పనిచేస్తుందో లేదో ఇలా తనిఖీ చేయండి:

opencode --version

మీరు ప్యాకేజీ మేనేజర్‌ను ఇష్టపడితే మరియు మీ సర్వర్‌లో ఇప్పటికే Node.js ఉంటే, npm ద్వారా సిస్టమ్ అంతటా ఈ టూల్‌ను ఇన్‌స్టాల్ చేయవచ్చు. ఇది opencode బైనరీని ప్రతి యూజర్ యొక్క PATH లో ఉంచుతుంది:

sudo npm install -g opencode-ai

ఏ పద్ధతిలో చేసినా, తనిఖీ మాత్రం ఒకటే: opencode --version కమాండ్ వెర్షన్ నంబర్‌ను చూపిస్తుంది. స్క్రిప్ట్ ఇన్‌స్టాల్ చేసిన తర్వాత command not found అని వస్తే, ప్రస్తుత షెల్ ఇంకా అప్‌డేట్ అయిన PATH ను గుర్తించలేదని అర్థం. కాబట్టి, opencode యూజర్‌గా లాగ్ అవుట్ అయ్యి మళ్ళీ లాగిన్ అవ్వండి.

API కీని ఒక ప్రైవేట్ ఫైల్‌లో ఉంచండి

మీరు ఉపయోగించే ఏ మోడల్ ప్రొవైడర్‌కైనా OpenCode కు ఒక కీ అవసరం, మరియు ఆ కీ మీ డబ్బును ఖర్చు చేయగలదు, కాబట్టి దానిని పాస్‌వర్డ్ లాగా పరిగణించండి. opencode వినియోగదారు మాత్రమే చదవగలిగేలా, 600 మోడ్‌తో ఒక ఫైల్‌ను సృష్టించండి. కీని కమాండ్లలో టైప్ చేస్తే అది మీ షెల్ హిస్టరీలో సేవ్ అవుతుంది, కాబట్టి అలా చేయకుండా కీని ఈ ఫైల్‌లోనే ఉంచండి:

install -m 600 /dev/null ~/opencode.env
nano ~/opencode.env

మీ ప్రొవైడర్ యొక్క వేరియబుల్‌ను అందులో ఉంచండి, ఉదాహరణకు ANTHROPIC_API_KEY=... లేదా మీ ప్రొవైడర్‌కు తగిన వేరియబుల్, ఎందుకంటే OpenCode ప్రామాణిక ప్రొవైడర్ ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను తీసుకుంటుంది. ఏజెంట్‌ను ప్రారంభించే ముందు ఫైల్‌ను మీ షెల్‌లోకి లోడ్ చేయండి:

set -a; source ~/opencode.env; set +a

OpenCode లో మరొక ఇంటరాక్టివ్ మార్గం కూడా ఉంది: TUI లోపల ఉండే /connect కమాండ్, ప్రొవైడర్‌ను జోడించే ప్రక్రియలో మీకు సహాయపడుతుంది మరియు క్రెడెన్షియల్‌ను వినియోగదారు హోమ్ డైరెక్టరీలోని ~/.local/share/opencode/auth.json లో సేవ్ చేస్తుంది. మీరు ఆ మార్గాన్ని ఎంచుకుంటే, chmod 600 ~/.local/share/opencode/auth.json తో ఫైల్ ప్రైవేట్‌గా ఉందని నిర్ధారించుకోండి. ఈ రెండు మార్గాలు కీని మీ కమాండ్ లైన్ల నుండి దూరంగా ఉంచుతాయి; ఏదో ఒకదానిని ఎంచుకుని దానినే అనుసరించండి.

tmux లో OpenCode ను ప్రారంభించడం

tmux ఉండటం వల్లే VPS సెటప్ విలువైనదిగా మారుతుంది, ఎందుకంటే మీ SSH కనెక్షన్ ముగిసినా tmux సెషన్ రన్ అవుతూనే ఉంటుంది. ఒక సెషన్‌ను ప్రారంభించి, మీ ప్రాజెక్ట్ డైరెక్టరీలోకి వెళ్లి, ఏజెంట్‌ను లాంచ్ చేయండి:

tmux new -s opencode
cd ~/my-project
opencode

TUI ఓపెన్ అవ్వడం, దిగువన ప్రాంప్ట్ కనిపించడం మరియు ఇంటర్‌ఫేస్‌లో మీ ప్రాజెక్ట్ పేరు ఉండటం మీరు గమనిస్తారు. దానికి సాధారణ భాషలో ఒక పనిని ఇవ్వండి, అది ఫైళ్లను చదివి మార్పులను ప్రతిపాదిస్తుంది. మీరు బయటకు రావాలనుకున్నప్పుడు, Ctrl-b ఆపై d నొక్కి detach అవ్వండి; మీ ల్యాప్‌టాప్ మూసివేసినా ఏజెంట్ పని చేస్తూనే ఉంటుంది. తర్వాత తిరిగి కనెక్ట్ అవ్వడానికి ఇలా చేయండి:

tmux attach -t opencode

సెషన్, సంభాషణ మరియు రన్ అవుతున్న ఏదైనా పని మీరు వదిలిపెట్టిన చోటే ఉంటాయి. ఇది మీ డిస్‌కనెక్షన్‌లను తట్టుకుంటుంది, కానీ సర్వర్ రీబూట్ అయితే కాదు, కాబట్టి రీబూట్ తర్వాత మీరు ఇదే విధంగా కొత్త tmux సెషన్‌ను ప్రారంభించాలి. మీరు రెండవ tmux విండోను ఓపెన్ చేసి మొదటి దాని పక్కనే మరొక ఏజెంట్‌ను రన్ చేయడానికి ఎటువంటి ఆటంకం లేదు, అయితే OpenCode సెషన్‌లు ఒకదానికొకటి స్వతంత్రంగా ఉంటాయి, కానీ ఒకే బాక్స్‌పై ఉన్న Claude Code సెషన్‌లు ఒకదానికొకటి సందేశాలను పంపుకోగలవు, ఇది పనిని రెండుగా విభజించడానికి భిన్నమైన మార్గం.

మోడల్‌ను ఎంచుకోవడం

OpenCode ప్రొవైడర్‌తో సంబంధం లేకుండా పనిచేస్తుంది. ఇది AI SDK మరియు Models.dev కేటలాగ్‌ను ఉపయోగించి 75 కంటే ఎక్కువ ప్రొవైడర్లకు మద్దతు ఇస్తుంది. కాబట్టి, Anthropic, OpenAI, Google మరియు స్థానిక సర్వర్లతో సహా అనేక ఇతర సేవలకు ఒకే సాధనం పనిచేస్తుంది. వేగవంతమైన మార్గం TUI లోపల /connect కమాండ్‌ను ఉపయోగించడం; ఇది ప్రొవైడర్ల జాబితాను చూపిస్తుంది మరియు క్రెడెన్షియల్స్‌ను నిర్వహిస్తుంది. మీరు సేవ్ చేసి, మళ్లీ ఉపయోగించగల సెటప్ కోసం, ప్రాజెక్ట్ రూట్‌లో ఒక opencode.json ఫైల్‌ను ఉంచి, మోడల్‌ను provider/model-id గా సెట్ చేయండి:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/claude-sonnet-4-20250514"
}

ఏదైనా OpenAI-అనుకూల సర్వర్‌ను ప్రొవైడర్‌గా ప్రకటించవచ్చు కాబట్టి, స్థానిక మోడల్ కూడా అదే ఫైల్ ద్వారా పనిచేస్తుంది. మీరు అదే VPS పై Ollama తో ఒక మోడల్‌ను రన్ చేస్తుంటే, కాన్ఫిగరేషన్ దాని స్థానిక API ని సూచిస్తుంది మరియు మోడల్ పేరు మీ బాక్స్‌లో ollama list చూపించే విధంగా ఉంటుంది:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": { "baseURL": "http://127.0.0.1:11434/v1" },
      "models": { "your-model-name": { "name": "Local coding model" } }
    }
  }
}

మొదటి రోజు నుండే అలవాటు చేసుకోవాల్సిన ఒక అంతర్నిర్మిత పద్ధతి ఉంది. OpenCode రెండు ఏజెంట్లను కలిగి ఉంటుంది, వీటి మధ్య మీరు Tab కీతో మారవచ్చు: Build, ఇది పూర్తి యాక్సెస్ ఉన్న డిఫాల్ట్ ఏజెంట్; మరియు Plan, ఇది మార్పులు చేసే సామర్థ్యాన్ని నిలిపివేస్తుంది. Plan లో కొత్త పనిని ప్రారంభించండి, అది కోడ్‌ను చదివి ఒక విధానాన్ని ప్రతిపాదించేలా చేయండి, ఆ ప్రణాళికతో మీరు ఏకీభవించినప్పుడు మాత్రమే Build కి మారండి. సర్వర్‌పై, కేవలం చదవగలిగే (read-only) మొదటి ప్రయత్నం ఒక మంచి భద్రతా చర్య. Claude Code ఇదే నిర్ణయాన్ని ఏజెంట్లకు బదులుగా పర్మిషన్ మోడ్స్‌గా పరిగణిస్తుంది, మరియు మీరు రెండు సాధనాలను ఉపయోగిస్తుంటే ఆటో మోడ్‌కు మారడం గురించి చదవడం మంచిది, ఎందుకంటే సెషన్ ఏ మోడ్‌లో ప్రారంభమవుతుందనేది పర్యవేక్షణ లేని ఏజెంట్ ఎంతవరకు మార్పులు చేయగలదో నిర్ణయిస్తుంది.

ప్రభావ పరిధి (blast radius)

కోడింగ్ ఏజెంట్ నిష్క్రియంగా ఉండదు, కాబట్టి ఈ సెటప్ ఏమి చేస్తుంది మరియు ఏమి చేయదు అనే విషయాన్ని స్పష్టంగా చెప్పాలి. ఇందులో ఫైల్ డ్యామేజ్ జరిగే అవకాశం ఉంది: opencode యూజర్ తన హోమ్ డైరెక్టరీకి మాత్రమే యజమాని, కాబట్టి మార్పులు మరియు తొలగింపులు ఆ పరిధిలోనే ఆగిపోతాయి. ఇందులో క్రెడెన్షియల్స్ బహిర్గతమయ్యే ప్రమాదం ఉంది: కీ (key) ఒకే ఫైల్‌లో, 600 మోడ్‌తో, ఒకే అకౌంట్‌లో ఉంటుంది. ఆ అకౌంట్‌కు ఏయే పనులు చేసే అధికారం ఉందో ఇందులో పరిమితి లేదు, కాబట్టి ప్రాజెక్ట్ డైరెక్టరీలో ప్రొడక్షన్ డిప్లాయ్ క్రెడెన్షియల్స్ ఉంటే, ఏజెంట్ వాటిని ఉపయోగించగలదు; అటువంటి వాటిని ఏజెంట్ అకౌంట్‌కు దూరంగా ఉంచండి.

OpenClaw వంటి గేట్‌వే ఏజెంట్ లాగా కాకుండా, OpenCode అనేది ఒక ఇంటరాక్టివ్ టెర్మినల్ ప్రోగ్రామ్, ఇది డెమన్ (daemon) కాదు. ఇది ఎటువంటి పోర్ట్‌ను ఓపెన్ చేయదు మరియు దీర్ఘకాలం నడిచే సర్వీస్ ఏదీ ఉండదు, కాబట్టి దీని కోసం ప్రత్యేకంగా systemd యూనిట్ రాయాల్సిన అవసరం లేదు మరియు ఏజెంట్ కోసం ఫైర్‌వాల్‌లో పోర్ట్ ఓపెన్ చేయాల్సిన పని లేదు. యూజర్ అకౌంట్ మరియు ప్రాజెక్ట్ డైరెక్టరీయే దీనికి రక్షణ కవచం, అందుకే ఈ గైడ్‌లో మొదటి విభాగం అత్యంత ముఖ్యమైనది.

కోడింగ్ VPS కూడా ఒక పబ్లిక్ సర్వర్ కాబట్టి, దీనికి కూడా ప్రామాణిక జాగ్రత్తలు అవసరం: SSH hardening on a VPS లో చెప్పినట్లుగా root లాగిన్‌ను డిసేబుల్ చేసి, కేవలం కీ-ఆధారిత SSH మాత్రమే వాడాలి, డిఫాల్ట్-deny ఫైర్‌వాల్ ఉండాలి మరియు క్రమం తప్పకుండా అప్‌డేట్స్ చేయాలి. అలాగే ఏజెంట్ సృష్టించిన అవుట్‌పుట్‌ను సమీక్షించండి. మీరు కోడ్‌ను పుష్ చేసే ముందు దాని diffs ను చదవండి, కొత్త కంట్రిబ్యూటర్ పంపిన pull request ను ఎలా పరిశీలిస్తారో అలాగే చూడండి, ఎందుకంటే ఆ ఫలితాన్ని డిప్లాయ్ చేసేది మీరే.

చివరగా, టూల్‌ను ఎప్పటికప్పుడు అప్‌డేట్‌గా ఉంచండి. OpenCode తరచుగా కొత్త వెర్షన్లను విడుదల చేస్తుంది, మీ సర్వర్‌పై కమాండ్లను రన్ చేసే ప్రోగ్రామ్‌కు ఈ అప్‌డేట్స్ చాలా ముఖ్యం. మీరు ఇన్‌స్టాల్ చేసిన పద్ధతిలోనే అప్‌డేట్ చేయండి: opencode యూజర్‌గా ఇన్‌స్టాల్ స్క్రిప్ట్‌ను మళ్ళీ రన్ చేయండి, లేదా మీరు npm ద్వారా ఇన్‌స్టాల్ చేసి ఉంటే sudo npm update -g opencode-ai రన్ చేయండి, ఆపై opencode --version తో కొత్త వెర్షన్‌ను నిర్ధారించుకోండి. పాత వెర్షన్ వల్ల వచ్చే సమస్యలను డీబగ్ చేయడం కంటే, అప్పుడప్పుడు ఒక నిమిషం కేటాయించి మెయింటెనెన్స్ చేయడం మంచిది.

FAQ

OpenCode చెల్లింపు API కి బదులుగా లోకల్ మోడల్‌ను ఉపయోగించగలదా?

అవును. OpenCode ఏదైనా OpenAI-compatible సర్వర్‌ను ప్రొవైడర్‌గా పరిగణిస్తుంది, కాబట్టి అదే VPSలో Ollama ద్వారా నడిచే మోడల్ పనిచేస్తుంది: opencode.json లో లోకల్ baseURL మరియు Ollama రిపోర్ట్ చేసే మోడల్ పేరును పేర్కొనండి. ఇక్కడ ఉన్న సవాలు హార్డ్‌వేర్, ఎందుకంటే నిజమైన కోడింగ్ పనికి తగిన మోడల్‌కు గణనీయమైన మెమరీ అవసరం, కాబట్టి మీరు డౌన్‌లోడ్ చేసే ముందు మోడల్‌కు సరిపోయేలా సర్వర్ పరిమాణాన్ని నిర్ణయించుకోండి.

నా ల్యాప్‌టాప్ మూసివేసిన తర్వాత OpenCode రన్ అయ్యేలా ఎలా ఉంచాలి?

దీనిని VPSలో tmux లోపల రన్ చేయండి. tmux new -s opencode తో ఒక named session లో ఏజెంట్‌ను ప్రారంభించండి, Ctrl-b ఆపై d నొక్కి detach చేయండి, మీ SSH కనెక్షన్ ముగిసిన తర్వాత కూడా సెషన్ సర్వర్‌లో రన్ అవుతూనే ఉంటుంది. ఎప్పుడైనా tmux attach -t opencode తో మళ్ళీ reattach అవ్వండి, అప్పుడు సంభాషణ మరియు రన్ అవుతున్న టాస్క్‌లు అలాగే ఉంటాయి. సర్వర్ రీబూట్ అయితే సెషన్ ముగుస్తుంది, కాబట్టి రీబూట్ తర్వాత కొత్త సెషన్‌ను ప్రారంభించండి.

నా VPSలో OpenCode కమాండ్లను రన్ చేయడానికి అనుమతించడం సురక్షితమేనా?

మీరు దానిని నియంత్రణలో ఉంచితే ఇది సురక్షితమే. OpenCode కోసం sudo లేని ప్రత్యేకమైన unprivileged userను కేటాయించండి, దాని ప్రాజెక్టులను gitలో ఉంచండి తద్వారా ప్రతి మార్పును వెనక్కి తీసుకోవచ్చు, API కీని 600 మోడ్ ఉన్న ఫైల్‌లో భద్రపరచండి, మరియు Build ఏజెంట్‌కు ఏదైనా మార్చడానికి అనుమతించే ముందు దాని Plan ఏజెంట్‌తో రీడ్-ఓన్లీ (read-only) మొదటి పాస్ చేయండి. అప్పుడు ఏజెంట్ తన ఖాతాకు చెందిన వాటిని మాత్రమే ప్రభావితం చేయగలదు, సర్వర్‌లోని మిగిలిన భాగాలు సురక్షితంగా ఉంటాయి.

OpenCode మరియు Claude Code మధ్య తేడా ఏమిటి?

OpenCode ఓపెన్ సోర్స్ (MIT) మరియు ప్రొవైడర్ అజ్ఞేయవాది (provider agnostic), ఇది ఒకే ఇంటర్‌ఫేస్ ద్వారా లోకల్ మోడల్స్‌తో సహా 75 కంటే ఎక్కువ మోడల్ ప్రొవైడర్‌లకు కనెక్ట్ అవుతుంది. Claude Code అనేది Anthropic యొక్క సొంత టెర్మినల్ ఏజెంట్, ఇది Anthropic మోడల్స్ చుట్టూ నిర్మించబడింది. మీకు అనేక ప్రొవైడర్లలో ఒకే సాధనం కావాలన్నా, లేదా లోకల్ మోడల్‌తో పూర్తిగా self-hosted స్టాక్ కావాలన్నా, OpenCode సరైన ఎంపిక; రెండూ VPSలో tmux లోపల, ఒకే unprivileged-user సెటప్‌తో బాగా పనిచేస్తాయి.