Ovaj vodič je za operatora samostalno hostovanog Hermes Agent sistema koji može da upravlja Linux nalogom i privatnim GitHub repozitorijumom. Ishod je konkretan: puna arhiva Hermes korisničkih podataka, šifrovana pre napuštanja servera, potvrđena na predviđenom privatnom udaljenom repozitorijumu, pa preuzeta i uvezena na zasebnoj privremenoj mašini. Postupak je dokumentovan za Hermes CLI na commit-u 86fa9e6, provereno 19. oktobra 2026. BIG CHANGE je proverio sintaksu i tok skripte inertnim lokalnim probnim podacima; nije izvršio stvarnu Hermes rezervnu kopiju, age šifrovanje, slanje na GitHub, zakazano pokretanje ili vraćanje. Smatrajte kopiju dokazanom za svoju instalaciju tek pošto lično obavite sve provere ispod.

Velika promena

  • Šta se promenilo: Hermes komanda za punu rezervnu kopiju može da prikupi radne podatke u ZIP, a njegov cron režim bez agenta može da izvrši pregledanu skriptu. Tako operator može da napravi zakazanu šifrovanu kopiju bez prepuštanja kopiranja AI modelu.
  • Zašto je važno: Operator proverava tri odvojene činjenice: Hermes je dovršio arhivu, šifrovani sadržaj je stigao u predviđeni privatni repozitorijum i nova instalacija može da ga uveze. Svaka provera otkriva drugu vrstu greške. Arhiva i dalje izostavlja aplikaciju i deo lokalnih podataka mašine.
  • Na šta obratiti pažnju: Praktična odluka je da li arhiva i rastuća Git istorija ostaju dovoljno mali za ovaj ograničeni put. Neuspešna vežba oporavka ili bilo koje ograničenje veličine zahteva drugi plan skladištenja pre oslanjanja na raspored.

1. Pripremite server, ključ i repozitorijum

Koristite Linux sa Bash-om, GNU alatima stat -c i du -sb, uz instalirani Hermes CLI, Git, GitHub CLI (gh), age, unzip, sha256sum, SSH i aktivan Hermes gateway za cron. Potvrdite da instalirane komande hermes backup, hermes import i hermes cron create --help odgovaraju referenci CLI-ja na fiksiranom commit-u, čestim pitanjima i cron priručniku. Utvrdite korisnika operativnog sistema i HERMES_HOME koji pripadaju gateway-u. Celokupno podešavanje i prvu ručnu kopiju izvršite kao taj korisnik. Primer pretpostavlja namenski čist Git klon i main granu.

Puna Hermes kopija uključuje konfiguraciju, pristupne podatke, memorije, veštine, sesije i profile ispod korena podataka. Izostavlja Hermes kod, preuzete zavisnosti i izvršno okruženje, ranije kopije, kontrolne tačke, profile pristupnih podataka pregledača, SQLite prateće datoteke i neke lokalne datoteke. Ne prikuplja nepovezane datoteke sa drugih mesta na serveru. Nemojte koristiti --quick za ovaj ishod pune kopije podataka. Pregledajte važne stavke izvan tog obuhvata i zaštitite ih zasebno. ZIP sadrži tajne čak i kada je odredišni repozitorijum privatan.

Napravite age identitet, privatni ključ potreban za dešifrovanje, na zaštićenom mestu izvan HERMES_HOME, pripremnog direktorijuma i Git klona. Sačuvajte nezavisno uskladištenu kopiju tog identiteta za oporavak. Ispisani primalac age1… je javan i ide u konfiguraciju; privatni identitet ne ide. Pratite referencu za korišćenje age.

Terminal
umask 077
install -d -m 700 /PRIVATE-KEY-STORE
age-keygen -o /PRIVATE-KEY-STORE/hermes-backup-identity.txt
age-keygen -y /PRIVATE-KEY-STORE/hermes-backup-identity.txt

