OpenCode Snabbstart: Installera, konfigurera och använd terminalens AI-kodningsagent

Hur man installerar, konfigurerar och använder OpenCode

Sidinnehåll

OpenCode är en öppen källkod AI-kodningsagent som du kan kör i terminalen (TUI + CLI) med valfria skrivbords- och IDE-ytor. Det här är OpenCode Quickstart: installera, verifiera, anslut en modell/leverantör och kör verkliga arbetsflöden (CLI + API).

Versionsnote: OpenCode släpps snabbt. De “senaste” kommandona här är stabila, men utdata och standardvärden kan ändras – kontrollera alltid officiella CLI-dokumentationen och changelogen (länkade nedan).

Den här artikeln är en del av AI Developer Tools: The Complete Guide to AI-Powered Development.

Vad OpenCode är (och varför det passar)

OpenCode är utformad för terminalförst, agentbaserad kodning, samtidigt som den är modell/leverantör-flexibel. I praktiken är det en arbetsflödeslager som kan:

  • starta en terminalgränssnitt när du kör opencode
  • köra interaktiva “one-shot”-prompter via opencode run (skript/automatisering)
  • exponera en headless HTTP-server via opencode serve (och en webbgränssnitt via opencode web)
  • kontrolleras programmerat via den officiella JS/TS SDK:n @opencode-ai/sdk

opencode med självvärdd qwen3.5 27b LLM

Om du bygger en /ai-devtools/-kluster, är OpenCode ett starkt alternativ för en underkluster eftersom det naturligt utvecklas till:

  • CLI djupdykning
  • modell/leverantörsbeteende och kostnader (LLM-jämförelse inom OpenCode)
  • konfiguration & agenter
  • integreringar (GitHub/GitLab/Copilot)
  • snabbguide

Förutsättningar

Du kommer vilja ha:

  • En modern terminalsimulator (viktigt för TUI-upplevelsen).
  • Åtkomst till minst en modell/leverantör (API-nycklar eller prenumerationsautentisering, beroende på leverantör).

Installera OpenCode (kopiera och klistra)

Officiell installationskript (Linux/macOS/WSL):

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

Alternativ med pakethanterare (officiella exempel):

# Global install med Node.js
npm install -g opencode-ai

# Homebrew (rekommenderas av OpenCode för de mest aktuella versionerna)
brew install anomalyco/tap/opencode

# Arch Linux (stabil)
sudo pacman -S opencode

# Arch Linux (senaste från AUR)
paru -S opencode-bin

Windows-anteckningar (officiell rekommendation är ofta WSL för bästa kompatibilitet). Alternativ inkluderar Scoop/Chocolatey eller npm.

# Chocolatey (Windows)
choco install opencode

# Scoop (Windows)
scoop install opencode

Docker (nyttigt för en snabb test):

docker run -it --rm ghcr.io/anomalyco/opencode

Verifiera installationen

opencode --version
opencode --help

Förväntat utdataformat (kan variera beroende på version):

# Exempel:
# <skriver ut en versionsnummer, t.ex. vX.Y.Z>
# <skriver ut hjälp med tillgängliga kommandon/underkommandon>

Anslut en leverantör (två praktiska vägar)

Sökväg A: TUI /connect (interaktiv)

Starta OpenCode:

opencode

Sedan kör:

/connect

Följ UI-stegen för att välja en leverantör och autentisera (vissa flöden öppnar en webbläsare/enhetlogin).

Sökväg B: CLI opencode auth login (leverantörsnycklar)

OpenCode stöder konfigurering av leverantörer via:

opencode auth login

Anteckningar:

  • Autentiseringsuppgifter lagras på ~/.local/share/opencode/auth.json.
  • OpenCode kan också ladda in nycklar från miljövariabler eller en .env-fil i din projekt.

Starta ett projekt korrekt (rekommenderad första körning)

Från din repo:

cd /path/to/your/repo
opencode

Sedan initiera:

/init

Detta analyserar ditt projekt och skapar en AGENTS.md-fil i projektets rot. Det är vanligtvis värt att commita denna fil så att OpenCode (och kollegor) delar konsistent projektkontext.

Core CLI-arbetsflöden (kopiera och klistra exempel)

OpenCode stöder icke-interaktiva körningar:

opencode run "Förklara hur closure fungerar i JavaScript"

Arbetsflöde: generera kod (CLI)

Mål: generera en liten, testbar funktion med minimal kontext.

