---
title: "Nedlastinger"
description: "Få Clavitor CLI og proxy på alle plattformer."
lang: no
url: https://clavitor.ai/no/downloads
markdown: https://clavitor.ai/no/downloads.md
translation_of: https://clavitor.ai/en/downloads.md
authoritative: false
publisher: Clavitor LLC
---

> This is the Norwegian translation of [Downloads](https://clavitor.ai/en/downloads.md). The original English text is authoritative; where the two differ, the English version prevails.

# Nedlastinger: Få Clavitor på maskinen din.

CLI-en gir AI-agentene dine begrenset tilgang til hvelvet ditt. Proxyen injiserer påloggingsinformasjon i HTTPS-forespørsler transparent. Begge er enkeltstående binærfiler uten avhengigheter.

## Last ned

> Live content (`downloads`) — see the [HTML version of this page](https://clavitor.ai/no/downloads).

## Nettleserutvidelse

Foretrekker du å fylle inn påloggingsinformasjon i nettleseren? Clavitor-utvidelsen fyller inn passord, passnøkler, kort og engangskoder i feltet som faktisk trenger dem — mens hvelvet ditt forblir eksternt, uten noe hurtigbuffer eller dekryptert på maskinen din.

Tilgjengelig nå for Chrome. Firefox og Safari kommer snart.

[Installer fra Chrome Web Store](https://chromewebstore.google.com/detail/clavitor/ddbhcfcclgjplbibgcphifegjadnmfpf)
[Les mer](https://clavitor.ai/no/extension)

## Sett opp en agent

To trinn. Under ett minutt fra en fersk CLI-installasjon til en fungerende agentidentitet.

### 1. Opprett agenten i hvelvet ditt

I hvelvets nettbaserte grensesnitt, gå til **Agenter → Ny**. Navngi agenten (for eksempel "Claude Code") og velg hvilke oppføringer den kan få tilgang til. Clavitor returnerer en **oppsettstoken** — en enkelt streng som koder hvelvets adresse, agentidentiteten og krypteringsnøkkelen den trenger.

Tokenet kan kun brukes én gang og har kort levetid (15 minutter som standard). Behandle det som et passord: gi det direkte til maskinen der agenten kjører, og kast det deretter.

### 2. Initialiser CLI-en på agentens maskin

```
$ clavitor-cli init <setup-token>
```

Tokenet dekodes og lagres som kryptert lokal konfigurasjon (`~/.config/clavitor/agent.clv` som standard — filrettigheter `0600`). Det opprinnelige tokenet forbrukes og kan ikke gjenbrukes. Neste avsnitt viser hvordan agenten bruker CLI-en fra dette punktet.

## Sett opp proxyen

For agenter som allerede snakker HTTP/HTTPS — Claude Desktop, egendefinerte skript, alt som bruker `requests` eller `fetch`. Proxyen sitter mellom agenten og den oppstrøms API-en, og løser `clavitor://Entry/field`-plassholdere på ledningen slik at agenten aldri holder den faktiske påloggingsinformasjonen. Se [proxyens tekniske side](https://clavitor.ai/no/proxy/technical) for trusselmodellen og protokoll detaljer.

Gjennomgangen er skrevet konversasjonelt slik at et menneske eller en AI-agent kan lese den fra topp til bunn og utføre den på en ekte maskin. Velg ditt operativsystem nedenfor — hver seksjon er en selvstendig prosedyre med seks trinn.

### Før du starter: hent en oppsettstoken fra hvelvet

Du trenger en oppsettstoken fra hvelvet ditt. **Dette er den eneste delen et menneske kan gjøre** — hvelvet krever en maskinvare-tapp for å autorisere en ny agent.

I hvelvets nettbaserte grensesnitt, gå til **Agenter → Ny**, navngi agenten (f.eks. "Lokal Proxy"), velg hvilke oppføringer den kan få tilgang til, og tapp sikkerhetsnøkkelen din når du blir bedt om det. Clavitor returnerer en engangsbruk-oppsettstoken med en 15-minutters TTL. Kopier den. Resten av trinnene nedenfor ber deg lime den inn én gang og deretter glemme den.

### Linux

Gjennomgangen nedenfor bruker bash og antar at du er på x86-64; erstatt `arm64` med `amd64` hvis du er på aarch64.

**1. Last ned proxy-binærfilen og gjør den kjørbar.** En enkelt selvstendig binærfil, ingen avhengigheter:

```
$ curl -LO https://clavitor.ai/downloads/clavitor-proxy-linux-amd64
$ chmod +x clavitor-proxy-linux-amd64
```

**2. Binærfilen er på disken. Bind den nå til hvelvet ditt.** Proxyen leser oppsettstokenen fra stdin (aldri fra kommandolinjen, så den lekker ikke inn i skallhistorikken din). Lim inn tokenet fra "Før du starter" når du blir bedt om det:

```
$ ./clavitor-proxy-linux-amd64 init
Paste enrollment token, then press Enter:
<paste-the-token-here>
✓ Authenticated.
```

Hva som skjedde: tokenet ble dekryptert lokalt (ingen nettverkskall), hvelvets adresse + agentidentitet + nøkkel for dekryptering av påloggingsinformasjon ble skrevet til en kryptert sidecar på `~/.config/clavitor-proxy/agent.clv` (modus `0600`), og selve tokenet er nå forbrukt. Du trenger den ikke igjen.

**3. Eksporter proxyens rot-CA.** Proxyen vil terminere hver HTTPS-tilkobling agenten din lager og utstede et sertifikat for hvert oppstrøms vertsnavn på farten. Uten å stole på rot-CA-en, ville disse sertifikatene feile verifisering:

```
$ ./clavitor-proxy-linux-amd64 ca > clavitor-proxy-ca.pem
```

**4. Installer CA-en i systemets tillitslager.** På Debian/Ubuntu og derivater:

```
$ sudo cp clavitor-proxy-ca.pem /usr/local/share/ca-certificates/clavitor-proxy-ca.crt
$ sudo update-ca-certificates
```

`update-ca-certificates` bør skrive ut `1 added`. Fra nå av aksepterer alle HTTPS-klienter på maskinen (curl, Python's requests, Go's net/http, osv.) proxyens sertifikater som legitime.

**5. Start proxyen.** Den binder seg til `127.0.0.1:1983` og kjører i forgrunnen; Ctrl-C stopper den:

```
$ ./clavitor-proxy-linux-amd64 serve
clavitor-proxy listening on 127.0.0.1:1983
```

For en permanent oppsett, legg inn en systemd-enhet som peker til samme binærfil slik at den starter på nytt ved omstart — se [proxy-dokumentasjonen](https://clavitor.ai/no/proxy/technical) for en referanse-enhet.

**6. Pek agenten din mot proxyen og verifiser ende-til-ende.** I et annet skall:

```
$ export HTTPS_PROXY=http://127.0.0.1:1983
$ curl -H "Authorization: Bearer clavitor://OpenAI/key" https://api.openai.com/v1/models
```

Hva som faktisk forlater proxyen og når OpenAIs servere — forespørselen agenten din aldri ser:

```
GET /v1/models HTTP/1.1
Host: api.openai.com
Authorization: Bearer sk-proj-abc123def456ghi789…    ← real key, injected by the proxy
User-Agent: curl/8.4.0
```

Hvis du får et JSON-svar fra OpenAI, er alt koblet til. Proxyen løste `clavitor://OpenAI/key` mot hvelvet ved hjelp av nøkkelen for dekryptering av påloggingsinformasjon fra trinn 2, erstattet den virkelige nøkkelen i `Authorization`-headeren, og videresendte forespørselen oppstrøms. Agentkoden din inneholder bare plassholderen; den virkelige nøkkelen forlater aldri proxyens prosessminne.

### macOS

Gjennomgangen nedenfor bruker zsh (standard skallet på macOS) og antar Apple Silicon; erstatt `amd64` med `arm64` hvis du er på en Intel Mac.

**1. Last ned proxy-binærfilen og gjør den kjørbar.** En enkelt selvstendig binærfil, ingen avhengigheter:

```
$ curl -LO https://clavitor.ai/downloads/clavitor-proxy-darwin-arm64
$ chmod +x clavitor-proxy-darwin-arm64
```

Hvis macOS Gatekeeper nekter å kjøre binærfilen første gang, høyreklikk den i Finder, velg **Åpne**, og bekreft — det registrerer unntaket. Etter det fungerer kommandolinje-kallet.

**2. Binærfilen er på disken. Bind den nå til hvelvet ditt.** Proxyen leser oppsettstokenen fra stdin (aldri fra kommandolinjen, så den lekker ikke inn i skallhistorikken din). Lim inn tokenet fra "Før du starter" når du blir bedt om det:

```
$ ./clavitor-proxy-darwin-arm64 init
Paste enrollment token, then press Enter:
<paste-the-token-here>
✓ Authenticated.
```

Hva som skjedde: tokenet ble dekryptert lokalt (ingen nettverkskall), hvelvets adresse + agentidentitet + nøkkel for dekryptering av påloggingsinformasjon ble skrevet til en kryptert sidecar på `~/.config/clavitor-proxy/agent.clv` (modus `0600`), og selve tokenet er nå forbrukt. Du trenger den ikke igjen.

**3. Eksporter proxyens rot-CA.** Proxyen vil terminere hver HTTPS-tilkobling agenten din lager og utstede et sertifikat for hvert oppstrøms vertsnavn på farten. Uten å stole på rot-CA-en, ville disse sertifikatene feile verifisering:

```
$ ./clavitor-proxy-darwin-arm64 ca > clavitor-proxy-ca.pem
```

**4. Installer CA-en i systemets nøkkelring.** Én kommando, ber om sudo-passordet ditt:

```
$ sudo security add-trusted-cert -d -r trustRoot \
    -k /Library/Keychains/System.keychain clavitor-proxy-ca.pem
```

Etter dette aksepterer Safari, curl, Swift, Python, Go og de fleste andre HTTPS-klienter på maskinen proxyens sertifikater. (Et lite antall kjøretidsmiljøer for språk leveres med sin egen tillitsbundt og trenger separat konfigurasjon — du vil se en sertifikatfeil hvis så.)

**5. Start proxyen.** Den binder seg til `127.0.0.1:1983` og kjører i forgrunnen; Ctrl-C stopper den:

```
$ ./clavitor-proxy-darwin-arm64 serve
clavitor-proxy listening on 127.0.0.1:1983
```

For en permanent oppsett, installer det som en launchd-agent slik at det starter ved innlogging og starter på nytt ved krasj.

**6. Pek agenten din mot proxyen og verifiser ende-til-ende.** I et annet skall:

```
$ export HTTPS_PROXY=http://127.0.0.1:1983
$ curl -H "Authorization: Bearer clavitor://OpenAI/key" https://api.openai.com/v1/models
```

Hva som faktisk forlater proxyen og når OpenAIs servere — forespørselen agenten din aldri ser:

```
GET /v1/models HTTP/1.1
Host: api.openai.com
Authorization: Bearer sk-proj-abc123def456ghi789…    ← real key, injected by the proxy
User-Agent: curl/8.4.0
```

Hvis du får et JSON-svar fra OpenAI, er alt koblet til. Proxyen løste `clavitor://OpenAI/key` mot hvelvet ved hjelp av nøkkelen for dekryptering av påloggingsinformasjon fra trinn 2, erstattet den virkelige nøkkelen i `Authorization`-headeren, og videresendte forespørselen oppstrøms. Agentkoden din inneholder bare plassholderen; den virkelige nøkkelen forlater aldri proxyens prosessminne.

### Windows

Gjennomgangen nedenfor bruker PowerShell og antar 64-biters Windows; erstatt `windows-386.exe` med `windows-amd64.exe` hvis du er på 32-biters.

**1. Last ned proxy-binærfilen.** En enkelt selvstendig .exe-fil, ingen avhengigheter:

```
> Invoke-WebRequest https://clavitor.ai/downloads/clavitor-proxy-windows-amd64.exe `
    -OutFile clavitor-proxy.exe
```

Windows SmartScreen kan vise en advarsel første gang du kjører en usignert binærfil — klikk **Mer informasjon → Kjør likevel** for å tillate det.

**2. Binærfilen er på disken. Bind den nå til hvelvet ditt.** Proxyen leser oppsettstokenen fra stdin (aldri fra kommandolinjen, så den lekker ikke inn i PowerShell-historikken din). Lim inn tokenet fra "Før du starter" når du blir bedt om det:

```
> .\clavitor-proxy.exe init
Paste enrollment token, then press Enter:
<paste-the-token-here>
✓ Authenticated.
```

Hva som skjedde: tokenet ble dekryptert lokalt (ingen nettverkskall), hvelvets adresse + agentidentitet + nøkkel for dekryptering av påloggingsinformasjon ble skrevet til en kryptert sidecar på `%APPDATA%\clavitor-proxy\agent.clv`, og selve tokenet er nå forbrukt. Du trenger den ikke igjen.

**3. Eksporter proxyens rot-CA.** Proxyen vil terminere hver HTTPS-tilkobling agenten din lager og utstede et sertifikat for hvert oppstrøms vertsnavn på farten. Uten å stole på rot-CA-en, ville disse sertifikatene feile verifisering:

```
> .\clavitor-proxy.exe ca > clavitor-proxy-ca.pem
```

**4. Installer CA-en i Local Machine Trusted Root-lageret.** Åpne en forhøyet PowerShell (Høyreklikk PowerShell → **Kjør som administrator**) og kjør:

```
> certutil -addstore -f "ROOT" clavitor-proxy-ca.pem
```

Etter dette aksepterer Edge, .NET, curl.exe og de fleste HTTP-klienter på maskinen proxyens sertifikater. (Firefox vedlikeholder sitt eget tillitslager; hvis du tester gjennom Firefox, importer CA-en separat under **Innstillinger → Personvern og sikkerhet → Sertifikater → Vis sertifikater → Myndigheter → Importer**.)

**5. Start proxyen.** Den binder seg til `127.0.0.1:1983` og kjører i forgrunnen; Ctrl-C stopper den:

```
> .\clavitor-proxy.exe serve
clavitor-proxy listening on 127.0.0.1:1983
```

For en permanent oppsett, registrer den som en Windows-tjeneste eller planlagt oppgave slik at den starter ved oppstart.

**6. Pek agenten din mot proxyen og verifiser ende-til-ende.** I et annet PowerShell-vindu:

```
> $env:HTTPS_PROXY = "http://127.0.0.1:1983"
> curl.exe -H "Authorization: Bearer clavitor://OpenAI/key" `
    https://api.openai.com/v1/models
```

(Bruk `curl.exe` eksplisitt — PowerShells `curl`-alias peker til `Invoke-WebRequest`, som håndterer proxy-miljøvariabelen annerledes.) Hva som faktisk forlater proxyen og når OpenAIs servere — forespørselen agenten din aldri ser:

```
GET /v1/models HTTP/1.1
Host: api.openai.com
Authorization: Bearer sk-proj-abc123def456ghi789…    ← real key, injected by the proxy
User-Agent: curl/8.4.0
```

Hvis du får et JSON-svar fra OpenAI, er alt koblet til. Proxyen løste `clavitor://OpenAI/key` mot hvelvet ved hjelp av nøkkelen for dekryptering av påloggingsinformasjon fra trinn 2, erstattet den virkelige nøkkelen i `Authorization`-headeren, og videresendte forespørselen oppstrøms. Agentkoden din inneholder bare plassholderen; den virkelige nøkkelen forlater aldri proxyens prosessminne.

## Installer Claude Code-ferdigheten

CLI-en leveres med en innebygd ferdighetsdefinisjon som lærer Claude Code hvordan den skal bruke hvelvet ditt. Én kommando installerer den.

```
# Install globally (all projects)

$ clavitor-cli skill > ~/.claude/skills/clavitor.md

# Or install for a specific project

$ clavitor-cli skill > /path/to/project/.claude/skills/clavitor.md
```

Ferdigheten er innebygd i binærfilen. Oppdater den ved å laste ned en ny utgivelse.

## Bruk den

Agenten din kan nå hente påloggingsinformasjon, generere TOTP-koder og lagre nye hemmeligheter. Hver tilgang logges i hvelvets revisjonsspor.

```
# Fetch a credential

$ clavitor-cli get github

# Generate a TOTP code

$ clavitor-cli totp github

# Store a new credential

$ clavitor-cli put credential "AWS Prod" --username admin --password s3cret

# List all entries

$ clavitor-cli list
```

## Én CLI-kommando. Alle hemmeligheter.

Ditt hvelv, dine omfang, ditt revisjonsspor. Ingen miljøvariabler, ingen konfigurasjonsfiler, ingen hemmeligheter i logger.
[Start gratis](https://clavitor.ai/no/checkout)
[Utviklerdokumentasjon](https://clavitor.ai/no/developers)