Napravite privatni repozitorijum samo za ovu kopiju, proverite ko ima pristup i podesite neinteraktivni pristup za čitanje pomoću gh i Git SSH pristup za upis pod istim korisnikom koji izvršava Hermes cron. Tokene i privatne SSH ključeve držite izvan Hermes podataka, pripreme i Git-a. Interaktivna prijava drugim nalogom ne dokazuje zakazani pristup. Zamenite oznake velikim slovima pre izvršavanja primera. Ako je pravljenje repozitorijuma već napravilo README ili main granu, proverite ih i preskočite nespojive inicijalizacione komande.

Terminal
gh repo create ACCOUNT/PRIVATE-REPOSITORY --private --clone
gh repo view ACCOUNT/PRIVATE-REPOSITORY --json isPrivate --jq .isPrivate
cd PRIVATE-REPOSITORY
git remote set-url origin git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git
git remote get-url --all origin
git remote get-url --push --all origin
git branch -M main
printf '%s\n' 'Encrypted Hermes backup storage; ciphertext and checksum only.' > README.md
git add README.md
git commit -m 'Initialize private backup repository'
git push -u origin HEAD:main
git ls-remote --heads origin main

gh repo create --clone može odabrati HTTPS iz lokalnih postavki; izričito navedeni SSH remote iznad određuje odredište ovog postupka. Nastavite tek kada isPrivate vrati true, saradnici budu predviđeni, efektivni URL za preuzimanje i slanje pojedinačno odgovaraju jednom pregledanom SSH URL-u i udaljeni pristup radi kao zakazani korisnik. Pravila udaljenih Git repozitorijuma dozvoljavaju prepisivanje URL-a, dodatna odredišta i zaseban pushurl; skripta ispod pri svakom izvršavanju proverava sirove i efektivne vrednosti.

Napustite klon pre čuvanja sledeća dva bloka koda. Napravite privatni direktorijum za podešavanje izvan korena Hermes podataka, Git klona, pripremnog direktorijuma i skladišta ključeva. Sačuvajte hermes-github-backup.sh i hermes-github-backup.conf tamo; instalacione komande ih kopiraju u vlasnički profil. Namenski Git klon mora ostati čist.

Terminal
install -d -m 700 /ABSOLUTE/PRIVATE-SETUP
cd /ABSOLUTE/PRIVATE-SETUP

2. Instalirajte pregledanu skriptu za kopiranje

Sačuvajte ceo Bash blok ispod kao hermes-github-backup.sh u tom privatnom direktorijumu. Drugi blok sačuvajte kao hermes-github-backup.conf pored njega, pošto zamenite svaku oznaku apsolutnom putanjom ili javnim primaocem. Ovo je shell konfiguracija koju treba lokalno pregledati pre učitavanja i dati dozvole samo vlasniku. Ne sme sadržati lozinku, token ili privatni age identitet. Skripta je kompletan predloženi primer; sintaksa i inertni tok su provereni, ali je prilagodite i testirajte na svojoj instalaciji. Nastala datoteka latest.zip.age je šifrovana arhiva.

Terminal
#!/usr/bin/env bash
# Documentation-based Linux sample for an operator to review and adapt.
# Place with hermes-github-backup.conf under the owning HERMES_HOME/scripts/.
# Requires GNU stat -c and du -sb. Git Bash was used only for inert fixtures.
set -Eeuo pipefail
umask 077

script_dir=$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)
owning_home=$(CDPATH= cd -- "$script_dir/.." && pwd -P)
if [[ -n ${HERMES_HOME:-} && $(CDPATH= cd -- "$HERMES_HOME" && pwd -P) != "$owning_home" ]]; then
  printf 'Backup stopped: cron profile and script directory differ.\n' >&2
  exit 1
fi
export HERMES_HOME="$owning_home"

config="$script_dir/hermes-github-backup.conf"
[[ -f "$config" ]] || { printf 'Backup stopped: reviewed configuration missing.\n' >&2; exit 1; }
# This file is local, owner-reviewed shell configuration. It must contain no secret.
# shellcheck source=/dev/null
source "$config"
: "${HERMES_BIN:?set an absolute Hermes executable path}"
: "${REPO_DIR:?set an absolute private clone path}"
: "${STAGING_PARENT:?set an absolute private staging path}"
: "${AGE_RECIPIENT:?set an age public recipient}"
: "${EXPECTED_REMOTE:?set the exact private GitHub SSH remote}"
: "${BRANCH:=main}"