opencode run "Skriv en Go-funktion ParsePort(envVar string, defaultPort int) (int, error). Den ska läsa miljövariabeln, tolka en int, validera 1-65535, och returnera defaultPort om tom. Inkludera 3 tabellbaserade tester."

Förväntat utdata:

  • En förklaring plus kodblock (funktion + tester). Exakt kod varierar beroende på modell/leverantör och prompt.

Arbetsflöde: omstrukturera en fil säkert (CLI + Plan-agent)

Mål: omstrukturera utan oavsiktliga redigeringar genom att använda en mer restriktiv agent.

opencode run --agent plan --file ./src/auth.ts \
  "Omstrukturera denna fil för att minska komplexiteten. Utdata: (1) en kort plan, (2) en sammanfogad diff-patch, (3) risker/kantfall att testa. Kör inte kommandon."

Förväntat utdata:

  • En plansektion + en diff --git ...-patchblock + en testchecklista.
  • Innehåll varierar. Om det inte producerar en diff, återfråga: “Returnera endast en sammanfogad diff” eller “Använd diff --git-format.”

Arbetsflöde: ställ frågor om repo (CLI)

Mål: hitta implementeringsdetaljer snabbt.

opencode run --agent explore \
  "I detta rep, var valideras autentisering för API-begäranden? Lista troliga filer och förklara flödet. Om osäker, säg vad du kontrollerade."

Förväntat utdata:

  • En kort kartläggning av filvägar + flödesbeskrivning.
  • Utdata beror på repos storlek och modell/leverantörs kontextverktyg.

Arbetsflöde: förbättra upprepade CLI-körningar med en kvarliggande server

Om du skriptar eller kör flera opencode run-anrop, kan du starta en headless server en gång:

Terminal 1:

opencode serve --port 4096 --hostname 127.0.0.1

Terminal 2:

opencode run --attach http://localhost:4096 "Sammanfatt repostrukturen och huvudsakliga ingångspunkter."
opencode run --attach http://localhost:496 "Föreslå nu 3 högverkande omstruktureringar och varför."

Förväntat utdata:

  • Samma som opencode run, men oftast med mindre upprepade startöverhuvud.

Programmatisk användning (officiell JS/TS SDK)

OpenCode exponerar en HTTP-server (OpenAPI) och tillhandahåller en typsäker JS/TS-klient.

Installera:

npm install @opencode-ai/sdk

Exempel: starta server + klient, sedan prompt

Skapa scripts/opencode-sdk-demo.mjs:

import { createOpencode } from "@opencode-ai/sdk";

const opencode = await createOpencode({
  hostname: "127.0.0.1",
  port: 4096,
  config: {
    // Modellsträngformat är leverantör/modell (endast exempel)
    // model: "anthropic/claude-3-5-sonnet-20241022",
  },
});

console.log(`Server kör på: ${opencode.server.url}`);

// Grundläggande hälsotest/versionstest
const health = await opencode.client.global.health();
console.log("Hälsocheck:", health.data.healthy, "Version:", health.data.version);

// Skapa en session och prompt
const session = await opencode.client.session.create({ body: { title: "SDK quickstart demo" } });

const result = await opencode.client.session.prompt({
  path: { id: session.data.id },
  body: {
    parts: [{ type: "text", text: "Generera en liten README-sektion som beskriver detta repo." }],
  },
});

console.log(result.data);

// Stäng server när du är klar
opencode.server.close();

Kör:

node scripts/opencode-sdk-demo.mjs

Förväntat utdataformat:

  • “Server kör på …”
  • En hälsorespons som inkluderar en versionssträng
  • En sessionpromptresponssobjekt (exakt struktur beror på responseStyle och SDK-version)

Minsta OpenCode-konfiguration du kan kopiera

OpenCode stöder JSON och JSONC-konfiguration. Detta är ett rimligt startpunkt för en projektlokalt konfiguration.

Skapa opencode.jsonc i din repo-root:

{
  "$schema": "https://opencode.ai/config.json",

  // Välj en standardmodell (leverantör/modell). Se till att det matchar vad `opencode models` visar.
  "model": "leverantör/modell",

  // Valfritt: en billigare “liten modell” för lättare uppgifter (titlar, osv.)
  "small_model": "leverantör/liten-modell",

  // Valfritt: OpenCode-serverstandardvärden (används av serve/web)
  "server": {
    "port": 4096,
    "hostname": "127.0.0.1"
  },

  // Valfritt säkerhet: kräv bekräftelse innan redigeringar/kommandon
  "permission": {
    "edit": "fråga",
    "bash": "fråga"
  }
}