fail() { printf 'Backup stopped: %s.\n' "$1" >&2; exit 1; }
for path in "$HERMES_BIN" "$REPO_DIR" "$STAGING_PARENT"; do
  [[ $path == /* ]] || fail 'a configured path is not absolute'
done
[[ -x "$HERMES_BIN" ]] || fail 'Hermes executable unavailable'
[[ $AGE_RECIPIENT == age1* ]] || fail 'age public recipient invalid'
[[ $EXPECTED_REMOTE == git@github.com:*/*.git ]] || fail 'remote is not the reviewed GitHub SSH URL'
[[ $BRANCH =~ ^[a-zA-Z0-9._/-]+$ ]] || fail 'branch name invalid'
[[ -d "$STAGING_PARENT" ]] || fail 'staging directory unavailable'
stage_parent=$(CDPATH= cd -- "$STAGING_PARENT" && pwd -P)
[[ $stage_parent != "$owning_home" && $stage_parent != "$owning_home"/* ]] || fail 'staging is inside Hermes data'

# Atomic, nonblocking whole-flow lock: keep it through push and remote readback.
# A stale directory after a crash requires operator inspection; never steal it.
lockdir="$stage_parent/.hermes-github-backup-flow.lock"
mkdir -- "$lockdir" 2>/dev/null || fail 'another backup flow holds the lock or a stale lock needs review'
work=''
cleanup() {
  if [[ -n $work ]]; then
    rm -f -- "$work/hermes.zip" "$work/latest.zip.age" "$work/latest.sha256" "$work/backup.log"
    rmdir -- "$work" 2>/dev/null || true
  fi
  rmdir -- "$lockdir" 2>/dev/null || true
}
trap cleanup EXIT

[[ -d "$REPO_DIR/.git" ]] || fail 'Git repository unavailable'
repo=$(CDPATH= cd -- "$REPO_DIR" && pwd -P)
[[ $repo != "$owning_home" && $repo != "$owning_home"/* ]] || fail 'repository is inside Hermes data'
[[ $stage_parent != "$repo" && $stage_parent != "$repo"/* ]] || fail 'staging is inside Git repository'
[[ $repo != "$stage_parent"/* ]] || fail 'Git repository is inside staging'

command -v age >/dev/null || fail 'age unavailable'
command -v gh >/dev/null || fail 'GitHub CLI unavailable for private visibility check'
command -v unzip >/dev/null || fail 'zip verifier unavailable'
command -v git >/dev/null || fail 'Git unavailable'
remote_repo=${EXPECTED_REMOTE#git@github.com:}
remote_repo=${remote_repo%.git}
visibility=$(gh repo view "$remote_repo" --json isPrivate --jq .isPrivate 2>/dev/null) || fail 'GitHub repository visibility unreadable'
[[ $visibility == true ]] || fail 'GitHub repository is not confirmed private'
raw_fetch_urls=$(git -C "$repo" config --get-all remote.origin.url) || fail 'Git fetch URL missing'
[[ $raw_fetch_urls == "$EXPECTED_REMOTE" ]] || fail 'Git has multiple or unexpected raw fetch URLs'
raw_push_urls=$(git -C "$repo" config --get-all remote.origin.pushurl || true)
[[ -z $raw_push_urls ]] || fail 'separate Git pushurl requires independent review'
effective_fetch_urls=$(git -C "$repo" remote get-url --all origin) || fail 'effective fetch URL unreadable'
effective_push_urls=$(git -C "$repo" remote get-url --push --all origin) || fail 'effective push URL unreadable'
[[ $effective_fetch_urls == "$EXPECTED_REMOTE" ]] || fail 'Git fetch URL rewrite or extra destination'
[[ $effective_push_urls == "$EXPECTED_REMOTE" ]] || fail 'Git push URL rewrite or extra destination'
[[ $(git -C "$repo" branch --show-current) == "$BRANCH" ]] || fail 'local branch changed'
[[ -z $(git -C "$repo" status --porcelain --untracked-files=all) ]] || fail 'repository has unrelated changes'

# No interactive prompt is possible in an unattended Hermes cron tick.
export GIT_TERMINAL_PROMPT=0
export GIT_SSH_COMMAND='ssh -o BatchMode=yes'
remote_head=$(git -C "$repo" ls-remote --heads origin "$BRANCH" | awk '{print $1}')
[[ -n $remote_head && $remote_head == "$(git -C "$repo" rev-parse HEAD)" ]] || fail 'remote unreadable or branch has changed'

work=$(mktemp -d "$stage_parent/hermes-backup.XXXXXXXX") || fail 'private staging creation failed'

if "$HERMES_BIN" backup -o "$work/hermes.zip" >"$work/backup.log" 2>&1; then
  :
else
  backup_rc=$?
  fail "Hermes full backup returned $backup_rc; temporary zip/log will be removed, so diagnose with a separate controlled manual run"
fi
[[ -s "$work/hermes.zip" ]] || fail 'Hermes archive absent or empty'
unzip -tq "$work/hermes.zip" >"$work/backup.log" 2>&1 || fail 'zip integrity check failed'
age -r "$AGE_RECIPIENT" -o "$work/latest.zip.age" "$work/hermes.zip" >"$work/backup.log" 2>&1 || fail 'archive encryption failed'
[[ -s "$work/latest.zip.age" ]] || fail 'encrypted archive absent or empty'

# Deliberately below GitHub's 50 MiB warning. Git history retains every version.
cipher_bytes=$(stat -c %s "$work/latest.zip.age")
(( cipher_bytes <= 40000000 )) || fail 'encrypted archive exceeds this small-repository recipe'
git_bytes=$(du -sb "$repo/.git" | awk '{print $1}')
(( git_bytes + cipher_bytes + 10000000 <= 500000000 )) || fail 'repository history approaches the review limit'
hash=$(sha256sum "$work/latest.zip.age" | awk '{print $1}')
printf '%s  latest.zip.age\n' "$hash" >"$work/latest.sha256"

cp -- "$work/latest.zip.age" "$repo/latest.zip.age"
cp -- "$work/latest.sha256" "$repo/latest.sha256"
git -C "$repo" add -- latest.zip.age latest.sha256
staged=$(git -C "$repo" diff --cached --name-only)
[[ $staged == $'latest.sha256\nlatest.zip.age' ]] || fail 'staged paths are not the two reviewed files'
git -C "$repo" diff --cached --check >/dev/null || fail 'staged content check failed'
git -C "$repo" commit -m "Encrypted Hermes backup $(date -u +%Y-%m-%dT%H:%M:%SZ)" >/dev/null || fail 'local backup commit failed'
run_head=$(git -C "$repo" rev-parse HEAD)
(( $(du -sb "$repo/.git" | awk '{print $1}') <= 500000000 )) || fail 'Git history exceeds review limit before push'
[[ $(git -C "$repo" rev-parse HEAD) == "$run_head" ]] || fail 'local HEAD changed before push'
git -C "$repo" push origin "$run_head:refs/heads/$BRANCH" >/dev/null || fail 'remote push failed; inspect exact remote before retrying'
remote_head=$(git -C "$repo" ls-remote --heads origin "$BRANCH" | awk '{print $1}')
[[ $remote_head == "$run_head" ]] || fail 'this run commit not confirmed at remote'
printf 'Encrypted backup verified at private remote commit %s.\n' "$run_head"
Terminal
# No passwords, tokens, age identities or private keys belong here.
HERMES_BIN=/absolute/path/to/hermes
REPO_DIR=/absolute/path/to/dedicated-private-github-clone
STAGING_PARENT=/absolute/path/to/private-staging-outside-hermes-and-git
AGE_RECIPIENT=age1replace_with_operator_public_recipient
EXPECTED_REMOTE=git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git
BRANCH=main

Napravite pripremni direktorijum izvan korena Hermes podataka i Git klona. Pregledane datoteke stavite u scripts/ direktorijum vlasničkog profila. Pre svakog izvršavanja klon mora biti čist i usklađen sa udaljenom main granom. Skripta zaključava ceo tok kroz slanje i povratno čitanje; nikada ne preuzima zauzetu ili staru bravu. Kao nove putanje pripremljene za Git prihvata samo latest.zip.age i latest.sha256. Staje kada šifrovana datoteka premaši 40.000.000 bajtova ili lokalni .git sa rezervnim prostorom priđe 500.000.000 bajtova. To su konzervativna ograničenja primera, ne garancije GitHub skladištenja.

Terminal
export HERMES_HOME=/absolute/path/to/owning-hermes-data-root
install -d -m 700 /ABSOLUTE/PRIVATE-STAGING
install -d -m 700 "$HERMES_HOME/scripts"
install -m 700 hermes-github-backup.sh "$HERMES_HOME/scripts/hermes-github-backup.sh"
install -m 600 hermes-github-backup.conf "$HERMES_HOME/scripts/hermes-github-backup.conf"
"$HERMES_HOME/scripts/hermes-github-backup.sh"

Ručno izvršavanje treba da završi izlaznim kodom nula i ispiše commit napravljen baš tim izvršavanjem nakon novog čitanja udaljenog repozitorijuma. Potvrdite da gh repo view i dalje prijavljuje privatnost, pregledajte praćene putanje u klonu i proverite tačan commit na predviđenom remote-u. Lokalna arhiva ili commit nisu udaljeni rezultat. Zaustavljeno izvršavanje ne beležite kao takvo. Hermes navodi da puna kopija vraća 0 samo kada je svaka izabrana datoteka dodata, 1 za nepotpunu arhivu, čak i ako ZIP postoji, i 2 kada druga kopija radi. Skripta pri izlasku briše privremeni ZIP i dnevnik; obično brisanje nije bezbedno uništavanje podataka. Za preskočene datoteke istražite odvojenom kontrolisanom ručnom komandom hermes backup -o /PRIVATE-DIAGNOSTIC/hermes.zip, pregledajte izlazni status i izveštaj i odlučite kako zaštititi izostavljeni materijal.

3. Zakažite i pregledajte prvo dospelo izvršavanje

Tek nakon ručnog rezultata koristite dokumentovani Hermes režim --no-agent --script iz istog profila. Izvršava datoteku bez LLM poziva. Namerno odaberite učestalost i lokalno dostavljanje statusa bez tajni. Proverite OS identitet gateway-a, profil i sledeće vreme. Prema Hermes dokumentaciji, vremensko ograničenje skripte dolazi iz HERMES_CRON_SCRIPT_TIMEOUT, zatim cron.script_timeout_seconds, zatim podrazumevanih 3.600 sekundi. Postavite i proverite vrednost primerenu posmatranom izvršavanju; istek vremena je greška. Pročišćeno okruženje skripte ne prima automatski pristupne podatke provajdera kojima upravlja Hermes, pa proverite nenadgledani gh i SSH pristup pod stvarnim zakazanim korisnikom pre oslanjanja na njega.

Terminal
hermes cron create '0 3 * * *' --no-agent --script hermes-github-backup.sh --deliver local --name 'Encrypted Hermes backup'
hermes cron list
hermes cron status
hermes cron doctor

Posle prvog zakazanog termina pregledajte tačan ID posla i zapis izvršavanja, lokalni izlaz pod ~/.hermes/cron/output/ za podrazumevani profil, svaki incident i glavni commit predviđenog udaljenog repozitorijuma. Potvrdite da je gateway ostao dostupan i da je izvršavanje prijavilo udaljeni commit nastao baš tim okidanjem. Ručno pokretanje ne dokazuje da je cron radio. Ako nema izlaza, pregledajte taj posao i gateway, ne pravite drugi raspored. Statusne poruke ne smeju sadržati ZIP sadržaj, tajne ili pristupne podatke.

4. Dokažite preuzimanje i uvoz na novoj mašini

Koristite zasebnu privremenu Linux mašinu bez produkcionog Hermes profila ili gateway-a. Prvo instalirajte kompatibilno Hermes izdanje: arhiva je korisnički podatak, ne slika aplikacije ili izvršnog okruženja. Test mašini dajte nezavisan odobren pristup za čitanje predviđenog privatnog repozitorijuma i nezavisno sačuvanog age identiteta. Potvrdite remote klona i izabrani commit. Ne pokrećite hermes import na izvornom serveru ili postojećem profilu. Sve vraćene rasporede i spoljne radnje držite neaktivnim dok čovek ne pregleda odredišta i odluči o uključivanju.

Terminal
umask 077
unset HERMES_HOME
git clone git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git /PRIVATE-RECOVERY/hermes-backup-clone
cd /PRIVATE-RECOVERY/hermes-backup-clone
sha256sum -c latest.sha256
age --decrypt -i /PRIVATE-KEY-STORE/hermes-backup-identity.txt -o /PRIVATE-RECOVERY/hermes.zip latest.zip.age
unzip -tq /PRIVATE-RECOVERY/hermes.zip
hermes import /PRIVATE-RECOVERY/hermes.zip
hermes setup
hermes cron list

Uporedite uvezene profile, veštine, memorije, sesije i cron definicije sa onim što ste želeli da zaštitite. hermes setup proverava konfiguraciju provajdera, ali pregledajte pristupne podatke i putanje specifične za mašinu koje treba prilagoditi. Zabeležite stvarne rezultate. Tačna kontrolna suma i ZIP koji može da se dešifruje sami ne dokazuju upotrebljivo vraćanje. Uklonite nešifrovani probni ZIP posle vežbe prema lokalnim pravilima; obično brisanje ne garantuje bezbedno uništavanje.

Kada provere stanu

Nepotpuna Hermes kopija, ZIP ili šifrovačka greška, neočekivan efektivni Git URL, neprivatan ili nečitljiv repozitorijum, zauzeta brava toka, ograničenje veličine, neuspešno slanje, različit udaljeni commit ili neuspešan uvoz ostavlja izvršavanje nepotvrđenim. Rešite konkretan uzrok i proverite trenutno stanje pre novog pokušaja. Ako je ishod slanja neizvestan, prvo proverite tačnu udaljenu granu i commit. Ako brava ostane posle pada, proverite živ proces i lokalno/udaljeno stanje; nikada ne brišite aktivnu bravu. Ako se izgubi privatni age identitet, za dešifrovanje treba nezavisna ispravna kopija. Prvo promenite otkrivene pristupne podatke ako nešifrovane tajne uđu u Git; kasnije brisanje datoteke ne uklanja raniju istoriju ili druge klonove.

GitHub smernice za velike datoteke upozoravaju na 50 MiB, blokiraju obične Git datoteke iznad 100 MiB i navode da Git nije zamišljen kao alat za rezervne kopije. Primer namerno staje ispod tih granica. Svaka promenjena šifrovana datoteka ostaje u Git istoriji i kada se latest.zip.age zameni. Ne podižite prećutno granice 40 MB/500 MB, ne prepisujte istoriju i ne smatrajte privatnost šifrovanjem. Preispitajte namensko skladište za kopije ili zasebno pregledan LFS plan ako padnu provere veličine ili oporavka. Troškovi naloga, skladišta, mreže i servera i dalje važe; skripta bez agenta sama ne zahteva LLM poziv. Nisu mereni trajanje, uspešnost ili uštede ovog postupka.

Za zaseban, uži Hermes zadatak zakazivanja pogledajte kako podesiti ponavljajući Hermes posao zasnovan na veštini i proveriti prvo izvršavanje. Provera njegovog izveštaja ne zamenjuje šifrovanu arhivu i vežbu oporavka.

Izvori i dodatno čitanje