Kort snabbguide (snabbreferens)

Kommandon du kommer använda varje dag

opencode                       # starta TUI
opencode run "..."             # icke-interaktiv körning (automatisering)
opencode run --file path "..." # bifoga filer till prompt
opencode models --refresh      # uppdatera modelllista
opencode auth login            # konfigurera leverantörsautentisering
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + webbgränssnitt
opencode session list          # lista sessioner
opencode stats                 # token/kostnadssatser

TUI-kommandon värt att memorera

/connect   # anslut en leverantör
/init      # analysera repo, generera AGENTS.md
/share     # dela en session (om aktiverat)
/undo      # ångra en ändring
/redo      # gör om en ändring
/help      # hjälp/shortcut

Standard “leader key”-koncept (TUI)

OpenCode använder en konfigurerbar “leader”-nyckel (ofta ctrl+x) för att undvika terminalkonflikter. Många snabbtangentkommandon är “Leader + nyckel”.

FAQ (schema-klar)

Vad är OpenCode?

OpenCode är en öppen källkod AI-kodningsagent som är utformad för att fungera i din terminal (TUI + CLI) med ytterligare skrivbords/IDE-ytor.

Är OpenCode gratis?

Verktyget är öppen källkod. Användningskostnaden beror på den modell/leverantör du ansluter. Vissa leverantörer kan erbjuda prenumerationsbaserad autentisering eller gratis nivåer.

Hur kör jag OpenCode utan att öppna TUI?

Använd opencode run "..." för icke-interaktivt läge (nyttigt för skript/automatisering).

Var lagrar OpenCode leverantörsautentiseringsuppgifter?

opencode auth login lagrar autentiseringsuppgifter på ~/.local/share/opencode/auth.json.

Har OpenCode en API / SDK?

Ja. OpenCode kan köra en headless HTTP-server (opencode serve) med en OpenAPI-specifikation på /doc, och den tillhandahåller en officiell JS/TS-SDK: @opencode-ai/sdk.

Kan jag använda GitHub Copilot med OpenCode?

GitHub har annonserat att Copilot stöder autentisering med OpenCode via en formell integration. Den exakta tillgängligheten beror på din Copilot-plan och den aktuella leverantörsautentiseringssystemet.

En-sida tryckbar OpenCode snabbguide tabell

Den här versionen är avsiktligt tät och “tryckvänlig.” (Du kan klistra in den i en dedikerad /ai-devtools/opencode/cheatsheet/-sida senare.)

Uppgift Kommando / snabbtangent Anteckningar
Starta TUI opencode Standardbeteendet är att starta terminalgränssnittet
Kör en one-shot prompt opencode run "..." Icke-interaktivt läge för skript/automatisering
Bifoga filer till prompt opencode run --file path/to/file "..." Använd flera --file-flaggor för flera filer
Välj modell för en körning opencode run --model provider/model "..." Modellsträngar är provider/model
Välj agent opencode run --agent plan "..." Plan är utformad för säkrare “inga ändringar”-arbete (åtkomstbegränsat)
Lista modeller opencode models [provider] Använd --refresh för att uppdatera cachelista
Konfigurera leverantörsautentisering opencode auth login Lagrar autentiseringsuppgifter i ~/.local/share/opencode/auth.json
Lista autentiserade leverantörer opencode auth list / opencode auth ls Bekräfta vad OpenCode ser
Starta headless server opencode serve --port 4096 --hostname 127.0.0.1 OpenAPI-specifikation på http://host:port/doc
Bifoga körningar till server opencode run --attach http://localhost:4096 "..." Något som hjälper att undvika upprepade kalla startar
Aktivera grundläggande autentisering OPENCODE_SERVER_PASSWORD=... opencode serve Standardanvändare är opencode om inte åsidosatt
Webbgränssnittsläge opencode web Startar server + öppnar webbläsare
Exportera en session opencode export [sessionID] Något som är användbart för arkivering eller delning av kontext
Importera en session opencode import session.json Kan också importera från en delningslänk
Visa globala CLI-flaggor opencode --help / opencode --version --print-logs + --log-level för felsökning
TUI leader key-koncept standard leader key ofta ctrl+x Kan anpassas i tui.json

Källor (officiella först)

Officiella:

Mycket myntiga integrationsreferenser:

Reputabla jämförelser/utbildningar: